Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt
+++ CMakeLists.txt
@@ -221,4 +221,4 @@
 add_subdirectory(docs)
 add_subdirectory(COFF)
 add_subdirectory(ELF)
-
+add_subdirectory(wasm)
Index: CODE_OWNERS.TXT
===================================================================
--- CODE_OWNERS.TXT
+++ CODE_OWNERS.TXT
@@ -17,3 +17,6 @@
 E: lhames@gmail.com, kledzik@apple.com
 D: Mach-O backend
 
+N: Sam Clegg
+E: sbc@chromium.org
+D: WebAssembly backend (wasm/*)
Index: include/lld/Driver/Driver.h
===================================================================
--- include/lld/Driver/Driver.h
+++ include/lld/Driver/Driver.h
@@ -28,6 +28,11 @@
 bool link(llvm::ArrayRef<const char *> Args,
           llvm::raw_ostream &Diag = llvm::errs());
 }
+
+namespace wasm {
+bool link(llvm::ArrayRef<const char *> Args,
+          llvm::raw_ostream &Diag = llvm::errs());
+}
 }
 
 #endif
Index: test/lit.cfg
===================================================================
--- test/lit.cfg
+++ test/lit.cfg
@@ -162,6 +162,7 @@
                  r"\bnot\b",
                  NoPreJunk + r"\blld\b" + NoPostJunk,
                  r"\bld.lld\b",
+                 r"\bllc\b",
                  r"\blld-link\b",
                  r"\bllvm-as\b",
                  r"\bllvm-mc\b",
Index: test/wasm/Inputs/allow-undefined.txt
===================================================================
--- /dev/null
+++ test/wasm/Inputs/allow-undefined.txt
@@ -0,0 +1 @@
+foo
Index: test/wasm/Inputs/archive1.ll
===================================================================
--- /dev/null
+++ test/wasm/Inputs/archive1.ll
@@ -0,0 +1,7 @@
+declare i32 @bar() local_unnamed_addr #1
+
+define i32 @foo() local_unnamed_addr #0 {
+entry:
+  %call = tail call i32 @bar() #2
+  ret i32 %call
+}
Index: test/wasm/Inputs/archive2.ll
===================================================================
--- /dev/null
+++ test/wasm/Inputs/archive2.ll
@@ -0,0 +1,7 @@
+declare i32 @foo() local_unnamed_addr #1
+
+define i32 @bar() local_unnamed_addr #0 {
+entry:
+  %call = tail call i32 @foo() #2
+  ret i32 %call
+}
Index: test/wasm/Inputs/call-indirect.ll
===================================================================
--- /dev/null
+++ test/wasm/Inputs/call-indirect.ll
@@ -0,0 +1,18 @@
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+@indirect_bar = hidden local_unnamed_addr global i32 ()* @bar, align 4
+
+; Function Attrs: norecurse nounwind readnone
+define hidden i32 @bar() #0 {
+entry:
+  ret i32 1
+}
+
+; Function Attrs: nounwind
+define hidden void @call_bar_indirect() local_unnamed_addr #1 {
+entry:
+  %0 = load i32 ()*, i32 ()** @indirect_bar, align 4
+  %call = tail call i32 %0() #2
+  ret void
+}
Index: test/wasm/Inputs/hello.ll
===================================================================
--- /dev/null
+++ test/wasm/Inputs/hello.ll
@@ -0,0 +1,18 @@
+; Wasm module generated from the following C code:
+;   void puts(const char*);
+;   void hello() { puts("hello\n"); }
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+@.str = private unnamed_addr constant [7 x i8] c"hello\0A\00", align 1
+
+; Function Attrs: nounwind
+define hidden void @hello() local_unnamed_addr #0 {
+entry:
+  tail call void @puts(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i32 0, i32 0))
+  ret void
+}
+
+; Function Attrs: nounwind
+declare void @puts(i8* nocapture readonly) local_unnamed_addr #1
Index: test/wasm/Inputs/ret32.ll
===================================================================
--- /dev/null
+++ test/wasm/Inputs/ret32.ll
@@ -0,0 +1,9 @@
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+; Function Attrs: norecurse nounwind readnone
+define hidden i32 @ret32(float %arg) #0 {
+entry:
+    ret i32 0
+     ; ptrtoint (i32 (float)* @ret32 to i32)
+}
Index: test/wasm/Inputs/ret64.ll
===================================================================
--- /dev/null
+++ test/wasm/Inputs/ret64.ll
@@ -0,0 +1,7 @@
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+define hidden i64 @ret64(double %arg) local_unnamed_addr #0 {
+entry:
+    ret i64 1
+}
Index: test/wasm/Inputs/weak-alias.ll
===================================================================
--- /dev/null
+++ test/wasm/Inputs/weak-alias.ll
@@ -0,0 +1,13 @@
+define i32 @foo() #0 {
+entry:
+  ret i32 0
+}
+
+@bar = weak alias i32 (), i32 ()* @foo
+
+define hidden i32 @call_bar() #0 {
+entry:
+  %call = call i32 @bar()
+  ret i32 %call
+}
+
Index: test/wasm/archive.ll
===================================================================
--- /dev/null
+++ test/wasm/archive.ll
@@ -0,0 +1,25 @@
+; Verify that multually dependant object files in an archive is handled
+; correctly.
+;
+; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %s -o %t.o
+; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %S/Inputs/archive1.ll -o %t2.o
+; RUN: llc -filetype=obj -mtriple=wasm32-unknown-uknown-wasm %S/Inputs/archive2.ll -o %t3.o
+; RUN: llvm-ar rcs %t.a %t2.o %t3.o
+; RUN: lld -flavor wasm %t.a %t.o -o %t.wasm
+; RUN: llvm-nm -a %t.wasm | FileCheck %s
+
+; Specifying the same archive twice is allowed.
+; RUN: lld -flavor wasm %t.a %t.a %t.o -o %t.wasm
+
+declare i32 @foo() local_unnamed_addr #1
+
+define i32 @_start() local_unnamed_addr #0 {
+entry:
+  %call = tail call i32 @foo() #2
+  ret i32 %call
+}
+
+; CHECK: t _start
+; CHECK: t bar
+; CHECK: t foo
+; CHECK: T main
Index: test/wasm/call-indirect.ll
===================================================================
--- /dev/null
+++ test/wasm/call-indirect.ll
@@ -0,0 +1,109 @@
+; RUN: llc -filetype=obj %p/Inputs/call-indirect.ll -o %t2.o
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -o %t.wasm %t2.o %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; bitcode generated from the following C code:
+; int foo(void) { return 1; }
+; int (*indirect_func)(void) = &foo;
+; void _start(void) { indirect_func(); }
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+@indirect_func = hidden local_unnamed_addr global i32 ()* @foo, align 4
+
+; Function Attrs: norecurse nounwind readnone
+define hidden i32 @foo() #0 {
+entry:
+  ret i32 1
+}
+
+; Function Attrs: nounwind
+define hidden void @_start() local_unnamed_addr #1 {
+entry:
+  %0 = load i32 ()*, i32 ()** @indirect_func, align 4
+  %call = tail call i32 %0() #2
+  ret void
+}
+
+; CHECK:      !WASM
+; CHECK-NEXT: FileHeader:      
+; CHECK-NEXT:   Version:         0x00000001
+; CHECK-NEXT: Sections:        
+; CHECK-NEXT:   - Type:            TYPE
+; CHECK-NEXT:     Signatures:      
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         ReturnType:      I32
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:   - Type:            FUNCTION
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 1 ]
+; CHECK-NEXT:   - Type:            TABLE
+; CHECK-NEXT:     Tables:          
+; CHECK-NEXT:       - ElemType:        ANYFUNC
+; CHECK-NEXT:         Limits:          
+; CHECK-NEXT:           Flags:           0x00000001
+; CHECK-NEXT:           Initial:         0x00000003
+; CHECK-NEXT:           Maximum:         0x00000003
+; CHECK-NEXT:   - Type:            MEMORY
+; CHECK-NEXT:     Memories:        
+; CHECK-NEXT:       - Initial:         0x00000002
+; CHECK-NEXT:   - Type:            GLOBAL
+; CHECK-NEXT:     Globals:         
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         true
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           66576
+; CHECK-NEXT:   - Type:            EXPORT
+; CHECK-NEXT:     Exports:         
+; CHECK-NEXT:       - Name:            memory
+; CHECK-NEXT:         Kind:            MEMORY
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            main
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           3
+; CHECK:        - Type:            ELEM
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1
+; CHECK-NEXT:         Functions:       [ 0, 2 ]
+; CHECK-NEXT:   - Type:            CODE
+; CHECK-NEXT:     Functions:       
+; CHECK:            - Locals:          
+; CHECK:            - Locals:          
+; CHECK:            - Locals:          
+; CHECK:        - Type:            DATA
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - SectionOffset:    7
+; CHECK-NEXT:         MemoryIndex:      0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1024
+; CHECK-NEXT:         Content:         '01000000'
+; CHECK-NEXT:       - SectionOffset:    17
+; CHECK-NEXT:         MemoryIndex:      0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1028
+; CHECK-NEXT:         Content:         '02000000'
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        8
+; CHECK-NEXT:     DataAlignment:   0
+; CHECK-NEXT:     SymbolInfo:      
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            name
+; CHECK-NEXT:     FunctionNames:   
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            bar
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Name:            call_bar_indirect
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Name:            foo
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Name:            _start
Index: test/wasm/conflict.test
===================================================================
--- /dev/null
+++ test/wasm/conflict.test
@@ -0,0 +1,4 @@
+# RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+# RUN: not lld -flavor wasm -o %t.wasm %t.ret32.o %t.ret32.o 2>&1 | FileCheck %s
+
+# CHECK:      duplicate symbol: ret32
Index: test/wasm/data-layout.ll
===================================================================
--- /dev/null
+++ test/wasm/data-layout.ll
@@ -0,0 +1,49 @@
+; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -r -o %t.wasm %t.hello.o %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+@foo = hidden global i32 1, align 4
+@aligned_bar = hidden global i32 3, align 16
+
+; CHECK:        - Type:            GLOBAL
+; CHECK-NEXT:     Globals:         
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           16
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           32
+
+; CHECK:       - Type:            DATA
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - SectionOffset:     6
+; CHECK-NEXT:         MemoryIndex:       0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:         Content:         68656C6C6F0A00
+; CHECK-NEXT:       - SectionOffset:     18
+; CHECK-NEXT:         MemoryIndex:       0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           16
+; CHECK-NEXT:         Content:         '0100000000000000000000000000000003000000'
+
+; CHECK:       - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        36
+; CHECK-NEXT:     DataAlignment:   16
+; CHECK-NEXT:     SymbolInfo:      
Index: test/wasm/entry.ll
===================================================================
--- /dev/null
+++ test/wasm/entry.ll
@@ -0,0 +1,22 @@
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -e entry -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+; RUN: lld -flavor wasm --entry=entry -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+define hidden void @entry() local_unnamed_addr #0 {
+entry:
+  ret void
+}
+
+; CHECK:   - Type:            EXPORT
+; CHECK:     Exports:         
+; CHECK:       - Name:            memory
+; CHECK:         Kind:            MEMORY
+; CHECK:         Index:           0
+; CHECK:       - Name:            main
+; CHECK:         Kind:            FUNCTION
+; CHECK:         Index:           0
Index: test/wasm/function-imports-first.ll
===================================================================
--- /dev/null
+++ test/wasm/function-imports-first.ll
@@ -0,0 +1,34 @@
+; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -o %t.wasm %t.o %t.ret32.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+; Function Attrs: nounwind
+define hidden void @_start() local_unnamed_addr #0 {
+entry:
+  %call = tail call i32 @ret32(float 0.000000e+00) #2
+  ret void
+}
+
+declare i32 @ret32(float) local_unnamed_addr #1
+
+; CHECK:  - Type:            TYPE
+; CHECK:    Signatures:
+; CHECK-NEXT:      - Index:           0
+; CHECK-NEXT:        ReturnType:      NORESULT
+; CHECK-NEXT:        ParamTypes:
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        ReturnType:      I32
+; CHECK-NEXT:        ParamTypes:
+; CHECK-NEXT:          - F32
+; CHECK:  - Type:            FUNCTION
+; CHECK-NEXT:    FunctionTypes: [ 0, 1 ]
+; CHECK:  - Type:            CODE
+; CHECK-NEXT:    Functions:
+; CHECK-NEXT:      - Locals:
+; CHECK-NEXT:        Body:            43000000001081808080001A0B
+; CHECK-NEXT:      - Locals:
+; CHECK-NEXT:        Body:            41000B
Index: test/wasm/function-imports.ll
===================================================================
--- /dev/null
+++ test/wasm/function-imports.ll
@@ -0,0 +1,39 @@
+; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -o %t.wasm %t.ret32.o %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+; Function Attrs: nounwind
+define hidden void @_start() local_unnamed_addr #0 {
+entry:
+  %call = tail call i32 @ret32(float 0.000000e+00) #2
+  ret void
+}
+
+declare i32 @ret32(float) local_unnamed_addr #1
+
+; CHECK:      Sections:
+; CHECK:       - Type:            TYPE
+; CHECK-NEXT:    Signatures:
+; CHECK-NEXT:      - Index:           0
+; CHECK-NEXT:        ReturnType:      I32
+; CHECK-NEXT:        ParamTypes:
+; CHECK-NEXT:          - F32
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        ReturnType:      NORESULT
+; CHECK-NEXT:        ParamTypes:
+; CHECK-NEXT:  - Type:            FUNCTION
+; CHECK-NEXT:    FunctionTypes:   [ 0, 1 ]
+; CHECK:       - Type:            CODE
+; CHECK-NEXT:    Functions:
+; CHECK:           - Locals:
+; CHECK:           - Locals:
+; CHECK:         Name:            name
+; CHECK-NEXT:    FunctionNames:
+; CHECK-NEXT:      - Index:           0
+; CHECK-NEXT:        Name:            ret32
+; CHECK-NEXT:      - Index:           1
+; CHECK-NEXT:        Name:            _start
Index: test/wasm/function-index.test
===================================================================
--- /dev/null
+++ test/wasm/function-index.test
@@ -0,0 +1,18 @@
+# RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+# RUN: llc -filetype=obj %p/Inputs/ret64.ll -o %t.ret64.o
+# RUN: lld -flavor wasm -r -o %t.wasm %t.ret32.o %t.ret64.o
+# RUN: obj2yaml %t.wasm | FileCheck %s
+
+CHECK: Sections:
+CHECK:   - Type:            TYPE
+CHECK:     Signatures:
+CHECK:       - Index:           0
+CHECK:         ReturnType:      I32
+CHECK:         ParamTypes:
+CHECK:           - F32
+CHECK:       - Index:           1
+CHECK:         ReturnType:      I64
+CHECK:         ParamTypes:
+CHECK:           - F64
+CHECK: - Type:            FUNCTION
+CHECK:   FunctionTypes: [ 0, 1 ]
Index: test/wasm/import-memory.test
===================================================================
--- /dev/null
+++ test/wasm/import-memory.test
@@ -0,0 +1,13 @@
+# RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+# RUN: lld -flavor wasm -entry ret32 --import-memory -o %t.wasm %t.ret32.o
+# RUN: obj2yaml %t.wasm | FileCheck %s
+
+# Verify the --import-memory flag creates a memory import
+
+# CHECK:       - Type:            IMPORT
+# CHECK-NEXT:    Imports:         
+# CHECK-NEXT:      - Module:          env
+# CHECK-NEXT:        Field:           memory
+# CHECK-NEXT:        Kind:            MEMORY
+# CHECK-NEXT:        Memory:          
+# CHECK-NEXT:          Initial:         0x00000002
Index: test/wasm/invalid-stack-size.test
===================================================================
--- /dev/null
+++ test/wasm/invalid-stack-size.test
@@ -0,0 +1,9 @@
+; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj %s -o %t.o
+; RUN: not lld -flavor wasm -o %t.wasm -z stack-size=1 %t.o 2>&1 | FileCheck %s
+
+define i32 @_start() local_unnamed_addr #1 {
+entry:
+  ret i32 0
+}
+
+; CHECK: error: stack size must be 16-byte aligned
Index: test/wasm/lit.local.cfg
===================================================================
--- /dev/null
+++ test/wasm/lit.local.cfg
@@ -0,0 +1 @@
+config.suffixes = ['.test', '.yaml', '.ll']
Index: test/wasm/relocatable.ll
===================================================================
--- /dev/null
+++ test/wasm/relocatable.ll
@@ -0,0 +1,143 @@
+; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -r -o %t.wasm %t.hello.o %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+; Function Attrs: nounwind
+define hidden i32 @my_func() local_unnamed_addr #0 {
+entry:
+  %call = tail call i32 @foo_import() #2
+  ret i32 1
+}
+
+declare i32 @foo_import() local_unnamed_addr #1
+
+@func_addr1 = hidden global i32()* @my_func, align 4
+@func_addr2 = hidden global i32()* @foo_import, align 4
+
+; CHECK:      --- !WASM
+; CHECK-NEXT: FileHeader:      
+; CHECK-NEXT:   Version:         0x00000001
+; CHECK-NEXT: Sections:        
+; CHECK-NEXT:   - Type:            TYPE
+; CHECK-NEXT:     Signatures:      
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:           - I32
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         ReturnType:      I32
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:   - Type:            IMPORT
+; CHECK-NEXT:     Imports:         
+; CHECK-NEXT:       - Module:          env
+; CHECK-NEXT:         Field:           puts
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         SigIndex:        1
+; CHECK-NEXT:       - Module:          env
+; CHECK-NEXT:         Field:           foo_import
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         SigIndex:        2
+; CHECK-NEXT:   - Type:            FUNCTION
+; CHECK-NEXT:     FunctionTypes:   [ 0, 2 ]
+; CHECK-NEXT:   - Type:            TABLE
+; CHECK-NEXT:     Tables:          
+; CHECK-NEXT:       - ElemType:        ANYFUNC
+; CHECK-NEXT:         Limits:          
+; CHECK-NEXT:           Flags:           0x00000001
+; CHECK-NEXT:           Initial:         0x00000002
+; CHECK-NEXT:           Maximum:         0x00000002
+; CHECK-NEXT:   - Type:            MEMORY
+; CHECK-NEXT:     Memories:        
+; CHECK-NEXT:       - Initial:         0x00000001
+; CHECK-NEXT:   - Type:            GLOBAL
+; CHECK-NEXT:     Globals:         
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           8
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         false
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           12
+; CHECK-NEXT:   - Type:            EXPORT
+; CHECK-NEXT:     Exports:         
+; CHECK-NEXT:       - Name:            hello
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:       - Name:            my_func
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:   - Type:            ELEM
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:         Functions:       [ 3, 1 ]
+; CHECK-NEXT:   - Type:            CODE
+; CHECK-NEXT:     Relocations:     
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_ADDR_SLEB
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Offset:          0x00000004
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Offset:          0x0000000A
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Offset:          0x00000013
+; CHECK-NEXT:     Functions:       
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:          4180808080001080808080000B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:          1081808080001A41010B
+; CHECK-NEXT:   - Type:            DATA
+; CHECK-NEXT:     Relocations:     
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Offset:          0x00000012
+; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Offset:          0x00000016
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - SectionOffset:     6
+; CHECK-NEXT:         MemoryIndex:       0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           0
+; CHECK-NEXT:         Content:         68656C6C6F0A00
+; CHECK-NEXT:       - SectionOffset:     18
+; CHECK-NEXT:         MemoryIndex:       0
+; CHECK-NEXT:         Offset:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           8
+; CHECK-NEXT:         Content:         '0000000001000000'
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        16
+; CHECK-NEXT:     DataAlignment:   4
+; CHECK-NEXT:     SymbolInfo:      
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            name
+; CHECK-NEXT:     FunctionNames:   
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            puts
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Name:            foo_import
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Name:            hello
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Name:            my_func
+; CHECK-NEXT: ...
Index: test/wasm/strip-debug.test
===================================================================
--- /dev/null
+++ test/wasm/strip-debug.test
@@ -0,0 +1,6 @@
+RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+RUN: lld -flavor wasm --strip-debug --entry=ret32 -o %t.wasm %t.ret32.o
+RUN: obj2yaml %t.wasm | FileCheck %s
+
+# Check that there is no name section
+CHECK-NOT:   Name:    name
Index: test/wasm/undefined-entry.test
===================================================================
--- /dev/null
+++ test/wasm/undefined-entry.test
@@ -0,0 +1,4 @@
+RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
+RUN: not lld -flavor wasm -o %t.wasm %t.ret32.o 2>&1 | FileCheck %s
+
+CHECK: error: undefined symbol: _start
Index: test/wasm/undefined.ll
===================================================================
--- /dev/null
+++ test/wasm/undefined.ll
@@ -0,0 +1,22 @@
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm --allow-undefined -o %t.wasm %t.o
+
+; Fails due to undefined 'foo'
+; RUN: not lld -flavor wasm -o %t.wasm %t.o 2>&1 | FileCheck %s
+; CHECK: error: {{.*}}.o: undefined symbol: foo
+
+; But succeeds if we pass a file containing 'foo' as --allow-undefined-file.
+; RUN: lld -flavor wasm --allow-undefined-file=%S/Inputs/allow-undefined.txt -o %t.wasm %t.o
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+; Takes the address of the external foo() resulting in undefined external
+@bar = hidden local_unnamed_addr global i8* bitcast (i32 ()* @foo to i8*), align 4
+
+declare i32 @foo() #0
+
+define hidden void @_start() local_unnamed_addr #0 {
+entry:
+    ret void
+}
Index: test/wasm/version.ll
===================================================================
--- /dev/null
+++ test/wasm/version.ll
@@ -0,0 +1,16 @@
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: lld -flavor wasm -o %t.wasm %t.o
+; RUN: llvm-readobj -file-headers %t.wasm | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown-wasm"
+
+define hidden void @_start() local_unnamed_addr #0 {
+entry:
+    ret void
+}
+
+; CHECK: Format: WASM
+; CHECK: Arch: wasm32
+; CHECK: AddressSize: 32bit
+; CHECK: Version: 0x1
Index: test/wasm/weak-alias-overide.ll
===================================================================
--- /dev/null
+++ test/wasm/weak-alias-overide.ll
@@ -0,0 +1,97 @@
+; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
+; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
+; RUN: lld -flavor wasm %t.o %t2.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; Test that the strongly defined bar is used correctly despite the existence
+; of the weak alias
+
+define i32 @bar() local_unnamed_addr #1 {
+  ret i32 1
+}
+
+; Function Attrs: nounwind uwtable
+define void @_start() local_unnamed_addr #1 {
+entry:
+  %call = tail call i32 @bar() #2
+  ret void
+}
+
+; CHECK:      --- !WASM
+; CHECK-NEXT: FileHeader:      
+; CHECK-NEXT:   Version:         0x00000001
+; CHECK-NEXT: Sections:        
+; CHECK-NEXT:   - Type:            TYPE
+; CHECK-NEXT:     Signatures:      
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         ReturnType:      I32
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:   - Type:            FUNCTION
+; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 0 ]
+; CHECK-NEXT:   - Type:            TABLE
+; CHECK-NEXT:     Tables:          
+; CHECK-NEXT:       - ElemType:        ANYFUNC
+; CHECK-NEXT:         Limits:          
+; CHECK-NEXT:           Flags:           0x00000001
+; CHECK-NEXT:           Initial:         0x00000001
+; CHECK-NEXT:           Maximum:         0x00000001
+; CHECK-NEXT:   - Type:            MEMORY
+; CHECK-NEXT:     Memories:        
+; CHECK-NEXT:       - Initial:         0x00000002
+; CHECK-NEXT:   - Type:            GLOBAL
+; CHECK-NEXT:     Globals:         
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         true
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           66560
+; CHECK-NEXT:   - Type:            EXPORT
+; CHECK-NEXT:     Exports:         
+; CHECK-NEXT:       - Name:            memory
+; CHECK-NEXT:         Kind:            MEMORY
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            main
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:       - Name:            bar
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            _start
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:       - Name:            foo
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:       - Name:            call_bar
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           3
+; CHECK-NEXT:   - Type:            CODE
+; CHECK-NEXT:     Functions:       
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            41010B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            1080808080001A0B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            41000B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            1080808080000B
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        0
+; CHECK-NEXT:     DataAlignment:   0
+; CHECK-NEXT:     SymbolInfo:      
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            name
+; CHECK-NEXT:     FunctionNames:   
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            bar
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Name:            foo
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Name:            call_bar
+; CHECK-NEXT: ...
Index: test/wasm/weak-alias.ll
===================================================================
--- /dev/null
+++ test/wasm/weak-alias.ll
@@ -0,0 +1,87 @@
+; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
+; RUN: llc -mtriple=wasm32-unknown-unknown-wasm -filetype=obj %S/Inputs/weak-alias.ll -o %t2.o
+; RUN: lld -flavor wasm %t.o %t2.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; Test that weak aliases (bar is a weak alias of foo) are linked correctly
+
+declare i32 @bar() local_unnamed_addr #1
+
+; Function Attrs: nounwind uwtable
+define i32 @_start() local_unnamed_addr #1 {
+entry:
+  %call = tail call i32 @bar() #2
+  ret i32 %call
+}
+
+; CHECK:      --- !WASM
+; CHECK-NEXT: FileHeader:      
+; CHECK-NEXT:   Version:         0x00000001
+; CHECK-NEXT: Sections:        
+; CHECK-NEXT:   - Type:            TYPE
+; CHECK-NEXT:     Signatures:      
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         ReturnType:      I32
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:   - Type:            FUNCTION
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0 ]
+; CHECK-NEXT:   - Type:            TABLE
+; CHECK-NEXT:     Tables:          
+; CHECK-NEXT:       - ElemType:        ANYFUNC
+; CHECK-NEXT:         Limits:          
+; CHECK-NEXT:           Flags:           0x00000001
+; CHECK-NEXT:           Initial:         0x00000001
+; CHECK-NEXT:           Maximum:         0x00000001
+; CHECK-NEXT:   - Type:            MEMORY
+; CHECK-NEXT:     Memories:        
+; CHECK-NEXT:       - Initial:         0x00000002
+; CHECK-NEXT:   - Type:            GLOBAL
+; CHECK-NEXT:     Globals:         
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         true
+; CHECK-NEXT:         InitExpr:        
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           66560
+; CHECK-NEXT:   - Type:            EXPORT
+; CHECK-NEXT:     Exports:         
+; CHECK-NEXT:       - Name:            memory
+; CHECK-NEXT:         Kind:            MEMORY
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            main
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            bar
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:       - Name:            _start
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            foo
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:       - Name:            call_bar
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:   - Type:            CODE
+; CHECK-NEXT:     Functions:       
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            1081808080000B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            41000B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            1081808080000B
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        0
+; CHECK-NEXT:     DataAlignment:   0
+; CHECK-NEXT:     SymbolInfo:    
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            name
+; CHECK-NEXT:     FunctionNames:   
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Name:            foo
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Name:            call_bar
+; CHECK-NEXT: ...
Index: test/wasm/weak-external.ll
===================================================================
--- /dev/null
+++ test/wasm/weak-external.ll
@@ -0,0 +1,82 @@
+; RUN: llc -mtriple wasm32-unknown-unknown-wasm -filetype=obj -o %t.o %s
+; RUN: lld -flavor wasm -strip-debug %t.o -o %t.wasm
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; Test that undefined weak externals (global_var) and (foo) don't cause
+; link failures and resolve to zero.
+
+@global_var = extern_weak global i32, align 4
+
+declare extern_weak i32 @foo()
+
+define hidden i8* @get_address_of_foo() #0 {
+entry:
+  ret i8* bitcast (i32 ()* @foo to i8*)
+}
+
+define hidden i32 @_start() #0 {
+entry:
+    %0 = load i32, i32* @global_var, align 4
+    ret i32 %0
+}
+
+; CHECK:      --- !WASM
+; CHECK-NEXT: FileHeader:
+; CHECK-NEXT:   Version:         0x00000001
+; CHECK-NEXT: Sections:
+; CHECK-NEXT:   - Type:            TYPE
+; CHECK-NEXT:     Signatures:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         ReturnType:      I32
+; CHECK-NEXT:         ParamTypes:
+; CHECK-NEXT:   - Type:            FUNCTION
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0 ]
+; CHECK-NEXT:   - Type:            TABLE
+; CHECK-NEXT:     Tables:          
+; CHECK-NEXT:       - ElemType:        ANYFUNC
+; CHECK-NEXT:         Limits:          
+; CHECK-NEXT:           Flags:           0x00000001
+; CHECK-NEXT:           Initial:         0x00000002
+; CHECK-NEXT:           Maximum:         0x00000002
+; CHECK-NEXT:   - Type:            MEMORY
+; CHECK-NEXT:     Memories:
+; CHECK-NEXT:       - Initial:         0x00000002
+; CHECK-NEXT:   - Type:            GLOBAL
+; CHECK-NEXT:     Globals:
+; CHECK-NEXT:       - Type:            I32
+; CHECK-NEXT:         Mutable:         true
+; CHECK-NEXT:         InitExpr:
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           66560
+; CHECK-NEXT:   - Type:            EXPORT
+; CHECK-NEXT:     Exports:
+; CHECK-NEXT:       - Name:            memory
+; CHECK-NEXT:         Kind:            MEMORY
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            main
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:       - Name:            get_address_of_foo
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:       - Name:            _start
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:   - Type:            ELEM
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1
+; CHECK-NEXT:         Functions:       [ 0 ]
+; CHECK-NEXT:   - Type:            CODE
+; CHECK-NEXT:     Functions:
+; CHECK-NEXT:       - Locals:
+; CHECK-NEXT:         Body:            4181808080000B
+; CHECK-NEXT:       - Locals:
+; CHECK-NEXT:         Body:            4100280280808080000B
+; CHECK-NEXT:   - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     DataSize:        0
+; CHECK-NEXT:     DataAlignment:   0
+; CHECK-NEXT:     SymbolInfo:  
+; CHECK-NEXT: ...
Index: tools/lld/CMakeLists.txt
===================================================================
--- tools/lld/CMakeLists.txt
+++ tools/lld/CMakeLists.txt
@@ -10,13 +10,14 @@
   lldDriver
   lldCOFF
   lldELF
+  lldWasm
   )
 
 install(TARGETS lld
   RUNTIME DESTINATION bin)
 
 if(NOT LLD_SYMLINKS_TO_CREATE)
-  set(LLD_SYMLINKS_TO_CREATE lld-link ld.lld)
+  set(LLD_SYMLINKS_TO_CREATE lld-link ld.lld ld.wasm)
 endif()
 
 foreach(link ${LLD_SYMLINKS_TO_CREATE})
Index: tools/lld/lld.cpp
===================================================================
--- tools/lld/lld.cpp
+++ tools/lld/lld.cpp
@@ -34,6 +34,7 @@
   Gnu,     // -flavor gnu
   WinLink, // -flavor link
   Darwin,  // -flavor darwin
+  Wasm,    // -flavor wasm
 };
 
 LLVM_ATTRIBUTE_NORETURN static void die(const Twine &S) {
@@ -44,6 +45,7 @@
 static Flavor getFlavor(StringRef S) {
   return StringSwitch<Flavor>(S)
       .CasesLower("ld", "ld.lld", "gnu", Gnu)
+      .CasesLower("ld.wasm", "wasm", Wasm)
       .CaseLower("link", WinLink)
       .CaseLower("darwin", Darwin)
       .Default(Invalid);
@@ -106,6 +108,8 @@
     return !coff::link(Args);
   case Darwin:
     return !mach_o::link(Args);
+  case Wasm:
+    return !wasm::link(Args);
   default:
     die("lld is a generic driver.\n"
         "Invoke ld.lld (Unix), ld (macOS) or lld-link (Windows) instead.");
Index: wasm/CMakeLists.txt
===================================================================
--- /dev/null
+++ wasm/CMakeLists.txt
@@ -0,0 +1,26 @@
+set(LLVM_TARGET_DEFINITIONS Options.td)
+tablegen(LLVM Options.inc -gen-opt-parser-defs)
+add_public_tablegen_target(WasmOptionsTableGen)
+
+add_lld_library(lldWasm
+  Driver.cpp
+  Error.cpp
+  InputFiles.cpp
+  Strings.cpp
+  SymbolTable.cpp
+  Symbols.cpp
+  Writer.cpp
+
+  LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
+  BinaryFormat
+  Core
+  Demangle
+  Object
+  Option
+  Support
+
+  LINK_LIBS
+  lldConfig
+  lldCore
+  )
Index: wasm/Config.h
===================================================================
--- /dev/null
+++ wasm/Config.h
@@ -0,0 +1,57 @@
+//===- Config.h -------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_CONFIG_H
+#define LLD_WASM_CONFIG_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/Wasm.h"
+
+#include "Symbols.h"
+
+using llvm::wasm::WasmGlobal;
+
+#include <set>
+
+namespace lld {
+namespace wasm {
+
+struct Configuration {
+  bool AllowUndefined = false;
+  bool ColorDiagnostics = false;
+  bool Demangle = true;
+  bool EmitRelocs = false;
+  bool ImportMemory = false;
+  bool Relocatable = false;
+  bool Verbose = false;
+  bool StripDebug = false;
+  bool StripAll = false;
+  bool Threads = false;
+  uint32_t ZStackSize = 0;
+  uint32_t MaxMemory = 0;
+  uint32_t GlobalBase = 0;
+  uint32_t InitialMemory = 0;
+  uint64_t ErrorLimit = 0;
+  llvm::StringRef Entry;
+  llvm::StringRef Sysroot;
+  llvm::StringRef OutputFile;
+  llvm::StringRef ExportEntryAs = "main";
+
+  std::vector<llvm::StringRef> SearchPaths;
+  std::set<llvm::StringRef> AllowUndefinedSymbols;
+  std::vector<std::pair<Symbol*, WasmGlobal>> SyntheticGlobals;
+};
+
+// The only instance of Configuration struct.
+extern Configuration *Config;
+
+} // namespace wasm
+} // namespace lld
+
+#endif
Index: wasm/Driver.h
===================================================================
--- /dev/null
+++ wasm/Driver.h
@@ -0,0 +1,56 @@
+//===- Driver.h -------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_DRIVER_H
+#define LLD_WASM_DRIVER_H
+
+#include "InputFiles.h"
+#include "lld/Core/LLVM.h"
+#include "llvm/Option/ArgList.h"
+
+namespace lld {
+namespace wasm {
+
+// Parses command line options.
+class WasmOptTable : public llvm::opt::OptTable {
+public:
+  WasmOptTable();
+  llvm::opt::InputArgList parse(ArrayRef<const char *> Argv);
+};
+
+// Create enum with OPT_xxx values for each option in Options.td
+enum {
+  OPT_INVALID = 0,
+#define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11, _12) OPT_##ID,
+#include "Options.inc"
+#undef OPTION
+};
+
+class LinkerDriver {
+public:
+  void link(ArrayRef<const char *> ArgsArr);
+
+  // Used by ArchiveFile to add members.
+  void addArchiveBuffer(MemoryBufferRef MBRef, StringRef SymName,
+                        StringRef ParentName);
+private:
+  void addSyntheticUndefinedFunction(StringRef Name);
+  void addSyntheticGlobal(StringRef Name, int32_t Value);
+  void createFiles(llvm::opt::InputArgList &Args);
+  void addFile(StringRef Path);
+  void addLibrary(StringRef Name);
+  std::vector<InputFile *> Files;
+};
+
+extern LinkerDriver *Driver;
+
+} // namespace wasm
+} // namespace lld
+
+#endif
Index: wasm/Driver.cpp
===================================================================
--- /dev/null
+++ wasm/Driver.cpp
@@ -0,0 +1,335 @@
+//===- Driver.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Driver.h"
+
+#include "Config.h"
+#include "Error.h"
+#include "Memory.h"
+#include "SymbolTable.h"
+#include "Writer.h"
+#include "lld/Config/Version.h"
+#include "lld/Driver/Driver.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
+
+using namespace llvm;
+using namespace llvm::sys;
+using llvm::sys::Process;
+
+namespace lld {
+namespace wasm {
+
+std::vector<SpecificAllocBase *> SpecificAllocBase::Instances;
+Configuration *Config;
+LinkerDriver *Driver;
+
+bool link(ArrayRef<const char *> Args, raw_ostream &Error) {
+  ErrorCount = 0;
+  Argv0 = Args[0];
+  ErrorOS = &Error;
+  Config = make<Configuration>();
+  Driver = make<LinkerDriver>();
+  Symtab = make<SymbolTable>();
+
+  Driver->link(Args);
+  return !ErrorCount;
+}
+
+// Create OptTable
+
+// 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 opt::OptTable::Info OptInfo[] = {
+#define OPTION(X1, X2, ID, KIND, GROUP, ALIAS, X7, X8, X9, X10, X11, X12)      \
+  {X1, X2, X10,         X11,         OPT_##ID, opt::Option::KIND##Class,       \
+   X9, X8, OPT_##GROUP, OPT_##ALIAS, X7,       X12},
+#include "Options.inc"
+#undef OPTION
+};
+
+static std::vector<StringRef> getArgs(opt::InputArgList &Args, int Id) {
+  std::vector<StringRef> V;
+  for (auto *Arg : Args.filtered(Id))
+    V.push_back(Arg->getValue());
+  return V;
+}
+
+static int getInteger(opt::InputArgList &Args, unsigned Key, int Default) {
+  int V = Default;
+  if (auto *Arg = Args.getLastArg(Key)) {
+    StringRef S = Arg->getValue();
+    if (S.getAsInteger(10, V))
+      error(Arg->getSpelling() + ": number expected, but got " + S);
+  }
+  return V;
+}
+
+static uint64_t getZOptionValue(opt::InputArgList &Args, StringRef Key,
+                                uint64_t Default) {
+  for (auto *Arg : Args.filtered(OPT_z)) {
+    StringRef Value = Arg->getValue();
+    size_t Pos = Value.find("=");
+    if (Pos != StringRef::npos && Key == Value.substr(0, Pos)) {
+      Value = Value.substr(Pos + 1);
+      uint64_t Result;
+      if (Value.getAsInteger(0, Result))
+        error("invalid " + Key + ": " + Value);
+      return Result;
+    }
+  }
+  return Default;
+}
+
+static std::vector<StringRef> getLines(MemoryBufferRef MB) {
+  SmallVector<StringRef, 0> Arr;
+  MB.getBuffer().split(Arr, '\n');
+
+  std::vector<StringRef> Ret;
+  for (StringRef S : Arr) {
+    S = S.trim();
+    if (!S.empty())
+      Ret.push_back(S);
+  }
+  return Ret;
+}
+
+static void parseUndefinedFile(StringRef Filename) {
+  Optional<MemoryBufferRef> Buffer = readFile(Filename);
+  if (!Buffer.hasValue())
+    return;
+  for (StringRef SymbolName : getLines(*Buffer))
+    Config->AllowUndefinedSymbols.insert(SymbolName);
+}
+
+// Parse -color-diagnostics={auto,always,never} or -no-color-diagnostics.
+static bool getColorDiagnostics(opt::InputArgList &Args) {
+  auto *Arg = Args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
+                              OPT_no_color_diagnostics);
+  if (!Arg)
+    return ErrorOS->has_colors();
+  if (Arg->getOption().getID() == OPT_color_diagnostics)
+    return true;
+  if (Arg->getOption().getID() == OPT_no_color_diagnostics)
+    return false;
+
+  StringRef S = Arg->getValue();
+  if (S == "auto")
+    return ErrorOS->has_colors();
+  if (S == "always")
+    return true;
+  if (S != "never")
+    error("unknown option: -color-diagnostics=" + S);
+  return false;
+}
+
+// Find a file by concatenating given paths. If a resulting path
+// starts with "=", the character is replaced with a --sysroot value.
+static Optional<StringRef> findFile(StringRef Path1, const Twine &Path2) {
+  SmallString<128> S;
+  path::append(S, Path1, Path2);
+  if (fs::exists(S))
+    return S.str();
+  return None;
+}
+
+WasmOptTable::WasmOptTable() : OptTable(OptInfo) {}
+
+opt::InputArgList WasmOptTable::parse(ArrayRef<const char *> Argv) {
+  SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size());
+
+  unsigned MissingIndex;
+  unsigned MissingCount;
+  opt::InputArgList Args = this->ParseArgs(Vec, MissingIndex, MissingCount);
+
+  for (auto *Arg : Args.filtered(OPT_UNKNOWN))
+    fatal(Twine("unknown argument: ") + Arg->getSpelling());
+  return Args;
+}
+
+static void printHelp(const char *Argv0) {
+  WasmOptTable Table;
+  Table.PrintHelp(outs(), Argv0, "LLVM Linker", false);
+}
+
+void LinkerDriver::addFile(StringRef Path) {
+  Optional<MemoryBufferRef> Buffer = readFile(Path);
+  if (!Buffer.hasValue())
+    return;
+  MemoryBufferRef MBRef = *Buffer;
+
+  if (identify_magic(MBRef.getBuffer()) == file_magic::archive)
+    Files.push_back(make<ArchiveFile>(MBRef));
+  else
+    Files.push_back(make<ObjectFile>(MBRef));
+}
+
+void LinkerDriver::addArchiveBuffer(MemoryBufferRef MB, StringRef SymName,
+                                    StringRef ParentName) {
+  if (identify_magic(MB.getBuffer()) != file_magic::wasm_object) {
+    error("unknown file type: " + MB.getBufferIdentifier());
+    return;
+  }
+
+  InputFile *Obj = make<ObjectFile>(MB);
+  Obj->ParentName = ParentName;
+  Symtab->addFile(Obj);
+  log("Including " + toString(Obj) + " for: " + SymName);
+}
+
+// Add a given library by searching it from input search paths.
+void LinkerDriver::addLibrary(StringRef Name) {
+  for (StringRef Dir : Config->SearchPaths) {
+    if (Optional<StringRef> S = findFile(Dir, "lib" + Name + ".a")) {
+      addFile(*S);
+      return;
+    }
+  }
+
+  error("unable to find library -l" + Name);
+}
+
+// Inject a new wasm global into the output binary with the given value.
+// Wasm global are used in relocatable object files to model symbol imports
+// and exports.  In the final exectuable the only use of wasm globals is the
+// for the exlicit stack pointer (__stack_pointer).
+void LinkerDriver::addSyntheticGlobal(StringRef Name, int32_t Value) {
+  log("injecting global: " + Name);
+  Symbol* S = Symtab->addDefinedGlobal(Name);
+  S->setOutputIndex(Config->SyntheticGlobals.size());
+
+  WasmGlobal Global;
+  Global.Mutable = true;
+  Global.Type = WASM_TYPE_I32;
+  Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+  Global.InitExpr.Value.Int32 = Value;
+  Config->SyntheticGlobals.emplace_back(S, Global);
+}
+
+// Inject a new undefined symbol into the link.  This will cause the link to
+// fail unless this symbol can be found.
+void LinkerDriver::addSyntheticUndefinedFunction(StringRef Name) {
+  log("injecting undefined func: " + Name);
+  Symtab->addUndefinedFunction(Name);
+}
+
+void LinkerDriver::createFiles(opt::InputArgList &Args) {
+  for (auto *Arg : Args) {
+    switch (Arg->getOption().getUnaliasedOption().getID()) {
+    case OPT_l:
+      addLibrary(Arg->getValue());
+      break;
+    case OPT_INPUT:
+      addFile(Arg->getValue());
+      break;
+    }
+  }
+
+  if (Files.empty())
+    error("no input files");
+}
+
+void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
+  WasmOptTable Parser;
+  opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
+
+  // Handle /help
+  if (Args.hasArg(OPT_help)) {
+    printHelp(ArgsArr[0]);
+    return;
+  }
+
+  // Parse and evaluate -mllvm options.
+  std::vector<const char *> V;
+  V.push_back("lld-link (LLVM option parsing)");
+  for (auto *Arg : Args.filtered(OPT_mllvm))
+    V.push_back(Arg->getValue());
+  cl::ParseCommandLineOptions(V.size(), V.data());
+
+  Config->ColorDiagnostics = getColorDiagnostics(Args);
+
+  if (Args.hasArg(OPT_version) || Args.hasArg(OPT_v)) {
+    outs() << getLLDVersion() << "\n";
+    return;
+  }
+
+  Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
+  Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
+  Config->Entry = Args.getLastArgValue(OPT_entry);
+  Config->ImportMemory = Args.hasArg(OPT_import_memory);
+  Config->OutputFile = Args.getLastArgValue(OPT_o);
+  Config->Relocatable = Args.hasArg(OPT_relocatable);
+  Config->SearchPaths = getArgs(Args, OPT_L);
+  Config->StripAll = Args.hasArg(OPT_strip_all);
+  Config->StripDebug = Args.hasArg(OPT_strip_debug);
+  Config->Sysroot = Args.getLastArgValue(OPT_sysroot);
+  Config->Verbose = Args.hasArg(OPT_verbose);
+  Config->Threads = !Args.hasArg(OPT_no_threads);
+
+  Config->InitialMemory = getInteger(Args, OPT_initial_memory, 0);
+  Config->ErrorLimit = getInteger(Args, OPT_error_limit, 20);
+  Config->GlobalBase = getInteger(Args, OPT_global_base, 1024);
+  Config->MaxMemory = getInteger(Args, OPT_max_memory, 0);
+  Config->ZStackSize = getZOptionValue(Args, "stack-size", WasmPageSize);
+
+  StringRef AllowUndefinedFilename = Args.getLastArgValue(OPT_allow_undefined_file);
+  if (!AllowUndefinedFilename.empty())
+    parseUndefinedFile(AllowUndefinedFilename);
+
+  if (Config->OutputFile.empty())
+    fatal("no output file specified");
+
+  if (!Args.hasArgNoClaim(OPT_INPUT))
+    fatal("no input files");
+
+  if (Config->Relocatable && !Config->Entry.empty())
+    fatal("entry point specified for relocatable output file");
+
+  if (!Config->Relocatable) {
+    if (Config->Entry.empty())
+      Config->Entry = "_start";
+    addSyntheticUndefinedFunction(Config->Entry);
+
+    addSyntheticGlobal("__stack_pointer", 0);
+  }
+
+  createFiles(Args);
+  if (ErrorCount)
+    return;
+
+  // Add all files to the symbol table. This will add almost all
+  // symbols that we need to the symbol table.
+  for (InputFile *F : Files)
+    Symtab->addFile(F);
+
+  // Make sure we have resolved all symbols.
+  if (!Config->Relocatable && !Config->AllowUndefined) {
+    Symtab->reportRemainingUndefines();
+    if (ErrorCount)
+      return;
+  }
+
+  if (!Config->Entry.empty()) {
+    Symbol* Sym = Symtab->find(Config->Entry);
+    if (!Sym->isFunction())
+      fatal("entry point is not a function: " + Sym->getName());
+  }
+
+  // Write the result to the file.
+  writeResult(Symtab);
+}
+
+} // namespace wasm
+} // namespace lld
Index: wasm/Error.h
===================================================================
--- /dev/null
+++ wasm/Error.h
@@ -0,0 +1,57 @@
+//===- Error.h --------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_ERROR_H
+#define LLD_WASM_ERROR_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/Support/Error.h"
+
+namespace lld {
+namespace wasm {
+
+extern uint64_t ErrorCount;
+extern llvm::raw_ostream *ErrorOS;
+extern llvm::StringRef Argv0;
+
+void log(const Twine &Msg);
+void warn(const Twine &Msg);
+void error(const Twine &Msg);
+LLVM_ATTRIBUTE_NORETURN void fatal(const Twine &Msg);
+
+// check() functions are convenient functions to strip errors
+// from error-or-value objects.
+template <class T> T check(ErrorOr<T> E) {
+  if (auto EC = E.getError())
+    fatal(EC.message());
+  return std::move(*E);
+}
+
+template <class T> T check(Expected<T> E) {
+  if (!E)
+    fatal(llvm::toString(E.takeError()));
+  return std::move(*E);
+}
+
+template <class T> T check(ErrorOr<T> E, const Twine &Prefix) {
+  if (auto EC = E.getError())
+    fatal(Prefix + ": " + EC.message());
+  return std::move(*E);
+}
+
+template <class T> T check(Expected<T> E, const Twine &Prefix) {
+  if (!E)
+    fatal(Prefix + ": " + llvm::toString(E.takeError()));
+  return std::move(*E);
+}
+
+} // namespace wasm
+} // namespace lld
+
+#endif
Index: wasm/Error.cpp
===================================================================
--- /dev/null
+++ wasm/Error.cpp
@@ -0,0 +1,95 @@
+//===- Error.cpp ----------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Error.h"
+
+#include "Config.h"
+#include "llvm/ADT/Twine.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <mutex>
+
+#if !defined(_MSC_VER) && !defined(__MINGW32__)
+#include <unistd.h>
+#endif
+
+using namespace llvm;
+
+namespace lld {
+namespace wasm {
+
+uint64_t ErrorCount;
+raw_ostream *ErrorOS;
+StringRef Argv0;
+
+// The functions defined in this file can be called from multiple threads,
+// but outs() or errs() are not thread-safe. We protect them using a mutex.
+static std::mutex Mu;
+
+static void print(StringRef S, raw_ostream::Colors C) {
+  *ErrorOS << Argv0 + ": ";
+  if (Config->ColorDiagnostics) {
+    ErrorOS->changeColor(C, true);
+    *ErrorOS << S;
+    ErrorOS->resetColor();
+  } else {
+    *ErrorOS << S;
+  }
+}
+
+LLVM_ATTRIBUTE_NORETURN static void exitLld(int Val) {
+  // Dealloc/destroy ManagedStatic variables before calling
+  // _exit(). In a non-LTO build, this is a nop. In an LTO
+  // build allows us to get the output of -time-passes.
+  llvm_shutdown();
+
+  outs().flush();
+  errs().flush();
+  _exit(Val);
+}
+
+void log(const Twine &Msg) {
+  std::lock_guard<std::mutex> Lock(Mu);
+  if (Config->Verbose)
+    errs() << "lld: " << Msg << "\n";
+}
+
+void fatal(const Twine &Msg) {
+  std::lock_guard<std::mutex> Lock(Mu);
+  print("error: ", raw_ostream::RED);
+  *ErrorOS << Msg << "\n";
+  ErrorOS->flush();
+  exitLld(1);
+}
+
+void error(const Twine &Msg) {
+  std::lock_guard<std::mutex> Lock(Mu);
+
+  print("error: ", raw_ostream::RED);
+  *ErrorOS << Msg << "\n";
+
+  if (Config->ErrorLimit != 0 && ++ErrorCount >= Config->ErrorLimit) {
+    print("error: ", raw_ostream::RED);
+    *ErrorOS << "too many errors emitted, stopping now"
+             << " (use -error-limit=0 to see all errors)\n";
+    exitLld(1);
+  }
+
+}
+
+void warn(const Twine &Msg) {
+  std::lock_guard<std::mutex> Lock(Mu);
+  print("warning: ", raw_ostream::MAGENTA);
+  *ErrorOS << Msg << "\n";
+}
+
+} // namespace wasm
+} // namespace lld
Index: wasm/InputFiles.h
===================================================================
--- /dev/null
+++ wasm/InputFiles.h
@@ -0,0 +1,142 @@
+//===- InputFiles.h ---------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_INPUT_FILES_H
+#define LLD_WASM_INPUT_FILES_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/Wasm.h"
+
+#include <vector>
+
+using llvm::object::WasmObjectFile;
+using llvm::object::WasmSection;
+using llvm::object::WasmSymbol;
+using llvm::object::Archive;
+
+namespace lld {
+namespace wasm {
+
+class Symbol;
+
+class InputFile {
+public:
+  enum Kind {
+    ObjectKind,
+    ArchiveKind,
+  };
+
+  virtual ~InputFile() {}
+
+  // Returns the filename.
+  StringRef getName() const { return MB.getBufferIdentifier(); }
+
+  std::vector<Symbol *> &getSymbols() { return Symbols; }
+
+  // Reads a file (the constructor doesn't do that).
+  virtual void parse() = 0;
+
+  Kind kind() const { return FileKind; }
+
+  // An archive file name if this file is created from an archive.
+  StringRef ParentName;
+
+protected:
+  InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
+  MemoryBufferRef MB;
+
+  // List of all symbols referenced or defined by this file.
+  std::vector<Symbol *> Symbols;
+
+private:
+  const Kind FileKind;
+};
+
+// .a file (ar archive)
+class ArchiveFile : public InputFile {
+public:
+  explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
+  static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
+
+  void addMember(const Archive::Symbol *Sym);
+
+  void parse() override;
+
+private:
+  std::unique_ptr<Archive> File;
+  llvm::DenseSet<uint64_t> Seen;
+};
+
+// .o file (wasm object file)
+class ObjectFile : public InputFile {
+public:
+  explicit ObjectFile(MemoryBufferRef M) : InputFile(ObjectKind, M) {}
+  static bool classof(const InputFile *F) { return F->kind() == ObjectKind; }
+
+  Symbol *createDefined(const WasmSymbol &Sym);
+  Symbol *createUndefined(const WasmSymbol &Sym);
+
+  void parse() override;
+
+  // Returns the underlying wasm file.
+  const WasmObjectFile *getWasmObj() { return WasmObj.get(); }
+
+  void dumpInfo() const;
+
+  uint32_t relocateTypeIndex(uint32_t original) const;
+  uint32_t relocateFunctionIndex(uint32_t original) const;
+  uint32_t relocateGlobalIndex(uint32_t original) const;
+  uint32_t relocateTableIndex(uint32_t original) const;
+  uint32_t relocateDataLocation(uint32_t original) const;
+
+  int32_t getGlobalAddress(uint32_t index) const;
+
+  // Returns true if the given function index is an imported function,
+  // as opposed to the locally defined function.
+  bool isImportedFunction(uint32_t index) const;
+  // Returns true if the given global index is an imported global,
+  // as opposed to the locally defined (exported) global.
+  bool isImportedGlobal(uint32_t index) const;
+  // Return true if the given imported (undefined) function has been resolved
+  // in the output binary (i.e. defined by another object).
+  bool isResolvedFunctionImport(uint32_t index) const;
+  // Return true if the given imported (undefined) global has been resolved
+  // in the output binary (i.e. defined by another object).
+  bool isResolvedGlobalImport(uint32_t index) const;
+
+  int32_t FunctionIndexOffset = 0;
+  int32_t GlobalIndexOffset = 0;
+  int32_t TableIndexOffset = 0;
+  uint32_t DataOffset = 0;
+  const WasmSection* CodeSection = nullptr;
+  const WasmSection* DataSection = nullptr;
+
+  llvm::DenseMap<uint32_t, uint32_t> TypeMap;
+  std::vector<StringRef> FunctionImports;
+  std::vector<StringRef> GlobalImports;
+
+private:
+  std::unique_ptr<WasmObjectFile> WasmObj;
+
+  void initializeSymbols();
+};
+
+// Opens a given file.
+llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
+
+} // namespace wasm
+
+std::string toString(wasm::InputFile *File);
+} // namespace lld
+
+#endif
Index: wasm/InputFiles.cpp
===================================================================
--- /dev/null
+++ wasm/InputFiles.cpp
@@ -0,0 +1,256 @@
+//===- InputFiles.cpp -----------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "InputFiles.h"
+
+#include "Config.h"
+#include "Driver.h"
+#include "Error.h"
+#include "Memory.h"
+#include "Strings.h"
+#include "SymbolTable.h"
+#include "llvm/Object/Binary.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/raw_ostream.h"
+
+#define DEBUG_TYPE "lld"
+
+using namespace lld;
+using namespace lld::wasm;
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace llvm::wasm;
+
+namespace lld {
+namespace wasm {
+
+Optional<MemoryBufferRef> readFile(StringRef Path) {
+  log("Loading: " + Path);
+
+  auto MBOrErr = MemoryBuffer::getFile(Path);
+  if (auto EC = MBOrErr.getError()) {
+    error("cannot open " + Path + ": " + EC.message());
+    return None;
+  }
+  std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
+  MemoryBufferRef MBRef = MB->getMemBufferRef();
+  make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
+
+  return MBRef;
+}
+
+void ObjectFile::dumpInfo() const {
+  log("reloc info for: " + getName());
+  log("        FunctionIndexOffset : " + Twine(FunctionIndexOffset));
+  log("     FunctionImports.size() : " + Twine(FunctionImports.size()));
+  log("           TableIndexOffset : " + Twine(TableIndexOffset));
+  log("          GlobalIndexOffset : " + Twine(GlobalIndexOffset));
+  log("                 DataOffset : " + Twine(DataOffset));
+  log("       GlobalImports.size() : " + Twine(GlobalImports.size()));
+}
+
+bool ObjectFile::isImportedFunction(uint32_t Index) const {
+  return Index < FunctionImports.size();
+}
+
+bool ObjectFile::isImportedGlobal(uint32_t Index) const {
+  return Index < GlobalImports.size();
+}
+
+bool ObjectFile::isResolvedFunctionImport(uint32_t Index) const {
+  if (!isImportedFunction(Index))
+    return false;
+  StringRef Name = FunctionImports[Index];
+  Symbol *Sym = Symtab->find(Name);
+  assert(Sym);
+  return Sym->isDefined();
+}
+
+bool ObjectFile::isResolvedGlobalImport(uint32_t Index) const {
+  if (!isImportedGlobal(Index))
+    return false;
+  StringRef Name = GlobalImports[Index];
+  Symbol *Sym = Symtab->find(Name);
+  assert(Sym);
+  return Sym->isDefined();
+}
+
+int32_t ObjectFile::getGlobalAddress(uint32_t Index) const {
+  if (isImportedGlobal(Index))
+    return 0;
+
+  Index -= GlobalImports.size();
+  const WasmGlobal &Global = WasmObj->globals()[Index];
+  assert(Global.Type == WASM_TYPE_I32);
+  return Global.InitExpr.Value.Int32 + DataOffset;
+}
+
+uint32_t ObjectFile::relocateFunctionIndex(uint32_t original) const {
+  DEBUG(dbgs() << "relocateFunctionIndex: " << original << "\n");
+  if (isImportedFunction(original)) {
+    StringRef Name = FunctionImports[original];
+    Symbol *Sym = Symtab->find(Name);
+    assert(Sym && "imported symbol not found in symbol table");
+    return Sym->getOutputIndex();
+  }
+
+  DEBUG(dbgs() << " ---> " << FunctionIndexOffset << " "
+               << (original + FunctionIndexOffset) << "\n");
+  return original + FunctionIndexOffset;
+}
+
+uint32_t ObjectFile::relocateTypeIndex(uint32_t original) const {
+  assert(TypeMap.count(original) > 0);
+  return TypeMap.find(original)->second;
+}
+
+uint32_t ObjectFile::relocateTableIndex(uint32_t original) const {
+  return original + TableIndexOffset;
+}
+
+uint32_t ObjectFile::relocateGlobalIndex(uint32_t original) const {
+  if (isImportedGlobal(original)) {
+    StringRef Name = GlobalImports[original];
+    Symbol* Sym = Symtab->find(Name);
+    assert(Sym && "imported symbol not found in symbol table");
+    return Sym->getOutputIndex();
+  }
+
+  return original + GlobalIndexOffset;
+}
+
+void ObjectFile::parse() {
+  // Parse a memory buffer as a wasm file.
+  DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
+  std::unique_ptr<Binary> Bin = check(createBinary(MB), toString(this));
+
+  auto *Obj = dyn_cast<WasmObjectFile>(Bin.get());
+  if (!Obj)
+    fatal(toString(this) + " is not a wasm file");
+  // TODO(sbc): Enable this change once the llvm support for this
+  //  method lands
+  //if (!Obj->isRelocatableObject())
+  //  fatal(toString(this) + ": not a relocatable wasm file");
+
+  Bin.release();
+  WasmObj.reset(Obj);
+
+  for (const SectionRef &Sec: WasmObj->sections()) {
+    const WasmSection &Section = WasmObj->getWasmSection(Sec);
+    if (Section.Type == WASM_SEC_CODE)
+      CodeSection = &Section;
+    else if (Section.Type == WASM_SEC_DATA)
+      DataSection = &Section;
+  }
+
+  initializeSymbols();
+}
+
+void ObjectFile::initializeSymbols() {
+  uint32_t NumSymbols = WasmObj->getNumberOfSymbols();
+  Symbols.reserve(NumSymbols);
+
+  for (const WasmImport &Import: WasmObj->imports()) {
+    switch (Import.Kind) {
+    case WASM_EXTERNAL_FUNCTION:
+      FunctionImports.emplace_back(Import.Field);
+      break;
+    case WASM_EXTERNAL_GLOBAL:
+      GlobalImports.emplace_back(Import.Field);
+      break;
+    }
+  }
+
+  for (const SymbolRef &Sym: WasmObj->symbols()) {
+    const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
+    switch (WasmSym.Type) {
+      case WasmSymbol::SymbolType::FUNCTION_IMPORT:
+        createUndefined(WasmSym);
+        break;
+      case WasmSymbol::SymbolType::GLOBAL_IMPORT:
+        createUndefined(WasmSym);
+        break;
+      case WasmSymbol::SymbolType::FUNCTION_EXPORT:
+      case WasmSymbol::SymbolType::GLOBAL_EXPORT:
+        createDefined(WasmSym);
+        break;
+      case WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME:
+        // These are internal only, no need to create linker symbols for them
+        break;
+    }
+  }
+}
+
+Symbol *ObjectFile::createUndefined(const WasmSymbol &Sym) {
+  Symbol *S = Symtab->addUndefined(this, &Sym);
+  Symbols.push_back(S);
+  return S;
+}
+
+Symbol *ObjectFile::createDefined(const WasmSymbol &Sym) {
+  Symbol *S = Symtab->addDefined(this, &Sym);
+  Symbols.push_back(S);
+  return S;
+}
+
+void ArchiveFile::parse() {
+  // Parse a MemoryBufferRef as an archive file.
+  DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
+  File = check(Archive::create(MB), toString(this));
+
+  // Read the symbol table to construct Lazy symbols.
+  for (const Archive::Symbol &Sym : File->symbols())
+    Symtab->addLazy(this, &Sym);
+}
+
+void ArchiveFile::addMember(const Archive::Symbol *Sym) {
+  const Archive::Child &C =
+      check(Sym->getMember(),
+            "could not get the member for symbol " + Sym->getName());
+
+  // Don't try to load the same member twice (this can happen when members
+  // mutually reference each other.
+  if (!Seen.insert(C.getChildOffset()).second)
+    return;
+
+  DEBUG(dbgs() << "loading lazy: " << displayName(Sym->getName()) << "\n");
+  DEBUG(dbgs() << "from archive: " << toString(this) << "\n");
+  //DEBUG(dbgs() << "loading symbol from object symbol: " << C.getName() << "\n");
+  MemoryBufferRef MB =
+      check(C.getMemoryBufferRef(),
+            "could not get the buffer for the member defining symbol " +
+                Sym->getName());
+  Driver->addArchiveBuffer(MB, Sym->getName(), ParentName);
+}
+
+} // namespace wasm
+} // namespace lld
+
+// Returns the last element of a path, which is supposed to be a filename.
+static StringRef getBasename(StringRef Path) {
+  size_t Pos = Path.find_last_of("\\/");
+  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 lld::toString(wasm::InputFile *File) {
+  if (!File)
+    return "(internal)";
+
+  if (File->ParentName.empty())
+    return File->getName();
+
+  std::string Res =
+      (getBasename(File->ParentName) + "(" + getBasename(File->getName()) + ")")
+          .str();
+  return StringRef(Res);
+}
Index: wasm/Memory.h
===================================================================
--- /dev/null
+++ wasm/Memory.h
@@ -0,0 +1,52 @@
+//===- Memory.h -------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// See WASM/Memory.h
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_MEMORY_H
+#define LLD_WASM_MEMORY_H
+
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/StringSaver.h"
+#include <vector>
+
+namespace lld {
+namespace wasm {
+
+extern llvm::BumpPtrAllocator BAlloc;
+extern llvm::StringSaver Saver;
+
+struct SpecificAllocBase {
+  SpecificAllocBase() { Instances.push_back(this); }
+  virtual ~SpecificAllocBase() = default;
+  virtual void reset() = 0;
+  static std::vector<SpecificAllocBase *> Instances;
+};
+
+template <class T> struct SpecificAlloc : public SpecificAllocBase {
+  void reset() override { Alloc.DestroyAll(); }
+  llvm::SpecificBumpPtrAllocator<T> Alloc;
+};
+
+template <typename T, typename... U> T *make(U &&... Args) {
+  static SpecificAlloc<T> Alloc;
+  return new (Alloc.Alloc.Allocate()) T(std::forward<U>(Args)...);
+}
+
+inline void freeArena() {
+  for (SpecificAllocBase *Alloc : SpecificAllocBase::Instances)
+    Alloc->reset();
+  BAlloc.Reset();
+}
+}
+}
+
+#endif
Index: wasm/Options.td
===================================================================
--- /dev/null
+++ wasm/Options.td
@@ -0,0 +1,87 @@
+include "llvm/Option/OptParser.td"
+
+// For options whose names are multiple letters, either one dash or
+// two can precede the option name except those that start with 'o'.
+class F<string name>: Flag<["--", "-"], name>;
+class J<string name>: Joined<["--", "-"], name>;
+class S<string name>: Separate<["--", "-"], name>;
+
+def L: JoinedOrSeparate<["-"], "L">, MetaVarName<"<dir>">,
+  HelpText<"Add a directory to the library search path">;
+
+def color_diagnostics: F<"color-diagnostics">,
+  HelpText<"Use colors in diagnostics">;
+
+def color_diagnostics_eq: J<"color-diagnostics=">,
+  HelpText<"Use colors in diagnostics">;
+
+// The follow flags are shared with the ELF linker
+def help: F<"help">, HelpText<"Print option help">;
+
+def l: JoinedOrSeparate<["-"], "l">, MetaVarName<"<libName>">,
+  HelpText<"Root name of library to use">;
+
+def mllvm: S<"mllvm">, HelpText<"Options to pass to LLVM">;
+
+def no_threads: F<"no-threads">,
+  HelpText<"Do not run the linker multi-threaded">;
+
+def no_color_diagnostics: F<"no-color-diagnostics">,
+  HelpText<"Do not use colors in diagnostics">;
+
+def o: JoinedOrSeparate<["-"], "o">, MetaVarName<"<path>">,
+  HelpText<"Path to file to write output">;
+
+def v: Flag<["-"], "v">, HelpText<"Display the version number">;
+
+def version: F<"version">, HelpText<"Display the version number and exit">;
+
+def verbose: F<"verbose">, HelpText<"Verbose mode">;
+
+def relocatable: F<"relocatable">, HelpText<"Create relocatable object file">;
+
+def emit_relocs: F<"emit-relocs">, HelpText<"Generate relocations in output">;
+
+def strip_all: F<"strip-all">, HelpText<"Strip all symbols">;
+
+def strip_debug: F<"strip-debug">, HelpText<"Strip debugging information">;
+
+def sysroot: J<"sysroot=">, HelpText<"Set the system root">;
+
+def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
+  HelpText<"Linker option extensions">;
+
+def entry: S<"entry">, MetaVarName<"<entry>">,
+  HelpText<"Name of entry point symbol">;
+
+def error_limit: J<"error-limit=">,
+  HelpText<"Maximum number of errors to emit before stopping (0 = no limit)">;
+
+// The follow flags are unique to wasm
+
+def global_base: J<"global-base=">,
+  HelpText<"Where to start to place global data">;
+
+def initial_memory: J<"initial-memory=">,
+  HelpText<"Initial size of the linear memory">;
+
+def max_memory: J<"max-memory=">,
+  HelpText<"Maximum size of the linear memory">;
+
+def import_memory: F<"import-memory">,
+  HelpText<"Import memory from the environment">;
+
+def allow_undefined: F<"allow-undefined">,
+  HelpText<"Allow undefined symbols in linked binary">;
+
+def allow_undefined_file: J<"allow-undefined-file=">,
+  HelpText<"Allow symbols listed in <file> to be undefined in linked binary">;
+
+def allow_undefined_file_s: Separate<["-"], "allow-undefined-file">, Alias<allow_undefined_file>;
+
+// Aliases
+def alias_initial_memory_i: Flag<["-"], "i">, Alias<initial_memory>;
+def alias_max_memory_m: Flag<["-"], "m">, Alias<max_memory>;
+def alias_relocatable_r: Flag<["-"], "r">, Alias<relocatable>;
+def alias_entry_e: JoinedOrSeparate<["-"], "e">, Alias<entry>;
+def alias_entry_entry: J<"entry=">, Alias<entry>;
Index: wasm/Strings.h
===================================================================
--- /dev/null
+++ wasm/Strings.h
@@ -0,0 +1,25 @@
+//===- Strings.h ------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_STRINGS_H
+#define LLD_WASM_STRINGS_H
+
+namespace lld {
+namespace wasm {
+
+// Returns a demangled C++ symbol name. If Name is not a mangled
+// name, it returns Optional::None.
+llvm::Optional<std::string> demangle(StringRef Name);
+
+std::string displayName(StringRef Name);
+
+}
+}
+
+#endif
Index: wasm/Strings.cpp
===================================================================
--- /dev/null
+++ wasm/Strings.cpp
@@ -0,0 +1,45 @@
+//===- Strings.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 "llvm/ADT/StringRef.h"
+#include "llvm/Demangle/Demangle.h"
+
+using namespace llvm;
+
+namespace lld {
+namespace wasm {
+
+// Returns the demangled C++ symbol name for Name.
+Optional<std::string> demangle(StringRef Name) {
+  // itaniumDemangle can be used to demangle strings other than symbol
+  // names which do not necessarily start with "_Z". Name can be
+  // either a C or C++ symbol. Don't call itaniumDemangle if the name
+  // does not look like a C++ symbol name to avoid getting unexpected
+  // result for a C symbol that happens to match a mangled type name.
+  if (!Name.startswith("_Z"))
+    return None;
+
+  char *Buf = itaniumDemangle(Name.str().c_str(), nullptr, nullptr, nullptr);
+  if (!Buf)
+    return None;
+  std::string S(Buf);
+  free(Buf);
+  return S;
+}
+
+std::string displayName(StringRef Name) {
+  if (Config->Demangle)
+    if (Optional<std::string> S = demangle(Name))
+      return "`" + *S + "'";
+  return Name;
+}
+
+}
+}
Index: wasm/SymbolTable.h
===================================================================
--- /dev/null
+++ wasm/SymbolTable.h
@@ -0,0 +1,70 @@
+//===- SymbolTable.h --------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_SYMBOL_TABLE_H
+#define LLD_WASM_SYMBOL_TABLE_H
+
+#include "InputFiles.h"
+#include "Symbols.h"
+
+#include "llvm/ADT/CachedHashString.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Support/raw_ostream.h"
+
+using llvm::object::WasmSymbol;
+
+namespace llvm {
+struct LTOCodeGenerator;
+}
+
+namespace lld {
+namespace wasm {
+
+// 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 the
+// add*() functions, which are called by input files as they are parsed.
+// There is one add* function per symbol type.
+class SymbolTable {
+public:
+  void addFile(InputFile *File);
+
+  std::vector<ObjectFile *> ObjectFiles;
+  std::vector<Symbol *> SyntheticSymbols;
+
+  void reportDuplicate(Symbol *Existing, InputFile *NewFile);
+  void reportRemainingUndefines();
+
+  Symbol *find(StringRef Name);
+
+  Symbol *addDefined(InputFile *F, const WasmSymbol *Sym);
+  Symbol *addUndefined(InputFile *F, const WasmSymbol *Sym);
+  Symbol *addUndefinedFunction(StringRef Name);
+  Symbol *addDefinedGlobal(StringRef Name);
+  void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
+
+private:
+  std::pair<Symbol *, bool> insert(StringRef Name);
+
+  llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> Symtab;
+};
+
+extern SymbolTable *Symtab;
+
+} // namespace wasm
+} // namespace lld
+
+#endif
Index: wasm/SymbolTable.cpp
===================================================================
--- /dev/null
+++ wasm/SymbolTable.cpp
@@ -0,0 +1,191 @@
+//===- SymbolTable.cpp ----------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "SymbolTable.h"
+
+#include "Config.h"
+#include "Error.h"
+#include "Memory.h"
+#include "Strings.h"
+#include "llvm/ADT/SmallPtrSet.h"
+
+#define DEBUG_TYPE "lld"
+
+using namespace llvm;
+
+namespace lld {
+namespace wasm {
+
+SymbolTable *Symtab;
+
+void SymbolTable::addFile(InputFile *File) {
+  log("Processing: " + toString(File));
+  File->parse();
+
+  if (auto *F = dyn_cast<ObjectFile>(File))
+    ObjectFiles.push_back(F);
+}
+
+void SymbolTable::reportRemainingUndefines() {
+  SmallPtrSet<Symbol *, 8> Undefs;
+  for (auto &I : Symtab) {
+    Symbol *Sym = I.second;
+    if (Sym->isUndefined() && !Sym->isLazy() && !Sym->isWeak() &&
+        Config->AllowUndefinedSymbols.count(Sym->getName()) == 0) {
+      Undefs.insert(Sym);
+    }
+  }
+
+  if (Undefs.empty())
+    return;
+
+  for (ObjectFile *File : ObjectFiles)
+    for (Symbol *Sym : File->getSymbols())
+      if (Undefs.count(Sym))
+        error(toString(File) + ": undefined symbol: " + toString(*Sym));
+
+  for (Symbol *Sym : Undefs)
+    if (!Sym->getFile())
+      error("undefined symbol: " + toString(*Sym));
+}
+
+Symbol *SymbolTable::find(StringRef Name) {
+  auto It = Symtab.find(CachedHashStringRef(Name));
+  if (It == Symtab.end())
+    return nullptr;
+  return It->second;
+}
+
+std::pair<Symbol *, bool> SymbolTable::insert(StringRef Name) {
+  Symbol *&Sym = Symtab[CachedHashStringRef(Name)];
+  if (Sym)
+    return {Sym, false};
+  Sym = make<Symbol>(Name);
+  return {Sym, true};
+}
+
+void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
+  error("duplicate symbol: " + toString(*Existing) + " in " +
+        toString(Existing->getFile()) + " and in " +
+        (NewFile ? toString(NewFile) : "(internal)"));
+}
+
+static void checkSymbolTypes(Symbol *Existing, InputFile *F, const WasmSymbol *New) {
+  if (Existing->isLazy())
+    return;
+  bool NewIsFunction = New->Type == WasmSymbol::SymbolType::FUNCTION_EXPORT ||
+                       New->Type == WasmSymbol::SymbolType::FUNCTION_IMPORT;
+  if (Existing->isFunction() != NewIsFunction) {
+    error("symbol type mismatch: " + New->Name);
+    StringRef Filename = "<builtin>";
+    if (Existing->getFile())
+      Filename = Existing->getFile()->getName();
+    error(Filename + ": " + (Existing->isFunction() ? "Function" : "Global"));
+    error(F->getName() + ": " + (NewIsFunction ? "Function" : "Global"));
+  }
+}
+
+Symbol *SymbolTable::addDefinedGlobal(StringRef Name) {
+  DEBUG(dbgs() << "addDefinedGlobal: " << Name << "\n");
+  Symbol *S;
+  bool WasInserted;
+  std::tie(S, WasInserted) = insert(Name);
+  if (WasInserted)
+    S->update(Symbol::DefinedGlobalKind);
+  else if (!S->isFunction())
+    error("symbol type mismatch: " + Name);
+  return S;
+}
+
+Symbol *SymbolTable::addDefined(InputFile *F, const WasmSymbol *Sym) {
+  DEBUG(dbgs() << "addDefined: " << Sym->Name << "\n");
+  Symbol *S;
+  bool WasInserted;
+  Symbol::Kind Kind = Symbol::DefinedFunctionKind;
+  if (Sym->Type == WasmSymbol::SymbolType::GLOBAL_EXPORT)
+    Kind = Symbol::DefinedGlobalKind;
+
+  std::tie(S, WasInserted) = insert(Sym->Name);
+  if (WasInserted) {
+    S->update(Kind, F, Sym);
+  } else if (!S->isDefined()) {
+    // The existing symbol table entry in undefined. The new symbol replaces
+    // it
+    DEBUG(dbgs() << "resolving existing undefined symbol: " << Sym->Name << "\n");
+    checkSymbolTypes(S, F, Sym);
+    S->update(Kind, F, Sym);
+  } else {
+    // The existing symbol is defined.
+    if (Sym->isWeak()) {
+      // the new symbol is weak we can ignore it
+      DEBUG(dbgs() << "existing symbol takes precensence\n");
+    } else if (S->isWeak()) {
+      // the new symbol is not weak and the existing symbol is, so we replace
+      // it
+      DEBUG(dbgs() << "replacing existing weak symbol\n");
+      S->update(Kind, F, Sym);
+    } else {
+      // niether symbol is week. They conflict.
+      reportDuplicate(S, F);
+    }
+  }
+  return S;
+}
+
+Symbol *SymbolTable::addUndefinedFunction(StringRef Name) {
+  Symbol *S;
+  bool WasInserted;
+  std::tie(S, WasInserted) = insert(Name);
+  if (WasInserted)
+    S->update(Symbol::UndefinedFunctionKind);
+  else if (!S->isFunction())
+    error("symbol type mismatch: " + Name);
+  return S;
+}
+
+Symbol *SymbolTable::addUndefined(InputFile* F, const WasmSymbol *Sym) {
+  DEBUG(dbgs() << "addUndefined: " << displayName(Sym->Name) << "\n");
+  Symbol *S;
+  bool WasInserted;
+  Symbol::Kind Kind = Symbol::UndefinedFunctionKind;
+  if (Sym->Type == WasmSymbol::SymbolType::GLOBAL_IMPORT)
+    Kind = Symbol::UndefinedGlobalKind;
+  std::tie(S, WasInserted) = insert(Sym->Name);
+  if (WasInserted) {
+    S->update(Kind, F, Sym);
+  } else if (S->isLazy()) {
+    DEBUG(dbgs() << "resolved by existing lazy\n");
+    auto *AF = cast<ArchiveFile>(S->getFile());
+    AF->addMember(&S->getArchiveSymbol());
+  } else if (S->isDefined()) {
+    DEBUG(dbgs() << "resolved by existing\n");
+    checkSymbolTypes(S, F, Sym);
+  }
+  return S;
+}
+
+void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol *Sym) {
+  DEBUG(dbgs() << "addLazy: " << displayName(Sym->getName()) << "\n");
+  StringRef Name = Sym->getName();
+  Symbol *S;
+  bool WasInserted;
+  std::tie(S, WasInserted) = insert(Name);
+  if (WasInserted) {
+    S->update(Symbol::LazyKind, F);
+    S->setArchiveSymbol(*Sym);
+  } else if (S->isUndefined() && !S->isLazy()) {
+    // There is an existing undefined symbol.  The can load from the
+    // archive.
+    DEBUG(dbgs() << "replacing existing undefined\n");
+    F->addMember(Sym);
+  }
+}
+
+} // namespace wasm
+} // namespace lld
Index: wasm/Symbols.h
===================================================================
--- /dev/null
+++ wasm/Symbols.h
@@ -0,0 +1,107 @@
+//===- Symbols.h ------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_SYMBOLS_H
+#define LLD_WASM_SYMBOLS_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/Object/Archive.h"
+#include "llvm/Object/Wasm.h"
+
+using llvm::object::Archive;
+using llvm::object::WasmSymbol;
+using llvm::wasm::WasmImport;
+using llvm::wasm::WasmExport;
+
+namespace lld {
+namespace wasm {
+
+class InputFile;
+
+class Symbol {
+public:
+  enum Kind {
+    DefinedFunctionKind = 0,
+    DefinedGlobalKind,
+
+    LazyKind,
+    UndefinedFunctionKind,
+    UndefinedGlobalKind,
+
+    LastDefinedKind = DefinedGlobalKind,
+    InvalidKind,
+  };
+
+  Symbol(StringRef Name)
+      : WrittenToSymtab(0), WrittenToNameSec(0), Name(Name), ArchiveSymbol(nullptr, 0, 0) {}
+
+  Kind getKind() const { return SymbolKind; }
+
+  bool isLazy() const { return SymbolKind == LazyKind; }
+  bool isDefined() const { return SymbolKind <= LastDefinedKind; }
+  bool isUndefined() const { return !isDefined(); }
+  bool isFunction() const {
+    return SymbolKind == DefinedFunctionKind ||
+           SymbolKind == UndefinedFunctionKind;
+  }
+  bool isGlobal() const { return !isFunction(); }
+  bool isWeak() const;
+
+  // Returns the symbol name.
+  StringRef getName() const;
+
+  // Returns the file from which this symbol was created.
+  InputFile *getFile() const;
+
+  uint32_t getGlobalIndex() const;
+  uint32_t getFunctionIndex() const;
+  uint32_t getFunctionTypeIndex() const;
+  uint32_t getOutputIndex() const;
+
+  bool hasOutputIndex() { return OutputIndexSet; }
+
+  void setOutputIndex(uint32_t Index);
+
+  void update(Kind K, InputFile *F = nullptr, const WasmSymbol *Sym = nullptr);
+
+  void setArchiveSymbol(const Archive::Symbol &Sym);
+  const Archive::Symbol& getArchiveSymbol() { return ArchiveSymbol; }
+
+  // This bit is used by Writer::writeNameSection() to prevent
+  // symbols from being written to the symbol table more than once.
+  unsigned WrittenToSymtab : 1;
+  unsigned WrittenToNameSec : 1;
+
+protected:
+  const WasmImport &getImport() const;
+  const WasmExport &getExport() const;
+
+  StringRef Name;
+  Archive::Symbol ArchiveSymbol;
+  Kind SymbolKind = InvalidKind;
+  InputFile* File = nullptr;
+  const WasmSymbol* Sym = nullptr;
+  uint32_t OutputIndex = 0;
+  bool OutputIndexSet = false;
+};
+
+} // namespace wasm
+
+std::string toString(wasm::Symbol &Sym);
+std::string toString(wasm::Symbol::Kind &Kind);
+
+inline llvm::raw_ostream &operator<<(raw_ostream &OS, wasm::Symbol &Sym) {
+  OS << toString(Sym);
+  return OS;
+}
+
+} // namespace lld
+
+
+#endif
Index: wasm/Symbols.cpp
===================================================================
--- /dev/null
+++ wasm/Symbols.cpp
@@ -0,0 +1,117 @@
+//===- Symbols.cpp --------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Symbols.h"
+
+#include "Config.h"
+#include "Error.h"
+#include "InputFiles.h"
+#include "Strings.h"
+
+#define DEBUG_TYPE "lld"
+
+using namespace llvm;
+
+namespace lld {
+namespace wasm {
+
+StringRef Symbol::getName() const {
+  return Name;
+}
+
+InputFile* Symbol::getFile() const {
+  return File;
+}
+
+void Symbol::setArchiveSymbol(const Archive::Symbol &Sym) {
+  ArchiveSymbol = Sym;
+}
+
+uint32_t Symbol::getGlobalIndex() const {
+  const WasmExport &Export = getExport();
+  assert(Export.Kind == llvm::wasm::WASM_EXTERNAL_GLOBAL);
+  return Export.Index;
+}
+
+uint32_t Symbol::getFunctionIndex() const {
+  const WasmExport &Export = getExport();
+  assert(Export.Kind == llvm::wasm::WASM_EXTERNAL_FUNCTION);
+  return Export.Index;
+}
+
+uint32_t Symbol::getFunctionTypeIndex() const {
+  const WasmImport &Import = getImport();
+  assert(Import.Kind == llvm::wasm::WASM_EXTERNAL_FUNCTION);
+  return Import.SigIndex;
+}
+
+const WasmImport& Symbol::getImport() const {
+  assert(isUndefined());
+  assert(Sym != nullptr);
+  assert(isa<ObjectFile>(File));
+  ObjectFile* Obj = dyn_cast<ObjectFile>(File);
+  assert(Sym->ElementIndex < Obj->getWasmObj()->imports().size());
+  return Obj->getWasmObj()->imports()[Sym->ElementIndex];
+}
+
+const WasmExport& Symbol::getExport() const {
+  DEBUG(dbgs() << "getExport: " << getName()
+               << " ElementIndex: " << Sym->ElementIndex << "\n");
+  assert(isDefined());
+  assert(Sym != nullptr);
+  assert(isa<ObjectFile>(File));
+  ObjectFile* Obj = dyn_cast<ObjectFile>(File);
+  assert(Sym->ElementIndex < Obj->getWasmObj()->exports().size());
+  return Obj->getWasmObj()->exports()[Sym->ElementIndex];
+}
+
+uint32_t Symbol::getOutputIndex() const {
+  if (isUndefined() && isWeak()) {
+    return 0;
+  }
+  assert(OutputIndexSet);
+  return OutputIndex;
+}
+
+void Symbol::setOutputIndex(uint32_t Index) {
+  assert(!OutputIndexSet);
+  DEBUG(dbgs() << "setOutputIndex: " << Index << ": " << Name
+               << " kind=" << toString(SymbolKind) << "\n");
+  OutputIndex = Index;
+  OutputIndexSet = true;
+}
+
+void Symbol::update(Kind K, InputFile *F, const WasmSymbol *WasmSym) {
+  SymbolKind = K;
+  File = F;
+  Sym = WasmSym;
+}
+
+bool Symbol::isWeak() const {
+  return Sym && Sym->isWeak();
+}
+
+} // namespace wasm
+
+// Returns a symbol name for an error message.
+std::string toString(wasm::Symbol &Sym) {
+  return wasm::displayName(Sym.getName());
+}
+
+std::string toString(wasm::Symbol::Kind &Kind) {
+  switch (Kind) {
+  case wasm::Symbol::DefinedFunctionKind: return "DefinedFunction";
+  case wasm::Symbol::DefinedGlobalKind: return "DefinedGlobal";
+  case wasm::Symbol::UndefinedFunctionKind: return "UndefinedFunction";
+  case wasm::Symbol::UndefinedGlobalKind: return "UndefinedGlobal";
+  case wasm::Symbol::LazyKind: return "LazyKind";
+  }
+}
+
+} // namespace lld
Index: wasm/Threads.h
===================================================================
--- /dev/null
+++ wasm/Threads.h
@@ -0,0 +1,36 @@
+//===- Threads.h ------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file is essentially a fork of ELF/Threads.h
+// TODO(sbc): Refactor into library to avoid duplication.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_THREADS_H
+#define LLD_WASM_THREADS_H
+
+#include "Config.h"
+
+#include "llvm/Support/Parallel.h"
+#include <functional>
+
+namespace lld {
+namespace wasm {
+
+template <typename R, class FuncTy> void parallelForEach(R &&Range, FuncTy Fn) {
+  if (Config->Threads)
+    for_each(llvm::parallel::par, std::begin(Range), std::end(Range), Fn);
+  else
+    for_each(llvm::parallel::seq, std::begin(Range), std::end(Range), Fn);
+}
+
+} // namespace wasm
+} // namespace lld
+
+#endif
Index: wasm/Writer.h
===================================================================
--- /dev/null
+++ wasm/Writer.h
@@ -0,0 +1,41 @@
+//===- Writer.h -------------------------------------------------*- C++ -*-===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_WRITER_H
+#define LLD_WASM_WRITER_H
+
+#include "llvm/BinaryFormat/Wasm.h"
+#include "llvm/Object/Wasm.h"
+#include "llvm/Support/raw_ostream.h"
+
+using llvm::raw_fd_ostream;
+using llvm::OwningArrayRef;
+using namespace llvm::wasm;
+
+namespace lld {
+namespace wasm {
+
+class SymbolTable;
+
+// For patching purposes, we need to remember where each section starts, both
+// for patching up the section size field, and for patching up references to
+// locations within the section.
+struct SectionBookkeeping {
+  // Where the size of the section is written.
+  uint64_t SizeOffset;
+  // Where the contents of the section starts (after the header).
+  uint64_t ContentsOffset;
+};
+
+void writeResult(SymbolTable *T);
+
+}
+}
+
+#endif
Index: wasm/Writer.cpp
===================================================================
--- /dev/null
+++ wasm/Writer.cpp
@@ -0,0 +1,1401 @@
+//===- Writer.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Writer.h"
+
+#include "Config.h"
+#include "Error.h"
+#include "Memory.h"
+#include "SymbolTable.h"
+#include "Threads.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/EndianStream.h"
+#include "llvm/Support/FileOutputBuffer.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/LEB128.h"
+
+#include <cstdarg>
+
+#define DEBUG_TYPE "lld"
+
+using namespace llvm;
+using namespace llvm::wasm;
+using namespace lld;
+using namespace lld::wasm;
+
+struct OutputRelocation : public WasmRelocation {
+  uint32_t NewIndex;
+  int64_t Value;
+};
+
+static void calcRelocations(const ObjectFile &File,
+                            const std::vector<WasmRelocation> &Relocs,
+                            std::vector<OutputRelocation> &OutputRelocs,
+                            uint32_t OutputOffset, uint32_t Start=0, uint32_t End=0);
+
+static void applyRelocations(uint8_t *Data,
+                             const std::vector<OutputRelocation> &Relocs,
+                             uint32_t Offset);
+
+namespace {
+
+static const int kStackAlignment = 16;
+
+enum class RelocEncoding {
+  Uleb128,
+  Sleb128,
+  I32,
+};
+
+// Needed for WasmSignatureDenseMapInfo
+bool operator==(const WasmSignature& LHS, const WasmSignature& RHS) {
+  return LHS.ReturnType == RHS.ReturnType && LHS.ParamTypes == RHS.ParamTypes;
+}
+
+// Traits for using WasmSignature in a DenseMap.
+struct WasmSignatureDenseMapInfo {
+  static WasmSignature getEmptyKey() {
+    WasmSignature Sig;
+    Sig.ReturnType = 1;
+    return Sig;
+  }
+  static WasmSignature getTombstoneKey() {
+    WasmSignature Sig;
+    Sig.ReturnType = 2;
+    return Sig;
+  }
+  static unsigned getHashValue(const WasmSignature &Sig) {
+    uintptr_t Value = 0;
+    Value += DenseMapInfo<int32_t>::getHashValue(Sig.ReturnType);
+    for (int32_t Param : Sig.ParamTypes)
+      Value += DenseMapInfo<int32_t>::getHashValue(Param);
+    return Value;
+  }
+  static bool isEqual(const WasmSignature &LHS,
+                      const WasmSignature &RHS) {
+    return LHS == RHS;
+  }
+};
+
+static void debugWrite(raw_ostream &OS, const char *msg,
+                        const char *fmt = NULL, ...) {
+  DEBUG(
+    fprintf(stderr, "  | %08" PRIx64 ": %s", OS.tell(), msg);
+    if (fmt) {
+      fprintf(stderr, " [");
+      va_list ap;
+      va_start(ap, fmt);
+      vfprintf(stderr, fmt, ap);
+      va_end(ap);
+      fprintf(stderr, "]");
+    }
+    fprintf(stderr, "\n");
+  );
+}
+
+static void write_uleb128(raw_ostream& OS, uint32_t Number, const char* msg) {
+  if (msg)
+    debugWrite(OS, msg, "%x", Number);
+  encodeULEB128(Number, OS);
+}
+
+static void write_sleb128(raw_ostream& OS, int32_t Number, const char* msg) {
+  if (msg)
+    debugWrite(OS, msg, "%x", Number);
+  encodeSLEB128(Number, OS);
+}
+
+static void write_bytes(raw_ostream &OS, const char *bytes, size_t count,
+                        const char *msg = nullptr) {
+  if (msg)
+    debugWrite(OS, msg);
+  OS.write(bytes, count);
+}
+
+static void write_data(raw_ostream& OS, const StringRef String, const char* msg = nullptr) {
+  if (msg)
+    debugWrite(OS, msg, "data[%d]", String.size());
+  write_bytes(OS, String.data(), String.size());
+}
+
+static void write_str(raw_ostream& OS, const StringRef String, const char* msg = nullptr) {
+  if (msg)
+    debugWrite(OS, msg, "str[%d]: %.*s", String.size(), String.size(), String.data());
+  write_uleb128(OS, String.size(), nullptr);
+  write_bytes(OS, String.data(), String.size());
+}
+
+static const char* sectionTypeToString(uint32_t SectionType) {
+  switch (SectionType) {
+  case WASM_SEC_CUSTOM:
+    return "CUSTOM";
+  case WASM_SEC_TYPE:
+    return "TYPE";
+  case WASM_SEC_IMPORT:
+    return "IMPORT";
+  case WASM_SEC_FUNCTION:
+    return "FUNCTION";
+  case WASM_SEC_TABLE:
+    return "TABLE";
+  case WASM_SEC_MEMORY:
+    return "MEMORY";
+  case WASM_SEC_GLOBAL:
+    return "GLOBAL";
+  case WASM_SEC_EXPORT:
+    return "EXPORT";
+  case WASM_SEC_START:
+    return "START";
+  case WASM_SEC_ELEM:
+    return "ELEM";
+  case WASM_SEC_CODE:
+    return "CODE";
+  case WASM_SEC_DATA:
+    return "DATA";
+  default:
+    fatal("invalid section type");
+    return nullptr;
+  }
+}
+
+class OutputSection;
+std::string toString(OutputSection *Section);
+
+
+class OutputSection {
+public:
+  OutputSection(uint32_t Type, std::string Name = "")
+      : Type(Type), Name(Name), Offset(0) {}
+
+  virtual ~OutputSection() = default;
+
+  void setOffset(size_t NewOffset) {
+    log("setOffset: " + toString(this) + " -> " + Twine(NewOffset));
+    Offset = NewOffset;
+  }
+
+  void createHeader(size_t BodySize) {
+    raw_string_ostream OS(Header);
+    debugWrite(OS, "section type", "%s", sectionTypeToString(Type));
+    write_uleb128(OS, Type, nullptr);
+    write_uleb128(OS, BodySize, "section size");
+    OS.flush();
+    log("createHeader: " + toString(this) + " body=" + Twine(BodySize) +
+        " total=" + Twine(getSize()));
+  }
+
+  virtual size_t getSize() const = 0;
+  virtual void writeTo(uint8_t* Ptr) = 0;
+  virtual void finalizeContents() = 0;
+
+  std::string Header;
+  uint32_t Type;
+  std::string Name;
+  std::vector<OutputRelocation> Relocations;
+
+protected:
+  size_t Offset;
+};
+
+class SyntheticSection : public OutputSection {
+public:
+  SyntheticSection(uint32_t Type, std::string Name = "")
+      : OutputSection(Type, Name), BodyOutputStream(Body) {
+    if (!Name.empty())
+      write_str(BodyOutputStream, Name);
+  }
+
+  void writeTo(uint8_t* Ptr) override {
+    assert(Offset);
+    log("writing " + toString(this));
+    Ptr += Offset;
+    memcpy(Ptr, Header.data(), Header.size());
+    Ptr += Header.size();
+    memcpy(Ptr, Body.data(), Body.size());
+  }
+
+  size_t getSize() const override {
+    return Header.size() + Body.size();
+  }
+
+  void finalizeContents() override {
+    BodyOutputStream.flush();
+    createHeader(Body.size());
+  }
+
+  raw_ostream& getStream() {
+    return BodyOutputStream;
+  }
+
+  std::string Body;
+
+protected:
+  raw_string_ostream BodyOutputStream;
+};
+
+class SubSection : public SyntheticSection {
+public:
+  explicit SubSection(uint32_t Type) : SyntheticSection(Type) {}
+
+  void writeToStream(raw_ostream& OS) {
+    write_data(OS, Header);
+    write_data(OS, Body);
+  }
+};
+
+class CodeSection : public OutputSection {
+public:
+  explicit CodeSection(uint32_t TotalFunctions, std::vector<ObjectFile *> &Objs)
+      : OutputSection(WASM_SEC_CODE), InputObjects(Objs), BodySize(0) {
+
+    raw_string_ostream OS(CodeSectionHeader);
+    write_uleb128(OS, TotalFunctions, "function count");
+    OS.flush();
+    BodySize = CodeSectionHeader.size();
+
+    uint32_t NumRelocations = 0;
+    for (ObjectFile *File: InputObjects) {
+      if (!File->CodeSection)
+        continue;
+
+      NumRelocations += File->CodeSection->Relocations.size();
+      const ArrayRef<uint8_t> Content = File->CodeSection->Content;
+      unsigned HeaderSize = 0;
+      decodeULEB128(Content.data(), &HeaderSize);
+
+      calcRelocations(*File, File->CodeSection->Relocations,
+                      Relocations, BodySize - CodeSectionHeader.size());
+
+      size_t PayloadSize = Content.size() - HeaderSize;
+      BodySize += PayloadSize;
+    }
+    assert(Relocations.size() == NumRelocations);
+    log("NumRelocations: " + Twine(NumRelocations));
+  }
+
+  size_t getSize() const override {
+    return Header.size() + BodySize;
+  }
+
+  void finalizeContents() override {
+    createHeader(BodySize);
+  }
+
+  void writeTo(uint8_t* Ptr) override {
+    log("writing " + toString(this));
+    log(" size=" + Twine(getSize()));
+    Ptr += Offset;
+
+    // Write section header
+    memcpy(Ptr, Header.data(), Header.size());
+    Ptr += Header.size();
+
+    uint8_t* ContentsStart = Ptr;
+
+    // Write code section headers
+    memcpy(Ptr, CodeSectionHeader.data(), CodeSectionHeader.size());
+    Ptr += CodeSectionHeader.size();
+
+
+    // Write code section body
+    for (ObjectFile *File: InputObjects) {
+      if (!File->CodeSection)
+        continue;
+
+      const ArrayRef<uint8_t>& Content(File->CodeSection->Content);
+
+      // Payload doesn't include the initial header (function count)
+      unsigned HeaderSize = 0;
+      decodeULEB128(Content.data(), &HeaderSize);
+
+      size_t PayloadSize = Content.size() - HeaderSize;
+      memcpy(Ptr, Content.data() + HeaderSize, PayloadSize);
+
+      Ptr += PayloadSize;
+    }
+
+    applyRelocations(ContentsStart, Relocations, 0);
+  }
+
+protected:
+  std::vector<ObjectFile*>& InputObjects;
+  std::string CodeSectionHeader;
+  size_t BodySize;
+};
+
+struct OutputDataSegment {
+  OutputDataSegment(std::string H, const object::WasmSegment* S) : Header(H), Segment(S) {}
+  std::string Header;
+  const object::WasmSegment* Segment;
+};
+
+class DataSection : public OutputSection {
+public:
+  explicit DataSection(uint32_t TotalDataSegments, std::vector<ObjectFile *> &Objs)
+      : OutputSection(WASM_SEC_DATA), InputObjects(Objs), BodySize(0) {
+
+    raw_string_ostream OS(DataSectionHeader);
+    write_uleb128(OS, TotalDataSegments, "data segment count");
+    OS.flush();
+    BodySize = DataSectionHeader.size();
+
+    uint32_t NumRelocations = 0;
+
+    for (ObjectFile *File: Symtab->ObjectFiles) {
+      if (!File->DataSection)
+        continue;
+      NumRelocations += File->DataSection->Relocations.size();
+      assert(File->getWasmObj()->dataSegments().size() <= 1);
+      //uint32_t DataSectionOffset = BodySize - DataSectionHeader.size();
+      for (const object::WasmSegment &Segment: File->getWasmObj()->dataSegments()) {
+        std::string SegmentHeader;
+        raw_string_ostream OS(SegmentHeader);
+        write_uleb128(OS, Segment.Data.MemoryIndex, "memory index");
+        write_uleb128(OS, WASM_OPCODE_I32_CONST, "opcode:i32const");
+        uint32_t NewOffset = Segment.Data.Offset.Value.Int32 + File->DataOffset;
+        write_sleb128(OS, NewOffset, "memory offset");
+        write_uleb128(OS, WASM_OPCODE_END, "opcode:end");
+        write_uleb128(OS, Segment.Data.Content.size(), "segment size");
+        OS.flush();
+        BodySize += SegmentHeader.size();
+
+        log("Data segment: size=" + Twine(Segment.Data.Content.size()));
+        calcRelocations(*File, File->DataSection->Relocations, Relocations, BodySize - Segment.SectionOffset, Segment.SectionOffset, Segment.SectionOffset + Segment.Data.Content.size());
+        BodySize += Segment.Data.Content.size();
+        OutputSegments.emplace_back(SegmentHeader, &Segment);
+      }
+    }
+
+    log("NumRelocations: " + Twine(NumRelocations));
+    assert(Relocations.size() == NumRelocations);
+  }
+
+  size_t getSize() const override {
+    return Header.size() + BodySize;
+  }
+
+  void finalizeContents() override {
+    createHeader(BodySize);
+  }
+
+  void writeTo(uint8_t* Ptr) override {
+    log("writing " + toString(this));
+    log(" size=" + Twine(getSize()) + " body=" + Twine(BodySize));
+    Ptr += Offset;
+
+    // Write section header
+    memcpy(Ptr, Header.data(), Header.size());
+    Ptr += Header.size();
+
+    uint8_t* ContentsStart = Ptr;
+
+    // Write code section headers
+    memcpy(Ptr, DataSectionHeader.data(), DataSectionHeader.size());
+    Ptr += DataSectionHeader.size();
+
+    for (OutputDataSegment& Segment: OutputSegments) {
+      // Write segment header
+      memcpy(Ptr, Segment.Header.data(), Segment.Header.size());
+      Ptr += Segment.Header.size();
+
+      // Data data payload
+      const ArrayRef<uint8_t>& Content(Segment.Segment->Data.Content);
+      memcpy(Ptr, Content.data(), Content.size());
+      Ptr += Content.size();
+    }
+
+    applyRelocations(ContentsStart,
+                     Relocations, 0);
+                     //Segment.SectionOffset);
+  }
+
+protected:
+  std::vector<ObjectFile*>& InputObjects;
+  std::vector<OutputDataSegment> OutputSegments;
+  std::string DataSectionHeader;
+  size_t BodySize;
+};
+
+std::string toString(OutputSection *Section) {
+  std::string rtn = "section: ";
+  rtn += sectionTypeToString(Section->Type);
+  if (!Section->Name.empty()) {
+    rtn += "(";
+    rtn += Section->Name;
+    rtn += ")";
+  }
+  return rtn;
+};
+
+// The writer writes a SymbolTable result to a file.
+class Writer {
+public:
+  Writer(SymbolTable *T) : Symtab(T) {}
+  void run();
+
+private:
+  void openFile();
+
+  void assignSymbolIndexes();
+  void calculateImports();
+  void calculateOffsets();
+  void calculateTypes();
+  void layoutMemory();
+  void createHeader();
+  void createSections();
+  SyntheticSection *createSyntheticSection(uint32_t Type, std::string Name = "");
+
+  // Builtin sections
+  void createTypeSection();
+  void createFunctionSection();
+  void createTableSection();
+  void createGlobalSection();
+  void createExportSection();
+  void createImportSection();
+  void createMemorySection();
+  void createElemSection();
+  void createStartSection();
+  void createCodeSection();
+  void createDataSection();
+
+  // Custom sections
+  void createRelocSections();
+  void createLinkingSection();
+  void createNameSection();
+
+  void writeHeader();
+  void writeSections();
+  void writeOutput(const uint8_t* Ptr, size_t Size, size_t Offset);
+
+  uint64_t FileSize = 0;
+  uint32_t DataSize = 0;
+  uint32_t DataAlignment = 1;
+  uint32_t TotalFunctions = 0;
+  uint32_t TotalGlobals = 0;
+  uint32_t TotalMemoryPages = 0;
+  uint32_t TotalTableLength = 0;
+  uint32_t TotalElements = 0;
+  uint32_t TotalDataSegments = 0;
+  uint32_t InitialTableOffset = 0;
+
+  SymbolTable *Symtab;
+  std::vector<const WasmSignature*> Types;
+  DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
+  std::vector<Symbol*> FunctionImports;
+  std::vector<Symbol*> GlobalImports;
+
+  // Elements that are used to construct the final output
+  std::string Header;
+  std::vector<OutputSection *> OutputSections;
+
+  std::unique_ptr<FileOutputBuffer> Buffer;
+};
+
+} // anonymous namespace
+
+// Return the padding size to write a 32-bit value into a 5-byte ULEB128.
+static unsigned paddingFor5ByteULEB128(uint32_t X) {
+  return X == 0 ? 4 : (4u - (31u - countLeadingZeros(X)) / 7u);
+}
+
+// Return the padding size to write a 32-bit value into a 5-byte SLEB128.
+static unsigned paddingFor5ByteSLEB128(int32_t X) {
+  return 5 - getSLEB128Size(X);
+}
+
+static void debugPrint(const char* fmt, ...) {
+  if (Config->Verbose) {
+    fprintf(stderr, "lld: ");
+    va_list ap;
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+  }
+}
+
+static const char* value_type_to_str(int32_t Type) {
+  switch (Type) {
+  case WASM_TYPE_I32:
+    return "i32";
+  case WASM_TYPE_I64:
+    return "i64";
+  case WASM_TYPE_F32:
+    return "f32";
+  case WASM_TYPE_F64:
+    return "f64";
+  default:
+    fatal("invalid value type: " + Twine(Type));
+    return nullptr;
+  }
+}
+
+static void write_u8(raw_ostream& OS, uint8_t byte, const char* msg) {
+  OS << byte;
+}
+
+static void write_u32(raw_ostream& OS, uint32_t Number, const char* msg) {
+  debugWrite(OS, msg, "%x", Number);
+  support::endian::Writer<support::little>(OS).write(Number);
+}
+
+static void write_value_type(raw_ostream& OS, int32_t Type, const char* msg) {
+  debugWrite(OS, msg, "type: %s", value_type_to_str(Type));
+  write_sleb128(OS, Type, nullptr);
+}
+
+static void write_sig(raw_ostream& OS, const WasmSignature &Sig) {
+  write_sleb128(OS, WASM_TYPE_FUNC, "signature type");
+  write_uleb128(OS, Sig.ParamTypes.size(), "param count");
+  for (int32_t ParamType: Sig.ParamTypes) {
+    write_value_type(OS, ParamType, "param type");
+  }
+  if (Sig.ReturnType == WASM_TYPE_NORESULT) {
+    write_uleb128(OS, 0, "result count");
+  } else {
+    write_uleb128(OS, 1, "result count");
+    write_value_type(OS, Sig.ReturnType, "result type");
+  }
+}
+
+static void write_init_expr(raw_ostream& OS, const WasmInitExpr& InitExpr) {
+  write_u8(OS, InitExpr.Opcode, "opcode");
+  switch (InitExpr.Opcode) {
+  case WASM_OPCODE_I32_CONST:
+    write_sleb128(OS, InitExpr.Value.Int32, "literal (i32)");
+    break;
+  case WASM_OPCODE_I64_CONST:
+    write_sleb128(OS, InitExpr.Value.Int64, "literal (i64)");
+    break;
+  case WASM_OPCODE_GET_GLOBAL:
+    write_uleb128(OS, InitExpr.Value.Global, "literal (global index)");
+    break;
+  default:
+    fatal("unknown opcode in init expr: " + Twine(InitExpr.Opcode));
+    break;
+  }
+  write_u8(OS, WASM_OPCODE_END, "opcode:end");
+}
+
+static void write_limits(raw_ostream& OS, const WasmLimits& Limits) {
+  write_uleb128(OS, Limits.Flags, "limits flags");
+  write_uleb128(OS, Limits.Initial, "limits initial");
+  if (Limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
+    write_uleb128(OS, Limits.Maximum, "limits max");
+}
+
+static void write_global(raw_ostream& OS, const WasmGlobal& Global) {
+  write_value_type(OS, Global.Type, "global type");
+  write_uleb128(OS, Global.Mutable, "global mutable");
+  write_init_expr(OS, Global.InitExpr);
+}
+
+static void write_import(raw_ostream& OS, const WasmImport& Import) {
+  write_str(OS, Import.Module, "import module name");
+  write_str(OS, Import.Field, "import field name");
+  write_u8(OS, Import.Kind, "import kind");
+  switch (Import.Kind) {
+    case WASM_EXTERNAL_FUNCTION:
+      write_uleb128(OS, Import.SigIndex, "import sig index");
+      break;
+    case WASM_EXTERNAL_GLOBAL:
+      write_value_type(OS, Import.Global.Type, "import global type");
+      write_uleb128(OS, Import.Global.Mutable, "import global mutable");
+      break;
+    case WASM_EXTERNAL_MEMORY:
+      write_limits(OS, Import.Memory);
+      break;
+    default:
+      fatal("unsupported import type: " + Twine(Import.Kind));
+      break;
+  }
+}
+
+static void write_export(raw_ostream& OS, const WasmExport& Export) {
+  write_str(OS, Export.Name, "export name");
+  write_u8(OS, Export.Kind, "export kind");
+  switch (Export.Kind) {
+    case WASM_EXTERNAL_FUNCTION:
+      write_uleb128(OS, Export.Index, "function index");
+      break;
+    case WASM_EXTERNAL_GLOBAL:
+      write_uleb128(OS, Export.Index, "global index");
+      break;
+    case WASM_EXTERNAL_MEMORY:
+      write_uleb128(OS, Export.Index, "memory index");
+      break;
+    default:
+      fatal("unsupported export type: " + Twine(Export.Kind));
+      break;
+  }
+}
+
+static void write_reloc(raw_ostream& OS, const OutputRelocation &Reloc) {
+  write_uleb128(OS, Reloc.Type, "reloc type");
+  write_uleb128(OS, Reloc.Offset, "reloc offset");
+  write_uleb128(OS, Reloc.NewIndex, "reloc index");
+
+  switch (Reloc.Type) {
+  case R_WEBASSEMBLY_GLOBAL_ADDR_LEB:
+  case R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
+  case R_WEBASSEMBLY_GLOBAL_ADDR_I32:
+    write_uleb128(OS, Reloc.Addend, "reloc addend");
+    break;
+  default:
+    break;
+  }
+}
+
+void Writer::createImportSection() {
+  uint32_t TotalImports = FunctionImports.size() + GlobalImports.size();
+  if (Config->ImportMemory)
+    TotalImports++;
+
+  if (TotalImports == 0)
+    return;
+
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_IMPORT);
+  raw_ostream& OS = Section->getStream();
+
+  write_uleb128(OS, TotalImports, "import count");
+
+  for (Symbol *Sym: FunctionImports) {
+    WasmImport Import;
+    Import.Module = "env";
+    Import.Field = Sym->getName();
+    Import.Kind = WASM_EXTERNAL_FUNCTION;
+    assert(isa<ObjectFile>(Sym->getFile()));
+    ObjectFile* Obj = dyn_cast<ObjectFile>(Sym->getFile());
+    Import.SigIndex = Obj->relocateTypeIndex(Sym->getFunctionTypeIndex());
+    write_import(OS, Import);
+  }
+
+  if (Config->ImportMemory) {
+    WasmImport Import;
+    Import.Module = "env";
+    Import.Field = "memory";
+    Import.Kind = WASM_EXTERNAL_MEMORY;
+    Import.Memory.Flags = 0;
+    Import.Memory.Initial = TotalMemoryPages;
+    write_import(OS, Import);
+  }
+
+  for (Symbol *Sym: GlobalImports) {
+    WasmImport Import;
+    Import.Module = "env";
+    Import.Field = Sym->getName();
+    Import.Kind = WASM_EXTERNAL_GLOBAL;
+    Import.Global.Mutable = false;
+    assert(isa<ObjectFile>(Sym->getFile()));
+    // TODO(sbc): Set type of this import
+    //ObjectFile* Obj = dyn_cast<ObjectFile>(Sym->getFile());
+    Import.Global.Type = WASM_TYPE_I32; //Sym->getGlobalType();
+    write_import(OS, Import);
+  }
+}
+
+void Writer::createTypeSection() {
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_TYPE);
+  raw_ostream& OS = Section->getStream();
+  write_uleb128(OS, Types.size(), "type count");
+  for (const WasmSignature *Sig : Types) {
+    write_sig(OS, *Sig);
+  }
+}
+
+void Writer::createFunctionSection() {
+  if (!TotalFunctions)
+    return;
+
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_FUNCTION);
+  raw_ostream& OS = Section->getStream();
+
+  write_uleb128(OS, TotalFunctions, "function count");
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    for (uint32_t Sig: File->getWasmObj()->functionTypes()) {
+      write_uleb128(OS, File->relocateTypeIndex(Sig), "sig index");
+    }
+  }
+}
+
+void Writer::createMemorySection() {
+  if (Config->ImportMemory)
+    return;
+
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_MEMORY);
+  raw_ostream& OS = Section->getStream();
+
+  write_uleb128(OS, 1, "memory count");
+  write_uleb128(OS, 0, "memory limits flags");
+  write_uleb128(OS, TotalMemoryPages, "initial pages");
+}
+
+void Writer::createGlobalSection() {
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_GLOBAL);
+  raw_ostream& OS = Section->getStream();
+
+  write_uleb128(OS, TotalGlobals, "global count");
+  for (auto& Pair: Config->SyntheticGlobals) {
+    WasmGlobal& Global = Pair.second;
+    write_global(OS, Global);
+  }
+
+  if (Config->Relocatable) {
+    for (ObjectFile *File: Symtab->ObjectFiles) {
+      uint32_t GlobalIndex = File->GlobalImports.size();
+      for (const WasmGlobal &Global: File->getWasmObj()->globals()) {
+        WasmGlobal RelocatedGlobal(Global);
+        if (Global.Type != WASM_TYPE_I32)
+          fatal("unsupported global type: " + Twine(Global.Type));
+        if (Global.InitExpr.Opcode != WASM_OPCODE_I32_CONST)
+          fatal("unsupported global init opcode: " +
+                Twine(Global.InitExpr.Opcode));
+        RelocatedGlobal.InitExpr.Value.Int32 = File->getGlobalAddress(GlobalIndex);
+        write_global(OS, RelocatedGlobal);
+        GlobalIndex++;
+      }
+    }
+  }
+}
+
+void Writer::createTableSection() {
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_TABLE);
+  raw_ostream& OS = Section->getStream();
+
+  write_uleb128(OS, 1, "table count");
+  write_sleb128(OS, WASM_TYPE_ANYFUNC, "table type");
+  write_uleb128(OS, WASM_LIMITS_FLAG_HAS_MAX, "table flags");
+  write_uleb128(OS, TotalTableLength, "table initial size");
+  write_uleb128(OS, TotalTableLength, "table max size");
+}
+
+void Writer::createExportSection() {
+  // Memory is and main function are exported for executables.
+  bool ExportMemory = !Config->Relocatable && !Config->ImportMemory;
+  bool ExportMain = !Config->Relocatable;
+  bool ExportOther = true; //Config->Relocatable;
+
+  if (Config->Entry == Config->ExportEntryAs && ExportOther)
+    ExportMain = false;
+
+  uint32_t NumExports = 0;
+
+  if (ExportMemory)
+    NumExports += 1;
+
+  if (ExportMain)
+    NumExports += 1;
+
+  if (ExportOther) {
+    for (ObjectFile *File : Symtab->ObjectFiles) {
+      for (Symbol *Sym : File->getSymbols()) {
+         if (!Sym->isFunction() || Sym->isUndefined() || Sym->WrittenToSymtab)
+           continue;
+         Sym->WrittenToSymtab = true;
+         NumExports++;
+      }
+    }
+  }
+
+  if (!NumExports)
+    return;
+
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_EXPORT);
+  raw_ostream& OS = Section->getStream();
+
+  write_uleb128(OS, NumExports, "export count");
+
+  if (ExportMemory) {
+    WasmExport MemoryExport;
+    MemoryExport.Name = "memory";
+    MemoryExport.Kind = WASM_EXTERNAL_MEMORY;
+    MemoryExport.Index = 0;
+    write_export(OS, MemoryExport);
+  }
+
+  if (ExportMain) {
+    Symbol* Sym = Symtab->find(Config->Entry);
+    if (!Sym->isFunction())
+      fatal("entry point is not a function: " + Sym->getName());
+
+    if (Config->Entry != Config->ExportEntryAs || !ExportOther) {
+      Symbol* ExportAs = Symtab->find(Config->ExportEntryAs);
+      if (ExportAs && ExportAs->isDefined()) {
+        warn("can't export entry point");
+        fatal("already an existing exported symbol: " + Config->ExportEntryAs);
+      }
+      WasmExport MainExport;
+      MainExport.Name = Config->ExportEntryAs;
+      MainExport.Kind = WASM_EXTERNAL_FUNCTION;
+      MainExport.Index = Sym->getOutputIndex();
+      write_export(OS, MainExport);
+    }
+  }
+
+  if (ExportOther) {
+    for (ObjectFile *File : Symtab->ObjectFiles) {
+      for (Symbol *Sym : File->getSymbols()) {
+        if (!Sym->isFunction() || Sym->isUndefined() || !Sym->WrittenToSymtab)
+          continue;
+        Sym->WrittenToSymtab = false;
+        log("Export: " + Sym->getName());
+        WasmExport Export;
+        Export.Name = Sym->getName();
+        Export.Index = Sym->getOutputIndex();
+        if (Sym->isFunction())
+          Export.Kind = WASM_EXTERNAL_FUNCTION;
+        else
+          Export.Kind = WASM_EXTERNAL_GLOBAL;
+        write_export(OS, Export);
+      }
+    }
+
+    // TODO(sbc): Export local symbols too, Even though they are not part
+    // of the symbol table?
+  }
+}
+
+void Writer::createStartSection() {}
+
+void Writer::createElemSection() {
+  if (!TotalElements)
+    return;
+
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_ELEM);
+  raw_ostream& OS = Section->getStream();
+
+  write_uleb128(OS, 1, "segment count");
+  write_uleb128(OS, 0, "table index");
+  WasmInitExpr InitExpr;
+  InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+  InitExpr.Value.Int32 = InitialTableOffset;
+  write_init_expr(OS, InitExpr);
+  write_uleb128(OS, TotalElements, "elem count");
+
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    for (const WasmElemSegment &Segment: File->getWasmObj()->elements()) {
+      for (uint64_t FunctionIndex: Segment.Functions) {
+        write_uleb128(OS, File->relocateFunctionIndex(FunctionIndex),
+                      "function index");
+      }
+    }
+  }
+}
+
+static uint32_t calcNewIndex(const ObjectFile &File, const WasmRelocation &Reloc) {
+  uint32_t NewIndex = 0;
+  switch (Reloc.Type) {
+  case R_WEBASSEMBLY_TYPE_INDEX_LEB:
+    NewIndex = File.relocateTypeIndex(Reloc.Index);
+    break;
+  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+    NewIndex = File.relocateFunctionIndex(Reloc.Index);
+    break;
+  case R_WEBASSEMBLY_TABLE_INDEX_I32:
+  case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+    NewIndex = File.relocateTableIndex(Reloc.Index);
+    break;
+  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+  case R_WEBASSEMBLY_GLOBAL_ADDR_LEB:
+  case R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
+  case R_WEBASSEMBLY_GLOBAL_ADDR_I32:
+    NewIndex = File.getGlobalAddress(Reloc.Index);
+    break;
+  default:
+    fatal("unhandled relocation type: " + Twine(Reloc.Type));
+    break;
+  }
+  return NewIndex;
+}
+
+static void writeRelocValue(const OutputRelocation &Reloc, uint8_t *Location) {
+  DEBUG(dbgs() << "write reloc: type=" << Reloc.Type << " index=" << Reloc.Index
+               << " new=" << Reloc.NewIndex
+               << " offset=" << Reloc.Offset << "\n");
+  RelocEncoding Encoding;
+  switch (Reloc.Type) {
+  case R_WEBASSEMBLY_TYPE_INDEX_LEB:
+  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+    assert(decodeULEB128(Location) == Reloc.Index);
+  case R_WEBASSEMBLY_GLOBAL_ADDR_LEB:
+  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+    Encoding = RelocEncoding::Uleb128;
+    break;
+  case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+    assert(decodeSLEB128(Location) == Reloc.Index);
+  case R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
+    Encoding = RelocEncoding::Sleb128;
+    break;
+  case R_WEBASSEMBLY_TABLE_INDEX_I32:
+  case R_WEBASSEMBLY_GLOBAL_ADDR_I32:
+    Encoding = RelocEncoding::I32;
+    break;
+  }
+
+  // Encode the new value
+  switch (Encoding) {
+  case RelocEncoding::Uleb128: {
+    unsigned Padding = paddingFor5ByteULEB128(Reloc.Value);
+    encodeULEB128(Reloc.Value, Location, Padding);
+    break;
+  }
+  case RelocEncoding::Sleb128: {
+    unsigned Padding = paddingFor5ByteSLEB128(Reloc.Value);
+    encodeSLEB128(Reloc.Value, Location, Padding);
+    break;
+  }
+  case RelocEncoding::I32:
+    support::endian::write32<support::little>(Location, Reloc.Value);
+    break;
+  }
+}
+
+static void calcRelocations(const ObjectFile &File,
+                            const std::vector<WasmRelocation> &Relocs,
+                            std::vector<OutputRelocation> &OutputRelocs,
+                            uint32_t OutputOffset, uint32_t Start, uint32_t End) {
+  log("calcRelocations: " + File.getName() + " offset=" + Twine(OutputOffset));
+  for (const WasmRelocation &Reloc: Relocs) {
+    int64_t NewIndex = calcNewIndex(File, Reloc);
+    if (Start && End) {
+      if (Reloc.Offset < Start && Reloc.Offset >= End)
+        continue;
+    }
+    OutputRelocation NewReloc;
+    NewReloc.Type = Reloc.Type;
+    NewReloc.Index = Reloc.Index;
+    NewReloc.Offset = Reloc.Offset + OutputOffset;
+    NewReloc.Addend = Reloc.Addend;
+    NewReloc.NewIndex = NewIndex;
+    DEBUG(dbgs() << "reloc: type=" << Reloc.Type << " index=" << Reloc.Index
+                 << " offset=" << Reloc.Offset << " new=" << NewIndex
+                 << " newOffset=" << NewReloc.Offset << "\n");
+
+    switch (Reloc.Type) {
+    case R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
+    case R_WEBASSEMBLY_GLOBAL_ADDR_I32:
+    case R_WEBASSEMBLY_GLOBAL_ADDR_LEB:
+      NewReloc.Value = File.getGlobalAddress(Reloc.Index) + Reloc.Addend;
+      break;
+    default:
+      NewReloc.Value = NewIndex;
+    }
+
+    OutputRelocs.emplace_back(NewReloc);
+  }
+}
+
+static void applyRelocations(uint8_t *Data,
+                             const std::vector<OutputRelocation> &Relocs,
+                             uint32_t Offset) {
+  log("applyRelocations: offset=" + Twine(Offset) + " count=" + Twine(Relocs.size()));
+  for (const OutputRelocation &Reloc: Relocs) {
+    uint8_t *Location = Data + Reloc.Offset - Offset;
+    writeRelocValue(Reloc, Location);
+  }
+}
+
+void Writer::createCodeSection() {
+  if (!TotalFunctions)
+    return;
+
+  log("createCodeSection");
+
+  auto Section = make<CodeSection>(TotalFunctions, Symtab->ObjectFiles);
+  OutputSections.push_back(Section);
+}
+
+void Writer::createDataSection() {
+  if (!TotalDataSegments)
+    return;
+
+  log("createDataSection");
+  auto Section = make<DataSection>(TotalDataSegments, Symtab->ObjectFiles);
+  OutputSections.push_back(Section);
+}
+
+void Writer::createRelocSections() {
+  for (OutputSection* S: OutputSections) {
+    if (S->Relocations.empty())
+      continue;
+    const char* name;
+    if (S->Type == WASM_SEC_DATA) {
+      name = "reloc.DATA";
+    } else {
+      assert(S->Type == WASM_SEC_CODE);
+      name = "reloc.CODE";
+    }
+    SyntheticSection* Section = createSyntheticSection(WASM_SEC_CUSTOM, name);
+    raw_ostream& OS = Section->getStream();
+    write_uleb128(OS, S->Type, "reloc section");
+    write_uleb128(OS, S->Relocations.size(), "reloc section");
+    for (const OutputRelocation &Reloc: S->Relocations)
+      write_reloc(OS, Reloc);
+  }
+}
+
+void Writer::createLinkingSection() {
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_CUSTOM, "linking");
+  raw_ostream& OS = Section->getStream();
+
+  SubSection DataSizeSubSection(WASM_DATA_SIZE);
+  write_uleb128(DataSizeSubSection.getStream(), DataSize, "data size");
+  DataSizeSubSection.finalizeContents();
+  DataSizeSubSection.writeToStream(OS);
+
+  if (Config->Relocatable) {
+    SubSection DataAlignSubSection(WASM_DATA_ALIGNMENT);
+    write_uleb128(DataAlignSubSection.getStream(), DataAlignment, "data align");
+    DataAlignSubSection.finalizeContents();
+    DataAlignSubSection.writeToStream(OS);
+  }
+}
+
+void Writer::createNameSection() {
+  SyntheticSection* Section = createSyntheticSection(WASM_SEC_CUSTOM, "name");
+
+  size_t FunctionNameCount = 0;
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    const WasmObjectFile* WasmFile = File->getWasmObj();
+    for (object::SymbolRef Sym : WasmFile->symbols()) {
+      const WasmSymbol &WasmSym = WasmFile->getWasmSymbol(Sym);
+      if (WasmSym.Type != WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME)
+        continue;
+      if (File->isResolvedFunctionImport(Sym.getValue()))
+        continue;
+      Symbol* S = Symtab->find(WasmSym.Name);
+      if (S) {
+        assert(S);
+        if (S->WrittenToNameSec)
+          continue;
+        S->WrittenToNameSec = true;
+      }
+      FunctionNameCount++;
+    }
+  }
+
+  SubSection FunctionSubsection(WASM_NAMES_FUNCTION);
+  raw_ostream& OS = FunctionSubsection.getStream();
+  write_uleb128(OS, FunctionNameCount, "name count");
+
+  // We have to iterate through the inputs twice so that all the imports
+  // appear first before any of the local function names.
+  for (bool ImportedNames: { true, false }) {
+    for (ObjectFile *File: Symtab->ObjectFiles) {
+      const WasmObjectFile* WasmFile = File->getWasmObj();
+      for (object::SymbolRef Sym : WasmFile->symbols()) {
+        if (File->isImportedFunction(Sym.getValue()) != ImportedNames)
+          continue;
+
+        const WasmSymbol &WasmSym = WasmFile->getWasmSymbol(Sym);
+        if (WasmSym.Type != WasmSymbol::SymbolType::DEBUG_FUNCTION_NAME)
+          continue;
+        if (File->isResolvedFunctionImport(Sym.getValue()))
+          continue;
+        Symbol* S = Symtab->find(WasmSym.Name);
+        if (S) {
+          if (!S->WrittenToNameSec)
+            continue;
+          S->WrittenToNameSec = false;
+        }
+        Expected<StringRef> NameOrError = Sym.getName();
+        if (!NameOrError)
+          fatal("error getting symbol name");
+        write_uleb128(OS, File->relocateFunctionIndex(Sym.getValue()), "func index");
+        write_str(OS, *NameOrError, "symbol name");
+      }
+    }
+  }
+
+  FunctionSubsection.finalizeContents();
+  FunctionSubsection.writeToStream(Section->getStream());
+}
+
+void Writer::writeOutput(const uint8_t* Ptr, size_t Size, size_t Offset) {
+  memcpy(Buffer->getBufferStart() + Offset, Ptr, Size);
+}
+
+void Writer::writeHeader() {
+  writeOutput((const uint8_t*)Header.data(), Header.size(), 0);
+}
+
+void Writer::writeSections() {
+  uint8_t* Buf = Buffer->getBufferStart();
+  parallelForEach(OutputSections, [Buf](OutputSection *S) {
+    S->writeTo(Buf);
+  });
+}
+
+void Writer::layoutMemory() {
+  uint32_t MemoryPtr = 0;
+  if (!Config->Relocatable) {
+    MemoryPtr += Config->GlobalBase;
+    debugPrint("mem: global base = %d\n", Config->GlobalBase);
+  }
+
+  // Static data from input object files comes first
+  MemoryPtr = alignTo(MemoryPtr, DataAlignment);
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    const WasmObjectFile* WasmFile = File->getWasmObj();
+    uint32_t Size = WasmFile->linkingData().DataSize;
+    if (Size) {
+      MemoryPtr = alignTo(MemoryPtr, WasmFile->linkingData().DataAlignment);
+      debugPrint("mem: [%s] offset=%#x size=%d\n",
+                  File->getName().str().c_str(), File->DataOffset, Size);
+      File->DataOffset = MemoryPtr;
+      MemoryPtr += Size;
+    } else {
+      debugPrint("mem: [%s] no data\n", File->getName().str().c_str());
+    }
+  }
+
+  DataSize = MemoryPtr;
+  if (!Config->Relocatable)
+    DataSize -= Config->GlobalBase;
+  debugPrint("mem: static data = %d\n", DataSize);
+
+  // Stack comes after static data
+  if (!Config->Relocatable) {
+    MemoryPtr = alignTo(MemoryPtr, kStackAlignment);
+    if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment))
+      error("stack size must be " + Twine(kStackAlignment) + "-byte aligned");
+    debugPrint("mem: stack size  = %d\n", Config->ZStackSize);
+    debugPrint("mem: stack base  = %d\n", MemoryPtr);
+    MemoryPtr += Config->ZStackSize;
+    Config->SyntheticGlobals[0].second.InitExpr.Value.Int32 = MemoryPtr;
+    debugPrint("mem: stack top   = %d\n", MemoryPtr);
+  }
+
+  uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize);
+  TotalMemoryPages = MemSize / WasmPageSize;
+  debugPrint("mem: total pages = %d\n", TotalMemoryPages);
+}
+
+SyntheticSection* Writer::createSyntheticSection(uint32_t Type, std::string Name) {
+  auto Sec = make<SyntheticSection>(Type, Name);
+  log("createSection: " + toString(Sec));
+  OutputSections.push_back(Sec);
+  return Sec;
+}
+
+void Writer::createSections() {
+  // Known sections
+  createTypeSection();
+  createImportSection();
+  createFunctionSection();
+  createTableSection();
+  createMemorySection();
+  createGlobalSection();
+  createExportSection();
+  createStartSection();
+  createElemSection();
+  createCodeSection();
+  createDataSection();
+
+  // Custom sections
+  if (Config->EmitRelocs || Config->Relocatable)
+    createRelocSections();
+  createLinkingSection();
+  if (!Config->StripDebug && !Config->StripAll)
+    createNameSection();
+
+  for (OutputSection* S : OutputSections) {
+    S->setOffset(FileSize);
+    S->finalizeContents();
+    FileSize += S->getSize();
+  }
+}
+
+void Writer::calculateOffsets() {
+  TotalGlobals = Config->SyntheticGlobals.size();
+  TotalTableLength = InitialTableOffset;
+
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    const WasmObjectFile* WasmFile = File->getWasmObj();
+
+    DataAlignment =
+        std::max(DataAlignment, WasmFile->linkingData().DataAlignment);
+
+    // Function Index
+    File->FunctionIndexOffset =
+        FunctionImports.size() - File->FunctionImports.size() + TotalFunctions;
+    TotalFunctions += WasmFile->functions().size();
+
+    // Global Index
+    if (Config->Relocatable) {
+      File->GlobalIndexOffset =
+          GlobalImports.size() - File->GlobalImports.size() + TotalGlobals;
+      TotalGlobals += WasmFile->globals().size();
+    }
+
+    // Memory
+    if (WasmFile->memories().size()) {
+      if (WasmFile->memories().size() > 1) {
+        fatal(File->getName() + ": contains more than one memory");
+      }
+    }
+
+    // Table
+    uint32_t TableCount = WasmFile->tables().size();
+    if (TableCount) {
+      if (TableCount > 1)
+        fatal(File->getName() + ": contains more than one table");
+      File->TableIndexOffset = TotalTableLength;
+      TotalTableLength += WasmFile->tables()[0].Limits.Initial;
+    }
+
+    // Elem
+    uint32_t SegmentCount = WasmFile->elements().size();
+    if (SegmentCount) {
+      if (SegmentCount > 1) {
+        fatal(File->getName() + ": contains more than element segment");
+      } else {
+        const WasmElemSegment &Segment = WasmFile->elements()[0];
+        if (Segment.TableIndex != 0)
+          fatal(File->getName() + ": unsupported table index");
+        else if (Segment.Offset.Value.Int32 != 0)
+          fatal(File->getName() + ": unsupported segment offset");
+        else
+          TotalElements += Segment.Functions.size();
+      }
+    }
+
+    // Data
+    TotalDataSegments += WasmFile->dataSegments().size();
+  }
+}
+
+void Writer::calculateImports() {
+  for (ObjectFile *File : Symtab->ObjectFiles) {
+    for (Symbol *Sym : File->getSymbols()) {
+      if (Sym->hasOutputIndex() || Sym->isDefined() || Sym->isWeak())
+        continue;
+
+      if (Sym->isFunction()) {
+        Sym->setOutputIndex(FunctionImports.size());
+        FunctionImports.push_back(Sym);
+      } else {
+        Sym->setOutputIndex(GlobalImports.size());
+        GlobalImports.push_back(Sym);
+      }
+    }
+  }
+}
+
+void Writer::calculateTypes() {
+  for (ObjectFile *File : Symtab->ObjectFiles) {
+    int Index = 0;
+    for (const WasmSignature &Sig: File->getWasmObj()->types()) {
+      auto Pair = TypeIndices.insert(std::make_pair(Sig, Types.size()));
+      if (Pair.second)
+        Types.push_back(&Sig);
+
+      // Now we map the input files index to the index in the linked output
+      File->TypeMap[Index++] = Pair.first->second;
+    }
+  }
+}
+
+void Writer::assignSymbolIndexes() {
+  for (ObjectFile *File : Symtab->ObjectFiles) {
+    DEBUG(dbgs() << "assignSymbolIndexes: " << File->getName() << "\n");
+    for (Symbol *Sym : File->getSymbols()) {
+      if (Sym->hasOutputIndex() || !Sym->isDefined())
+        continue;
+
+      if (Sym->getFile() && isa<ObjectFile>(Sym->getFile())) {
+        ObjectFile* Obj = dyn_cast<ObjectFile>(Sym->getFile());
+        if (Sym->isFunction())
+          Sym->setOutputIndex(
+              Obj->relocateFunctionIndex(Sym->getFunctionIndex()));
+        else
+          Sym->setOutputIndex(Obj->relocateGlobalIndex(Sym->getGlobalIndex()));
+      }
+    }
+  }
+}
+
+void Writer::run() {
+  if (!Config->Relocatable)
+    InitialTableOffset = 1;
+
+  log("-- calculateTypes");
+  calculateTypes();
+  log("-- calculateImports");
+  calculateImports();
+  log("-- calculateOffsets");
+  calculateOffsets();
+
+  if (Config->Verbose) {
+    log("TotalFunctions   : " + Twine(TotalFunctions));
+    log("TotalGlobals     : " + Twine(TotalGlobals));
+    log("TotalDataSegments: " + Twine(TotalDataSegments));
+    log("TotalImports     : " +
+        Twine(FunctionImports.size() + GlobalImports.size()));
+    log("FunctionImports  : " + Twine(FunctionImports.size()));
+    log("GlobalImports    : " + Twine(GlobalImports.size()));
+    for (ObjectFile *File: Symtab->ObjectFiles)
+      File->dumpInfo();
+  }
+
+  log("-- assignSymbolIndexes");
+  assignSymbolIndexes();
+  log("-- layoutMemory");
+  layoutMemory();
+
+  createHeader();
+  log("-- createSections");
+  createSections();
+
+  log("-- openFile");
+  openFile();
+  if (ErrorCount)
+    return;
+
+  writeHeader();
+
+  log("-- writeSections");
+  writeSections();
+  if (ErrorCount)
+    return;
+
+  if (auto EC = Buffer->commit())
+    fatal("failed to write the output file: " + EC.message());
+}
+
+// Open a result file.
+void Writer::openFile() {
+  log("writing: " + Config->OutputFile);
+  ::remove(Config->OutputFile.str().c_str());
+
+  ErrorOr<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
+      FileOutputBuffer::create(Config->OutputFile, FileSize,
+                               FileOutputBuffer::F_executable);
+
+  if (auto EC = BufferOrErr.getError())
+    error("failed to open " + Config->OutputFile + ": " + EC.message());
+  else
+    Buffer = std::move(*BufferOrErr);
+}
+
+void Writer::createHeader() {
+  raw_string_ostream OS(Header);
+  write_bytes(OS, WasmMagic, sizeof(WasmMagic), "wasm magic");
+  write_u32(OS, WasmVersion, "wasm version");
+  OS.flush();
+  FileSize += Header.size();
+}
+
+namespace lld {
+namespace wasm {
+
+void writeResult(SymbolTable *T) {
+  Writer(T).run();
+}
+
+} // namespace wasm
+} // namespace lld