[WebAssembly] Initial wasm linker implementation

[sbc100]

Summary

This linking backend is a work in progress, but is enough
to link simple programs including linking against library
archives.

[ruiu]

wasm/Writer.cpp

242

It needs comment -- it is not clear to me what this is for.

286–288

I don't think you need this as you can do this at the beginning of writeTo(). You need a finalizeContents if you don't know the size of a section unless you call that function, but this is not the case. I guess you can eliminate finalizeContents entirely from this patch.

415

Debug code?

419

clang-format

513

Flip the condition and do early return.

885–887

You can remove these three {s.

890

Can you add a comment? I think I do not understand this wasm-specific function.

916

Ditto

916

Location -> Buf

By convention, Buf should be the first parameter.

927

I think you can merge this and the following switch by removing Encoding variable.

943–944

Instead of computing the size of a padding, I think it is better to just write 5-bytes yourself. I'd define write{U,S}LEB128(uint8_t *Buf, {u,}int32_t) which always writes 5 byte to Buf.

958

I think I do not understand this function. Is this to create dynamic relocations? Please write a comment.

1022

What is this for? Is this a .rel.dyn section in wasm?

1042

This needs a comment.

1059

Ditto. Please describe it for those who are not very familiar with wasm.

1124

Looks like writeOutput is used only once, and writeOutput is a one-liner. You can inline it.

1134

Please write a comment so that I can understand what this function is supposed to do.

1137

MemoryPtr = alignTo(Config->GlobalBase, DataAlignment);

1243

What are Memory and Table?

1252

What is Elem?

1335–1338

"Num" is a more popular prefix than "Total" to manage a number of occurrences of something.

[krytarowski]

wasm/Error.cpp

22

Can we use:

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

[sbc100]

• Merge remote-tracking branch 'origin/master' into wasm
• [WebAssembly] Update relocation names
• [WebAssembly] Feedback from code review
• [WebAssembly] clang-format the patch
• [WebAssembly] Feedback from code review
• [WebAssembly] Factor out write utils
• [WebAssembly] For codereview feedback

[sbc100]

tools/lld/CMakeLists.txt

20

I'll just remove the link for now. The linker can be/is used via flavor=wasm.

wasm/Driver.cpp

211

I ran clang-format over the whole patch to fix this and the many other places like it.

wasm/Error.cpp

22

I don't think lld currently includes llvm's config.h. This is the exact same code in COFF/Error.cpp and ELF/Error.cpp so I think changing this can/should probably be done in a separate change.

wasm/InputFiles.cpp

143–144

I'm not sure I understand exactly what you mean. If I make WasmObj a regular pointer won't I have to manually delete it in the destructor? Why is that better? (Sorry C++11+ is kinda new to me).

FWIW, this is exacly how the COFF linker handles this (See COFF/InputFiles.cpp:92)

wasm/SymbolTable.cpp

40

Yes. In fact all lazy symbols are undefined. I believe this is try to ELF and COFF linkers too (i.e. LazyKind > LastDefinedKind)

85

Interesting, my intuition here is to check for error cases an early out.. so the that fall through at the end is the success path. But I guess this makes sense.

86–91

Also added a test for this.

wasm/Symbols.h

31

Copied from lld/COFF/Symbols.h.

49

Ok, I changed it so that lazy symbols are not undefined. This simplified the code a few places too. I had been assuming that all symbols were either defined or undefined, but it seems that doesn't need to be that case.

wasm/Writer.cpp

103

All these functions are for creating the synthetic sections, which are created in memory prior to mmaping the output file (since their size needs to be known).

103

I did some refactoring and put all these writer utility functions in a separate file.

173

Yes. Only custom sections have names. All the known sections are identified by their integer code.

186

Basically I'm printing extra information here in order to override the default behaviour of write_uleb128. Maybe the debug output a little more useful, but maybe over complicated?

239

For synthetic sections we need to fully serialize them in order to know that size of the final output file. i.e. we need to write them out before we can mmap the file.

This is only true for the synthetic sections.

286–288

Actually we don't know the size of the section until we synthesize its header, however you are right we can just this in the constructor and avoid implementing this method at all.

916

Renamed for clarity

943–944

I agree. But encodeULEB128 is defined in include/llvm/Support/LEB128.h and it takes a padding count. It should really take a total byte count to avoid having to do this calculation. But that should probably be a separate change. I work on that in parallel.

1022

This is for '-r' since the output object needs to contain all the relocs in that case (I assume this is the same for ELF/COFF)?

1243

Memory defines the linear memory required my the wasm module. It is essentially just and initial and max size.

Tables currently only used for indirect function calls. All indirect function calls are done via that table. Taking the address of a function in C causes that function to be added to this table. This is because functions don't themselves live in addressable memory.

1252

These are the element of the table (the indirect function call table).

[ruiu]

ELF/Error.cpp

19–22 ↗

(On Diff #113607)

What is this change?

tools/lld/lld.cpp

37

I don't think lld -flavor <flavor> is a preferred way of dispatching, and I'd avoid using it in wasm. If you use the option, and someone implements a different linker for wasm, it still has to claim it is lld and support -flavor option. How about ld-wasm? If, for example, bfd wants to support wasm, they could name their linker as ld-wasm.bfd.

wasm/Driver.cpp

113–116

By convention, I'd rename Result -> Res and SymbolName -> Sym.

142–143

Remove a comment about sysroot.

207

I don't think this function has to be a member of LinkerDriver. You can just move the code from here to Archive::addMember, no?

291–295

This is probably a bit simpler:

// Parse -allow-undefined-file <filename>
if (auto *Arg = Args.getLastArg(OPT_allow_undefined_file))
  if (Optional<MemoryBufferRef> Buf = readFile())
    for (StringRef S : getLines(*Buf))
      Config->AllowUndefinedSymbols.insert(S);

297–304

Use error instead of fatal as fatal is a noreturn function but we want to usually do not exit on the first error.

A rule of thumb is to use fatal only for corrupted file. For other errors, use error.

wasm/InputFiles.cpp

72

I wouldn't assert(Sym) because Symtab->find(Name)->isDefined() should immediately fail with SEGV if find returns a nullptr.

82

Ditto

98–99

We avoid hash table lookup as much as possible because it's too slow. Instead of storing symbol names to vectors, we usually store Symbol * or SymbolBody * to vectors, so that we don't need to lookup a hash table. Can you do that?

Basically, we don't want to lookup a hash table more than once for each string instance. If you do more than once, then you probably should keep the hash table lookup result (i.e. Symbol * or SymbolBody *) so that it doesn't have to repeat the same hash table lookup. I think this is one of the reasons why lld is much faster than other linkers.

99–101

It feels to me that the code has probably a bit too much asserts. Can you simply return Symtab->find(Name)->getOutputIndex()?

wasm/InputFiles.h

108

Could you add blank lines before the block comments?

wasm/SymbolTable.h

23–25

This is not used in the header.

wasm/Symbols.h

58

Isn't function global?

wasm/Writer.cpp

100

It is still using the streaming output interface, but is there a reason to prefer that? Since we are using mmap-based or std::vector-backed buffer exclusively in lld in general, I don't like to introduce a new way of writing to a buffer unless it is absolutely necessary.

102

Do you have to use formatv? It seems you can do "section type [" + sectionTypeToString(Type) + "]".

256

Outline this constructor and writeTo function.

497

Calculates

[sbc100]

• Merge branch 'master' into wasm
• [WebAssembly] Update expectations now that SymbolInfo not a required YAML field.
• [WebAssembly] Don't try to export main if its undefined
• [WebAssembly] Review feedback

wasm/Driver.cpp

291–295

I think I originally make the argument handling and the file processing seperate since I imagined a future where these files might grow in number and/or complexity (i.e. a set of default files in addition to the command line provided one). But I guess we can add that complexity where we get there.

wasm/Symbols.h

58

Wasm symbols are modeled as either either functions, or globals (in the wasm sense). Wasm globals correspond to C/C++ globals and have addresses in linear memory. So a given symbol is either a wasm function or a wasm global.

wasm/Writer.cpp

100

For writing these synthetic sections that contains a lot of LEB encoded data I think this stream interface makes a lot of sense. The LEB encoding functions can write directly to them and they grow on demand. Without this we would need to invent a new kind of auto-growing buffer that does basically the same thing. We can't know how big the vector/buffer is up front because we don't know the length of the LEBs until we encode them.

[sbc100]

• [WebAssembly] Fix index for R_WEBASSEMBLY_MEMORY_ADDR_* relocations
• Merge remote-tracking branch 'origin/master' into wasm
• [WebAssembly] Don't re-export entry point as 'main'
• [WebAssembly] Allow mulitple wasm data segments
• [WebAssembly] Update tests to match changes in llvm
• [WebAssembly] Update LEB to match changes to LEB128.h
• [WebAssembly] don't test data-layout with -r
• [WebAssembly] Refactor code to create OutputSections.cpp

[ruiu]

Sorry for the slow response. This patch is huge and needed concentration. Generally,

test/wasm/archive.ll

2

All these tests need "REQUIRES: wasm" so that they won't fail on buildbots that don't have wasm enabled.

wasm/Driver.cpp

181

I'd use fatal only to report corrupted input files. Since this is just a command-line error, I'd use error instead. This way, we can report more than one error.

229

This is -help. (/help is a Windows option.)

268–271

This is more consistent with other option handlers.

if (auto *Arg = Args.getLastArg(OPT_allow_undefined_file))
  if (Optional<MemoryBufferRef> Buf = readFile(A->getValue()))
    ...

Also this code catches error when you pass -allow-undefined-filename ''.

275–279

Please use error().

278

hasArgNoClaim is the same as hasArg in lld's usage of the class, so I"d use hasArg.

wasm/Driver.h

2

It seems everything declared in this header is actually being used only by Driver.cpp, so can you move them to Driver.cpp?

wasm/InputFiles.cpp

14

Driver.h is unused.

167–172

Do you think you can just insert symbols to the symbol table instead of temporarily storing names to these FunctionImports or GlobalImports variables? I'd just add an Undefined symbol (or something more appropriate) here and add its return value (a Symbol *) to FunctionSymbols and GlobalSymbols, so that I can remove FunctionImports and GlobalImports functions as well as getFunctionSymbol and getGlobalSymbol accessors.

184

Inlining this seems more straightforward since the function is short and used only once:

Symbols.push_back(Symtab->addUndefined(this, &Sym));

188

Symbols.push_back(Symtab->addDefined(this, &Sym));

209

Here's a question: do you have to use llvm-ar to create archive files for wasm files? I guess the answer is yes because regular ar commands don't understand wasm files so they cannot create symbol tables for them.

We have the same issue for LTO, because for LTO builds, input files are LLVM bitcode files which regular ar commands don't know about. We found that the problem is very annoying and using the right ar command is sometimes pretty hard. So we have this hack in ELF.

https://github.com/llvm-project/llvm-project/blob/51124a3e488376d9d3ba846fc251e510d082d10b/lld/ELF/Driver.cpp#L184

You don't want make a change to this patch at the moment, but I think this is something you want to consider.

267

We found that it doesn't make much sense to strip directory name components. I wouldn't call getBasename() on them.

wasm/OutputSections.cpp

29 ↗

(On Diff #115885)

Can you return StringRef so that it becomes more llvm-ish?

56–57 ↗

(On Diff #115885)

If the use of fatal is correct (if this is to report a corrupted input file), then please remove return after that, since fatal is a _Noreturn function. If not, please use error.

61 ↗

(On Diff #115885)

toString functions should be named in lld namespace instead of lld::<arch> namespace, so that it doesn't hide overriden toString functions in lld namespace.

62 ↗

(On Diff #115885)

"section: " is not part of a name, so I'd remove it. If you need this label, print it out on caller side.

63 ↗

(On Diff #115885)

This is perhaps a bit easier to read.

std::string S = sectionTypeToString(Section->Type);
if (!Section->Name.empty())
  return S + "(" + Section->Name + ")";
return S;

80 ↗

(On Diff #115885)

Looks like you can just return the RHS value instead of assigning it to a temporary variable.

97 ↗

(On Diff #115885)

fatal is a _Noreturn function, so no need to add break after it, as it is unreacahble.

wasm/OutputSections.h

24–25 ↗

(On Diff #115885)

I don't think you need this constructor because, instead of

OutputDataSegment(Foo, Bar)

you can write like this:

{Foo, Bar}

53 ↗

(On Diff #115885)

Offset = 0

is a preferred way of initializing a member if it always initialized to 0.

67–70 ↗

(On Diff #115885)

nit: you could write without reassignments:

memcpy(Buf + Offset, Header.data(), Header.size());
memcpy(Buf + Offset + Header.size(), Body.data(), Body.size());

[ruiu]

wasm/OutputSections.cpp

106 ↗

(On Diff #115885)

Can you use ArrayRef?

147 ↗

(On Diff #115885)

Is it okay to fallthrough? If so, add LLVM_FALLTHROUGH.

150 ↗

(On Diff #115885)

Why you can't directly call encodeULEB128(Reloc.Value, Buf, 5); here?

155 ↗

(On Diff #115885)

Ditto -- it seems you could call encodeSLEB128(Reloc.Value, Buf, 5); here.

164 ↗

(On Diff #115885)

Previous switch doesn't have a default, so the control could reach here with Encoding uninitialized, no?

165–172 ↗

(On Diff #115885)

Remove {}

195 ↗

(On Diff #115885)

I believe you don't need this because raw_string_ostream::~raw_string_ostream would do this for you.

201 ↗

(On Diff #115885)

If BodySize is always initialized to 0, the preferred way is to declare the variable with the initial value (i.e. BodySize = 0;)

213 ↗

(On Diff #115885)

remove const as it is obvious that we don't mutate Content.

230–231 ↗

(On Diff #115885)

You want to merge successive log into one function call because otherwise other thread could write other lines between the two lines.

wasm/OutputSections.h

50 ↗

(On Diff #115885)

I don't know why you need to aggregate input sections' relocations into one place. For COFF or ELF, we don't do that. Each input section has writeTo method and knows how to copy itself to a given buffer and relocate itself. Can't you do in the same way?

wasm/Symbols.cpp

47

If you know File is of ObjectFile, use cast instead of dyn_cast.

wasm/Symbols.h

95

I geuss you can initialize

ArchiveSymbol = {nullptr, 0, 0};

107–110

In lld we don't use operator overloading unless it is absolutely necessary. Since you can explicitly call toString() before emitting it to an output buffer, you can live without this. I'd remove this function.

wasm/Writer.cpp

36

constexpr instead of const may make more sense.

70

Do you need this?

145

We use pre-increments unless there's reason to use post-increments.

194–196

You can omit {}

207–211

You can omit {}

267

is?

346

Remove an empty function.

376

auto -> auto *

385

auto -> auto *

505

We usually name this Offset.

Is uint32_t enough? I thought 64-bit executables could be larger than 4 GiB.

585

I'm a bit confused about what this function does. Does this calculate file offsets as opposed to virtual memory offsets? In general, this file needs more comments.

608–613

Looks like it's the same as

if (WasmFile->memories().size() > 1)
  fatal(File->getName() + ": contains more than one memory");

628

No else after fatal, as fatal does not return.

765–771

You could write

void wasm::writeResult() { Writer().run(); }

without these namespaces.

wasm/Writer.h

23–27

It seems you are not using this struct.

wasm/WriterUtils.cpp

23 ↗

(On Diff #115885)

Use the LLVM naming convention.

34–35 ↗

(On Diff #115885)

fatal is _Noreturn.

39–40 ↗

(On Diff #115885)

Instead of enclosing the entire file, can you explicitly add wasm:: to each public functions?

wasm/WriterUtils.h

39–43 ↗

(On Diff #115885)

These two functions look the same.

[ruiu]

I'm sorry that I accidentally hit "Submit" button while I was writing a comment.

So, generally, this patch is improved in a right direction. There are still some code that I don't understand yet, mainly in Writer, but it is probably due to my lack of knowledge about wasm.

[sbc100]

Thank you for all the feedback @ruiu. It not surprise to me that a patch of this size takes a long time to review. I'm currently working on a fairly large change to allow data sections with the same name to be combined into a single section.. in order to allow things like init_array/fini_array. My aim is to get that done before the initial version of this patch lands.

[sbc100]

• [WebAssembly] Update test output to match llvm changes
• [WebAssembly] only run wasm tests when wasm is enabled
• [WebAssembly] Review feedback

[sbc100]

test/wasm/archive.ll

2

I added lit.local.cfg to this directory to disable them all in this case.

wasm/InputFiles.cpp

167–172

Yes, you are right. The work i'm doing to combine data sections will address, and makes this code much cleaner. So this will be fixed on my next upload.

209

Yes, llvm-ar would be needed to great the archive indexes.

I see yes, it might be good to handle archives with no symbol table. I'll add a TODO note here.

267

Ah, I was copying from the COFF linker. We should probably make this consistent at some point (perhaps as good candidate for shared code?)

wasm/OutputSections.cpp

56–57 ↗

(On Diff #115885)

switched to llvm_unreachable

195 ↗

(On Diff #115885)

True, but the getSize() below depends on Header, so we need the value before the end of the function. I could refactor to avoid this, especially since its only a logging statement.

wasm/OutputSections.h

24–25 ↗

(On Diff #115885)

I'm creating these using emplace_back() which seems to require a constructor. I could just use push_back() instead I guess?

[ruiu]

Is this ready for another round of review?

wasm/WriterUtils.cpp

38 ↗

(On Diff #116282)

More conventional way of doing it is to add using namespace lld; at the start of each file and do not enclose a file with namespace lld {}.

[sbc100]

• Merge branch 'master' into wasm
• [WebAssembly] Use UINT32_MAX rather than 0 for adddresses of undefined globals/functions
• [WebAssembly] Combine data segments with the same name
• Reflect upstream path changes to include/lld/common (#7)
• Delete lldConfig library from CMakeFiles.txt
• Add lldCommon to wasm LINK_LIBS (left over from last update)
• Merge branch 'master' into wasm
• Fix a merge conflict
• Merge remote-tracking branch 'origin/master' into wasm
• [WebAssembly] Ensure than name section is in function index order
• [WebAssembly] Fix for SLEB relocations of type UINT32_MAX.
• Merge remote-tracking branch 'origin/master' into wasm_work
• [WebAssembly] Switch to Common/ErrorHandler.h
• [WebAssembly] use Common/Threads.h

[ruiu]

This patch generally looking good. Looks like all my big concerns have already been resolved.

I have a little concern on documentation. Since wasm is a new object file format, and it employs different concepts than ELF or COFF, we cannot assume any prior knowledge to readers on wasm file format or linking semantics other than the common knowledge about linking. So, in short, I think this patch needs a bit more comment. Particularly, comments from high level would help readers understand your code, because once you understand a concept, minor details of your code will look pretty obvious. (This is a pretty straightforward linker implementation, so once you understand what it is supposed to do, it is easy to understand the code, I think.)

tools/lld/CMakeLists.txt

20

Looks like <arch>-<toolname> is more common than <toolname>-<arch>. For example, cross gcc for AVR installed on my system is avr-gcc and not gcc-avr. So, maybe wasm-ld is a better name than ld-wasm.

Sorry for back-and-forth.

wasm/InputFiles.cpp

136

Please add a brief function comment saying that this function returns a segment that contains a given symbol.

156–159

nit: pre-++ is a bit more C++-ish.

234

count++ → ++Count

245

each other.)

wasm/InputFiles.h

84–86

They are private functions, no?

118

nit: add a blank line.

124–128

Can you add a blank line before each line comment?

wasm/InputSegment.h

7 ↗

(On Diff #120681)

Can you describe what is "segment" in wasm? I was thinking that segments are another name for output sections, but looks like it is a different concept.

wasm/OutputSections.cpp

33 ↗

(On Diff #120681)

Return StringRef instead of const char *.

56–57 ↗

(On Diff #115885)

Looks like this function is not updated.

wasm/Symbols.cpp

36

Can you add function comments to functions defined in this file?

wasm/Writer.cpp

70

Looks like you didn't update this file for my previous comments.

[sbc100]

• [WebAssembly] Handle early exit via exitLld
• Merge remote-tracking branch 'origin/master' into wasm
• [WebAssembly] Fix --verbose flag
• [WebAssembly] Fix gcc warnings/errors
• [WebAssembly] Fix code relocation for large output files
• Merge remote-tracking branch 'origin/master' into wasm
• [WebAssembly] Support comments in wasm.syms
• Merge remote-tracking branch 'origin/master' into wasm
• [WebAssembly] Update for llvm change
• [WebAssembly] Review feedback

[sbc100]

• add docs

[sbc100]

• Remove whole-file namespace wrapping

[sbc100]

Hi ruiu.

I've added some documentation, removed the whole-file namesspace wrapping, integrated with the recent libCommon changes and upstream llvm changes.

Hopefully we can land this soon, so we can move to incremental diffs that will be easier to review. Or maybe you think I think try to be more feature complete for the initial version?

[ruiu]

I'd write more documents to describe the wasm object file format and the wasm linker's semantics, but we can do that later.

LGTM with these changes.

Thank you very much for your patience!

docs/WebAssembly.rst

8 ↗

(On Diff #122741)

mimic

33 ↗

(On Diff #122741)

functions

wasm/Driver.cpp

83

If you change this to LinkerDriver().link(Args), can you remove global variable Driver?

151

Could you revert this '#' check if you don't need it now? I mean if we want to add a way to have a comment in some file, we want to do the same thing for ELF and wasm, instead of inventing a different way for each target.

[sbc100]

• Fix use after free
• Merge remote-tracking branch 'origin/master' into wasm
• [WebAssembly] Add test case for output >128 functions
• [WebAssembly] Refactor the way relocations are applied and written
• [WebAssemlby] Parallel code writing
• [WebAssembly] Parallel data writing
• [WebAssembly] clang-format
• [WebAssembly] IWYU
• fix typo in addDefinedGlobal
• Merge branch 'master' into wasm
• review feedback

[aheejin]

wasm/Driver.cpp

103

After this was changed from const to constexpr, VS 2017 compiler on the waterfall bot does not compile this, saying:

tools\lld\wasm\Options.inc(28): error C2131: expression did not evaluate to a constant
tools\lld\wasm\Options.inc(28): note: failure was caused by non-constant arguments or reference to a non-constant symbol

I'm not really sure what the problem is, since this looks fine to me, but anyway could you possibly revert this to const, to make the VS2017 happy?

[sbc100]

• fix windows build

[sbc100]

• final tweaks (i hope!)

[sbc100]

No problem! Glad to land this initial version. Lets hope it sticks ..

docs/WebAssembly.rst

33 ↗

(On Diff #122741)

Reworded.

wasm/Driver.cpp

103

Ok, I reverted that for now. The other linker backed all use const rather than `constexpr` anyway.

151

This is already a completely wasm-specific feature. And it quite useful to support comments at the moment.

See: https://github.com/jfbastien/musl/blob/wasm-prototype-1/arch/wasm32/wasm.syms

In the long run I think we might be able to find a better solution to this. Some way to inform the linker about the expected undefined symbols. Maybe some kind of declspec in the source code?

CMakeLists.txt

 if (LLVM_INCLUDE_TESTS)
   add_subdirectory(test)
   add_subdirectory(unittests)
 endif()
 
 add_subdirectory(docs)
 add_subdirectory(COFF)
 add_subdirectory(ELF)
-
+add_subdirectory(wasm)

CODE_OWNERS.TXT

 N: Rui Ueyama
 E: [e-mail]
 D: COFF, ELF backends (COFF/* ELF/*)
 
 N: Lang Hames, Nick Kledzik
 E: [e-mail], [e-mail]
 D: Mach-O backend
 
+N: Sam Clegg
+E: [e-mail]
+D: WebAssembly backend (wasm/*)

include/lld/Driver/Driver.h

 bool link(llvm::ArrayRef<const char *> Args, bool CanExitEarly,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 
 namespace mach_o {
 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

test/lit.cfg

 NoPostJunk = r"(?!(-|\.))"
 
 config.substitutions.append( (r"\bld.lld\b", 'ld.lld --full-shutdown') )
 
 tool_patterns = [r"\bFileCheck\b",
                  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",
                  r"\bllvm-nm\b",
                  r"\bllvm-objdump\b",
                  r"\bllvm-pdbutil\b",
                  r"\bllvm-readobj\b",
                  r"\bobj2yaml\b",

test/wasm/Inputs/archive1.ll

+declare i32 @bar() local_unnamed_addr #1
+
+define i32 @foo() local_unnamed_addr #0 {
+entry:
+  %call = tail call i32 @bar() #2
+  ret i32 %call
+}

test/wasm/Inputs/archive2.ll

+declare i32 @foo() local_unnamed_addr #1
+
+define i32 @bar() local_unnamed_addr #0 {
+entry:
+  %call = tail call i32 @foo() #2
+  ret i32 %call
+}

test/wasm/Inputs/hello.ll

+; 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

test/wasm/Inputs/ret32.ll

+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)
+}

test/wasm/Inputs/ret64.ll

+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
+}

test/wasm/Inputs/weak-alias.ll

+define i32 @foo() #0 {
+entry:
+  ret i32 0
+}
+
+@bar = weak alias i32 (), i32 ()* @foo

test/wasm/archive.ll

+; 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

test/wasm/call-indirect.ll

+; 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

test/wasm/conflict.test

+# 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

test/wasm/entry.ll

+; 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

test/wasm/function-imports-first.ll

+; 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

test/wasm/function-imports.ll

+; 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

test/wasm/function-index.test

+# 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 ]

test/wasm/import-memory.test

+# 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

test/wasm/lit.local.cfg

+config.suffixes = ['.test', '.yaml', '.ll']

test/wasm/relocatable.ll

+; 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: ...
+
+

test/wasm/strip-debug.test

+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

test/wasm/undefined-entry.test

+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

test/wasm/undefined.ll

+; 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

test/wasm/version.ll

+; 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

test/wasm/weak-alias.ll

+; 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

test/wasm/weak-external.ll

+; 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: ...

tools/lld/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_lld_tool(lld
   lld.cpp
   )
 
 target_link_libraries(lld
   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})
   add_lld_symlink(${link} lld)
 endforeach()

tools/lld/lld.cpp

 using namespace llvm;
 using namespace llvm::sys;
 
 enum Flavor {
   Invalid,
   Gnu,     // -flavor gnu
   WinLink, // -flavor link
   Darwin,  // -flavor darwin
+  Wasm,    // -flavor wasm
 };
 
 LLVM_ATTRIBUTE_NORETURN static void die(const Twine &S) {
   errs() << S << "\n";
   exit(1);
 }
 
 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);
 }
 
 static Flavor parseProgname(StringRef Progname) {
 #if __APPLE__
   // Use Darwin driver for "ld" on Darwin.
int main(int Argc, const char **Argv) {
   std::vector<const char *> Args(Argv, Argv + Argc);
   switch (parseFlavor(Args)) {
   case Gnu:
     return !elf::link(Args, true);
   case WinLink:
     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.");
   }
 }

wasm/CMakeLists.txt

+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
+  )

wasm/Config.h

+//===- 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

wasm/Driver.h

+//===- 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

wasm/Driver.cpp

+//===- Driver.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "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

wasm/Error.h

+//===- 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

wasm/Error.cpp

+//===- 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

wasm/InputFiles.h

+//===- 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

wasm/InputFiles.cpp

+//===- InputFiles.cpp -----------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "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);
+}

wasm/Memory.h

+//===- 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

wasm/Options.td

+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>;

wasm/Strings.h

+//===- 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

wasm/Strings.cpp

+//===- 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;
+}
+
+}
+}

wasm/SymbolTable.h

+//===- 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

wasm/SymbolTable.cpp

+//===- SymbolTable.cpp ----------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "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

wasm/Symbols.h

+//===- 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

wasm/Symbols.cpp

+//===- Symbols.cpp --------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "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

wasm/Writer.h

+//===- 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

wasm/Writer.cpp

+//===- Writer.cpp ---------------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "Config.h"
+#include "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