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/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/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,6 @@
+define i32 @foo() #0 {
+entry:
+  ret i32 0
+}
+
+@bar = weak alias i32 (), i32 ()* @foo
Index: test/wasm/archive.ll
===================================================================
--- /dev/null
+++ test/wasm/archive.ll
@@ -0,0 +1,22 @@
+; 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
+
+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,99 @@
+; 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
+
+; Wasm module 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: FileHeader:      
+; CHECK:   Version:         0x00000001
+; CHECK: Sections:        
+; CHECK:   - Type:            TYPE
+; CHECK:     Signatures:      
+; CHECK:       - Index:           0
+; CHECK:         ReturnType:      I32
+; CHECK:         ParamTypes:      
+; CHECK:           - F32
+; CHECK:       - Index:           1
+; CHECK:         ReturnType:      I32
+; CHECK:         ParamTypes:      
+; CHECK:       - Index:           2
+; CHECK:         ReturnType:      NORESULT
+; CHECK:         ParamTypes:      
+; CHECK:   - Type:            FUNCTION
+; CHECK:     FunctionTypes:   [ 0, 1, 2 ]
+; CHECK:   - Type:            TABLE
+; CHECK:     Tables:          
+; CHECK:       - ElemType:        ANYFUNC
+; CHECK:         Limits:          
+; CHECK:           Flags:           0x00000001
+; CHECK:           Initial:         0x00000001
+; CHECK:           Maximum:         0x00000001
+; CHECK:   - Type:            MEMORY
+; CHECK:     Memories:        
+; CHECK:       - Initial:         0x00000003
+; CHECK:   - Type:            GLOBAL
+; CHECK:     Globals:         
+; CHECK:       - Type:            I32
+; CHECK:         Mutable:         true
+; CHECK:         InitExpr:        
+; CHECK:           Opcode:          I32_CONST
+; CHECK:           Value:           132096
+; CHECK:   - Type:            EXPORT
+; CHECK:     Exports:         
+; CHECK:       - Name:            memory
+; CHECK:         Kind:            MEMORY
+; CHECK:         Index:           0
+; CHECK:       - Name:            main
+; CHECK:         Kind:            FUNCTION
+; CHECK:         Index:           2
+; CHECK:   - Type:            ELEM
+; CHECK:     Segments:        
+; CHECK:       - Offset:          
+; CHECK:           Opcode:          I32_CONST
+; CHECK:           Value:           0
+; CHECK:         Functions:       [ 0 ]
+; CHECK:   - Type:            CODE
+; CHECK:     Functions:       
+; CHECK:       - Locals:          
+; CHECK:       - Locals:          
+; CHECK:       - Locals:          
+; CHECK:   - Type:            DATA
+; CHECK:     Segments:        
+; CHECK:       - Index:           0
+; CHECK:         Offset:          
+; CHECK:           Opcode:          I32_CONST
+; CHECK:           Value:           1024
+; CHECK:         Content:         '00000000'
+; CHECK:   - Type:            CUSTOM
+; CHECK:     Name:            name
+; CHECK:     FunctionNames:   
+; CHECK:       - Index:           0
+; CHECK:         Name:            ret32
+; CHECK:       - Index:           1
+; CHECK:         Name:            foo
+; CHECK:       - Index:           2
+; CHECK:         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/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,40 @@
+; 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:      - Type:            CUSTOM
+; CHECK-NEXT:     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/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,100 @@
+; 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
+
+; 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:            MEMORY
+; CHECK-NEXT:     Memories:        
+; CHECK-NEXT:       - Initial:         0x00000002
+; 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:           1024
+; 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:            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:          {{.*}}
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:          {{.*}}
+; CHECK-NEXT:   - Type:            DATA
+; CHECK-NEXT:     Segments:        
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Offset:          
+; CHECK-NEXT:           Opcode:          I32_CONST
+; CHECK-NEXT:           Value:           1024
+; CHECK-NEXT:         Content:         68656C6C6F0A00
+; 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,5 @@
+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-NOT:   - Type:            CUSTOM
Index: test/wasm/undefined-entry.test
===================================================================
--- /dev/null
+++ test/wasm/undefined-entry.test
@@ -0,0 +1,5 @@
+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: lld: error: undefined symbol: _start
+CHECK: lld: error: link failed
Index: test/wasm/undefined.ll
===================================================================
--- /dev/null
+++ test/wasm/undefined.ll
@@ -0,0 +1,13 @@
+; RUN: llc -filetype=obj %s -o %t.o
+; RUN: not lld -flavor wasm -o %t.wasm %t.o 2>&1 | FileCheck %s
+
+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
+
+; CHECK: lld: error: {{.*}}.o: undefined symbol: foo
+; CHECK: lld: error: link failed
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.ll
===================================================================
--- /dev/null
+++ test/wasm/weak-alias.ll
@@ -0,0 +1,61 @@
+; 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:       - Index:           1
+; CHECK-NEXT:         ReturnType:      NORESULT
+; CHECK-NEXT:         ParamTypes:      
+; CHECK-NEXT:   - Type:            FUNCTION
+; CHECK-NEXT:     FunctionTypes:   [ 0, 0 ]
+; 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:   - Type:            CODE
+; CHECK-NEXT:     Functions:       
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            1081808080000B
+; CHECK-NEXT:       - Locals:          
+; CHECK-NEXT:         Body:            41000B
+; 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
Index: test/wasm/weak-external.ll
===================================================================
--- /dev/null
+++ test/wasm/weak-external.ll
@@ -0,0 +1,58 @@
+; 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: FileHeader:
+; CHECK:   Version:         0x00000001
+; CHECK: Sections:
+; CHECK:   - Type:            TYPE
+; CHECK:     Signatures:
+; CHECK:       - Index:           0
+; CHECK:         ReturnType:      I32
+; CHECK:         ParamTypes:
+; CHECK:   - Type:            FUNCTION
+; CHECK:     FunctionTypes:   [ 0, 0 ]
+; CHECK:   - Type:            MEMORY
+; CHECK:     Memories:
+; CHECK:       - Initial:         0x00000002
+; CHECK:   - Type:            GLOBAL
+; CHECK:     Globals:
+; CHECK:       - Type:            I32
+; CHECK:         Mutable:         true
+; CHECK:         InitExpr:
+; CHECK:           Opcode:          I32_CONST
+; CHECK:           Value:           66560
+; CHECK:   - Type:            EXPORT
+; CHECK:     Exports:
+; CHECK:       - Name:            memory
+; CHECK:         Kind:            MEMORY
+; CHECK:         Index:           0
+; CHECK:       - Name:            main
+; CHECK:         Kind:            FUNCTION
+; CHECK:         Index:           1
+; CHECK:   - Type:            CODE
+; CHECK:     Functions:
+; CHECK:       - Locals:
+; CHECK:         Body:            4180808080000B
+; CHECK:       - Locals:
+; CHECK:         Body:            4100280280808080000B
+; CHECK: ...
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,56 @@
+//===- 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 Relocatable = false;
+  bool Verbose = false;
+  bool StripDebug = false;
+  bool StripAll = false;
+  bool ImportMemory = 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,58 @@
+//===- 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;
+void printHelp(const char *Argv0);
+llvm::Optional<std::string> searchLibrary(StringRef Name);
+
+} // namespace wasm
+} // namespace lld
+
+#endif
Index: wasm/Driver.cpp
===================================================================
--- /dev/null
+++ wasm/Driver.cpp
@@ -0,0 +1,365 @@
+//===- 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;
+
+// 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 StringRef getString(opt::InputArgList &Args, unsigned Key,
+                           StringRef Default = "") {
+  if (auto *Arg = Args.getLastArg(Key))
+    return Arg->getValue();
+  return Default;
+}
+
+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 bool parseUndefinedFile(StringRef Filename) {
+  Optional<MemoryBufferRef> Buffer = readFile(Filename);
+  if (!Buffer.hasValue())
+    return false;
+  StringRef Str = Buffer->getBuffer();
+  size_t Pos = 0;
+  while (1) {
+    size_t NextLine = Str.find('\n', Pos);
+    StringRef SymbolName = Str.slice(Pos, NextLine);
+    if (!SymbolName.empty())
+      Config->AllowUndefinedSymbols.insert(SymbolName);
+    if (NextLine == StringRef::npos)
+      break;
+    Pos = NextLine + 1;
+  }
+
+
+  return true;
+}
+
+// Parse -color-diagnostics={auto,always,never} or -no-color-diagnostics.
+static bool getColorDiagnostics(opt::InputArgList &Args) {
+  bool Default = (ErrorOS == &errs() && Process::StandardErrHasColors());
+
+  auto *Arg = Args.getLastArg(OPT_color_diagnostics, OPT_color_diagnostics_eq,
+                              OPT_no_color_diagnostics);
+  if (!Arg)
+    return Default;
+  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 Default;
+  if (S == "always")
+    return true;
+  if (S != "never")
+    error("unknown option: -color-diagnostics=" + S);
+  return false;
+}
+
+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;
+}
+
+void LinkerDriver::addFile(StringRef Path) {
+  Optional<MemoryBufferRef> Buffer = readFile(Path);
+  if (!Buffer.hasValue())
+    return;
+  MemoryBufferRef MBRef = *Buffer;
+
+  switch (identify_magic(MBRef.getBuffer())) {
+  case file_magic::archive:
+    Files.push_back(make<ArchiveFile>(MBRef));
+    break;
+  default:
+    Files.push_back(make<ObjectFile>(MBRef));
+    break;
+  }
+}
+
+void LinkerDriver::addArchiveBuffer(MemoryBufferRef MB, StringRef SymName,
+                                    StringRef ParentName) {
+  InputFile *Obj;
+  file_magic Magic = identify_magic(MB.getBuffer());
+  if (Magic == file_magic::wasm_object) {
+    Obj = make<ObjectFile>(MB);
+  } else {
+    error("unknown file type: " + MB.getBufferIdentifier());
+    return;
+  }
+
+  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) {
+  if (Optional<std::string> Path = searchLibrary(Name))
+    addFile(*Path);
+  else
+    error("unable to find library -l" + Name);
+}
+
+void LinkerDriver::addSyntheticGlobal(StringRef Name, int32_t Value) {
+  log("injecting global: " + Twine(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);
+}
+
+void LinkerDriver::addSyntheticUndefinedFunction(StringRef Name) {
+  log("injecting undefined func: " + Twine(Name));
+  Symtab->addUndefinedFunction(Name);
+}
+
+void LinkerDriver::createFiles(opt::InputArgList &Args) {
+  for (auto *Arg : Args) {
+    switch (Arg->getOption().getID()) {
+    case OPT_l:
+      addLibrary(Arg->getValue());
+      break;
+    case OPT_INPUT:
+      addFile(Arg->getValue());
+    }
+  }
+
+  if (Files.empty())
+    error("no input files");
+}
+
+void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
+  SymbolTable Symtab;
+  wasm::Symtab = &Symtab;
+
+  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);
+
+  // GNU linkers disagree here. Though both -version and -v are mentioned
+  // in help to print the version information, GNU ld just normally exits,
+  // while gold can continue linking. We are compatible with ld.bfd here.
+  if (Args.hasArg(OPT_version) || Args.hasArg(OPT_v))
+    outs() << getLLDVersion() << "\n";
+  if (Args.hasArg(OPT_version))
+    return;
+
+  Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
+  Config->EmitRelocs = Args.hasArg(OPT_emit_relocs);
+  Config->Entry = getString(Args, OPT_entry);
+  Config->ImportMemory = Args.hasArg(OPT_import_memory);
+  Config->OutputFile = getString(Args, 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 = getString(Args, OPT_sysroot);
+  Config->Verbose = Args.hasArg(OPT_verbose);
+
+  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 = getString(Args, OPT_allow_undefined_file);
+  if (!AllowUndefinedFilename.empty()) {
+    if (!parseUndefinedFile(AllowUndefinedFilename))
+      return;
+  }
+
+  // Default output filename is "a.out" by the Unix tradition.
+  if (Config->OutputFile.empty())
+    Config->OutputFile = "a.out";
+
+  if (!Args.hasArgNoClaim(OPT_INPUT))
+    fatal("no input files");
+
+  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->AllowUndefined && !Config->Relocatable)
+    Symtab.reportRemainingUndefines();
+
+  if (!Config->Relocatable) {
+    Symbol* Sym = Symtab.find(Config->Entry);
+    if (!Sym->isFunction())
+      fatal("entry point is not a function: " + Sym->getName());
+    if (!Sym->isDefined())
+      fatal("entry point undefined: " + Sym->getName());
+  }
+
+  // Write the result to the file.
+  writeResult(&Symtab);
+}
+
+void printHelp(const char *Argv0) {
+  WasmOptTable Table;
+  Table.PrintHelp(outs(), Argv0, "LLVM Linker", false);
+}
+
+bool link(ArrayRef<const char *> Args, raw_ostream &Error) {
+  ErrorCount = 0;
+  Argv0 = Args[0];
+  ErrorOS = &Error;
+  Config = make<Configuration>();
+  Driver = make<LinkerDriver>();
+  Driver->link(Args);
+  return !ErrorCount;
+}
+
+// Find a file by concatenating given paths. If a resulting path
+// starts with "=", the character is replaced with a --sysroot value.
+static Optional<std::string> findFile(StringRef Path1, const Twine &Path2) {
+  SmallString<128> S;
+  if (Path1.startswith("="))
+    path::append(S, Config->Sysroot, Path1.substr(1), Path2);
+  else
+    path::append(S, Path1, Path2);
+
+  if (fs::exists(S))
+    return S.str().str();
+  return None;
+}
+
+static Optional<std::string> findFromSearchPaths(StringRef Path) {
+  for (StringRef Dir : Config->SearchPaths)
+    if (Optional<std::string> S = findFile(Dir, Path))
+      return S;
+  return None;
+}
+
+// This is for -lfoo. We'll look for libfoo.so or libfoo.a from
+// search paths.
+Optional<std::string> searchLibrary(StringRef Name) {
+  if (Name.startswith(":"))
+    return findFromSearchPaths(Name.substr(1));
+
+  for (StringRef Dir : Config->SearchPaths) {
+    if (Optional<std::string> S = findFile(Dir, "lib" + Name + ".a"))
+      return S;
+  }
+  return None;
+}
+
+} // 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,96 @@
+//===- 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,135 @@
+//===- 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;
+};
+
+// .lib or .a file.
+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.
+class ObjectFile : public InputFile {
+  std::unique_ptr<WasmObjectFile> WasmObj;
+
+  void initializeSymbols();
+
+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 underying 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 relocateCodeOffset(uint32_t original) const;
+  uint32_t relocateDataLocation(uint32_t original) const;
+
+  int32_t getGlobalAddress(uint32_t index) const;
+
+  bool isImportedFunction(uint32_t index) const;
+  bool isImportedGlobal(uint32_t index) const;
+  bool isResolvedFunctionImport(uint32_t index) const;
+  bool isResolvedGlobalImport(uint32_t index) const;
+
+  int32_t FunctionIndexOffset = 0;
+  int32_t GlobalIndexOffset = 0;
+  uint32_t TableIndexOffset = 0;
+  uint32_t CodeSectionOffset = 0;
+  uint32_t DataOffset = 0;
+  const WasmSection* CodeSection = nullptr;
+  const WasmSection* DataSection = nullptr;
+
+  llvm::DenseMap<uint32_t, uint32_t> TypeMap;
+  std::vector<const WasmSymbol*> FunctionImports;
+  std::vector<const WasmSymbol*> GlobalImports;
+};
+
+// 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,244 @@
+//===- 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 "SymbolTable.h"
+#include "Config.h"
+#include "Driver.h"
+#include "Error.h"
+#include "Memory.h"
+#include "Strings.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;
+  const WasmSymbol *WasmSym = FunctionImports[index];
+  Symbol* Sym = Symtab->find(WasmSym->Name);
+  return Sym->isDefined();
+}
+
+bool ObjectFile::isResolvedGlobalImport(uint32_t index) const {
+  if (!isImportedGlobal(index))
+    return false;
+  const WasmSymbol *WasmSym = GlobalImports[index];
+  Symbol* Sym = Symtab->find(WasmSym->Name);
+  return Sym->isDefined();
+}
+
+int32_t ObjectFile::getGlobalAddress(uint32_t index) const {
+  if (isImportedGlobal(index)) {
+    return 0;
+  } else {
+    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 {
+  if (isImportedFunction(original)) {
+    const WasmSymbol *WasmSym = FunctionImports[original];
+    Symbol* Sym = Symtab->find(WasmSym->Name);
+    assert(Sym && "imported symbol not found in symbol table");
+    return Sym->getOutputIndex();
+  } else {
+    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)) {
+    const WasmSymbol *WasmSym = GlobalImports[original];
+    Symbol* Sym = Symtab->find(WasmSym->Name);
+    assert(Sym && "imported symbol not found in symbol table");
+    return Sym->getOutputIndex();
+  } else {
+    return original + GlobalIndexOffset;
+  }
+}
+
+uint32_t ObjectFile::relocateCodeOffset(uint32_t original) const {
+  return original + CodeSectionOffset;
+}
+
+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));
+
+  if (auto *Obj = dyn_cast<WasmObjectFile>(Bin.get())) {
+    Bin.release();
+    WasmObj.reset(Obj);
+  } else {
+    fatal(toString(this) + " is not a wasm file");
+  }
+
+  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 SymbolRef &Sym: WasmObj->symbols()) {
+    const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
+    switch (WasmSym.Type) {
+      case WasmSymbol::SymbolType::FUNCTION_IMPORT:
+        FunctionImports.emplace_back(&WasmSym);
+        createUndefined(WasmSym);
+        break;
+      case WasmSymbol::SymbolType::GLOBAL_IMPORT:
+        GlobalImports.emplace_back(&WasmSym);
+        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);
+  if (S)
+    Symbols.push_back(S);
+  return S;
+}
+
+Symbol *ObjectFile::createDefined(const WasmSymbol &Sym) {
+  Symbol *S = Symtab->addDefined(this, &Sym);
+  if (S)
+    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 objects.
+  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,84 @@
+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_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/Demangle/Demangle.h"
+#include "llvm/ADT/StringRef.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,209 @@
+//===- 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;
+    DEBUG(dbgs() << "checking sym: " << *Sym << "\n");
+    if (Sym->isUndefined() && !Sym->isLazy() && !Sym->isWeak() &&
+        Config->AllowUndefinedSymbols.count(Sym->getName()) == 0) {
+      Undefs.insert(Sym);
+      DEBUG(dbgs() << "found undefined sym: " << *Sym << "\n");
+    }
+  }
+
+  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));
+  }
+
+  fatal("link failed");
+}
+
+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"));
+    fatal(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
+      } else if (S->isWeak()) {
+        // the new symbol is not weak and the existing symbol is, so we replace
+        // it
+        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()) {
+      // 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,106 @@
+//===- 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), 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;
+
+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 {
+  assert(OutputIndexSet);
+  return OutputIndex;
+}
+
+void Symbol::setOutputIndex(uint32_t Index) {
+  assert(!OutputIndexSet);
+  DEBUG(dbgs() << "setOutputIndex: " << this << " " << Name << ": " << Index
+               << " 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) {
+  if (wasm::Config->Demangle)
+    if (Optional<std::string> S = wasm::demangle(Sym.getName()))
+      return *S;
+  return 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/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,1012 @@
+//===- Writer.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Config.h"
+#include "Error.h"
+#include "Memory.h"
+#include "SymbolTable.h"
+#include "Writer.h"
+#include "llvm/Support/Endian.h"
+#include "llvm/Support/EndianStream.h"
+#include "llvm/Support/Format.h"
+#include "llvm/Support/LEB128.h"
+
+#define DEBUG_TYPE "lld"
+
+using namespace llvm;
+using namespace llvm::wasm;
+using namespace lld;
+using namespace lld::wasm;
+
+namespace {
+
+// 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;
+  }
+};
+
+// 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 writeHeader();
+  void writeSections(raw_fd_ostream &OS);
+
+  // Builtin sections
+  void writeTypeSection(raw_fd_ostream &OS);
+  void writeFunctionSection(raw_fd_ostream &OS);
+  void writeTableSection(raw_fd_ostream &OS);
+  void writeGlobalSection(raw_fd_ostream &OS);
+  void writeExportSection(raw_fd_ostream &OS);
+  void writeImportSection(raw_fd_ostream &OS);
+  void writeMemorySection(raw_fd_ostream &OS);
+  void writeElemSection(raw_fd_ostream &OS);
+  void writeStartSection(raw_fd_ostream &OS);
+  void writeCodeSection(raw_fd_ostream &OS);
+  void writeDataSection(raw_fd_ostream &OS);
+
+  // Custom sections
+  void writeRelocSections(raw_fd_ostream &OS);
+  void writeNameSection(raw_fd_ostream &OS);
+
+  void applyCodeRelocations(const ObjectFile &File,
+                            OwningArrayRef<uint8_t> &data);
+
+  SectionBookkeeping writeSectionHeader(uint32_t Type, raw_fd_ostream &OS);
+  void endSection(SectionBookkeeping& Section, raw_fd_ostream &OS) const;
+
+  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 TotalCodeRelocations = 0;
+  uint32_t TotalDataRelocations = 0;
+
+  SymbolTable *Symtab;
+  std::vector<const WasmSignature*> Types;
+  DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
+  std::vector<Symbol*> FunctionImports;
+  std::vector<Symbol*> GlobalImports;
+  std::unique_ptr<raw_fd_ostream> OS;
+};
+
+// Return the padding size to write a 32-bit value into a 5-byte ULEB128.
+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.
+unsigned PaddingFor5ByteSLEB128(int32_t X) {
+  return 5 - getSLEB128Size(X);
+}
+
+uint32_t round_up_to_page_size(uint32_t size) {
+  static const uint32_t PageMask = ~(WasmPageSize - 1);
+  return (size + WasmPageSize - 1) & PageMask;
+}
+
+void debug_print(const char* fmt, ...) {
+  if (Config->Verbose) {
+    fprintf(stderr, "lld: ");
+    va_list ap;
+    va_start(ap, fmt);
+    vfprintf(stderr, fmt, ap);
+    va_end(ap);
+  }
+}
+
+const char* section_type_to_str(uint32_t SectionType) {
+#define ECase(X)                 \
+  case WASM_SEC_##X:             \
+    return #X;
+  switch (SectionType) {
+    ECase(CUSTOM);
+    ECase(TYPE);
+    ECase(IMPORT);
+    ECase(FUNCTION);
+    ECase(TABLE);
+    ECase(MEMORY);
+    ECase(GLOBAL);
+    ECase(EXPORT);
+    ECase(START);
+    ECase(ELEM);
+    ECase(CODE);
+    ECase(DATA);
+  default:
+    fatal("invalid section type");
+    return nullptr;
+  }
+}
+
+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;
+  }
+}
+
+void debug_write(raw_ostream& OS, const char* msg, const char* fmt=NULL, ...) {
+  DEBUG(
+    fprintf(stderr, "%08lx: %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");
+  );
+}
+
+void write_u8(uint8_t byte, raw_ostream& OS, const char* msg) {
+  OS << byte;
+}
+
+void write_u32(uint32_t Number, raw_ostream& OS, const char* msg) {
+  debug_write(OS, msg, "%x", Number);
+  support::endian::Writer<support::little>(OS).write(Number);
+}
+
+void write_uleb128(uint32_t Number, raw_ostream& OS, const char* msg) {
+  if (msg)
+    debug_write(OS, msg, "%x", Number);
+  encodeULEB128(Number, OS);
+}
+
+void write_uleb128_padded(uint32_t Number, raw_ostream& OS, const char* msg) {
+  if (msg)
+    debug_write(OS, msg);
+  unsigned Padding = PaddingFor5ByteULEB128(Number);
+  encodeULEB128(Number, OS, Padding);
+}
+
+void write_sleb128(int32_t Number, raw_ostream& OS, const char* msg) {
+  if (msg)
+    debug_write(OS, msg, "%x", Number);
+  encodeSLEB128(Number, OS);
+}
+
+void write_bytes(const char* bytes, uint32_t count, raw_ostream& OS, const char* msg) {
+  if (msg)
+    debug_write(OS, msg);
+  OS.write(bytes, count);
+}
+
+void write_str(const StringRef String, raw_ostream& OS, const char* msg) {
+  debug_write(OS, msg, "str[%d]: %.*s", String.size(), String.size(), String.data());
+  write_uleb128(String.size(), OS, nullptr);
+  write_bytes(String.data(), String.size(), OS, nullptr);
+}
+
+void write_value_type(int32_t Type, raw_ostream& OS, const char* msg) {
+  debug_write(OS, msg, "type: %s", value_type_to_str(Type));
+  write_sleb128(Type, OS, nullptr);
+}
+
+void write_sig(const WasmSignature &Sig, raw_ostream& OS) {
+  write_sleb128(WASM_TYPE_FUNC, OS, "signature type");
+  write_uleb128(Sig.ParamTypes.size(), OS, "param count");
+  for (int32_t ParamType: Sig.ParamTypes) {
+    write_value_type(ParamType, OS, "param type");
+  }
+  if (Sig.ReturnType == WASM_TYPE_NORESULT) {
+    write_uleb128(0, OS, "result count");
+  } else {
+    write_uleb128(1, OS, "result count");
+    write_value_type(Sig.ReturnType, OS, "result type");
+  }
+}
+
+static void write_init_expr(const WasmInitExpr& InitExpr, raw_fd_ostream& OS) {
+  write_u8(InitExpr.Opcode, OS, "opcode");
+  switch (InitExpr.Opcode) {
+  case WASM_OPCODE_I32_CONST:
+    write_sleb128(InitExpr.Value.Int32, OS, "literal (i32)");
+    break;
+  case WASM_OPCODE_I64_CONST:
+    write_sleb128(InitExpr.Value.Int64, OS, "literal (i64)");
+    break;
+  case WASM_OPCODE_GET_GLOBAL:
+    write_uleb128(InitExpr.Value.Global, OS, "literal (global index)");
+    break;
+  default:
+    fatal("unknown opcode in init expr: " + Twine(InitExpr.Opcode));
+    break;
+  }
+  write_u8(WASM_OPCODE_END, OS, "opcode:end");
+}
+
+static void write_limits(const WasmLimits& Limits, raw_fd_ostream& OS) {
+  write_uleb128(Limits.Flags, OS, "limits flags");
+  write_uleb128(Limits.Initial, OS, "limits initial");
+  if (Limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
+    write_uleb128(Limits.Maximum, OS, "limits max");
+}
+
+static void write_global(const WasmGlobal& Global, raw_fd_ostream& OS) {
+  write_value_type(Global.Type, OS, "global type");
+  write_uleb128(Global.Mutable, OS, "global mutable");
+  write_init_expr(Global.InitExpr, OS);
+}
+
+static void write_import(const WasmImport& Import, raw_fd_ostream& OS) {
+  write_str(Import.Module, OS, "import module name");
+  write_str(Import.Field, OS, "import field name");
+  write_u8(Import.Kind, OS, "import kind");
+  switch (Import.Kind) {
+    case WASM_EXTERNAL_FUNCTION:
+      write_uleb128(Import.SigIndex, OS, "import sig index");
+      break;
+    case WASM_EXTERNAL_GLOBAL:
+      write_value_type(Import.Global.Type, OS, "import global type");
+      write_uleb128(Import.Global.Mutable, OS, "import global mutable");
+      break;
+    case WASM_EXTERNAL_MEMORY:
+      write_limits(Import.Memory, OS);
+      break;
+    default:
+      fatal("unsupported import type: " + Twine(Import.Kind));
+      break;
+  }
+}
+
+static void write_export(const WasmExport& Export, raw_fd_ostream& OS) {
+  write_str(Export.Name, OS, "export name");
+  write_u8(Export.Kind, OS, "export kind");
+  switch (Export.Kind) {
+    case WASM_EXTERNAL_FUNCTION:
+      write_uleb128(Export.Index, OS, "function index");
+      break;
+    case WASM_EXTERNAL_GLOBAL:
+      write_sleb128(Export.Index, OS, "global index");
+      break;
+    case WASM_EXTERNAL_MEMORY:
+      write_sleb128(Export.Index, OS, "memory index");
+      break;
+    default:
+      fatal("unsupported export type: " + Twine(Export.Kind));
+      break;
+  }
+}
+
+SectionBookkeeping Writer::writeSectionHeader(uint32_t Type,
+                                                  raw_fd_ostream &OS) {
+  SectionBookkeeping Section;
+  debug_write(OS, "section type", "%s", section_type_to_str(Type));
+  write_uleb128(Type, OS, nullptr);
+  Section.SizeOffset = OS.tell();
+  write_uleb128_padded(0, OS, "section size");
+  Section.ContentsOffset = OS.tell();
+  return Section;
+}
+
+void Writer::endSection(SectionBookkeeping &Section,
+                        raw_fd_ostream &OS) const {
+  uint64_t End = OS.tell();
+  uint64_t Size = End - Section.ContentsOffset;
+  OS.seek(Section.SizeOffset);
+  write_uleb128_padded(Size, OS, "fixup section size");
+  OS.seek(End);
+}
+
+void Writer::writeImportSection(raw_fd_ostream& OS) {
+  uint32_t TotalImports = FunctionImports.size() + GlobalImports.size();
+  if (Config->ImportMemory)
+    TotalImports++;
+
+  if (TotalImports == 0)
+    return;
+
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_IMPORT, OS);
+  write_uleb128(TotalImports, OS, "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(Import, OS);
+  }
+
+  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(Import, OS);
+  }
+
+  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(Import, OS);
+  }
+
+  endSection(Section, OS);
+}
+
+void Writer::writeTypeSection(raw_fd_ostream& OS) {
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_TYPE, OS);
+  write_uleb128(Types.size(), OS, "type count");
+  for (const WasmSignature *Sig : Types) {
+    write_sig(*Sig, OS);
+  }
+  endSection(Section, OS);
+}
+
+void Writer::writeFunctionSection(raw_fd_ostream& OS) {
+  if (!TotalFunctions)
+    return;
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_FUNCTION, OS);
+  write_uleb128(TotalFunctions, OS, "function count");
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    for (uint32_t Sig: File->getWasmObj()->functionTypes()) {
+      write_uleb128(File->relocateTypeIndex(Sig), OS, "sig index");
+    }
+  }
+  endSection(Section, OS);
+}
+
+void Writer::writeMemorySection(raw_fd_ostream& OS) {
+  if (Config->ImportMemory)
+    return;
+
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_MEMORY, OS);
+
+  write_uleb128(1, OS, "memory count");
+  write_uleb128(0, OS, "memory limits flags");
+  write_uleb128(TotalMemoryPages, OS, "initial pages");
+
+  endSection(Section, OS);
+}
+
+void Writer::writeGlobalSection(raw_fd_ostream& OS) {
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_GLOBAL, OS);
+
+  write_uleb128(TotalGlobals, OS, "global count");
+  for (auto& Pair: Config->SyntheticGlobals) {
+    WasmGlobal& Global = Pair.second;
+    write_global(Global, OS);
+  }
+
+  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(RelocatedGlobal, OS);
+        GlobalIndex++;
+      }
+    }
+  }
+  endSection(Section, OS);
+}
+
+void Writer::writeTableSection(raw_fd_ostream& OS) {
+  if (!TotalTableLength)
+    return;
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_TABLE, OS);
+  write_uleb128(1, OS, "table count");
+  write_sleb128(WASM_TYPE_ANYFUNC, OS, "table type");
+  write_uleb128(WASM_LIMITS_FLAG_HAS_MAX, OS, "table flags");
+  write_uleb128(TotalTableLength, OS, "table initial size");
+  write_uleb128(TotalTableLength, OS, "table max size");
+  endSection(Section, OS);
+}
+
+void Writer::writeExportSection(raw_fd_ostream& OS) {
+  // Memory is and main function are exported for executables.
+  bool ExportMemory = !Config->Relocatable && !Config->ImportMemory;
+  bool ExportMain = !Config->Relocatable;
+  bool ExportOther = Config->Relocatable;
+
+  uint32_t NumExports = 0;
+
+  if (ExportMemory)
+    NumExports += 1;
+
+  if (ExportMain)
+    NumExports += 1;
+
+  if (ExportOther) {
+    for (ObjectFile *File : Symtab->ObjectFiles)
+      for (const Symbol *Sym : File->getSymbols())
+        if (Sym->isDefined()) NumExports++;
+  }
+
+  if (!NumExports)
+    return;
+
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_EXPORT, OS);
+  write_uleb128(NumExports, OS, "export count");
+
+  if (ExportMemory) {
+    WasmExport MemoryExport;
+    MemoryExport.Name = "memory";
+    MemoryExport.Kind = WASM_EXTERNAL_MEMORY;
+    MemoryExport.Index = 0;
+    write_export(MemoryExport, OS);
+  }
+
+  if (ExportMain) {
+    Symbol* Sym = Symtab->find(Config->Entry);
+    if (!Sym->isFunction())
+      fatal("entry point is not a function: " + Sym->getName());
+
+    WasmExport MainExport;
+    MainExport.Name = Config->ExportEntryAs;
+    MainExport.Kind = WASM_EXTERNAL_FUNCTION;
+    MainExport.Index = Sym->getOutputIndex();
+    write_export(MainExport, OS);
+  }
+
+  if (ExportOther) {
+    for (ObjectFile *File : Symtab->ObjectFiles) {
+      for (const Symbol *Sym : File->getSymbols()) {
+        if (Sym->isUndefined())
+          continue;
+        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(Export, OS);
+      }
+    }
+
+    // TODO(sbc): Export local symbols too, Even though they are not part
+    // of the symbol table?
+  }
+
+  endSection(Section, OS);
+}
+
+void Writer::writeStartSection(raw_fd_ostream& OS) {
+  /*
+  if (Config->Entry.empty())
+    return;
+
+  Symbol* Sym = Symtab->find(Config->Entry);
+  assert(isa<ObjectFile>(Sym->getFile()));
+  ObjectFile* Obj = dyn_cast<ObjectFile>(Sym->getFile());
+
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_START, OS);
+  write_uleb128(Obj->relocateFunctionIndex(Sym->getIndex()), OS, "start function index");
+  endSection(Section, OS);
+  */
+}
+
+void Writer::writeElemSection(raw_fd_ostream& OS) {
+  if (!TotalElements)
+    return;
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_ELEM, OS);
+  write_uleb128(1, OS, "segment count");
+  write_uleb128(0, OS, "table index");
+  WasmInitExpr InitExpr;
+  InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+  InitExpr.Value.Int32 = 0;
+  write_init_expr(InitExpr, OS);
+  write_uleb128(TotalElements, OS, "elem count");
+
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    for (const WasmElemSegment &Segment: File->getWasmObj()->elements()) {
+      for (uint64_t FunctionIndex: Segment.Functions) {
+        write_uleb128(FunctionIndex, OS, "function index");
+      }
+    }
+  }
+  endSection(Section, OS);
+}
+
+void Writer::applyCodeRelocations(const ObjectFile &File, OwningArrayRef<uint8_t> &Data) {
+  DEBUG(dbgs() << "applyCodeRelocations: " << File.getName() << "\n");
+  for (const WasmRelocation &Reloc: File.CodeSection->Relocations) {
+    int64_t NewValue = 0;
+    switch (Reloc.Type) {
+    case R_WEBASSEMBLY_TYPE_INDEX_LEB:
+      NewValue = File.relocateTypeIndex(Reloc.Index);
+      break;
+    case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+      NewValue = File.relocateFunctionIndex(Reloc.Index);
+      break;
+    case R_WEBASSEMBLY_TABLE_INDEX_I32:
+    case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+      NewValue = File.relocateTableIndex(Reloc.Index) + Reloc.Addend;
+      break;
+    case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+      NewValue = File.relocateGlobalIndex(Reloc.Index) + Reloc.Addend;
+      break;
+    case R_WEBASSEMBLY_GLOBAL_ADDR_LEB:
+    case R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
+    case R_WEBASSEMBLY_GLOBAL_ADDR_I32:
+      NewValue = File.getGlobalAddress(Reloc.Index) + Reloc.Addend;
+      break;
+    default:
+      fatal("unhandled relocation type: " + Twine(Reloc.Type));
+      break;
+    }
+
+    DEBUG(dbgs() << "reloc: type=" << Reloc.Type << " index=" << Reloc.Index
+                 << " offset=" << Reloc.Offset << " new=" << NewValue << "\n");
+
+    uint8_t *Location = Data.data() + Reloc.Offset;
+
+    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: {
+      unsigned Padding = PaddingFor5ByteULEB128(NewValue);
+      assert(NewValue >= 0 && NewValue <= UINT32_MAX);
+      encodeULEB128(NewValue, Location, Padding);
+      break;
+    }
+    case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+      assert(decodeSLEB128(Location) == Reloc.Index);
+    case R_WEBASSEMBLY_GLOBAL_ADDR_SLEB: {
+      unsigned Padding = PaddingFor5ByteSLEB128(NewValue);
+      assert(NewValue >= INT32_MIN && NewValue <= INT32_MAX);
+      encodeSLEB128(NewValue, Location, Padding);
+      break;
+    }
+    case R_WEBASSEMBLY_TABLE_INDEX_I32:
+    case R_WEBASSEMBLY_GLOBAL_ADDR_I32:
+      llvm_unreachable("unimplemented");
+      break;
+    }
+  }
+}
+
+void Writer::writeCodeSection(raw_fd_ostream& OS) {
+  if (!TotalFunctions)
+    return;
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_CODE, OS);
+  write_uleb128(TotalFunctions, OS, "function count");
+  uint32_t ContentsStart = OS.tell();
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    if (!File->CodeSection)
+      continue;
+    File->CodeSectionOffset = OS.tell() - ContentsStart;
+
+    // Make copy of the section content so that we can apply relocations
+    OwningArrayRef<uint8_t> Content(File->CodeSection->Content);
+    applyCodeRelocations(*File, Content);
+
+    // Payload doesn't include the intial function count
+    unsigned PayloadOffset = 0;
+    decodeULEB128(Content.data(), &PayloadOffset);
+
+    const char* Payload = reinterpret_cast<const char *>(Content.data());
+    write_bytes(Payload + PayloadOffset,
+                Content.size() - PayloadOffset, OS, "section data");
+  }
+  endSection(Section, OS);
+}
+
+void Writer::writeDataSection(raw_fd_ostream& OS) {
+  if (!TotalDataSegments)
+    return;
+
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_DATA, OS);
+  write_uleb128(TotalDataSegments, OS, "data segment count");
+
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    assert(File->getWasmObj()->dataSegments().size() <= 1);
+    for (const WasmDataSegment &Segment: File->getWasmObj()->dataSegments()) {
+      write_uleb128(Segment.Index, OS, "memory index");
+      write_uleb128(WASM_OPCODE_I32_CONST, OS, "opcode:i32const");
+      uint32_t NewOffset = Segment.Offset.Value.Int32 + File->DataOffset;
+      write_sleb128(NewOffset, OS, "memory offset");
+      write_uleb128(WASM_OPCODE_END, OS, "opcode:end");
+      write_uleb128(Segment.Content.size(), OS, "segment size");
+      write_bytes(reinterpret_cast<const char *>(Segment.Content.data()), Segment.Content.size(), OS, "memory data");
+    }
+  }
+
+  endSection(Section, OS);
+}
+
+void Writer::writeRelocSections(raw_fd_ostream& OS) {
+  if (!TotalCodeRelocations)
+    return;
+
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_CUSTOM, OS);
+  write_str("reloc.CODE", OS, "reloc section string name");
+  write_uleb128(WASM_SEC_CODE, OS, "reloc section");
+  write_uleb128(TotalCodeRelocations, OS, "reloc section");
+  for (const ObjectFile *File: Symtab->ObjectFiles) {
+    if (!File->CodeSection)
+      continue;
+    for (const WasmRelocation &Reloc: File->CodeSection->Relocations) {
+      write_uleb128(Reloc.Type, OS, "reloc type");
+      write_uleb128(File->relocateCodeOffset(Reloc.Offset), OS, "reloc offset");
+
+      switch (Reloc.Type) {
+      case R_WEBASSEMBLY_TYPE_INDEX_LEB:
+        write_uleb128(File->relocateTypeIndex(Reloc.Index), OS, "reloc index");
+        break;
+      case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+        write_uleb128(File->relocateFunctionIndex(Reloc.Index), OS, "reloc index");
+        break;
+      case R_WEBASSEMBLY_TABLE_INDEX_I32:
+      case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
+        write_uleb128(File->relocateTableIndex(Reloc.Index), OS, "reloc index");
+        break;
+      case R_WEBASSEMBLY_GLOBAL_ADDR_LEB:
+      case R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
+      case R_WEBASSEMBLY_GLOBAL_ADDR_I32:
+      case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
+        write_uleb128(File->relocateGlobalIndex(Reloc.Index), OS, "reloc index");
+        break;
+      default:
+        llvm_unreachable("invalid reloc type");
+        fatal("unhandled relocation type: " + Twine(Reloc.Type));
+      }
+
+      switch (Reloc.Type) {
+      case R_WEBASSEMBLY_GLOBAL_ADDR_LEB:
+      case R_WEBASSEMBLY_GLOBAL_ADDR_SLEB:
+      case R_WEBASSEMBLY_GLOBAL_ADDR_I32:
+        write_uleb128(Reloc.Addend, OS, "reloc addend");
+        break;
+      default:
+        break;
+      }
+    }
+  }
+
+  endSection(Section, OS);
+}
+
+void Writer::writeNameSection(raw_fd_ostream& OS) {
+  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->WrittenToSymtab)
+          continue;
+        S->WrittenToSymtab = true;
+      }
+      FunctionNameCount++;
+    }
+  }
+
+  SectionBookkeeping Section = writeSectionHeader(WASM_SEC_CUSTOM, OS);
+  write_str("name", OS, "name section string name");
+  SectionBookkeeping SubSection = writeSectionHeader(WASM_NAMES_FUNCTION, OS);
+  write_uleb128(FunctionNameCount, OS, "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->WrittenToSymtab)
+            continue;
+          S->WrittenToSymtab = false;
+        }
+        write_uleb128(File->relocateFunctionIndex(Sym.getValue()), OS, "func index");
+        Expected<StringRef> NameOrError = Sym.getName();
+        if (!NameOrError)
+          fatal("error getting symbol name");
+        write_str(*NameOrError, OS, "symbol name");
+      }
+    }
+  }
+  endSection(SubSection, OS);
+  endSection(Section, OS);
+}
+
+void Writer::writeSections(raw_fd_ostream& OS) {
+  writeTypeSection(OS);
+  writeImportSection(OS);
+  writeFunctionSection(OS);
+  writeTableSection(OS);
+  writeMemorySection(OS);
+  writeGlobalSection(OS);
+  writeExportSection(OS);
+  writeStartSection(OS);
+  writeElemSection(OS);
+  writeCodeSection(OS);
+  writeDataSection(OS);
+
+  // Optional, custom sections for relocations and debug names
+  if (Config->EmitRelocs || Config->Relocatable)
+    writeRelocSections(OS);
+  if (!Config->StripDebug && !Config->StripAll)
+    writeNameSection(OS);
+
+}
+
+void Writer::layoutMemory() {
+  uint32_t MemoryPtr = Config->GlobalBase;
+  debug_print("mem: global base = %d\n", Config->GlobalBase);
+
+  // Stat data input object files comes first
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    const WasmObjectFile* WasmFile = File->getWasmObj();
+    if (WasmFile->memories().size() == 0)
+      continue;
+    if (WasmFile->memories()[0].Initial == 0)
+      continue;
+    File->DataOffset = MemoryPtr;
+    debug_print("mem: [%s] offset=%#x pages=%d\n",
+                File->getName().str().c_str(), File->DataOffset,
+                WasmFile->memories()[0].Initial);
+    MemoryPtr += WasmFile->memories()[0].Initial * WasmPageSize;
+  }
+
+  // Stack comes last
+  if (!Config->Relocatable) {
+    debug_print("mem: stack base  = %#x\n", MemoryPtr);
+    MemoryPtr += Config->ZStackSize;
+    Config->SyntheticGlobals[0].second.InitExpr.Value.Int32 = MemoryPtr;
+    debug_print("mem: stack top   = %#x\n", MemoryPtr);
+  }
+
+  uint32_t MemSize = round_up_to_page_size(MemoryPtr);
+  TotalMemoryPages = MemSize / WasmPageSize;
+  debug_print("mem: total size  = %#x\n", MemSize);
+  debug_print("mem: total pages = %d\n", TotalMemoryPages);
+}
+
+void Writer::calculateOffsets() {
+  TotalGlobals = Config->SyntheticGlobals.size();
+
+  for (ObjectFile *File: Symtab->ObjectFiles) {
+    const WasmObjectFile* WasmFile = File->getWasmObj();
+
+    // 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");
+      else
+        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();
+
+    if (File->CodeSection)
+      TotalCodeRelocations += File->CodeSection->Relocations.size();
+    if (File->DataSection)
+      TotalDataRelocations += File->DataSection->Relocations.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) {
+    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->FunctionIndexOffset + Sym->getFunctionIndex());
+        else
+          Sym->setOutputIndex(Obj->GlobalIndexOffset + Sym->getGlobalIndex());
+      }
+    }
+  }
+}
+
+void Writer::run() {
+  log("-- calculateTypes");
+  calculateTypes();
+  log("-- calculateImports");
+  calculateImports();
+  log("-- calculateOffsets");
+  calculateOffsets();
+  log("-- assignSymbolIndexes");
+  assignSymbolIndexes();
+  log("-- layoutMemory");
+  layoutMemory();
+
+  if (Config->Verbose)
+    for (ObjectFile *File: Symtab->ObjectFiles)
+      File->dumpInfo();
+
+  log("-- openFile");
+  openFile();
+  if (ErrorCount)
+    return;
+
+  writeHeader();
+  log("-- writeHeader");
+  if (ErrorCount)
+    return;
+
+  log("-- writeSections");
+  writeSections(*OS);
+  if (ErrorCount)
+    return;
+}
+
+// Open a result file.
+void Writer::openFile() {
+  log("writing: " + Config->OutputFile);
+  ::remove(Config->OutputFile.str().c_str());
+  std::error_code EC;
+  OS = make_unique<raw_fd_ostream>(StringRef(Config->OutputFile), EC, sys::fs::OpenFlags::F_None);
+  if (EC)
+    error("failed to open " + Config->OutputFile + ": " + EC.message());
+}
+
+void Writer::writeHeader() {
+  write_bytes(WasmMagic, sizeof(WasmMagic), *OS, "wasm magic");
+  write_u32(WasmVersion, *OS, "wasm version");
+}
+
+} // anonymous namespace
+
+namespace lld {
+namespace wasm {
+
+void writeResult(SymbolTable *T) {
+  Writer(T).run();
+}
+
+} // namespace wasm
+} // namespace lld