[LLD] Add a new PE/COFF port

[ruiu]

Summary

This is an initial patch for a section-based COFF linker.

The patch is 2300 lines including comments and blank lines.
Before diving into details, you may want to start from reading
README because it should give you an overview of the design.

All important things are written in the README file, so I write
summary here.

• The linker is already able to self-link on Windows.

• It's significantly faster than the existing implementation. The existing one takes 5 seconds to link LLD on my machine, while the new one only takes 1.2 seconds, even though the new one is not multi-threaded yet. (And a proof-of-concept multi- threaded version was able to link it in 0.5 seconds.)

• It uses much less memory (250MB vs. 2GB virtual memory space to self-host).

• IMHO the new code is much simpler and easier to read than the existing PE/COFF port.

[majnemer]

Some first round comments.

We should open archive files if you have symbols marked IMAGE_WEAK_EXTERN_SEARCH_LIBRARY.

COFF/InputFiles.cpp

32

Can we chose a better name? This overloads with basename(3).

39

Can we not make this a member function?

204–206

We should have an isAbsolute() and it should use COFF::IMAGE_SYM_ABSOLUTE.

207

Should we follow this path if we see a IMAGE_WEAK_EXTERN_SEARCH_ALIAS symbol?

COFF/README.md

7

s/the LLD/LLD

10–11

Perhaps we should prefer "instead" over "on the other hand" in this instance.

32–35

I think ArchiveSymbol might be a better fit than CanBeDefined.

83

belongs

COFF/Symbols.cpp

36–42

We should probably verify that MS LINK is OK with multiple definitions of a symbol where one of them is COMMON. For example, consider a non-common DefinedRegular symbol whose size is smaller than a common DefinedRegular symbol.

COFF/Symbols.h

49

Perhaps DefinedImportThunkKind

94

If you are going to use comparisons here, please do it like LLVM does like CmpInst::FIRST_ICMP_PREDICATE and CmpInst::LAST_ICMP_PREDICATE by adding additional enumerators.

COFF/Writer.cpp

55–56

This needs a comment.

78

You could do S.split('$').first

[ruiu]

Address review comments.

[ruiu]

Added folks who may be interested by this patch to the CC list.

COFF/InputFiles.cpp

32

Renamed getBasename.

39

This function uses ParentName and getName() defined in InputFile class, so maybe it's better to keep it as a member function.

204–206

Done.

207

Added a TODO.

COFF/README.md

32–35

As we discussed offline, "Archive" would conflict with libObject's Archive class, so let's rename "Lazy".

83

Fixed.

COFF/Symbols.cpp

36–42

Added a TODO.

COFF/Symbols.h

49

Done.

94

Done.

COFF/Writer.cpp

55–56

Done.

78

Done.

[davide]

JFYI, I have plans to carefully review this but unfortunately I wouldn't be able to for the next couple of days. In case this lands without, I'll do a post-commit review.

[pcc]

Clang build fixes:

clang.diff4 KBDownload

COFF/InputFiles.cpp

242

Here (and in a few other places) you are making assumptions about the host system's data layout. This may be a largely theoretical problem though.

COFF/SymbolTable.cpp

88

Should this diagnose that Undef is undefined because Sym->Body is undefined?

test/COFF/driver.test

3

On Linux this reads "nosuchfile.obj: No such file or directory" (capital N).

[majnemer]

COFF/InputFiles.cpp

242

I agree. I think the right fix is to add a coff_import_header to llvm/Object/COFF.h and reinterpret_cast the Buf.

[ruiu]

Peter,

Thank you for the patch. I applied that to my local copy. Will upload a new
patch.

[ruiu]

Updated as per Peter's comments.

[ruiu]

Davide,

I need more eyes for this patch than for regular patches this is important.
I expect it'll stay here for a while. Even if you can't make it, I'd really
appreciate if you could review.

If you are not particularly interested in Windows-specific thing, you can
skip the code for the import table, and you'll still be able to get the
meaning of the other code. That piece of code is probably a good example
about how to create chunks of data that's not backed by input sections
(it's very easy, btw), but details about the DLL import table may not be
interesting for you.

[• rafael]

This is beautiful!

Please do check it in. Given the time I would be eager to explore a similar design for ELF.

CMakeLists.txt

99

No need to change it now, but what do you think this will look like once we add ELF? Will this be renamed SectionObj or there will be an ELF directory and the common code will be moved to lib?

COFF/Chunks.h

20

Using "using" in headers? Maybe at least move them to a namespace.

41

Is there an out of line key method?

Is this deleted polimorficaly?

45

A more descriptive string would be nice :-)

66

Having a HasData protected member would be more llvm like.

80

COFF has nothing like SHF_MERGE sections, right?

This is called only for COMDAT discarding, right? There is nothing like --gc_sections at the moment.

Where should it print? STDOUT? Document that.

89

This is a bit confusing. If this represents an "output thing", how can it be a root?

Reading the rest of the code makes it clear I just just confused by Chunk being an output entity. It is something that is being "copied" to the output. Not sure where/if to document it, but it is clear enough after reading a bit.

100

Thank you so much for using llvm naming style.

113

s/representing/corresponding/?

229

Why is it called Null then?

COFF/Driver.cpp

125

So, make_dynamic_error_code is a bit of a misfeature IMHO.

There are two things at play

• Issuing a diagnostic
• Returning an error

For the diagnostic, something as simple as llvm::errs() is a reasonable start (or passing down a raw_ostream). At some point we really have move the diagnostic handling code out of lib/IR so that it can be used for all of llvm.

For error handling, we just need as many error_code enums as the callers can handle. For example, for all of the bitcode reading we use just InvalidBitcodeSignature, CorruptedBitcode.

170

Does link.exe really use the file name instead of the file signature?
Even if it does, it might be better to pass a MemoryBufferRef to the ArchiveFile and ObjectFile constructors and have them *not* own the buffer.

COFF/InputFiles.cpp

112

dyn_cast instead of isa+cast

151

who owns this?

COFF/InputFiles.h

42

Exposing an iterator might be better, no?

COFF/Memory.h

23

We should make this the one true StringSaver in llvm :-)

COFF/README.md

155

Nice explanation of the differences. I must say I like the COFF way :-)

COFF/Symbols.cpp

25

At least on ELF common is not that simple. The end result of linking two common symbols with the same name is a common symbol with the maximum size and the maximum alignment, so it is possible that it corresponds to none of the input common symbols. Is that the case for COFF?

[ruiu]

Updated as per Rafael's comments.

[ruiu]

Thank you for reviewing!

CMakeLists.txt

99

It depends on how it goes. If we end up having code that works really well for COFF but not fit to ELF, we would decide to share less code, and if that's the case keeping class definitions in the same directory would make sense. If that's not the case, we should move them out of this directory to lib.

COFF/Chunks.h

20

Done.

41

It's deleted polimorfically. Writer has a vector of unique_ptr<Chunk>.

45

Done.

66

Writer uses this member function.

80

It has COMDAT merging; search for "opt:icf". And gc-sections is already implemented in this patch.

113

Done.

229

Added comments.

COFF/Driver.cpp

125

I agree with that. If you want to use this as a library (not in a fancy way, but just by passing a list of mix of strings (command line options) and memory buffer objects (instead of filename string) to link in-memory objects, you want to get a machine-readable error code instead of this kind of human-readable error messages.

However, there's a beauty of this dynamic_error_code thing. It contains a error string. Every time you check for an error, you can construct a new error message by appending prefix to that. For example, if you get an error string "file not found" from a subroutine, you can then construct a new error message "foo.obj: file not found" and then propagate it up to the caller. The caller may append more error messages, like "reading bar.obj's directive section: foo.obj: file not found".

I don't think you can do that with error code enums.

I'll leave this as is as this is not that important, I'll revisit this later.

170

Maybe I should create Driver class and make it own MemoryBuffers. Currently as you can see below it's just a non-member function. Let me do that in a follow-up patch.

I don't think link.exe uses extensions at least this way. This is just my negligence.

COFF/InputFiles.cpp

112

Done.

151

This is a placement new.

COFF/InputFiles.h

42

Are you suggesting adding begin() and end() to InputFile? If so, because a subclass of thiis class contains another iterable object, vector<Chunk *>, adding begin and end is confusing.

COFF/Memory.h

23

Yeah. This is off topic, but do you think if it makes sense to add these member functions to BumpPtrAllocator itself?

COFF/Symbols.cpp

25

The PE/COFF spec uses a term "common symbol" without defining it, there's no explanation what it is. I was thinking to investigate the behavior of the actual linker.

As to how to handle the case you described for ELF, I guess we can change the signature of this function to return ErrorOr<SymbolBody*> and return this, Other or a new SymbolBody object. This doesn't have to be done in this patch, but this needs considering. Thank you for pointing that out.

[• rafael]

Comment at: COFF/Chunks.h:65
@@ +64,3 @@
+ // by this chunk is filled with zeros.
+ virtual bool hasData() const { return true; }

+

rafael wrote:

Having a HasData protected member would be more llvm like.

Writer uses this member function.

Oh, I meant in addition, so the method would look like

bool hasData() const { return HasData; }

This is called only for COMDAT discarding, right? There is nothing like --gc_sections at the moment.

Where should it print? STDOUT? Document that.

It has COMDAT merging; search for "opt:icf". And gc-sections is already implemented in this patch.

No results for icf :-)

What I mean by --gc-sections is something on the style of ELF, where
even sections that are not in COMDATs can be gced. I know link.exe
doesn't have that, I was just confused by the term "gc".

---

rafael wrote:

So, make_dynamic_error_code is a bit of a misfeature IMHO.

There are two things at play

• Issuing a diagnostic
• Returning an error

For the diagnostic, something as simple as llvm::errs() is a reasonable start (or passing down a raw_ostream). At some point we really have move the diagnostic handling code out of lib/IR so that it can be used for all of llvm.

For error handling, we just need as many error_code enums as the callers can handle. For example, for all of the bitcode reading we use just InvalidBitcodeSignature, CorruptedBitcode.

I agree with that. If you want to use this as a library (not in a fancy way, but just by passing a list of mix of strings (command line options) and memory buffer objects (instead of filename string) to link in-memory objects, you want to get a machine-readable error code instead of this kind of human-readable error messages.

However, there's a beauty of this dynamic_error_code thing. It contains a error string. Every time you check for an error, you can construct a new error message by appending prefix to that. For example, if you get an error string "file not found" from a subroutine, you can then construct a new error message "foo.obj: file not found" and then propagate it up to the caller. The caller may append more error messages, like "reading bar.obj's directive section: foo.obj: file not found".

I don't think you can do that with error code enums.

With enums you can't, that is the point :-)

The idea is to only add an enum value if a caller wants to do
something different for that error case. That is why for bitcode
reading we have just enums for "there was an error" and "this is not a
bitcode file at all": Some callers want to try to open a file and
ignore it if it is not a bitcode, but actual errors have to be
reported.

The diagnostic path is separate and far richer:

if (!isa<PointerType>(PtrType))
  return Error(DH, "Load/Store operand is not a pointer type");

The DH is a DiagnosticHandler callback. It can do pretty much
anything: print to stdout, abort the program, log it over the
internet, open a dialog window, etc. It is also extensible. In the
case of the bitcode reader we pass just the error_code and the user
readable message, but it is possible to include as much context as
needed.

Last but not least, the callback is an incredibly convenient point for
putting a breakpoint when debugging. When the error occurs the entire
stack is still alive.

I'll leave this as is as this is not that important, I'll revisit this later.

I agree, please don't consider any of my comments as blockers. The
performance improvements you showed are more than convincing to get
this committed and iterate afterwards.

rafael wrote:

who owns this?

This is a placement new.

oops :-)

rafael wrote:

Exposing an iterator might be better, no?

Are you suggesting adding begin() and end() to InputFile? If so, because a subclass of thiis class contains another iterable object, vector<Chunk *>, adding begin and end is confusing.

I was thinking of creating the Chunk lazily, but I see it probably
wouldn't help much.

Comment at: COFF/Memory.h:22
@@ +21,3 @@
+
+class StringAllocator {

+public:

rafael wrote:

We should make this the one true StringSaver in llvm :-)

Yeah. This is off topic, but do you think if it makes sense to add these member functions to BumpPtrAllocator itself?

I would probably leave it as a convenience class just like you have
it. It is just that the one in llvm is silly (virtual base with only
one implementation that uses a std::vector).

As to how to handle the case you described for ELF, I guess we can change the signature of this function to return ErrorOr<SymbolBody*> and return this, Other or a new SymbolBody object. This doesn't have to be done in this patch, but this needs considering. Thank you for pointing that out.

Should work.

Thanks again for all the work on this!

[davide]

The overall patch looks very good to me. Some comments, don't take them as mandatory just suggestions.
Thanks!

COFF/Chunks.cpp

47

Can you add a small comment here explaining why COMDATs are GC roots?

73

using 'auto' here? Or do you think it makes the code less readable?

132

In other places you assign E in the for() initialization, any reason you don't do that here as well? Maybe there are few other places where you do this that I missed.

COFF/InputFiles.cpp

112

No braces needed, I guess.

COFF/Memory.h

30

I think it may make sense to make this function (or set of function(s)) available everywhere, rather than making them specific to lld.
I can imagine the usefulness of having a facility to return a NULL-terminated copy of a string somewhere else in the tree.

COFF/Options.td

22

Can you sort these (alphabetically?)

COFF/Writer.cpp

31

I personally prefer to express power-of-two constant(s) as 1 << SOMETHING; but it's not a strong preference.

[ruiu]

Davide,

Thank you for reviewing!

COFF/Chunks.cpp

47

Done.

73

I think explicit type is more readable this case, although we are using C as a variable for Chunk in almost all cases.

132

I think I wrote E before for if E's initializer is too long (I just don't want to line-warp for conditionals).

COFF/InputFiles.cpp

112

I omit {} only when it doesn't have else consistently, so keeping it is probably better.

COFF/Options.td

22

Done.

COFF/Writer.cpp

31

Interesting. I always think in the other way just like this, so page size is 4096 to me than 1<<12 and disk sector is 512 than 1<<9.

CMakeLists.txt

 endif()
 
 add_subdirectory(docs)
+add_subdirectory(COFF)

COFF/CMakeLists.txt

+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
+  Driver.cpp
+  InputFiles.cpp
+  SymbolTable.cpp
+  Symbols.cpp
+  Writer.cpp
+  )
+
+add_dependencies(lldCOFF COFFOptionsTableGen)

COFF/Chunks.h

+//===- Chunks.h -----------------------------------------------------------===//
+//
+//                             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 "lld/Core/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Object/COFF.h"
+#include <map>
+#include <vector>
+
+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;
+
+namespace lld {
+namespace coff {
+
+class Defined;
+class DefinedImportData;
+class ObjectFile;
+class OutputSection;
+
+// A Chunk represents a chunk of data that will occupy space in the
+// output (if the resolver chose that). It may or may not be backed by
+// a section of an input file. It could be linker-created data, or
+// doesn't even have actual data (if common or bss).
+class Chunk {
+public:
+  virtual ~Chunk() {}
+
+  // Returns the pointer to data. It is illegal to call this function if
+  // this is a common or BSS chunk.
+  virtual const uint8_t *getData() const { llvm_unreachable("internal error"); }
+
+  // Returns the size of this chunk (even if this is a common or BSS.)
+  virtual size_t getSize() const = 0;
+
+  // The writer sets and uses the addresses.
+  uint64_t getRVA() { return RVA; }
+  uint64_t getFileOff() { return FileOff; }
+  uint32_t getAlign() { return Align; }
+  void setRVA(uint64_t V) { RVA = V; }
+  void setFileOff(uint64_t V) { FileOff = V; }
+
+  // Applies relocations, assuming Buffer points to beginning of an
+  // mmap'ed output file. Because this function uses file offsets and
+  // RVA values of other chunks, you need to set them properly before
+  // calling this function.
+  virtual void applyRelocations(uint8_t *Buf) {}
+
+  // Returns true if getData() returns a valid pointer to data.
+  // BSS chunks return false. If false is returned, the space occupied
+  // by this chunk is 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("internal error");
+  }
+
+  // Called if the garbage collector decides to not include this chunk
+  // in a final output. It's supposed to print out a log message. It
+  // is illegal to call this function on non-section chunks because
+  // only section chunks are subject of garbage collection.
+  virtual void printDiscardedMessage() { llvm_unreachable("internal error"); }
+
+  // Returns true if this is a COMDAT section. Usually, it is an error
+  // if there are more than one defined symbols having the same name,
+  // but symbols at begining of COMDAT sections allowed to duplicate.
+  virtual bool isCOMDAT() const { return false; }
+
+  // Used by the garbage collector.
+  virtual bool isRoot() { return false; }
+  virtual bool isLive() { return true; }
+  virtual void markLive() {}
+
+  // 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; }
+
+protected:
+  // The RVA of this chunk in the output. The writer sets a value.
+  uint64_t RVA = 0;
+
+  // The offset from beginning of the output file. The writer sets a
+  // value.
+  uint64_t FileOff = 0;
+
+  // The alignment of this chunk. The writer uses the value.
+  uint32_t Align = 1;
+
+  // The output section for this chunk.
+  OutputSection *Out = nullptr;
+};
+
+// A chunk representing a section of an input file.
+class SectionChunk : public Chunk {
+public:
+  SectionChunk(ObjectFile *File, const coff_section *Header,
+               uint32_t SectionIndex);
+  const uint8_t *getData() const override;
+  size_t getSize() const override { return Header->SizeOfRawData; }
+  void applyRelocations(uint8_t *Buf) override;
+  bool hasData() const override;
+  uint32_t getPermissions() const override;
+  StringRef getSectionName() const override { return SectionName; }
+  void printDiscardedMessage() override;
+  bool isCOMDAT() const override;
+
+  bool isRoot() override;
+  void markLive() override;
+  bool isLive() override { return Live; }
+
+  // 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);
+
+private:
+  SectionRef getSectionRef();
+  void applyReloc(uint8_t *Buf, const coff_relocation *Rel);
+
+  // A file this chunk was created from.
+  ObjectFile *File;
+
+  const coff_section *Header;
+  uint32_t SectionIndex;
+  StringRef SectionName;
+  bool Live = false;
+  std::vector<Chunk *> AssocChildren;
+  bool IsAssocChild = false;
+};
+
+// A chunk for common symbols. Common chunks don't have actual data.
+class CommonChunk : public Chunk {
+public:
+  CommonChunk(const COFFSymbolRef S) : Sym(S) {}
+  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);
+  const uint8_t *getData() const override { return &Data[0]; }
+  size_t getSize() const override { return Data.size(); }
+
+private:
+  std::vector<uint8_t> Data;
+};
+
+// All chunks below are for the DLL import descriptor table and
+// Windows-specific. You may need to read the Microsoft PE/COFF spec
+// to understand details about the data structures.
+
+static const uint8_t ImportThunkData[] = {
+    0xff, 0x25, 0x00, 0x00, 0x00, 0x00, // JMP *0x0
+};
+
+// 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 ImportThunkChunk : public Chunk {
+public:
+  explicit ImportThunkChunk(Defined *S) : ImpSymbol(S) {}
+  const uint8_t *getData() const override { return ImportThunkData; }
+  size_t getSize() const override { return sizeof(ImportThunkData); }
+  void applyRelocations(uint8_t *Buf) override;
+
+private:
+  Defined *ImpSymbol;
+};
+
+// A chunk for the import descriptor table.
+class HintNameChunk : public Chunk {
+public:
+  explicit HintNameChunk(StringRef Name);
+  const uint8_t *getData() const override { return Data.data(); }
+  size_t getSize() const override { return Data.size(); }
+
+private:
+  std::vector<uint8_t> Data;
+};
+
+// A chunk for the import descriptor table.
+class LookupChunk : public Chunk {
+public:
+  explicit LookupChunk(HintNameChunk *H) : HintName(H) {}
+  bool hasData() const override { return false; }
+  size_t getSize() const override { return sizeof(uint64_t); }
+  void applyRelocations(uint8_t *Buf) override;
+  HintNameChunk *HintName;
+};
+
+// A chunk for the import descriptor table.
+class DirectoryChunk : public Chunk {
+public:
+  explicit DirectoryChunk(StringChunk *N) : DLLName(N) {}
+  bool hasData() const override { return false; }
+  size_t getSize() const override { return sizeof(ImportDirectoryTableEntry); }
+  void applyRelocations(uint8_t *Buf) override;
+
+  StringChunk *DLLName;
+  LookupChunk *LookupTab;
+  LookupChunk *AddressTab;
+};
+
+// A chunk for the import descriptor table.
+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; }
+
+private:
+  size_t Size;
+};
+
+// ImportTable creates a set of import table chunks for a given
+// DLL-imported symbols.
+class ImportTable {
+public:
+  ImportTable(StringRef DLLName, std::vector<DefinedImportData *> &Symbols);
+  StringChunk *DLLName;
+  DirectoryChunk *DirTab;
+  std::vector<LookupChunk *> LookupTables;
+  std::vector<LookupChunk *> AddressTables;
+  std::vector<HintNameChunk *> HintNameTables;
+};
+
+} // namespace coff
+} // namespace lld
+
+#endif

COFF/Chunks.cpp

+//===- Chunks.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Chunks.h"
+#include "InputFiles.h"
+#include "Writer.h"
+#include "lld/Core/Error.h"
+#include "llvm/ADT/STLExtras.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"
+
+using namespace llvm::object;
+using namespace llvm::support::endian;
+using llvm::COFF::ImportHeader;
+using llvm::RoundUpToAlignment;
+
+namespace lld {
+namespace coff {
+
+SectionChunk::SectionChunk(ObjectFile *F, const coff_section *H, uint32_t SI)
+    : File(F), Header(H), SectionIndex(SI) {
+  File->getCOFFObj()->getSectionName(Header, SectionName);
+  // Bit [20:24] contains section alignment.
+  unsigned Shift = ((Header->Characteristics & 0xF00000) >> 20) - 1;
+  Align = uint32_t(1) << Shift;
+}
+
+const uint8_t *SectionChunk::getData() const {
+  assert(hasData());
+  ArrayRef<uint8_t> Data;
+  File->getCOFFObj()->getSectionContents(Header, Data);
+  return Data.data();
+}
+
+// Returns true if this chunk should be considered as a GC root.
+bool SectionChunk::isRoot() {
+  if (isCOMDAT())
+    return false;
+
+  // Associative sections are live if their parent COMDATs are live,
+  // and vice versa, so they are not considered live by themselves.
+  if (IsAssocChild)
+    return false;
+
+  // Only code is subject of dead-stripping.
+  return !(Header->Characteristics & llvm::COFF::IMAGE_SCN_CNT_CODE);
+}
+
+void SectionChunk::markLive() {
+  if (Live)
+    return;
+  Live = true;
+
+  // Mark all symbols listed in the relocation table for this section.
+  for (const auto &I : getSectionRef().relocations()) {
+    const coff_relocation *Rel = File->getCOFFObj()->getCOFFRelocation(I);
+    SymbolBody *B = File->getSymbolBody(Rel->SymbolTableIndex);
+    if (auto *Def = dyn_cast<Defined>(B))
+      Def->markLive();
+  }
+
+  // Mark associative sections if any.
+  for (Chunk *C : AssocChildren)
+    C->markLive();
+}
+
+void SectionChunk::addAssociative(SectionChunk *Child) {
+  Child->IsAssocChild = true;
+  AssocChildren.push_back(Child);
+}
+
+void SectionChunk::applyRelocations(uint8_t *Buf) {
+  for (const auto &I : getSectionRef().relocations()) {
+    const coff_relocation *Rel = File->getCOFFObj()->getCOFFRelocation(I);
+    applyReloc(Buf, Rel);
+  }
+}
+
+static void add16(uint8_t *P, int32_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); }
+
+// Implements x64 PE/COFF relocations.
+void SectionChunk::applyReloc(uint8_t *Buf, const coff_relocation *Rel) {
+  using namespace llvm::COFF;
+  uint8_t *Off = Buf + FileOff + Rel->VirtualAddress;
+  SymbolBody *Body = File->getSymbolBody(Rel->SymbolTableIndex);
+  uint64_t S = cast<Defined>(Body)->getRVA();
+  uint64_t P = RVA + Rel->VirtualAddress;
+  switch (Rel->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, Out->getSectionIndex()); break;
+  case IMAGE_REL_AMD64_SECREL:   add32(Off, S - Out->getRVA()); break;
+  default:
+    llvm::report_fatal_error("Unsupported relocation type");
+  }
+}
+
+bool SectionChunk::hasData() const {
+  return !(Header->Characteristics & llvm::COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA);
+}
+
+uint32_t SectionChunk::getPermissions() const {
+  return Header->Characteristics & PermMask;
+}
+
+bool SectionChunk::isCOMDAT() const {
+  return Header->Characteristics & llvm::COFF::IMAGE_SCN_LNK_COMDAT;
+}
+
+// Prints "Discarded <symbol>" for all external function symbols.
+void SectionChunk::printDiscardedMessage() {
+  uint32_t E = File->getCOFFObj()->getNumberOfSymbols();
+  for (uint32_t I = 0; I < E; ++I) {
+    auto SrefOrErr = File->getCOFFObj()->getSymbol(I);
+    COFFSymbolRef Sym = SrefOrErr.get();
+    if (Sym.getSectionNumber() != SectionIndex)
+      continue;
+    if (!Sym.isFunctionDefinition())
+      continue;
+    StringRef SymbolName;
+    File->getCOFFObj()->getSymbolName(Sym, SymbolName);
+    llvm::dbgs() << "Discarded " << SymbolName << " from "
+                 << File->getShortName() << "\n";
+    I += Sym.getNumberOfAuxSymbols();
+  }
+}
+
+SectionRef SectionChunk::getSectionRef() {
+  DataRefImpl Ref;
+  Ref.p = uintptr_t(Header);
+  return SectionRef(Ref, File->getCOFFObj());
+}
+
+uint32_t CommonChunk::getPermissions() const {
+  using namespace llvm::COFF;
+  return IMAGE_SCN_CNT_UNINITIALIZED_DATA | IMAGE_SCN_MEM_READ |
+         IMAGE_SCN_MEM_WRITE;
+}
+
+StringChunk::StringChunk(StringRef S) : Data(S.size() + 1) {
+  memcpy(Data.data(), S.data(), S.size());
+  Data[S.size()] = 0;
+}
+
+void ImportThunkChunk::applyRelocations(uint8_t *Buf) {
+  uint32_t Operand = ImpSymbol->getRVA() - RVA - getSize();
+  // The first two bytes are a JMP instruction. Fill its operand.
+  write32le(Buf + FileOff + 2, Operand);
+}
+
+HintNameChunk::HintNameChunk(StringRef Name)
+    : Data(RoundUpToAlignment(Name.size() + 4, 2)) {
+  memcpy(&Data[2], Name.data(), Name.size());
+}
+
+void LookupChunk::applyRelocations(uint8_t *Buf) {
+  write32le(Buf + FileOff, HintName->getRVA());
+}
+
+void DirectoryChunk::applyRelocations(uint8_t *Buf) {
+  auto *E = (coff_import_directory_table_entry *)(Buf + FileOff);
+  E->ImportLookupTableRVA = LookupTab->getRVA();
+  E->NameRVA = DLLName->getRVA();
+  E->ImportAddressTableRVA = AddressTab->getRVA();
+}
+
+ImportTable::ImportTable(StringRef N,
+                         std::vector<DefinedImportData *> &Symbols) {
+  DLLName = new StringChunk(N);
+  DirTab = new DirectoryChunk(DLLName);
+  for (DefinedImportData *S : Symbols)
+    HintNameTables.push_back(new HintNameChunk(S->getExportName()));
+
+  for (HintNameChunk *H : HintNameTables) {
+    LookupTables.push_back(new LookupChunk(H));
+    AddressTables.push_back(new LookupChunk(H));
+  }
+
+  for (int I = 0, E = Symbols.size(); I < E; ++I)
+    Symbols[I]->setLocation(AddressTables[I]);
+
+  DirTab->LookupTab = LookupTables[0];
+  DirTab->AddressTab = AddressTables[0];
+}
+
+} // namespace coff
+} // namespace lld

COFF/Config.h

+//===- Config.h -----------------------------------------------------------===//
+//
+//                             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 <cstdint>
+#include <set>
+#include <string>
+
+namespace lld {
+namespace coff {
+
+class Configuration {
+public:
+  bool Verbose = false;
+  std::string EntryName = "mainCRTStartup";
+  uint64_t ImageBase = 0x140000000;
+
+  bool insertFile(llvm::StringRef Path) {
+    return VisitedFiles.insert(Path.lower()).second;
+  }
+
+private:
+  std::set<std::string> VisitedFiles;
+};
+
+extern Configuration *Config;
+
+} // namespace coff
+} // namespace lld
+
+#endif

COFF/Driver.h

+//===- Driver.h -----------------------------------------------------------===//
+//
+//                             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 "Memory.h"
+#include "llvm/ADT/StringRef.h"
+#include <memory>
+#include <system_error>
+#include <vector>
+
+namespace lld {
+namespace coff {
+
+class InputFile;
+
+std::error_code parseDirectives(StringRef S,
+                                std::vector<std::unique_ptr<InputFile>> *Res,
+                                StringAllocator *Alloc);
+
+} // namespace coff
+} // namespace lld
+
+#endif

COFF/Driver.cpp

+//===- 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 "InputFiles.h"
+#include "Memory.h"
+#include "SymbolTable.h"
+#include "Writer.h"
+#include "lld/Core/Error.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/STLExtras.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/Debug.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+#include "llvm/Support/raw_ostream.h"
+#include <memory>
+
+using namespace llvm;
+
+// Create enum with OPT_xxx values for each option in Options.td
+enum {
+  OPT_INVALID = 0,
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELP, META)                                                     \
+  OPT_##ID,
+#include "Options.inc"
+#undef OPTION
+};
+
+// Create prefix string literals used in Options.td
+#define PREFIX(NAME, VALUE) const char *const NAME[] = VALUE;
+#include "Options.inc"
+#undef PREFIX
+
+// Create table mapping all options defined in Options.td
+static const llvm::opt::OptTable::Info infoTable[] = {
+#define OPTION(PREFIX, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,  \
+               HELPTEXT, METAVAR)                                              \
+  {                                                                            \
+    PREFIX, NAME, HELPTEXT, METAVAR, OPT_##ID, llvm::opt::Option::KIND##Class, \
+        PARAM, FLAGS, OPT_##GROUP, OPT_##ALIAS, ALIASARGS                      \
+  }                                                                            \
+  ,
+#include "Options.inc"
+#undef OPTION
+};
+
+namespace {
+
+class COFFOptTable : public llvm::opt::OptTable {
+public:
+  COFFOptTable() : OptTable(infoTable, llvm::array_lengthof(infoTable), true) {}
+};
+
+class BumpPtrStringSaver : public llvm::cl::StringSaver {
+public:
+  BumpPtrStringSaver(lld::coff::StringAllocator *A) : Alloc(A) {}
+
+  const char *SaveString(const char *S) override {
+    return Alloc->save(S).data();
+  }
+
+private:
+  lld::coff::StringAllocator *Alloc;
+};
+}
+
+static std::string getOutputPath(llvm::opt::InputArgList *Args) {
+  if (auto *Arg = Args->getLastArg(OPT_out))
+    return Arg->getValue();
+  for (auto *Arg : Args->filtered(OPT_INPUT)) {
+    if (!StringRef(Arg->getValue()).endswith_lower(".obj"))
+      continue;
+    SmallString<128> Val = Arg->getValue();
+    llvm::sys::path::replace_extension(Val, ".exe");
+    return Val.str();
+  }
+  llvm_unreachable("internal error");
+}
+
+// Split the given string with the path separator.
+static std::vector<StringRef> splitPathList(StringRef str) {
+  std::vector<StringRef> ret;
+  while (!str.empty()) {
+    StringRef path;
+    std::tie(path, str) = str.split(';');
+    ret.push_back(path);
+  }
+  return ret;
+}
+
+namespace lld {
+namespace coff {
+
+Configuration *Config;
+
+ErrorOr<std::unique_ptr<llvm::opt::InputArgList>>
+parseArgs(int Argc, const char *Argv[]) {
+  COFFOptTable Table;
+  unsigned MissingIndex;
+  unsigned MissingCount;
+  std::unique_ptr<llvm::opt::InputArgList> Args(
+      Table.ParseArgs(&Argv[1], &Argv[Argc], MissingIndex, MissingCount));
+  if (MissingCount) {
+    std::string S;
+    llvm::raw_string_ostream OS(S);
+    OS << llvm::format("missing arg value for \"%s\", expected %d argument%s.",
+                       Args->getArgString(MissingIndex), MissingCount,
+                       (MissingCount == 1 ? "" : "s"));
+    OS.flush();
+    return make_dynamic_error_code(StringRef(S));
+  }
+  for (auto *Arg : Args->filtered(OPT_UNKNOWN))
+    llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n";
+  return std::move(Args);
+}
+
+std::string findLib(StringRef Filename) {
+  if (llvm::sys::fs::exists(Filename))
+    return Filename;
+  std::string Name;
+  if (Filename.endswith_lower(".lib")) {
+    Name = Filename;
+  } else {
+    Name = (Filename + ".lib").str();
+  }
+
+  llvm::Optional<std::string> Env = llvm::sys::Process::GetEnv("LIB");
+  if (!Env.hasValue())
+    return Filename;
+  for (StringRef Dir : splitPathList(*Env)) {
+    SmallString<128> Path = Dir;
+    llvm::sys::path::append(Path, Name);
+    if (llvm::sys::fs::exists(Path.str()))
+      return Path.str();
+  }
+  return Filename;
+}
+
+std::string findFile(StringRef Filename) {
+  if (llvm::sys::fs::exists(Filename))
+    return Filename;
+  llvm::Optional<std::string> Env = llvm::sys::Process::GetEnv("LIB");
+  if (!Env.hasValue())
+    return Filename;
+  for (StringRef Dir : splitPathList(*Env)) {
+    SmallString<128> Path = Dir;
+    llvm::sys::path::append(Path, Filename);
+    if (llvm::sys::fs::exists(Path.str()))
+      return Path.str();
+  }
+  return Filename;
+}
+
+std::unique_ptr<InputFile> createFile(StringRef Path) {
+  if (StringRef(Path).endswith_lower(".lib"))
+    return llvm::make_unique<ArchiveFile>(Path);
+  return llvm::make_unique<ObjectFile>(Path);
+}
+
+// Parses .drectve section contents and returns a list of files
+// specified by /defaultlib.
+std::error_code parseDirectives(StringRef S,
+                                std::vector<std::unique_ptr<InputFile>> *Res,
+                                StringAllocator *Alloc) {
+  SmallVector<const char *, 16> Tokens;
+  Tokens.push_back("link"); // argv[0] value. Will be ignored.
+  BumpPtrStringSaver Saver(Alloc);
+  llvm::cl::TokenizeWindowsCommandLine(S, Saver, Tokens);
+  Tokens.push_back(nullptr);
+  int Argc = Tokens.size() - 1;
+  const char **Argv = &Tokens[0];
+
+  auto ArgsOrErr = parseArgs(Argc, Argv);
+  if (auto EC = ArgsOrErr.getError())
+    return EC;
+  std::unique_ptr<llvm::opt::InputArgList> Args = std::move(ArgsOrErr.get());
+
+  for (auto *Arg : Args->filtered(OPT_defaultlib)) {
+    std::string Path = findLib(Arg->getValue());
+    if (!Config->insertFile(Path))
+      continue;
+    Res->push_back(llvm::make_unique<ArchiveFile>(Path));
+  }
+  return std::error_code();
+}
+
+bool link(int Argc, const char *Argv[]) {
+  // Parse command line options.
+  Config = new Configuration();
+  auto ArgsOrErr = parseArgs(Argc, Argv);
+  if (auto EC = ArgsOrErr.getError()) {
+    llvm::errs() << EC.message() << "\n";
+    return false;
+  }
+  std::unique_ptr<llvm::opt::InputArgList> Args = std::move(ArgsOrErr.get());
+
+  if (Args->filtered_begin(OPT_INPUT) == Args->filtered_end()) {
+    llvm::errs() << "no input files.\n";
+    return false;
+  }
+  if (Args->hasArg(OPT_verbose))
+    Config->Verbose = true;
+  if (auto *Arg = Args->getLastArg(OPT_entry))
+    Config->EntryName = Arg->getValue();
+
+  // Parse all input files and put all symbols to the symbol table.
+  // The symbol table will take care of name resolution.
+  SymbolTable Symtab;
+  for (auto *Arg : Args->filtered(OPT_INPUT)) {
+    std::string Path = findFile(Arg->getValue());
+    if (!Config->insertFile(Path))
+      continue;
+    if (auto EC = Symtab.addFile(createFile(Path))) {
+      llvm::errs() << Path << ": " << EC.message() << "\n";
+      return false;
+    }
+  }
+  if (Symtab.reportRemainingUndefines())
+    return false;
+
+  // Write the result.
+  Writer Out(&Symtab);
+  if (auto EC = Out.write(getOutputPath(Args.get()))) {
+    llvm::errs() << EC.message() << "\n";
+    return false;
+  }
+  return true;
+}
+}
+}

COFF/InputFiles.h

+//===- InputFiles.h -------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_INPUT_FILES_H
+#define LLD_COFF_INPUT_FILES_H
+
+#include "Chunks.h"
+#include "Memory.h"
+#include "Symbols.h"
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/COFF.h"
+#include <memory>
+#include <set>
+#include <vector>
+
+using llvm::object::Archive;
+using llvm::object::COFFObjectFile;
+
+namespace lld {
+namespace coff {
+
+// The root class of input files.
+class InputFile {
+public:
+  enum Kind { ArchiveKind, ObjectKind, ImportKind };
+  Kind kind() const { return FileKind; }
+  virtual ~InputFile() {}
+
+  // Returns the filename.
+  virtual StringRef getName() = 0;
+
+  // Returns symbols defined by this file.
+  virtual std::vector<SymbolBody *> &getSymbols() = 0;
+
+  // Reads a file (constructors don't do that). Returns an error if a
+  // file is broken.
+  virtual std::error_code parse() = 0;
+
+  // Returns a short, human-friendly filename. If this is a member of
+  // an archive file, a returned value includes parent's filename.
+  // Used for logging or debugging.
+  std::string getShortName();
+
+  // Sets a parent filename if this file is created from an archive.
+  void setParentName(StringRef N) { ParentName = N; }
+
+protected:
+  explicit InputFile(Kind K) : FileKind(K) {}
+
+private:
+  const Kind FileKind;
+  StringRef ParentName;
+};
+
+// .lib or .a file.
+class ArchiveFile : public InputFile {
+public:
+  explicit ArchiveFile(StringRef S) : InputFile(ArchiveKind), Name(S) {}
+  static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
+  std::error_code parse() override;
+  StringRef getName() override { return Name; }
+
+  // Returns a memory buffer for a given symbol. An empty memory buffer
+  // is returned if we have already returned the same memory buffer.
+  // (So that we don't instantiate same members more than once.)
+  ErrorOr<MemoryBufferRef> getMember(const Archive::Symbol *Sym);
+
+  // NB: All symbols returned by ArchiveFiles are of Lazy type.
+  std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
+
+private:
+  std::unique_ptr<Archive> File;
+  std::string Name;
+  std::unique_ptr<MemoryBuffer> MB;
+  std::vector<SymbolBody *> SymbolBodies;
+  std::set<const char *> Seen;
+  llvm::MallocAllocator Alloc;
+};
+
+// .obj or .o file. This may be a member of an archive file.
+class ObjectFile : public InputFile {
+public:
+  explicit ObjectFile(StringRef S) : InputFile(ObjectKind), Name(S) {}
+  ObjectFile(StringRef S, MemoryBufferRef M)
+      : InputFile(ObjectKind), Name(S), MBRef(M) {}
+
+  static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
+  std::error_code parse() override;
+  StringRef getName() override { return Name; }
+  std::vector<Chunk *> &getChunks() { return Chunks; }
+  std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
+
+  // Returns a SymbolBody object for the SymbolIndex'th symbol in the
+  // underlying object file.
+  SymbolBody *getSymbolBody(uint32_t SymbolIndex);
+
+  // Returns .drectve section contents if exist.
+  StringRef getDirectives() { return Directives; }
+
+  // Returns the underying COFF file.
+  COFFObjectFile *getCOFFObj() { return COFFObj.get(); }
+
+private:
+  std::error_code initializeChunks();
+  std::error_code initializeSymbols();
+
+  SymbolBody *createSymbolBody(StringRef Name, COFFSymbolRef Sym,
+                               const void *Aux, bool IsFirst);
+
+  std::string Name;
+  std::unique_ptr<COFFObjectFile> COFFObj;
+  std::unique_ptr<MemoryBuffer> MB;
+  MemoryBufferRef MBRef;
+  StringRef Directives;
+  llvm::BumpPtrAllocator Alloc;
+
+  // List of all chunks defined by this file. This includes both section
+  // chunks and non-section chunks for common symbols.
+  std::vector<Chunk *> Chunks;
+
+  // This vector contains the same chunks as Chunks, but they are
+  // indexed such that you can get a SectionChunk by section index.
+  // Nonexistent section indices are filled with null pointers.
+  // (Because section number is 1-based, the first slot is always a
+  // null pointer.)
+  std::vector<Chunk *> SparseChunks;
+
+  // List of all symbols referenced or defined by this file.
+  std::vector<SymbolBody *> SymbolBodies;
+
+  // This vector contains the same symbols as SymbolBodies, but they
+  // are indexed such that you can get a SymbolBody by symbol
+  // index. Nonexistent indices (which are occupied by auxiliary
+  // symbols in the real symbol table) are filled with null pointers.
+  std::vector<SymbolBody *> SparseSymbolBodies;
+};
+
+// This type represents import library members that contain DLL names
+// and symbols exported from the DLLs. See Microsoft PE/COFF spec. 7
+// for details about the format.
+class ImportFile : public InputFile {
+public:
+  explicit ImportFile(MemoryBufferRef M) : InputFile(ImportKind), MBRef(M) {}
+  static bool classof(const InputFile *F) { return F->kind() == ImportKind; }
+  StringRef getName() override { return MBRef.getBufferIdentifier(); }
+  std::vector<SymbolBody *> &getSymbols() override { return SymbolBodies; }
+
+private:
+  std::error_code parse() override;
+
+  MemoryBufferRef MBRef;
+  std::vector<SymbolBody *> SymbolBodies;
+  llvm::BumpPtrAllocator Alloc;
+  StringAllocator StringAlloc;
+};
+
+} // namespace coff
+} // namespace lld
+
+#endif

COFF/InputFiles.cpp

+//===- InputFiles.cpp -----------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Chunks.h"
+#include "InputFiles.h"
+#include "Writer.h"
+#include "lld/Core/Error.h"
+#include "llvm/ADT/STLExtras.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"
+
+using namespace llvm::object;
+using namespace llvm::support::endian;
+using llvm::COFF::ImportHeader;
+using llvm::RoundUpToAlignment;
+using llvm::sys::fs::identify_magic;
+using llvm::sys::fs::file_magic;
+
+namespace lld {
+namespace coff {
+
+// Returns the last element of a path, which is supposed to be a filename.
+static StringRef getBasename(StringRef Path) {
+  size_t Pos = Path.rfind('\\');
+  if (Pos == StringRef::npos)
+    return Path;
+  return Path.substr(Pos + 1);
+}
+
+// Returns a string in the format of "foo.obj" or "foo.obj(bar.lib)".
+std::string InputFile::getShortName() {
+  if (ParentName == "")
+    return getName().lower();
+  std::string Res = (getBasename(ParentName) + "(" +
+                     getBasename(getName()) + ")").str();
+  return StringRef(Res).lower();
+}
+
+std::error_code ArchiveFile::parse() {
+  // Get a memory buffer.
+  auto MBOrErr = MemoryBuffer::getFile(Name);
+  if (auto EC = MBOrErr.getError())
+    return EC;
+  MB = std::move(MBOrErr.get());
+
+  // Parse a memory buffer as an archive file.
+  auto ArchiveOrErr = Archive::create(MB->getMemBufferRef());
+  if (auto EC = ArchiveOrErr.getError())
+    return EC;
+  File = std::move(ArchiveOrErr.get());
+
+  // Allocate a buffer for Lazy objects.
+  size_t BufSize = File->getNumberOfSymbols() * sizeof(Lazy);
+  Lazy *Buf = (Lazy *)Alloc.Allocate(BufSize, llvm::alignOf<Lazy>());
+
+  // Read the symbol table to construct Lazy objects.
+  uint32_t I = 0;
+  for (const Archive::Symbol &Sym : File->symbols()) {
+    // Skip special symbol exists in import library files.
+    if (Sym.getName() == "__NULL_IMPORT_DESCRIPTOR")
+      continue;
+    SymbolBodies.push_back(new (&Buf[I++]) Lazy(this, Sym));
+  }
+  return std::error_code();
+}
+
+// Returns a buffer pointing to a member file containing a given symbol.
+ErrorOr<MemoryBufferRef> ArchiveFile::getMember(const Archive::Symbol *Sym) {
+  auto ItOrErr = Sym->getMember();
+  if (auto EC = ItOrErr.getError())
+    return EC;
+  Archive::child_iterator It = ItOrErr.get();
+
+  // Return an empty buffer if we have already returned the same buffer.
+  const char *StartAddr = It->getBuffer().data();
+  auto Pair = Seen.insert(StartAddr);
+  if (!Pair.second)
+    return MemoryBufferRef();
+
+  auto MBRefOrErr = It->getMemoryBufferRef();
+  if (auto EC = MBRefOrErr.getError())
+    return EC;
+  return MBRefOrErr.get();
+}
+
+std::error_code ObjectFile::parse() {
+  // MBRef is not initialized if this is not an archive member.
+  if (MBRef.getBuffer().empty()) {
+    auto MBOrErr = MemoryBuffer::getFile(Name);
+    if (auto EC = MBOrErr.getError())
+      return EC;
+    MB = std::move(MBOrErr.get());
+    MBRef = MB->getMemBufferRef();
+  }
+
+  // Parse a memory buffer as a COFF file.
+  auto BinOrErr = createBinary(MBRef);
+  if (auto EC = BinOrErr.getError())
+    return EC;
+  std::unique_ptr<Binary> Bin = std::move(BinOrErr.get());
+
+  if (!isa<COFFObjectFile>(Bin.get()))
+    return make_dynamic_error_code(Twine(Name) + " is not a COFF file.");
+  COFFObj.reset(cast<COFFObjectFile>(Bin.release()));
+
+  // Read section and symbol tables.
+  if (auto EC = initializeChunks())
+    return EC;
+  if (auto EC = initializeSymbols())
+    return EC;
+  return std::error_code();
+}
+
+SymbolBody *ObjectFile::getSymbolBody(uint32_t SymbolIndex) {
+  return SparseSymbolBodies[SymbolIndex]->getReplacement();
+}
+
+std::error_code ObjectFile::initializeChunks() {
+  uint32_t NumSections = COFFObj->getNumberOfSections();
+  Chunks.reserve(NumSections);
+  SparseChunks.resize(NumSections + 1);
+  for (uint32_t I = 1; I < NumSections + 1; ++I) {
+    const coff_section *Sec;
+    StringRef Name;
+    if (auto EC = COFFObj->getSection(I, Sec))
+      return make_dynamic_error_code(Twine("getSection failed: ") + Name +
+                                     ": " + EC.message());
+    if (auto EC = COFFObj->getSectionName(Sec, Name))
+      return make_dynamic_error_code(Twine("getSectionName failed: ") + Name +
+                                     ": " + EC.message());
+    if (Name == ".drectve") {
+      ArrayRef<uint8_t> Data;
+      COFFObj->getSectionContents(Sec, Data);
+      Directives = StringRef((char *)Data.data(), Data.size()).trim();
+      continue;
+    }
+    if (Name.startswith(".debug"))
+      continue;
+    if (Sec->Characteristics & llvm::COFF::IMAGE_SCN_LNK_REMOVE)
+      continue;
+    auto *C = new (Alloc) SectionChunk(this, Sec, I);
+    Chunks.push_back(C);
+    SparseChunks[I] = C;
+  }
+  return std::error_code();
+}
+
+std::error_code ObjectFile::initializeSymbols() {
+  uint32_t NumSymbols = COFFObj->getNumberOfSymbols();
+  SymbolBodies.reserve(NumSymbols);
+  SparseSymbolBodies.resize(NumSymbols);
+  int32_t LastSectionNumber = 0;
+  for (uint32_t I = 0; I < NumSymbols; ++I) {
+    // Get a COFFSymbolRef object.
+    auto SymOrErr = COFFObj->getSymbol(I);
+    if (auto EC = SymOrErr.getError())
+      return make_dynamic_error_code(Twine("broken object file: ") + Name +
+                                     ": " + EC.message());
+    COFFSymbolRef Sym = SymOrErr.get();
+
+    // Get a symbol name.
+    StringRef SymbolName;
+    if (auto EC = COFFObj->getSymbolName(Sym, SymbolName))
+      return make_dynamic_error_code(Twine("broken object file: ") + Name +
+                                     ": " + EC.message());
+    // Skip special symbols.
+    if (SymbolName == "@comp.id" || SymbolName == "@feat.00")
+      continue;
+
+    const void *AuxP = nullptr;
+    if (Sym.getNumberOfAuxSymbols())
+      AuxP = COFFObj->getSymbol(I + 1)->getRawPtr();
+    bool IsFirst = (LastSectionNumber != Sym.getSectionNumber());
+
+    SymbolBody *Body = createSymbolBody(SymbolName, Sym, AuxP, IsFirst);
+    if (Body) {
+      SymbolBodies.push_back(Body);
+      SparseSymbolBodies[I] = Body;
+    }
+    I += Sym.getNumberOfAuxSymbols();
+    LastSectionNumber = Sym.getSectionNumber();
+  }
+  return std::error_code();
+}
+
+SymbolBody *ObjectFile::createSymbolBody(StringRef Name, COFFSymbolRef Sym,
+                                         const void *AuxP, bool IsFirst) {
+  if (Sym.isUndefined())
+    return new Undefined(Name);
+  if (Sym.isCommon()) {
+    Chunk *C = new (Alloc) CommonChunk(Sym);
+    Chunks.push_back(C);
+    return new (Alloc) DefinedRegular(this, Name, Sym, C);
+  }
+  if (Sym.isAbsolute())
+    return new (Alloc) DefinedAbsolute(Name, Sym.getValue());
+  // TODO: Handle IMAGE_WEAK_EXTERN_SEARCH_ALIAS
+  if (Sym.isWeakExternal()) {
+    auto *Aux = (const coff_aux_weak_external *)AuxP;
+    return new (Alloc) Undefined(Name, &SparseSymbolBodies[Aux->TagIndex]);
+  }
+  if (IsFirst && AuxP) {
+    if (Chunk *C = SparseChunks[Sym.getSectionNumber()]) {
+      auto *Aux = (coff_aux_section_definition *)AuxP;
+      auto *Parent =
+          (SectionChunk *)(SparseChunks[Aux->getNumber(Sym.isBigObj())]);
+      if (Parent)
+        Parent->addAssociative((SectionChunk *)C);
+    }
+  }
+  if (Chunk *C = SparseChunks[Sym.getSectionNumber()])
+    return new (Alloc) DefinedRegular(this, Name, Sym, C);
+  return nullptr;
+}
+
+std::error_code ImportFile::parse() {
+  const char *Buf = MBRef.getBufferStart();
+  const char *End = MBRef.getBufferEnd();
+
+  // The size of the string that follows the header.
+  uint32_t DataSize = read32le(Buf + offsetof(ImportHeader, SizeOfData));
+
+  // Check if the total size is valid.
+  if (size_t(End - Buf) != sizeof(ImportHeader) + DataSize)
+    return make_dynamic_error_code("broken import library");
+
+  StringRef Name = StringAlloc.save(StringRef(Buf + sizeof(ImportHeader)));
+  StringRef ImpName = StringAlloc.save(Twine("__imp_") + Name);
+  StringRef DLLName(Buf + sizeof(ImportHeader) + Name.size() + 1);
+  auto *ImpSym = new (Alloc) DefinedImportData(DLLName, ImpName, Name);
+  SymbolBodies.push_back(ImpSym);
+
+  uint16_t TypeInfo = read16le(Buf + offsetof(ImportHeader, TypeInfo));
+  int Type = TypeInfo & 0x3;
+  if (Type == llvm::COFF::IMPORT_CODE)
+    SymbolBodies.push_back(new (Alloc) DefinedImportThunk(Name, ImpSym));
+  return std::error_code();
+}
+}
+}

COFF/Memory.h

+//===- Memory.h -----------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_MEMORY_H
+#define LLD_COFF_MEMORY_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/Allocator.h"
+#include <memory>
+
+namespace lld {
+namespace coff {
+
+class StringAllocator {
+public:
+  // Returns a null-terminated copy of a string.
+  StringRef save(StringRef S) {
+    char *P = Alloc.Allocate<char>(S.size() + 1);
+    memcpy(P, S.data(), S.size());
+    P[S.size()] = '\0';
+    return StringRef(P, S.size());
+  }
+
+  StringRef save(Twine S) { return save(StringRef(S.str())); }
+  StringRef save(const char *S) { return save(StringRef(S)); }
+
+private:
+  llvm::BumpPtrAllocator Alloc;
+};
+
+} // namespace coff
+} // namespace lld
+
+#endif

COFF/Options.td

+include "llvm/Option/OptParser.td"
+
+// link.exe accepts options starting with either a dash or a slash.
+
+// Flag that takes no arguments.
+class F<string name> : Flag<["/", "-", "-?"], name>;
+
+// Flag that takes one argument after ":".
+class P<string name, string help> :
+      Joined<["/", "-", "-?"], name#":">, HelpText<help>;
+
+// Boolean flag suffixed by ":no".
+multiclass B<string name, string help> {
+  def "" : F<name>;
+  def _no : F<name#":no">, HelpText<help>;
+}
+
+def alternatename : P<"alternatename", "Define weak alias">;
+def base    : P<"base", "Base address of the program">;
+def defaultlib : P<"defaultlib", "Add the library to the list of input files">;
+def nodefaultlib : P<"nodefaultlib", "Remove a default library">;
+def disallowlib : Joined<["/", "-", "-?"], "disallowlib:">, Alias<nodefaultlib>;
+def entry   : P<"entry", "Name of entry point symbol">;
+// No help text because /failifmismatch is not intended to be used by the user.
+def export  : P<"export", "Export a function">;
+def failifmismatch : P<"failifmismatch", "">;
+def heap    : P<"heap", "Size of the heap">;
+def align   : P<"align", "Section alignment">;
+def libpath : P<"libpath", "Additional library search path">;
+def mllvm   : P<"mllvm", "Options to pass to LLVM">;
+def out     : P<"out", "Path to file to write output">;
+def stack   : P<"stack", "Size of the stack">;
+def machine : P<"machine", "Specify target platform">;
+def version : P<"version", "Specify a version number in the PE header">;
+def merge   : P<"merge", "Combine sections">;
+def section : P<"section", "Specify section attributes">;
+def subsystem : P<"subsystem", "Specify subsystem">;
+def stub    : P<"stub", "Specify DOS stub file">;
+def opt     : P<"opt", "Control optimizations">;
+def implib  : P<"implib", "Import library name">;
+def delayload : P<"delayload", "Delay loaded DLL name">;
+def pdb : P<"pdb", "PDB file path">;
+
+def manifest : F<"manifest">;
+def manifest_colon : P<"manifest", "Create manifest file">;
+def manifestuac : P<"manifestuac", "User access control">;
+def manifestfile : P<"manifestfile", "Manifest file path">;
+def manifestdependency : P<"manifestdependency",
+                           "Attributes for <dependency> in manifest file">;
+
+// We cannot use multiclass P because class name "incl" is different
+// from its command line option name. We do this because "include" is
+// a reserved keyword in tablegen.
+def incl : Joined<["/", "-"], "include:">,
+    HelpText<"Force symbol to be added to symbol table as undefined one">;
+
+// "def" is also a keyword.
+def deffile : Joined<["/", "-"], "def:">,
+    HelpText<"Use module-definition file">;
+
+def nodefaultlib_all : F<"nodefaultlib">;
+def noentry : F<"noentry">;
+def dll : F<"dll">;
+def verbose : F<"verbose">;
+def debug : F<"debug">;
+def swaprun_cd : F<"swaprun:cd">;
+def swaprun_net : F<"swaprun:net">;
+def profile : F<"profile">;
+
+def force : F<"force">,
+    HelpText<"Allow undefined symbols when creating executables">;
+def force_unresolved : F<"force:unresolved">;
+
+defm nxcompat : B<"nxcompat", "Disable data execution provention">;
+defm largeaddressaware : B<"largeaddressaware", "Disable large addresses">;
+defm allowbind: B<"allowbind", "Disable DLL binding">;
+defm fixed    : B<"fixed", "Enable base relocations">;
+defm tsaware  : B<"tsaware", "Create non-Terminal Server aware executable">;
+defm allowisolation : B<"allowisolation", "Set NO_ISOLATION bit">;
+defm dynamicbase : B<"dynamicbase",
+     "Disable address space layout randomization">;
+defm safeseh : B<"safeseh", "Produce an image with Safe Exception Handler">;
+defm highentropyva : B<"highentropyva", "Set HIGH_ENTROPY_VA bit">;
+
+def help : F<"help">;
+def help_q : Flag<["/?", "-?"], "">, Alias<help>;
+
+def DASH_DASH : Option<["--"], "", KIND_REMAINING_ARGS>;
+
+// Flag for debug
+def lldmoduledeffile : Joined<["/", "-"], "lldmoduledeffile:">;
+
+//==============================================================================
+// The flags below do nothing. They are defined only for link.exe compatibility.
+//==============================================================================
+
+class QF<string name> : Joined<["/", "-", "-?"], name#":">;
+
+multiclass QB<string name> {
+  def "" : F<name>;
+  def _no : F<name#":no">;
+}
+
+def functionpadmin : F<"functionpadmin">;
+def ignoreidl : F<"ignoreidl">;
+def incremental : F<"incremental">;
+def no_incremental : F<"incremental:no">;
+def nologo : F<"nologo">;
+
+def delay : QF<"delay">;
+def errorreport : QF<"errorreport">;
+def idlout : QF<"idlout">;
+def ignore : QF<"ignore">;
+def maxilksize : QF<"maxilksize">;
+def pdbaltpath : QF<"pdbaltpath">;
+def tlbid : QF<"tlbid">;
+def tlbout : QF<"tlbout">;
+def verbose_all : QF<"verbose">;
+
+defm wx : QB<"wx">;

COFF/README.md

+The New PE/COFF Linker
+======================
+
+This directory contains an experimental linker for the PE/COFF file
+format. Because the fundamental design of this port is different from
+the other ports of LLD, this port is separated to this directory.
+
+The other ports are based on the Atom model, in which symbols and
+references are represented as vertices and edges of graphs. The port
+in this directory is based on sections instead. The aim is
+simplicity and better performance. Our plan is to implement a linker
+for the PE/COFF format based on a different idea, and then apply the
+same idea to the ELF if proved to be effective.
+
+Overall Design
+--------------
+
+This is a list of important data types in this linker.
+
+* SymbolBody
+
+  SymbolBody is a class for symbols, which may be created for symbols
+  in object files or in archive file headers. The linker may create
+  them out of nothing.
+
+  There are mainly three types of SymbolBodies: Defined, Undefined, or
+  Lazy. Defined symbols are for all symbols that are considered as
+  "resolved", including real defined symbols, COMDAT symbols, common
+  symbols, absolute symbols, linker-created symbols, etc. Undefined
+  symbols are for undefined symbols, which need to be replaced by
+  Defined symbols by the resolver. Lazy symbols represent symbols we
+  found in archive file headers -- which can turn into Defined symbols
+  if we read archieve members, but we haven't done that yet.
+
+* Symbol
+
+  Symbol is a pointer to a SymbolBody. There's only one Symbol for
+  each unique symbol name (this uniqueness is guaranteed by the symbol
+  table). Because SymbolBodies are created for each file
+  independently, there can be many SymbolBodies for the same
+  name. Thus, the relationship between Symbols and SymbolBodies is 1:N.
+
+  The resolver keeps the Symbol's pointer to always point to the "best"
+  SymbolBody. Pointer mutation is the resolve operation in this
+  linker.
+
+  SymbolBodies have pointers to their Symbols. That means you can
+  always find the best SymbolBody from any SymbolBody by following
+  pointers twice. This structure makes it very easy to find
+  replacements for symbols. For example, if you have an Undefined
+  SymbolBody, you can find a Defined SymbolBody for that symbol just
+  by going to its Symbol and then to SymbolBody, assuming the resolver
+  have successfully resolved all undefined symbols.
+
+* Chunk
+
+  Chunk represents a chunk of data that will occupy space in an
+  output. They may be backed by sections of input files, but can be
+  created for something different, if they are for common or BSS
+  symbols. The linker may also create chunks out of nothing to append
+  additional data to an output.
+
+  Chunks know about their size, how to copy their data to mmap'ed
+  outputs, and how to apply relocations to them. Specifically,
+  section-based chunks know how to read relocation tables and how to
+  apply them.
+
+* SymbolTable
+
+  SymbolTable is basically a hash table from strings to Symbols, with
+  a logic to resolve symbol conflicts. It resolves conflicts by symbol
+  type. For example, if we add Undefined and Defined symbols, the
+  symbol table will keep the latter. If we add Undefined and Lazy
+  symbols, it will keep the latter. If we add Lazy and Undefined, it
+  will keep the former, but it will also trigger the Lazy symbol to
+  load the archive member to actually resolve the symbol.
+
+* OutputSection
+
+  OutputSection is a container of Chunks. A Chunk belongs to at most
+  one OutputSection.
+
+There are mainly three actors in this linker.
+
+* InputFile
+
+  InputFile is a superclass for file readers. We have a different
+  subclass for each input file type, such as regular object file,
+  archive file, etc. They are responsible for creating and owning
+  SymbolBodies and Chunks.
+
+* Writer
+
+  The writer is responsible for writing file headers and Chunks to a
+  file. It creates OutputSections, put all Chunks into them, assign
+  unique, non-overlapping addresses and file offsets to them, and then
+  write them down to a file.
+
+* Driver
+
+  The linking process is drived by the driver. The driver
+
+  - processes command line options,
+  - creates a symbol table,
+  - creates an InputFile for each input file and put all symbols in it
+    into the symbol table,
+  - checks if there's no remaining undefined symbols,
+  - creates a writer,
+  - and passes the symbol table to the writer to write the result to a
+    file.
+
+Performance
+-----------
+
+Currently it's able to self-host on the Windows platform. It takes 1.2
+seconds to self-host on my Xeon 2580 machine, while the existing
+Atom-based linker takes 5 seconds to self-host. We believe the
+performance difference comes from simplification and optimizations we
+made to the new port. Notable differences are listed below.
+
+* Reduced number of relocation table reads
+
+  In the existing design, relocation tables are read from beginning to
+  construct graphs because they consist of graph edges. In the new
+  design, they are not read until we actually apply relocations.
+
+  This simplification has two benefits. One is that we don't create
+  additional objects for relocations but instead consume relocation
+  tables directly. The other is that it reduces number of relocation
+  entries we have to read, because we won't read relocations for
+  dead-stripped COMDAT sections. Large C++ programs tend to consist of
+  lots of COMDAT sections. In the existing design, the time to process
+  relocation table is linear to size of input. In this new model, it's
+  linear to size of output.
+
+* Reduced number of symbol table lookup
+
+  Symbol table lookup can be a heavy operation because number of
+  symbols can be very large and each symbol name can be very long
+  (think of C++ mangled symbols -- time to compute a hash value for a
+  string is linear to the length.)
+
+  We look up the symbol table exactly only once for each symbol in the
+  new design. This is I believe the minimum possible number. This is
+  achieved by the separation of Symbol and SymbolBody. Once you get a
+  pointer to a Symbol by looking up the symbol table, you can always
+  get the latest symbol resolution result by just dereferencing a
+  pointer. (I'm not sure if the idea is new to the linker. At least,
+  all other linkers I've investigated so far seem to look up hash
+  tables or sets more than once for each new symbol, but I may be
+  wrong.)
+
+* Reduced number of file visits
+
+  The symbol table implements the Windows linker semantics. We treat
+  the symbol table as a bucket of all known symbols, including symbols
+  in archive file headers. We put all symbols into one bucket as we
+  visit new files. That means we visit each file only once.
+
+  This is different from the Unix linker semantics, in which we only
+  keep undefined symbols and visit each file one by one until we
+  resolve all undefined symbols. In the Unix model, we have to visit
+  archive files many times if there are circular dependencies between
+  archives.
+
+* Avoiding creating additional objects or copying data
+
+  The data structures described in the previous section are all thin
+  wrappers for classes that LLVM libObject provides. We avoid copying
+  data from libObject's objects to our objects. We read much less data
+  than before. For example, we don't read symbol values until we apply
+  relocations because these values are not relevant to symbol
+  resolution. Again, COMDAT symbols may be discarded during symbol
+  resolution, so reading their attributes too early could result in a
+  waste. We use underlying objects directly where doing so makes
+  sense.
+
+Parallelism
+-----------
+
+The abovementioned data structures are also chosen with
+multi-threading in mind. It should relatively be easy to make the
+symbol table a concurrent hash map, so that we let multiple workers
+work on symbol table concurrently. Symbol resolution in this design is
+a single pointer mutation, which allows the resolver work concurrently
+in a lock-free manner using atomic pointer compare-and-swap.
+
+It should also be easy to apply relocations and write chunks concurrently.
+
+We created an experimental multi-threaded linker using the Microsoft
+ConcRT concurrency library, and it was able to link itself in 0.5
+seconds, so we think the design is promising.

COFF/SymbolTable.h

+//===- SymbolTable.h ------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_SYMBOL_TABLE_H
+#define LLD_COFF_SYMBOL_TABLE_H
+
+#include "InputFiles.h"
+#include "Memory.h"
+#include "llvm/Support/Allocator.h"
+#include <unordered_map>
+
+namespace lld {
+namespace coff {
+
+// SymbolTable is a bucket of all known symbols, including defined,
+// undefined, or lazy symbols (the last one is symbols in archive
+// files whose archive members are not yet loaded).
+//
+// We put all symbols of all files to a SymbolTable, and the
+// SymbolTable selects the "best" symbols if there are name
+// conflicts. For example, obviously, a defined symbol is better than
+// an undefined symbol. Or, if there's a conflict between a lazy and a
+// undefined, it'll read an archive member to read a real definition
+// to replace the lazy symbol. The logic is implemented in resolve().
+class SymbolTable {
+public:
+  SymbolTable();
+
+  std::error_code addFile(std::unique_ptr<InputFile> File);
+
+  // Print an error message on undefined symbols.
+  bool reportRemainingUndefines();
+
+  // Returns a list of chunks of selected symbols.
+  std::vector<Chunk *> getChunks();
+
+  // Returns a symbol for a given name. It's not guaranteed that the
+  // returned symbol actually has the same name (because of various
+  // mechanisms to allow aliases, a name can be resolved to a
+  // different symbol). Returns a nullptr if not found.
+  SymbolBody *find(StringRef Name);
+
+  // Dump contents of the symbol table to stderr.
+  void dump();
+
+  // The writer needs to handle DLL import libraries specially in
+  // order to create the import descriptor table.
+  std::vector<std::unique_ptr<ImportFile>> ImportFiles;
+
+private:
+  std::error_code addObject(ObjectFile *File);
+  std::error_code addArchive(ArchiveFile *File);
+  std::error_code addImport(ImportFile *File);
+
+  std::error_code resolve(SymbolBody *Body);
+  std::error_code addMemberFile(Lazy *Body);
+  void addInitialSymbol(SymbolBody *Body);
+
+  std::unordered_map<StringRef, Symbol *> Symtab;
+  std::vector<std::unique_ptr<ObjectFile>> ObjectFiles;
+  std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
+  std::vector<std::unique_ptr<SymbolBody>> OwnedSymbols;
+  llvm::BumpPtrAllocator Alloc;
+  StringAllocator StringAlloc;
+};
+
+} // namespace pecoff
+} // namespace lld
+
+#endif

COFF/SymbolTable.cpp

+//===- SymbolTable.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 "SymbolTable.h"
+#include "lld/Core/Error.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace lld {
+namespace coff {
+
+SymbolTable::SymbolTable() {
+  addInitialSymbol(new DefinedAbsolute("__ImageBase", Config->ImageBase));
+  addInitialSymbol(new Undefined(Config->EntryName));
+}
+
+void SymbolTable::addInitialSymbol(SymbolBody *Body) {
+  OwnedSymbols.push_back(std::unique_ptr<SymbolBody>(Body));
+  Symtab[Body->getName()] = new (Alloc) Symbol(Body);
+}
+
+std::error_code SymbolTable::addFile(std::unique_ptr<InputFile> File) {
+  if (auto EC = File->parse())
+    return EC;
+  InputFile *FileP = File.release();
+  if (auto *P = dyn_cast<ObjectFile>(FileP))
+    return addObject(P);
+  if (auto *P = dyn_cast<ArchiveFile>(FileP))
+    return addArchive(P);
+  return addImport(cast<ImportFile>(FileP));
+}
+
+std::error_code SymbolTable::addObject(ObjectFile *File) {
+  ObjectFiles.emplace_back(File);
+  for (SymbolBody *Body : File->getSymbols())
+    if (Body->isExternal())
+      if (auto EC = resolve(Body))
+        return EC;
+
+  // If an object file contains .drectve section, read it and add
+  // files listed in the section.
+  StringRef Dir = File->getDirectives();
+  if (!Dir.empty()) {
+    std::vector<std::unique_ptr<InputFile>> Libs;
+    if (auto EC = parseDirectives(Dir, &Libs, &StringAlloc))
+      return EC;
+    for (std::unique_ptr<InputFile> &Lib : Libs)
+      addFile(std::move(Lib));
+  }
+  return std::error_code();
+}
+
+std::error_code SymbolTable::addArchive(ArchiveFile *File) {
+  ArchiveFiles.emplace_back(File);
+  for (SymbolBody *Body : File->getSymbols())
+    if (auto EC = resolve(Body))
+      return EC;
+  return std::error_code();
+}
+
+std::error_code SymbolTable::addImport(ImportFile *File) {
+  ImportFiles.emplace_back(File);
+  for (SymbolBody *Body : File->getSymbols())
+    if (auto EC = resolve(Body))
+      return EC;
+  return std::error_code();
+}
+
+bool SymbolTable::reportRemainingUndefines() {
+  bool Ret = false;
+  for (auto &I : Symtab) {
+    Symbol *Sym = I.second;
+    auto *Undef = dyn_cast<Undefined>(Sym->Body);
+    if (!Undef)
+      continue;
+    if (SymbolBody *Alias = Undef->getWeakAlias()) {
+      Sym->Body = Alias->getReplacement();
+      if (!isa<Defined>(Sym->Body)) {
+        llvm::errs() << "undefined symbol: " << Undef->getName() << "\n";
+        Ret = true;
+      }
+      continue;
+    }
+    llvm::errs() << "undefined symbol: " << Undef->getName() << "\n";
+    Ret = true;
+  }
+  return Ret;
+}
+
+// This function resolves conflicts if there's an existing symbol with
+// the same name. Decisions are made based on symbol type.
+std::error_code SymbolTable::resolve(SymbolBody *New) {
+  // Find an existing Symbol or create and insert a new one.
+  StringRef Name = New->getName();
+  Symbol *&Sym = Symtab[Name];
+  if (!Sym) {
+    Sym = new (Alloc) Symbol(New);
+    New->setBackref(Sym);
+    return std::error_code();
+  }
+  New->setBackref(Sym);
+
+  // compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
+  // equivalent (conflicting), or more preferable, respectively.
+  SymbolBody *Existing = Sym->Body;
+  int comp = Existing->compare(New);
+  if (comp < 0)
+    Sym->Body = New;
+  if (comp == 0)
+    return make_dynamic_error_code(Twine("duplicate symbol: ") + Name);
+
+  // If we have an Undefined symbol for a Lazy symbol, we need
+  // to read an archive member to replace the Lazy symbol with
+  // a Defined symbol.
+  if (isa<Undefined>(Existing) || isa<Undefined>(New))
+    if (auto *B = dyn_cast<Lazy>(Sym->Body))
+      return addMemberFile(B);
+  return std::error_code();
+}
+
+// Reads an archive member file pointed by a given symbol.
+std::error_code SymbolTable::addMemberFile(Lazy *Body) {
+  auto FileOrErr = Body->getMember();
+  if (auto EC = FileOrErr.getError())
+    return EC;
+  std::unique_ptr<InputFile> File = std::move(FileOrErr.get());
+
+  // getMember returns an empty buffer if the member was already
+  // read from the library.
+  if (!File)
+    return std::error_code();
+  if (Config->Verbose)
+    llvm::dbgs() << "Loaded " << File->getShortName() << " for "
+                 << Body->getName() << "\n";
+  return addFile(std::move(File));
+}
+
+std::vector<Chunk *> SymbolTable::getChunks() {
+  std::vector<Chunk *> Res;
+  for (std::unique_ptr<ObjectFile> &File : ObjectFiles) {
+    std::vector<Chunk *> &V = File->getChunks();
+    Res.insert(Res.end(), V.begin(), V.end());
+  }
+  return Res;
+}
+
+SymbolBody *SymbolTable::find(StringRef Name) {
+  auto It = Symtab.find(Name);
+  if (It == Symtab.end())
+    return nullptr;
+  return It->second->Body;
+}
+
+void SymbolTable::dump() {
+  for (auto &P : Symtab) {
+    StringRef Name = P.first;
+    Symbol *Ref = P.second;
+    if (auto *Body = dyn_cast<Defined>(Ref->Body))
+      llvm::dbgs() << Twine::utohexstr(Config->ImageBase + Body->getRVA())
+                   << " " << Body->getName() << "\n";
+  }
+}
+
+} // namespace coff
+} // namespace lld

COFF/Symbols.h

+//===- Symbols.h ----------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_SYMBOLS_H
+#define LLD_COFF_SYMBOLS_H
+
+#include "Chunks.h"
+#include "Config.h"
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/COFF.h"
+#include <memory>
+#include <vector>
+
+using llvm::object::Archive;
+using llvm::object::COFFSymbolRef;
+
+namespace lld {
+namespace coff {
+
+class ArchiveFile;
+class InputFile;
+class ObjectFile;
+class SymbolBody;
+
+// A real symbol object, SymbolBody, is usually accessed indirectly
+// through a Symbol. There's always one Symbol for each symbol name.
+// The resolver updates SymbolBody pointers as it resolves symbols.
+struct Symbol {
+  explicit Symbol(SymbolBody *P) : Body(P) {}
+  SymbolBody *Body;
+};
+
+// The base class for real symbol classes.
+class SymbolBody {
+public:
+  enum Kind {
+    DefinedFirst,
+    DefinedRegularKind,
+    DefinedAbsoluteKind,
+    DefinedImportDataKind,
+    DefinedImportThunkKind,
+    DefinedLast,
+    UndefinedKind,
+    LazyKind,
+  };
+
+  Kind kind() const { return SymbolKind; }
+  virtual ~SymbolBody() {}
+
+  // Returns true if this is an external symbol.
+  virtual bool isExternal() { return true; }
+
+  // Returns the symbol name.
+  StringRef getName() { return Name; }
+
+  // A SymbolBody has a backreference to a Symbol. Originally they are
+  // doubly-linked. A backreference will never change. But the pointer
+  // in the Symbol may be mutated by the resolver. If you have a
+  // pointer P to a SymbolBody and are not sure whether the resolver
+  // has chosen the object among other objects having the same name,
+  // you can access P->getSymbol()->Body to get the resolver's result.
+  void setBackref(Symbol *P) { Backref = P; }
+  SymbolBody *getReplacement() { return Backref ? Backref->Body : this; }
+
+  // Decides which symbol should "win" in the symbol table, this or
+  // the Other. Returns 1 if this wins, -1 if the Other wins, or 0 if
+  // they are duplicate (conflicting) symbols.
+  virtual int compare(SymbolBody *Other) = 0;
+
+protected:
+  SymbolBody(Kind K, StringRef N) : SymbolKind(K), Name(N) {}
+
+private:
+  const Kind SymbolKind;
+  StringRef Name;
+  Symbol *Backref = nullptr;
+};
+
+// The base class for any defined symbols, including absolute symbols,
+// etc.
+class Defined : public SymbolBody {
+public:
+  Defined(Kind K, StringRef Name) : SymbolBody(K, Name) {}
+
+  static bool classof(const SymbolBody *S) {
+    Kind K = S->kind();
+    return DefinedFirst <= K && K <= DefinedLast;
+  }
+
+  // Returns the RVA (relative virtual address) of this symbol. The
+  // writer sets and uses RVAs.
+  virtual uint64_t getRVA() = 0;
+
+  // Returns the file offset of this symbol in the final executable.
+  // The writer uses this information to apply relocations.
+  virtual uint64_t getFileOff() = 0;
+
+  // Called by the garbage collector. All Defined subclasses should
+  // know how to call markLive to dependent symbols.
+  virtual void markLive() {}
+
+  int compare(SymbolBody *Other) override;
+};
+
+// Regular defined symbols read from object file symbol tables.
+class DefinedRegular : public Defined {
+public:
+  DefinedRegular(ObjectFile *F, StringRef Name, COFFSymbolRef S, Chunk *C)
+      : Defined(DefinedRegularKind, Name), File(F), Sym(S), Data(C) {}
+
+  static bool classof(const SymbolBody *S) {
+    return S->kind() == DefinedRegularKind;
+  }
+
+  uint64_t getRVA() override { return Data->getRVA() + Sym.getValue(); }
+  bool isExternal() override { return Sym.isExternal(); }
+  void markLive() override { Data->markLive(); }
+  uint64_t getFileOff() override { return Data->getFileOff() + Sym.getValue(); }
+  bool isCOMDAT() const { return Data->isCOMDAT(); }
+
+  // Returns true if this is a common symbol.
+  bool isCommon() const { return Sym.isCommon(); }
+  uint32_t getCommonSize() const { return Sym.getValue(); }
+
+private:
+  ObjectFile *File;
+  COFFSymbolRef Sym;
+  Chunk *Data;
+};
+
+// Absolute symbols.
+class DefinedAbsolute : public Defined {
+public:
+  DefinedAbsolute(StringRef Name, uint64_t VA)
+      : Defined(DefinedAbsoluteKind, Name), RVA(VA - Config->ImageBase) {}
+
+  static bool classof(const SymbolBody *S) {
+    return S->kind() == DefinedAbsoluteKind;
+  }
+
+  uint64_t getRVA() override { return RVA; }
+  uint64_t getFileOff() override { llvm_unreachable("internal error"); }
+
+private:
+  uint64_t RVA;
+};
+
+// This class represents a symbol imported from a DLL. This has two
+// names for internal use and external use. The former is used for
+// name resolution, and the latter is used for the import descriptor
+// table in an output. The former has "__imp_" prefix.
+class DefinedImportData : public Defined {
+public:
+  DefinedImportData(StringRef D, StringRef ImportName, StringRef ExportName)
+      : Defined(DefinedImportDataKind, ImportName), DLLName(D),
+        ExpName(ExportName) {}
+
+  static bool classof(const SymbolBody *S) {
+    return S->kind() == DefinedImportDataKind;
+  }
+
+  uint64_t getRVA() override { return Location->getRVA(); }
+  uint64_t getFileOff() override { return Location->getFileOff(); }
+  StringRef getDLLName() { return DLLName; }
+  StringRef getExportName() { return ExpName; }
+  void setLocation(Chunk *AddressTable) { Location = AddressTable; }
+
+private:
+  StringRef DLLName;
+  StringRef ExpName;
+  Chunk *Location = nullptr;
+};
+
+// This class represents a symbol defined in an archive file. It is
+// created from an archive file header, and it knows how to load an
+// object file from an archive to replace itself with a defined
+// symbol. If the resolver finds both Undefined and Lazy for
+// the same name, it will ask the Lazy to load a file.
+class Lazy : public SymbolBody {
+public:
+  Lazy(ArchiveFile *F, const Archive::Symbol S)
+      : SymbolBody(LazyKind, S.getName()), File(F), Sym(S) {}
+
+  static bool classof(const SymbolBody *S) { return S->kind() == LazyKind; }
+
+  // Returns an object file for this symbol, or a nullptr if the file
+  // was already returned.
+  ErrorOr<std::unique_ptr<InputFile>> getMember();
+
+  int compare(SymbolBody *Other) override;
+
+private:
+  ArchiveFile *File;
+  const Archive::Symbol Sym;
+};
+
+// Undefined symbols.
+class Undefined : public SymbolBody {
+public:
+  explicit Undefined(StringRef Name, SymbolBody **S = nullptr)
+      : SymbolBody(UndefinedKind, Name), Alias(S) {}
+
+  static bool classof(const SymbolBody *S) {
+    return S->kind() == UndefinedKind;
+  }
+
+  // An undefined symbol can have a fallback symbol which gives an
+  // undefined symbol a second chance if it would remain undefined.
+  // If it remains undefined, it'll be replaced with whatever the
+  // Alias pointer points to.
+  SymbolBody *getWeakAlias() { return Alias ? *Alias : nullptr; }
+
+  int compare(SymbolBody *Other) override;
+
+private:
+  SymbolBody **Alias;
+};
+
+// Windows-specific classes.
+
+// This class represents a symbol for a jump table entry which jumps
+// to a function in a DLL. Linker are supposed to create such symbols
+// without "__imp_" prefix for all function symbols exported from
+// DLLs, so that you can call DLL functions as regular functions with
+// a regular name. A function pointer is given as a DefinedImportData.
+class DefinedImportThunk : public Defined {
+public:
+  DefinedImportThunk(StringRef Name, DefinedImportData *S)
+      : Defined(DefinedImportThunkKind, Name), Data(S) {}
+
+  static bool classof(const SymbolBody *S) {
+    return S->kind() == DefinedImportThunkKind;
+  }
+
+  uint64_t getRVA() override { return Data.getRVA(); }
+  uint64_t getFileOff() override { return Data.getFileOff(); }
+  Chunk *getChunk() { return &Data; }
+
+private:
+  DefinedImportData *ImpSymbol;
+  ImportThunkChunk Data;
+};
+
+} // namespace coff
+} // namespace lld
+
+#endif

COFF/Symbols.cpp

+//===- Symbols.cpp --------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InputFiles.h"
+#include "Symbols.h"
+#include "lld/Core/Error.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/raw_ostream.h"
+
+using namespace llvm::object;
+using llvm::sys::fs::identify_magic;
+using llvm::sys::fs::file_magic;
+
+namespace lld {
+namespace coff {
+
+// Returns 1, 0 or -1 if this symbol should take precedence over the
+// Other in the symbol table, tie or lose, respectively.
+int Defined::compare(SymbolBody *Other) {
+  if (!isa<Defined>(Other))
+    return 1;
+  auto *X = dyn_cast<DefinedRegular>(this);
+  auto *Y = dyn_cast<DefinedRegular>(Other);
+  if (!X || !Y)
+    return 0;
+
+  // Common symbols are weaker than other types of defined symbols.
+  if (X->isCommon() && Y->isCommon())
+    return (X->getCommonSize() < Y->getCommonSize()) ? -1 : 1;
+  // TODO: we are not sure if regular defined symbol and common
+  // symbols are allowed to have the same name.
+  if (X->isCommon())
+    return -1;
+  if (Y->isCommon())
+    return 1;
+
+  if (X->isCOMDAT() && Y->isCOMDAT())
+    return 1;
+  return 0;
+}
+
+int Lazy::compare(SymbolBody *Other) {
+  if (isa<Defined>(Other))
+    return -1;
+
+  // Undefined symbols with weak aliases will turn into defined
+  // symbols if they remain undefined, so we don't need to resolve
+  // such symbols.
+  if (auto *U = dyn_cast<Undefined>(Other))
+    if (U->getWeakAlias())
+      return -1;
+  return 1;
+}
+
+int Undefined::compare(SymbolBody *Other) {
+  if (isa<Defined>(Other))
+    return -1;
+  if (isa<Lazy>(Other))
+    return getWeakAlias() ? 1 : -1;
+  if (cast<Undefined>(Other)->getWeakAlias())
+    return -1;
+  return 1;
+}
+
+ErrorOr<std::unique_ptr<InputFile>> Lazy::getMember() {
+  auto MBRefOrErr = File->getMember(&Sym);
+  if (auto EC = MBRefOrErr.getError())
+    return EC;
+  MemoryBufferRef MBRef = MBRefOrErr.get();
+
+  // getMember returns an empty buffer if the member was already
+  // read from the library.
+  if (MBRef.getBuffer().empty())
+    return nullptr;
+
+  file_magic Magic = identify_magic(MBRef.getBuffer());
+  if (Magic == file_magic::coff_import_library)
+    return llvm::make_unique<ImportFile>(MBRef);
+
+  if (Magic != file_magic::coff_object)
+    return make_dynamic_error_code("unknown file type");
+
+  std::unique_ptr<ObjectFile> Obj(new ObjectFile(MBRef.getBufferIdentifier(), MBRef));
+  Obj->setParentName(File->getName());
+  return std::move(Obj);
+}
+}
+}

COFF/Writer.h

+//===- Writer.h -----------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_COFF_WRITER_H
+#define LLD_COFF_WRITER_H
+
+#include "InputFiles.h"
+#include "SymbolTable.h"
+#include "llvm/Support/FileOutputBuffer.h"
+#include <memory>
+#include <vector>
+
+namespace lld {
+namespace coff {
+
+// Mask for section types (code, data or bss) and permissions
+// (writable, readable or executable).
+const uint32_t PermMask = 0xF00000F0;
+
+// OutputSection represents a section in an output file. It's a
+// container of chunks. OutputSection and Chunk are 1:N relationship.
+// Chunks cannot belong to more than one OutputSections. The writer
+// creates multiple OutputSections and assign them unique,
+// non-overlapping file offsets and RVAs.
+class OutputSection {
+public:
+  OutputSection(StringRef Name, uint32_t SectionIndex);
+  void setRVA(uint64_t);
+  void setFileOffset(uint64_t);
+  void addChunk(Chunk *C);
+  StringRef getName() { return Name; }
+  uint64_t getSectionIndex() { return SectionIndex; }
+  std::vector<Chunk *> &getChunks() { return Chunks; }
+
+  const llvm::object::coff_section getHeader() { return Header; }
+  void addPermissions(uint32_t C);
+  uint32_t getPermissions() { return Header.Characteristics & PermMask; }
+  uint32_t getCharacteristics() { return Header.Characteristics; }
+  uint64_t getRVA() { return Header.VirtualAddress; }
+  uint64_t getFileOff() { return Header.PointerToRawData; }
+
+  // Returns the size of this section in an executable memory image.
+  // This may be smaller than the raw size (the raw size is multiple
+  // of disk sector size, so there may be padding at end), or may be
+  // larger (if that's the case, the loader reserves spaces after end
+  // of raw data).
+  uint64_t getVirtualSize() { return Header.VirtualSize; }
+
+  // Returns the size of the section in the output file.
+  uint64_t getRawSize() { return Header.SizeOfRawData; }
+
+private:
+  llvm::object::coff_section Header;
+  StringRef Name;
+  uint32_t SectionIndex;
+  std::vector<Chunk *> Chunks;
+};
+
+// The writer writes a SymbolTable result to a file.
+class Writer {
+public:
+  explicit Writer(SymbolTable *T) : Symtab(T) {}
+  std::error_code write(StringRef Path);
+
+private:
+  void markLive();
+  void createSections();
+  void createImportTables();
+  void assignAddresses();
+  void removeEmptySections();
+  std::error_code openFile(StringRef OutputPath);
+  void writeHeader();
+  void writeSections();
+  void applyRelocations();
+
+  OutputSection *findSection(StringRef Name);
+  OutputSection *createSection(StringRef Name);
+
+  uint32_t getSizeOfInitializedData();
+  std::map<StringRef, std::vector<DefinedImportData *>> binImports();
+
+  SymbolTable *Symtab;
+  std::unique_ptr<llvm::FileOutputBuffer> Buffer;
+  std::vector<std::unique_ptr<OutputSection>> OutputSections;
+  Chunk *ImportAddressTable = nullptr;
+  uint32_t ImportDirectoryTableSize = 0;
+  uint32_t ImportAddressTableSize = 0;
+
+  Defined *Entry;
+  uint64_t FileSize;
+  uint64_t SizeOfImage;
+  uint64_t SizeOfHeaders;
+
+  std::vector<std::unique_ptr<Chunk>> Chunks;
+};
+
+} // namespace pecoff
+} // namespace lld
+
+#endif

COFF/Writer.cpp

+//===- Writer.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Config.h"
+#include "Writer.h"
+#include "lld/Core/Error.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/raw_ostream.h"
+#include <algorithm>
+#include <functional>
+#include <map>
+#include <utility>
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::COFF;
+
+static const int PageSize = 4096;
+static const int FileAlignment = 512;
+static const int SectionAlignment = 4096;
+static const int DOSStubSize = 64;
+static const int NumberfOfDataDirectory = 16;
+static const int HeaderSize =
+    DOSStubSize + sizeof(PEMagic) + sizeof(coff_file_header) +
+    sizeof(pe32plus_header) + sizeof(data_directory) * NumberfOfDataDirectory;
+
+namespace lld {
+namespace coff {
+
+OutputSection::OutputSection(StringRef N, uint32_t SI)
+    : Name(N), SectionIndex(SI) {
+  memset(&Header, 0, sizeof(Header));
+  strncpy(Header.Name, Name.data(), std::min(Name.size(), size_t(8)));
+}
+
+void OutputSection::setRVA(uint64_t RVA) {
+  Header.VirtualAddress = RVA;
+  for (Chunk *C : Chunks)
+    C->setRVA(C->getRVA() + RVA);
+}
+
+void OutputSection::setFileOffset(uint64_t Off) {
+  // If a section has no actual data (i.e. BSS section), we want to
+  // set 0 to its PointerToRawData. Otherwise the output is rejected
+  // by the loader.
+  if (Header.SizeOfRawData == 0)
+    return;
+  Header.PointerToRawData = Off;
+  for (Chunk *C : Chunks)
+    C->setFileOff(C->getFileOff() + Off);
+}
+
+void OutputSection::addChunk(Chunk *C) {
+  Chunks.push_back(C);
+  uint64_t Off = Header.VirtualSize;
+  Off = RoundUpToAlignment(Off, C->getAlign());
+  C->setRVA(Off);
+  C->setFileOff(Off);
+  Off += C->getSize();
+  Header.VirtualSize = Off;
+  if (C->hasData())
+    Header.SizeOfRawData = RoundUpToAlignment(Off, FileAlignment);
+}
+
+void OutputSection::addPermissions(uint32_t C) {
+  Header.Characteristics = Header.Characteristics | (C & PermMask);
+}
+
+void Writer::markLive() {
+  Entry = cast<Defined>(Symtab->find(Config->EntryName));
+  Entry->markLive();
+  for (Chunk *C : Symtab->getChunks())
+    if (C->isRoot())
+      C->markLive();
+}
+
+void Writer::createSections() {
+  std::map<StringRef, std::vector<Chunk *>> Map;
+  for (Chunk *C : Symtab->getChunks()) {
+    if (!C->isLive()) {
+      if (Config->Verbose)
+        C->printDiscardedMessage();
+      continue;
+    }
+    // '$' and all following characters in input section names are
+    // discarded when determining output section. So, .text$foo
+    // contributes to .text, for example. See PE/COFF spec 3.2.
+    Map[C->getSectionName().split('$').first].push_back(C);
+  }
+
+  // Input sections are ordered by their names including '$' parts,
+  // which gives you some control over the output layout.
+  auto Comp = [](Chunk *A, Chunk *B) {
+    return A->getSectionName() < B->getSectionName();
+  };
+  for (auto &P : Map) {
+    StringRef SectionName = P.first;
+    std::vector<Chunk *> &Chunks = P.second;
+    std::stable_sort(Chunks.begin(), Chunks.end(), Comp);
+    auto Sec =
+        llvm::make_unique<OutputSection>(SectionName, OutputSections.size());
+    for (Chunk *C : Chunks) {
+      C->setOutputSection(Sec.get());
+      Sec->addChunk(C);
+      Sec->addPermissions(C->getPermissions());
+    }
+    OutputSections.push_back(std::move(Sec));
+  }
+}
+
+std::map<StringRef, std::vector<DefinedImportData *>> Writer::binImports() {
+  // Group DLL-imported symbols by DLL name because that's how symbols
+  // are layed out in the import descriptor table.
+  std::map<StringRef, std::vector<DefinedImportData *>> Res;
+  OutputSection *Text = createSection(".text");
+  for (std::unique_ptr<ImportFile> &P : Symtab->ImportFiles) {
+    for (SymbolBody *B : P->getSymbols()) {
+      if (auto *Import = dyn_cast<DefinedImportData>(B)) {
+        Res[Import->getDLLName()].push_back(Import);
+        continue;
+      }
+      // Linker-created function thunks for DLL symbols are added to
+      // .text section.
+      Text->addChunk(cast<DefinedImportThunk>(B)->getChunk());
+    }
+  }
+
+  // Sort symbols by name for each group.
+  auto Comp = [](DefinedImportData *A, DefinedImportData *B) {
+    return A->getName() < B->getName();
+  };
+  for (auto &P : Res) {
+    std::vector<DefinedImportData *> &V = P.second;
+    std::sort(V.begin(), V.end(), Comp);
+  }
+  return Res;
+}
+
+// Create .idata section contents.
+void Writer::createImportTables() {
+  if (Symtab->ImportFiles.empty())
+    return;
+
+  std::vector<ImportTable> Tabs;
+  for (auto &P : binImports()) {
+    StringRef DLLName = P.first;
+    std::vector<DefinedImportData *> &Imports = P.second;
+    Tabs.emplace_back(DLLName, Imports);
+  }
+  OutputSection *Idata = createSection(".idata");
+  size_t NumChunks = Idata->getChunks().size();
+
+  // Add the directory tables.
+  for (ImportTable &T : Tabs)
+    Idata->addChunk(T.DirTab);
+  Idata->addChunk(new NullChunk(sizeof(ImportDirectoryTableEntry)));
+  ImportDirectoryTableSize = (Tabs.size() + 1) * sizeof(ImportDirectoryTableEntry);
+
+  // Add the import lookup tables.
+  for (ImportTable &T : Tabs) {
+    for (LookupChunk *C : T.LookupTables)
+      Idata->addChunk(C);
+    Idata->addChunk(new NullChunk(sizeof(uint64_t)));
+  }
+
+  // Add the import address tables. Their contents are the same as the
+  // lookup tables.
+  for (ImportTable &T : Tabs) {
+    for (LookupChunk *C : T.AddressTables)
+      Idata->addChunk(C);
+    Idata->addChunk(new NullChunk(sizeof(uint64_t)));
+    ImportAddressTableSize += (T.AddressTables.size() + 1) * sizeof(uint64_t);
+  }
+  ImportAddressTable = Tabs[0].AddressTables[0];
+
+  // Add the hint name table.
+  for (ImportTable &T : Tabs)
+    for (HintNameChunk *C : T.HintNameTables)
+      Idata->addChunk(C);
+
+  // Add DLL names.
+  for (ImportTable &T : Tabs)
+    Idata->addChunk(T.DLLName);
+
+  // Claim ownership of all chunks in the .idata section.
+  for (size_t I = NumChunks, E = Idata->getChunks().size(); I < E; ++I)
+    Chunks.push_back(std::unique_ptr<Chunk>(Idata->getChunks()[I]));
+}
+
+// The Windows loader doesn't seem to like empty sections,
+// so we remove them if any.
+void Writer::removeEmptySections() {
+  auto IsEmpty = [](const std::unique_ptr<OutputSection> &S) {
+    return S->getVirtualSize() == 0;
+  };
+  OutputSections.erase(
+      std::remove_if(OutputSections.begin(), OutputSections.end(), IsEmpty),
+      OutputSections.end());
+}
+
+// Visits all sections to assign incremental, non-overlapping RVAs and
+// file offsets.
+void Writer::assignAddresses() {
+  SizeOfHeaders = RoundUpToAlignment(
+      HeaderSize + sizeof(coff_section) * OutputSections.size(), PageSize);
+  uint64_t RVA = 0x1000; // The first page is kept unmapped.
+  uint64_t FileOff = SizeOfHeaders;
+  for (std::unique_ptr<OutputSection> &Sec : OutputSections) {
+    Sec->setRVA(RVA);
+    Sec->setFileOffset(FileOff);
+    RVA += RoundUpToAlignment(Sec->getVirtualSize(), PageSize);
+    FileOff += RoundUpToAlignment(Sec->getRawSize(), FileAlignment);
+  }
+  SizeOfImage = SizeOfHeaders + RoundUpToAlignment(RVA - 0x1000, PageSize);
+  FileSize = SizeOfHeaders +
+             RoundUpToAlignment(FileOff - SizeOfHeaders, FileAlignment);
+}
+
+void Writer::writeHeader() {
+  // Write DOS stub
+  uint8_t *Buf = Buffer->getBufferStart();
+  auto *DOS = reinterpret_cast<dos_header *>(Buf);
+  Buf += DOSStubSize;
+  DOS->Magic[0] = 'M';
+  DOS->Magic[1] = 'Z';
+  DOS->AddressOfRelocationTable = sizeof(dos_header);
+  DOS->AddressOfNewExeHeader = DOSStubSize;
+
+  // Write PE magic
+  memcpy(Buf, PEMagic, sizeof(PEMagic));
+  Buf += sizeof(PEMagic);
+
+  // Write COFF header
+  coff_file_header *COFF = reinterpret_cast<coff_file_header *>(Buf);
+  Buf += sizeof(coff_file_header);
+  COFF->Machine = IMAGE_FILE_MACHINE_AMD64;
+  COFF->NumberOfSections = OutputSections.size();
+  COFF->Characteristics =
+      (IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_RELOCS_STRIPPED |
+       IMAGE_FILE_LARGE_ADDRESS_AWARE);
+  COFF->SizeOfOptionalHeader =
+      sizeof(pe32plus_header) + sizeof(data_directory) * NumberfOfDataDirectory;
+
+  // Write PE header
+  pe32plus_header *PE = reinterpret_cast<pe32plus_header *>(Buf);
+  Buf += sizeof(pe32plus_header);
+  PE->Magic = PE32Header::PE32_PLUS;
+  PE->ImageBase = Config->ImageBase;
+  PE->SectionAlignment = SectionAlignment;
+  PE->FileAlignment = FileAlignment;
+  PE->MajorOperatingSystemVersion = 6;
+  PE->MajorSubsystemVersion = 6;
+  PE->Subsystem = IMAGE_SUBSYSTEM_WINDOWS_CUI;
+  PE->SizeOfImage = SizeOfImage;
+  PE->SizeOfHeaders = SizeOfHeaders;
+  PE->AddressOfEntryPoint = Entry->getRVA();
+  PE->SizeOfStackReserve = 1024 * 1024;
+  PE->SizeOfStackCommit = 4096;
+  PE->SizeOfHeapReserve = 1024 * 1024;
+  PE->SizeOfHeapCommit = 4096;
+  PE->NumberOfRvaAndSize = NumberfOfDataDirectory;
+  if (OutputSection *Text = findSection(".text")) {
+    PE->BaseOfCode = Text->getRVA();
+    PE->SizeOfCode = Text->getRawSize();
+  }
+  PE->SizeOfInitializedData = getSizeOfInitializedData();
+
+  // Write data directory
+  data_directory *DataDirectory = reinterpret_cast<data_directory *>(Buf);
+  Buf += sizeof(data_directory) * NumberfOfDataDirectory;
+  if (OutputSection *Idata = findSection(".idata")) {
+    using namespace llvm::COFF;
+    DataDirectory[IMPORT_TABLE].RelativeVirtualAddress = Idata->getRVA();
+    DataDirectory[IMPORT_TABLE].Size = ImportDirectoryTableSize;
+    DataDirectory[IAT].RelativeVirtualAddress = ImportAddressTable->getRVA();
+    DataDirectory[IAT].Size = ImportAddressTableSize;
+  }
+
+  // Write section table
+  coff_section *SectionTable = reinterpret_cast<coff_section *>(Buf);
+  int Idx = 0;
+  for (std::unique_ptr<OutputSection> &Out : OutputSections)
+    SectionTable[Idx++] = Out->getHeader();
+}
+
+std::error_code Writer::openFile(StringRef Path) {
+  if (auto EC = FileOutputBuffer::create(Path, FileSize, Buffer,
+                                         FileOutputBuffer::F_executable))
+    return make_dynamic_error_code(Twine("Failed to open ") + Path + ": " +
+                                   EC.message());
+  return std::error_code();
+}
+
+// Write section contents to a mmap'ed file.
+void Writer::writeSections() {
+  uint8_t *Buf = Buffer->getBufferStart();
+  for (std::unique_ptr<OutputSection> &Sec : OutputSections) {
+    // Fill gaps between functions in .text with INT3 instructions
+    // instead of leaving as NUL bytes (which can be interpreted as
+    // ADD instructions).
+    if (Sec->getPermissions() & IMAGE_SCN_CNT_CODE)
+      memset(Buf + Sec->getFileOff(), 0xCC, Sec->getRawSize());
+    for (Chunk *C : Sec->getChunks())
+      if (C->hasData())
+        memcpy(Buf + C->getFileOff(), C->getData(), C->getSize());
+  }
+}
+
+OutputSection *Writer::findSection(StringRef Name) {
+  for (std::unique_ptr<OutputSection> &Sec : OutputSections)
+    if (Sec->getName() == Name)
+      return Sec.get();
+  return nullptr;
+}
+
+uint32_t Writer::getSizeOfInitializedData() {
+  uint32_t Res = 0;
+  for (std::unique_ptr<OutputSection> &S : OutputSections)
+    if (S->getPermissions() & IMAGE_SCN_CNT_INITIALIZED_DATA)
+      Res += S->getRawSize();
+  return Res;
+}
+
+// Returns an existing section or create a new one if not found.
+OutputSection *Writer::createSection(StringRef Name) {
+  if (auto *Sec = findSection(Name))
+    return Sec;
+  const auto R = IMAGE_SCN_MEM_READ;
+  const auto W = IMAGE_SCN_MEM_WRITE;
+  const auto E = IMAGE_SCN_MEM_EXECUTE;
+  uint32_t Perm = StringSwitch<uint32_t>(Name)
+                      .Case(".bss", IMAGE_SCN_CNT_UNINITIALIZED_DATA | R | W)
+                      .Case(".data", IMAGE_SCN_CNT_INITIALIZED_DATA | R | W)
+                      .Case(".idata", IMAGE_SCN_CNT_INITIALIZED_DATA | R)
+                      .Case(".rdata", IMAGE_SCN_CNT_INITIALIZED_DATA | R)
+                      .Case(".text", IMAGE_SCN_CNT_CODE | R | E)
+                      .Default(0);
+  if (!Perm)
+    llvm_unreachable("unknown section name");
+  auto Sec = new OutputSection(Name, OutputSections.size());
+  Sec->addPermissions(Perm);
+  OutputSections.push_back(std::unique_ptr<OutputSection>(Sec));
+  return Sec;
+}
+
+void Writer::applyRelocations() {
+  uint8_t *Buf = Buffer->getBufferStart();
+  for (std::unique_ptr<OutputSection> &Sec : OutputSections)
+    for (Chunk *C : Sec->getChunks())
+      C->applyRelocations(Buf);
+}
+
+std::error_code Writer::write(StringRef OutputPath) {
+  markLive();
+  createSections();
+  createImportTables();
+  assignAddresses();
+  removeEmptySections();
+  if (auto EC = openFile(OutputPath))
+    return EC;
+  writeHeader();
+  writeSections();
+  applyRelocations();
+  if (auto EC = Buffer->commit())
+    return EC;
+  return std::error_code();
+}
+
+} // namespace coff
+} // namespace lld

include/lld/Driver/Driver.h

   WinLinkDriver() = delete;
 };
 
+/// Driver for Windows 'link.exe' command line options
+namespace coff {
+bool link(int argc, const char *argv[]);
+}
+
 /// Driver for lld unit tests
 class CoreDriver : public Driver {
 public:

lib/Driver/UniversalDriver.cpp

   invalid,
   gnu_ld,    // -flavor gnu
   win_link,  // -flavor link
+  win_link2, // -flavor link2
   darwin_ld, // -flavor darwin
   core       // -flavor core OR -core
 };

       .Case("gnu", Flavor::gnu_ld)
       .Case("link", Flavor::win_link)
       .Case("lld-link", Flavor::win_link)
+      .Case("link2", Flavor::win_link2)
+      .Case("lld-link2", Flavor::win_link2)
       .Case("darwin", Flavor::darwin_ld)
       .Case("core", Flavor::core)
       .Case("ld", Flavor::gnu_ld)

     return DarwinLdDriver::linkMachO(args.size(), args.data(), diagnostics);
   case Flavor::win_link:
     return WinLinkDriver::linkPECOFF(args.size(), args.data(), diagnostics);
+  case Flavor::win_link2:
+    return coff::link(args.size(), args.data());
   case Flavor::core:
     return CoreDriver::link(args.size(), args.data(), diagnostics);
   case Flavor::invalid:

test/COFF/Inputs/hello64.asm

+;; ml64 hello64.asm /link /subsystem:windows /defaultlib:kernel32 \
+;;    /defaultlib:user32 /out:hello64.exe /entry:main
+
+extern ExitProcess : PROC
+extern MessageBoxA : PROC
+
+.data
+        caption db 'Hello', 0
+        message db 'Hello World!', 0
+
+.code
+main PROC
+        sub rsp,28h
+        mov rcx, 0
+        lea rdx, message
+        lea r8, caption
+        mov r9d, 0
+        call MessageBoxA
+        mov ecx, 0
+        call ExitProcess
+main ENDP
+END

test/COFF/driver.test

+# RUN: not lld -flavor link2 nosuchfile.obj >& %t.log
+# RUN: FileCheck -check-prefix=MISSING %s < %t.log
+MISSING: nosuchfile.obj: no such file or directory
+
+# RUN: lld -flavor link2 /entry:main /out:%t.exe %p/Inputs/ret42.obj

test/COFF/imports.test

+# Verify that the lld can handle .lib files and emit .idata sections.
+#
+# RUN: lld -flavor link2 /out:%t.exe /entry:main %p/Inputs/hello64.obj \
+# RUN:   %p/Inputs/std64.lib
+# RUN: llvm-objdump -d %t.exe | FileCheck -check-prefix=TEXT %s
+# RUN: llvm-readobj -coff-imports %t.exe | FileCheck -check-prefix=IMPORT %s
+
+TEXT: Disassembly of section .text:
+TEXT-NEXT: .text:
+TEXT-NEXT: subq    $40, %rsp
+TEXT-NEXT: movq    $0, %rcx
+TEXT-NEXT: leaq    -4108(%rip), %rdx
+TEXT-NEXT: leaq    -4121(%rip), %r8
+TEXT-NEXT: movl    $0, %r9d
+TEXT-NEXT: callq   16
+TEXT-NEXT: movl    $0, %ecx
+TEXT-NEXT: callq   0
+TEXT-NEXT: jmpq    *4108(%rip)
+TEXT-NEXT: jmpq    *4110(%rip)
+
+IMPORT:      Import {
+IMPORT-NEXT:   Name: std64.dll
+IMPORT-NEXT:   ImportLookupTableRVA: 0x3028
+IMPORT-NEXT:   ImportAddressTableRVA: 0x3040
+IMPORT-NEXT:   Symbol: ExitProcess (0)
+IMPORT-NEXT:   Symbol: MessageBoxA (0)
+IMPORT-NEXT: }

tools/lld/CMakeLists.txt

 
 target_link_libraries(lld
   lldDriver
+  lldCOFF
   LLVMSupport
   )
 

unittests/DriverTests/CMakeLists.txt

 
 target_link_libraries(DriverTests
   lldDriver
+  lldCOFF
   lldCore
   lldPECOFF
   lldMachO