[WebAssembly] Add explicit symbol table

[sbc100]

Summary

This change modified lld to in response the llvm change which
moved to a more explicit symbol table in the object format.

Based on patches by Nicholas Wilson:

1. https://reviews.llvm.org/D41955
2. https://reviews.llvm.org/D42585

The primary difference that we see in the test output is that
for relocatable (-r) output we now have symbol table which
replaces exports/imports and globals.

See: https://github.com/WebAssembly/tool-conventions/issues/38

[sbc100]

• cleanup

[sbc100]

• commit

[ruiu]

Could you explain what you meant by "a more explicit symbol table"? This is fairly large change, so it isn't very easy to get the gist of it.

[sbc100]

This is indeed a large change. I added a little more to the description.

@ncw has been working on these changes as two seperate partss (actual 4 parts, 2 in llvm and 2 on lld). I decided to merge them into single commit in each repo.

Essentially, for the relocatable output (llc output and lld -r output) we using an explicit symbol table rather than trying to module the entire thing using wasm's import/export/global concepts.

We get several advantages when doing this:

1. relocations can refer a symbol index (previously we have no symbol index space)
2. Data symbols can have other information such as size (previously we have just a single 32-bit address)
3. Data symbols can specify which segment they live in. We had we previously having trouble with data symbols that we on the boundy of two segments. Now we store "segment index + offset".

Some downside:

1. Relocatable output is less readable by standard wasm tools (and browsers).
2. Relocatable and executable output have two different way to export things.

The original bug: https://github.com/WebAssembly/tool-conventions/issues/38

[sbc100]

We are hoping this will be the last major change before we try push WebAssembly out of experimental on the llvm side. After that things should settle down (somewhat).

[sbc100]

• format

[sbc100]

• cleanup

[ruiu]

wasm/InputChunks.h

183

Chunk is a concept to represent some contiguous bytes in an input file or a synthesized one. Essentially, a chunk is a section or something similar.

It doesn't seems to me that this class falls in that category, though I may be wrong due to lack of knowledge on wasm. Is this an appropriate abstraction?

wasm/InputFiles.cpp

248

I'd just call Symbols.push_back(createUndefined(WasmSym)) and remove S.

Or, I'd move this switch-cases to a new function returning Symbol * and call like this:

Symbols.push_back(createSymbol(WasmSym));

wasm/InputFiles.h

111–114

Symbol -> Index

132–135

It seems more straightforward if you define getDataAddress and getDataSize.

wasm/MarkLive.cpp

73–76

Since we skip only one line, I'd flip the condition so that we can wreite

for (...)
  if (Reloc.Type != ...)
    Enqueue(...);

wasm/SymbolTable.cpp

133–136

If you wrap this up as a lambda

auto Error = [&](const Twine &Old, const Twine &New) {
  error(toString(NewType) + " type mismatch: " + Existing.getName() +
        "\n>>> defined as " + Old + " in " +
        toString(Existing.getFile()) + "\n>>> defined as " + New +
        " in " + F.getName());
};

then you can eliminate OldSigStr and NewSigStr variables from this function.

wasm/Symbols.cpp

140

Extraneous ()

201

I believe llvm_unreachable is defined as _Noreturn, so you don't need this return "" after llvm_noreturn.

217

Ditto

wasm/Symbols.h

152–154

A function is created for a chunk, so it is a bit odd that there's a situation that you have to change a chunk for an existing function symbol. What is this for?

234–240

Why does this have two constructors?

wasm/Writer.cpp

194–198

This is where you want to use cast instead of dyn_cast.

} else {
   auto *GlobalSym = cast<GlobalSymbol>(Sym);
   ....
}

412–416

This nested ?: operators look a bit fancy to me. I'd perhaps make this a tiny helper function that takes a Sym and returns a Kind.

wasm/WriterUtils.cpp

221–225

This is perhaps a personal taste, but isn't this better?

std::string S = toString(static_cast<ValType>(Sig.Type));
if (Sig.Mutable)
  return "mutable " + S;
return S;

[sbc100]

• feedback

[sbc100]

wasm/InputChunks.h

183

Yes, are you very astute. This was my feedback on @ncw 's original change too. However after playing around with it locally a bunch I decided it might be OK (for now anyway).

I did put a TODO below about this.

One idea which would work OK is to remove this from the "InputChunk" class hierarchy. However, if I do this then this new class is out on its own, maybe in a new file. Not a big deal I guess.

If we come up with higher level concept such as a more general "ElementFromIntoFile" :) perhaps we could share a bare class? I'm happy to experiment more with that once this lands. Or if you feel strongly, before it lands.

wasm/InputFiles.cpp

248

Makes sense. I was trying to minimize the delta. Perhaps I split that off into a pre-(or post) change.

wasm/InputFiles.h

132–135

Remove this function completely.

wasm/Symbols.h

152–154

This exists purely for the synthetic function which we create in Writer::createCtorFunction(). In this case we want to create the symbol at startup, and then create its body later on. I also agree this could be factored more elegantly. I'll add a TODO comment here.

234–240

One is for file-defined globals and one is for synthetic defined globals. Comment added.

[ncw]

All looks good, thanks for integrating with the Symbols.h changes!

wasm/InputChunks.h

183

My feedback when Sam asked about this was: Well it's not exactly a chunk of contiguous bytes with relocations, but it is nonetheless a piece of "data" from the input file that has to be copied to the output file.

The data is a struct WasmInitExpr; it's a fixed-size chunk of data that doesn't support any relocations, but is nonetheless a kind of input section, where the contents satisfy certain constraints. We could in fact have the data() method return a reference to its binary encoding as the "Body" of the chunk that will be written out in the GLOBALS part of the Wasm file, and then get rid of the getInitExpr() method. Would that be a suitable post-commit tidy?

wasm/InputFiles.cpp

189

Could just use cast<> to get the assertion for free?

wasm/Symbols.h

133

Could add a comment explaining that the symbol type is available via the InputChunk for DefinedFunction. Even though I implemented that, and forgot about it just now when I was reviewing, and spent a minute trying to remember how checkSymbolTypes was able to work if the FunctionType wasn't set for defined functions!

[sbc100]

• rebase + feedback

[ruiu]

Honestly I don't think I understand what InputGlobal class is doing and what's that for. The comment says that InputGlobal represents a single Wasm Global, and for that purpose, we do have symbol class right? That I can't understand that part of code doesn't necessarily mean that that's wrong, but it is a signal that something isn't quite right.

[sbc100]

• clang-format

[sbc100]

Maybe I can explain a little better.

This change introduces this new concept of a first class wasm "global" which can be named by "GlobalSymbol". This is distinct from data objects which are names via "DataSymbol". For now, llvm is only using one actual such wasm global (the one it used for stack pointer manipulation via the __stack_pointer symbol).

For parity with Functions and Data objects we want to allow a many-to-one mapping between symbols and the things symbols point to. This is mostly for supporting aliases. This means you can have several names (Symbols) pointing to a given InputFunction, InputGlobal, or InputSegment (segments can have even more names pointing to them because symbols can point to offsets within a segment).

However, as you point out, it is strange that InputGlobal is not really an InputChunk, in that it is not copied into place with memcpy + relocations like the other two subtypes. We can fix that in a followup CL, either by having it use memcpy for its tiny region, or my breaking the inheritance hierarchy.

[ruiu]

It sounds like InputGlobal is a symbol. Is this correct? (I know that you guys want to fix this later in a follow-up patch, but I cannot say LGTM to the code that I don't understand how it works...)

[ruiu]

wasm/InputChunks.h

193–194

Looks like this class is defined to wrap WasmGlobal objects so that they have these methods -- {set,get,has}OutputIndex. Is that correct? This class design looks really odd to me.

[sbc100]

In D43264#1008019, @ruiu wrote:

It sounds like InputGlobal is a symbol. Is this correct? (I know that you guys want to fix this later in a follow-up patch, but I cannot say LGTM to the code that I don't understand how it works...)

It represents a wasm global that could have an initial value. Several symbols could point to a given global. For example __stack_pointer and __stack_pointer_alias could both point to global 0, and in this case we would only want to write a single global to the final output and have both those symbols resolve to the same value when used in relocations.

[sbc100]

wasm/InputChunks.h

193–194

Yes, that is pretty much exactly what it does. That is the behavior we need.

Should we move it out of this hierarchy, and called it "OutputGlobal" perhaps?

[ruiu]

What is the relationship between Wasm Global and Wasm Symbol? In most object file formats, global/local is an attribute of a symbol, so when you say "global" it implies that it is a symbol. So I was thinking of symbols when you wrote "wasm global". But it sounds like that's different in wasm.

[sbc100]

Sorry, I can see why its confusing. The concept of a wasm global is different to the concept of a symbol (which can have local or global binding). We now have three symbols types which can name data, functions or wasm globals. I the ELF world the first two would be called STT_OBJECT and STT_FUNC. This new type has no ELF equivalent since its a wasm specific concept. So far the only use for this symbol type is the stack pointer but we see future uses (for example for tls access and possibly via intrinsics or assembly).

[ruiu]

So, InputFunction is a function, InputSegment is a data segment, and what is "wasm global" for? It sounds like it is more like data than a function, but I wonder how "wasm global" is different from regular data section.

[sbc100]

In D43264#1008031, @ruiu wrote:

So, InputFunction is a function, InputSegment is a data segment, and what is "wasm global" for? It sounds like it is more like data than a function, but I wonder how "wasm global" is different from regular data section.

Wasm has these first class things called globals that live outside the address space:
https://github.com/WebAssembly/design/blob/master/Modules.md#global-section

The can only be accessed via special get_global and set_gobal instructions.

[sbc100]

rebase

[ncw]

In D43264#1008031, @ruiu wrote:

So, InputFunction is a function, InputSegment is a data segment, and what is "wasm global" for? It sounds like it is more like data than a function, but I wonder how "wasm global" is different from regular data section.

It's basically a special type of data section; what makes it special is that it's accessed more like a register than a memory region.

The InputGlobal object represents the allocation of the memory/storage for the symbol, and contains the region of memory to be copied into the output binary with the initial value of the data.

You're right, it's very similar to a data symbol. The InputGlobal has really the same role for a GlobalSymbol as an InputSection does for a DataSymbol.

// Will be stored in ordinary memory, addressable down to individual bytes.
// Creates a 12-byte data section (InputSegment), holding its initial value, which
// the data Symbol points to as its definition.
std::tuple<int,int,int> global_variable = {1,2,3};

// Will create a 4-byte section, but using a "Wasm global". Not addressable down
// to individual bytes, it's like a register. Can't take address-of, can only assign
// and read from the storage. Requests the WebAssembly virtual machine to
// allocate a thread-local register. Constrained to be of register type (int32/float32/
// int64/float64) so the size of an InputGlobal is always a 4- or 8-byte section.
//
// Unlike x86 registers, you can have have as many as you want, they are storage
// slots allocated at program startup, just like ordinary sections are mapped to
// RAM. (NB The WebAssembly interpreter will spill the globals to RAM if the "real"
// CPU doesn't have enough spare registers to use for the Wasm globals). So it's like
// data, in that these are variables with a value, but the mechanics of the storage
// slots are different. There's no analogue in ELF, because x86 has a fixed number of
// registers, and the binary doesn't have to ask for them to be created.
//
// The 4-byte section containing the initial value is represented by an InputGlobal,
// which the Wasm-global symbol points to as its definition.  It's written out in a
// different place in the final Wasm object, since it has distinct semantics.
//
// NB. This attribute isn't actually implemented in the C frontend ("Wasm globals"
// are only accessible via intrinsics). Conceptually these are just variables though.
int __attribute__((wasm_global)) wasm_global = 123;

[sbc100]

• shorten yaml names

[ruiu]

I read the documentation of wasm to understand its model better. Here is my observation (some of them are very obvious to you guys though)

• Wasm has linear memory (which is basically a contiguous byte-addressable memory), functions (that don't exist in the linear memory space but you can call them by their indices) and global variables (that live in their own addressing space)
• Globals variables basically consists of types and indices

It looks more and more like global variables are just symbols with indices. Do you agree? I believe it can naturally be modeled as a symbol.

That makes me wonder what the current DefinedGlobal represents. Is this a symbol that lives in the linear memory or global variable?

[sbc100]

In the old code we used DefinedGlobal to meant global data in linear memory. In the new code that got renamed to DefinedData and a new type of entity called DefinedGlobal was added for wasm globals. Its a shame it has the same name in the new code, but I think it makes sense.

To make this even more complicated to follow, we previously modeled data symbols as wasm globals... i.e. we use the wasm globals in the object format to store the addresses in linear memory of data symbols. A little confusing, and one reason why we are making this change to have a more explicit symbol table.

We could simply store the wasm global data in the DefinedGlobal itself, rather then having it point to an InputGlobal. I think the problem there is when more than one symbol aliases the same global. But, we don't have the case yet so perhaps we can push that down the line a little. Let me see if I can simplify things.

[ruiu]

We could simply store the wasm global data in the DefinedGlobal itself, rather then having it point to an InputGlobal. I think the problem there is when more than one symbol aliases the same global. But, we don't have the case yet so perhaps we can push that down the line a little. Let me see if I can simplify things.

What is your concern on aliasing? In general, symbols can have aliases (by just pointing to the same offset in the same section). We don't do anything special about it in other file formats, and it just works fine -- we don't need to find if a symbol has aliases or not to generate a correct output. I'm wondering if there's some wasm-specific concern about it.

[ncw]

In D43264#1009526, @sbc100 wrote:

To make this even more complicated to follow, we previously modeled data symbols as wasm globals... i.e. we use the wasm globals in the object format to store the addresses in linear memory of data symbols. A little confusing, and one reason why we are making this change to have a more explicit

We could simply store the wasm global data in the DefinedGlobal itself, rather then having it point to an InputGlobal. I think the problem there is when more than one symbol aliases the same global. But, we don't have the case yet so perhaps we can push that down the line a little. Let me see if I can simplify things.

I'm not sure it would be simpler to put the definition (initialiser) for the symbol in the symbol itself. As you say, it's conceptually wrong because it doesn't work with aliases (unused in this case, but it demonstates the model wouldn't be right); secondly it breaks the link between defined symbols and their "chunk" containing the initializer; and thirdly, worst, prevents unifying the handling of globals/data (eg with comdat for globals, then symbols could then be initialized in the same way for all types).

I think we should aim to have globals work in the same way in LLD as data/function symbols, to keep the mental model simple, rather than arbitrarily constraing them with different resolution semantics (eg coding up a way of defining global symbols that doesn't allow aliases).

In D43264#1009514, @ruiu wrote:

• Globals variables basically consists of types and indices

And an initializer! That's what distinguishes a defined global from an imported/undefined one, in the same way that the initializer (bss or data section) does for a data symbol, or the function body does for a function symbol.

It looks more and more like global variables are just symbols with indices. Do you agree? I believe it can naturally be modeled as a symbol.

That makes me wonder what the current DefinedGlobal represents. Is this a symbol that lives in the linear memory or global variable?

DefinedGlobal is a symbol representing storage that's only accessible via its global index, rather than via a linear memory address. "Defined" means the Wasm file allocates that storage, rather than importing the storage from another DSO. We definitely need the distinction between defined and undefined for globals.

The key takeaway is that a global is a storage/memory slot that can be allocated by a binary, just like a data symbol in ELF, it's only the addressing model that's different (via index rather than RAM address).

Thanks for looking into this!

[ruiu]

And an initializer! That's what distinguishes a defined global from an imported/undefined one, in the same way that the initializer (bss or data section) does for a data symbol, or the function body does for a function symbol.

An initializer can just be a member of a symbol, no?

Global variables look very similar to imported functions. There's no "body" of imported symbols, and therefore there's no chunk that represents imported function body, even though imported symbols are "defined" (as opposed to "undefined" symbols that have to be resolved until the end of linking). Symbols doesn't have to have chunks, and that's not actually odd.

[ncw]

Aliasing works because of InputSection/InputChunk, which allows multiple symbols to reference the same chunk of memory, without having the section or body duplicated in the output. If you get rid of InputGlobal, you'll have aliasing issues, because the output will duplicate the global, causing it to be allocated storage twice - just like if a data section aliased by two symbols would chew up double the RAM if the symbols weren't able to share the InputSection. Plus the semantics would be wrong because writes to one alias should be visible by reads to the other.

[ruiu]

Aliasing works because of InputSection/InputChunk, which allows multiple symbols to reference the same chunk of memory, without having the section or body duplicated in the output. If you get rid of InputGlobal, you'll have aliasing issues, because the output will duplicate the global, causing it to be allocated storage twice - just like if a data section aliased by two symbols would chew up double the RAM if the symbols weren't able to share the InputSection. Plus the semantics would be wrong because writes to one alias should be visible by reads to the other.

I don't think you need to use InputChunk to address the issue. You can just maintain the indices of globals the linker has already emitted so that it doesn't assign different indices to two Globals that originally had the same index, for example. There may be easier way of doing it than that.

[ncw]

In D43264#1009579, @ruiu wrote:

An initializer can just be a member of a symbol, no?

By that logic, you wouldn't need InputSection at if all in the ELF linker. You just put the body of each symbol on the symbols, rather than allowing multiple symbols to defence the same section.

Global variables look very similar to imported functions. There's no "body" of imported symbols, and therefore there's no chunk that represents imported function body, even though imported symbols are "defined" (as opposed to "undefined" symbols that have to be resolved until the end of linking). Symbols doesn't have to have chunks, and that's not actually odd.

Globals are really more like data symbols. An int variable would have a 4-byte section asking the ELF interpreter to allocate 4 bytes of ram. A wasm global I32 has its own section in the wasm file, asking for a 4byte register-backed region to be allocated.

Do we have a different understanding of "imported"? An imported function is definitely undefined from a wasm and a linking point of view - both in ELF and warm, the function symbols with no body are undefined and the linker is looking for a definition against which to reduce any calls.

[ncw]

In D43264#1009589, @ruiu wrote:

I don't think you need to use InputChunk to address the issue. You can just maintain the indices of globals the linker has already emitted so that it doesn't assign different indices to two Globals that originally had the same index, for example. There may be easier way of doing it than that.

That's true, I admit. But you haven't done that for functions (even though it would be equally possible to get rid of InputSection or InputFunction in the same way). I just thinks it really helps comprehension if all the symbol clases are implemented in the same way, rather than differing in ad-hoc ways. Wanting DefinedFunction to work like DefinedGlobal is similar to wanting the wasm Symbol class to match the ELF symbol class.

I don't want to argue though - I'll go with your preference as the code owners, now I've (hopefully) explained my reasoning.

[ruiu]

By that logic, you wouldn't need InputSection at if all in the ELF linker. You just put the body of each symbol on the symbols, rather than allowing multiple symbols to defence the same section.

I don't know if I understand what you wrote correctly. In ELF, you need both symbols and sections in the linker. One section can have multiple symbols at its various offsets, and some of them are aliases (e.g. two symbols can point to the same location in the same section).

Globals are really more like data symbols. An int variable would have a 4-byte section asking the ELF interpreter to allocate 4 bytes of ram. A wasm global I32 has its own section in the wasm file, asking for a 4byte register-backed region to be allocated.

Well, that runtime allocates some memory at runtime doesn't necessarily mean that that has to be represented as Chunk. At least to me the use of Chunk in this patch to represent Globals is very odd and is not an intended use of Chunk. Chunk is designed to represent sections or something like that, and Globals is different.

Do we have a different understanding of "imported"? An imported function is definitely undefined from a wasm and a linking point of view - both in ELF and warm, the function symbols with no body are undefined and the linker is looking for a definition against which to reduce any calls.

By imported, I mean symbols in DSO (DLL) files. In ELF, it's SharedSymbol. In COFF, It's DLLImported symbol. They are considered "defined" because they are already resolved, but the actual code is not given until load-time.

[ncw]

I see about "imported", thanks! I hadn't realized that terminology in DSOs, my mistake. In wasm "imported" really is undefined.

Maybe we could compromise on keeping InputGlobal, but renaming it and making it not derive from InputChunk. That would almost compile as-is in fact, and I think maybe you've right that would be cleaner. MarkLive would have to gain support for it, but that's only a few lines of code actually.

I could try that tomorrow, or Sam could try now?

[sbc100]

In D43264#1009610, @ncw wrote:

I see about "imported", thanks! I hadn't realized that terminology in DSOs, my mistake. In wasm "imported" really is undefined.

Maybe we could compromise on keeping InputGlobal, but renaming it and making it not derive from InputChunk. That would almost compile as-is in fact, and I think maybe you've right that would be cleaner. MarkLive would have to gain support for it, but that's only a few lines of code actually.

I could try that tomorrow, or Sam could try now?

I've been trying to do this this evening but its fairly entangled. I will try again tomorrow, perhaps with a preparatory change to precede it.

[sbc100]

• rebase

[sbc100]

• rebase

[ncw]

In D43264#1009642, @sbc100 wrote:

I've been trying to do this this evening but its fairly entangled. I will try again tomorrow, perhaps with a preparatory change to precede it.

Sorry Sam, somehow this didn't catch my eye in my inbox -I realise now we might have been working on the same cleanup :( Oh well, don't worry if you go a different direction to what I did in D43391.

I can't really chat this evening - not that I'd be much help anyway!

If you and Rui can come up with a solution that works for InputGlobal - go ahead and merge! I'll take any solution, I'm only arguing for changes at the moment that are fairly close to how these patches are currently, to so that we don't end up with another big refactor on our hands before we can merge what we've got so far.

Do you have any thoughts at this point on how you think InputGlobal should fit into the hierarchy, eg like the comment in D43391?

[sbc100]

It also didn't feel right to have InputGlobal to inherit from InputChunk. For me the Chunks are really for the non-synthetic sections. That is the ones construct using memory copied from the input files + relocations.

I think of the global section as being a sythentic section (indeed it is right now). So I guess I agree with ruiu here. But don't worry, I'm sure we can find a solution...we will get this thing landed soon one way or another :)

[sbc100]

• Don't use InputChunk to model globals

[sbc100]

• revert parts

[ncw]

It looks OK still. It's familiar, in that I tried a similar refactor (making InputGlobal not inherit InputChunk), and I can see you've faced the same problems.

I think it works, just some comments about consistency below.

wasm/MarkLive.cpp

45–47

You're not marking globals as Live, so how will they avoid being GC'd? You need something like this to be added I think:

if (DefinedGlobal *G = dyn_cast<DefinedGlobal>(Sym)) {
  G->Global->Live = true;
  return;
}
InputChunk *Chunk = ...

It's probably just slipped under the radar because the stack-pointer is a synthetic global, and there aren't any tests yet for non-synthetic ones.

I have some tests I'm waiting to commit for more global support, I guess we could fix GC for defined globals then.

wasm/SymbolTable.cpp

174–175

It's odd that this is the one case without an assert(WasInserted) - I've forgotten, is there a reason we can't assert here like we do in addSyntheticFunction/Global?

wasm/Symbols.cpp

32–33

Missing specialisation for DefinedGlobal here; hasOutputIndex should definitely match the implementation for getOutputIndex below!

147–154

Shouldn't this method go away too now? We got rid of it on master for FunctionSymbol, so GlobalSymbol should match that unless there's a good reason to use the old scheme still.

wasm/Writer.cpp

146

Should this unique_ptr<InputGlobal> still be here? There are now two of these, one in the Linker and one here. (Personally, I think it makes sense to own the stack-pointer here and get rid of the InputGlobal in Linker, so that CtorFunction and StackPointer behave in the same way; I can't immediately think of a reason why they shouldn't...)

728–736

Also needs a special branch like in MarkLive:

if (DefinedGlobal* G = dyn_cast<DefinedGlobal>(Sym))
  if (G->Global && !G->Global->Live)
    continue;
}
InputChunk *Chunk = Sym->getChunk();
if (Chunk && !Chunk->Live)
  continue;

I know it's tedious... but if you're going to have the Live flag on InputGlobal (which I agree we do want) then we have to check it separately everywhere that we currently check the InputChunk::Live flag. That's the nuisancesome consequence of splitting InputGlobal off from InputChunk, but we can stomach that cost for now.

827–832

?? Shouldn't this be done in MarkLive; why should globals be different to functions in this regard?

[sbc100]

• feedback

wasm/MarkLive.cpp

45–47

Globals (like Types) are always generated precisely regardless of --gc-sections, and so are not handled here.

wasm/SymbolTable.cpp

174–175

Oops, that must have been merge conflict. Restored.

wasm/Writer.cpp

728–736

I think we will want an isLive() method on Symbol, like the COFF linker has. I will add that before landing this change.

827–832

When I added GC I decided to make it only apply to functions and data (chunks). For synthetic sections like the Type section, and now the Global section, I decided to always be precise and write only the types/globals that are needed. This means that you effectivly get type and global GC regardless of the --gc-sections flag. The code above marks the types are live already, this just extends it to handle globals

[ruiu]

test/wasm/many-functions.ll

14

I know this test tests "many functions", but it seems a bit too many. Do you really need this many functions?

wasm/Driver.cpp

307

Why don't you use make<>?

wasm/InputChunks.h

14

after relocations are applied

wasm/InputFiles.cpp

220–221

You can eliminate Global local variable.

wasm/InputFiles.h

127–129

InputGlobal *Global

wasm/InputGlobal.h

1 ↗

(On Diff #135163)

Wrong header name

19–20 ↗

(On Diff #135163)

I think using in a header isn't a good idea.

25 ↗

(On Diff #135163)

Wasm Global Variable is perhaps better? Global functions are global, so the use of Global is wasm-speak.

42 ↗

(On Diff #135163)

How large is WasmGlobal? I wonder which is better, keeping it through a reference or copying it here.

45 ↗

(On Diff #135163)

It is better to keep this kind of things trivially destructible.

wasm/Symbols.h

268

Ditto

290–291

I prefer explicit code even if it's a bit verbose, so let's avoid default parameters in lld. I believe you want to pass (null, null) only when you are adding synthetic sections, so in that case, you can explicitly pass (null, null).

wasm/Writer.cpp

133

DefinedGlobal is a symbol type, so this variable name is a it confusing.

706–721

Let's be consistent -- omit {}.

[sbc100]

• add Symbol::isLive()

[sbc100]

• feedback
• clang-format
• feedback

test/wasm/many-functions.ll

14

This is designed to test the case there there are more then 127 functions, which means the number of functions no longer can serialized as a single byte LEB. Since wasm uses LEBs extensively there can be a serialization bugs that only show up as we go from 127 to 128 elements. if you can think of a better way to tickle this case I'm open to changing this test.

(Also, I just noticed the comment above above describes this)

wasm/InputChunks.h

14

But relocations are applies after the memcpy, no?

wasm/InputGlobal.h

19–20 ↗

(On Diff #135163)

We have other uses like this of using specific types. If its OK with you I'll cleanup in a separate change and we can discuss there.

42 ↗

(On Diff #135163)

Around 16 bytes or so. And there is currently only one of them :) There may be more soon, but currently we are only talking about stack_pointer. If we find users are generating a lot of these we could reconsider this. In that case we could need to handle the stack_pointer differently since we currently really on the mutability of this field to set the SP value.

For now I think this is fine.

45 ↗

(On Diff #135163)

Why? I think its better to match the pattern used in InputChunks.h (initially anyway).

(Also, Optional is only non-trivial on gcc due to a compiler bug)

[ruiu]

wasm/InputChunks.h

14

I meant there was a typo in this line.

wasm/InputGlobal.h

42 ↗

(On Diff #135163)

Agreed.

45 ↗

(On Diff #135163)

Because I thought you would allocate a lot of instances of this class for a large program, just like we do to Symbol.

[sbc100]

• rebase

[sbc100]

• fix typos in comment

[ncw]

wasm/Symbols.h

76–77

OK, I'm happy with doing GC for globals in a separate place, if that's what you prefer... the isLive method is good. The comment here isn't accurate though (pedantic complaint this!) - "For function/data symbols, only valid after calling markLive; for global symbols only valid after global GC has been done".

wasm/Writer.cpp

835

(I guess this should be AddInputGlobal now)

898–899

It would be neater to give SyntheticFunction a std::string member, and call its constructor with std::move(CtorFunctionBody) so that the SyntheticFunction owns the synthetic body. Can do post-merge.

[sbc100]

• feedback

wasm/Writer.cpp

898–899

Sure. Unrelated to this change though.

[sbc100]

wabt change is ready to go: https://github.com/WebAssembly/wabt/pull/769

Any more feedback on this?

[sbc100]

• typos
• feedback
• Simplify address calculations for data symbols

[ruiu]

LGTM

There are a few things that hasn't been addressed, but we can address them later if we still want to do that.

wasm/SymbolTable.cpp

247–262

Overall, in the symbol table, we should have three functions for Function, GLobal and Data, instead of combining them into one function. I believe that'd be easier to read.

wasm/Symbols.h

181–182

That's a bit alarming that this function has so many parameters with default arguments. I generally do not prefer default parameters much because, for every optional parameter, it essentially defines a new overloaded function behind the scene. I'll try to address that later.

wasm/Writer.cpp

407–441

We should split this function because it grows organically to the point that it's too large.

[ruiu]

(So my previous comments were optional -- you can submit without fixing them.)

[sbc100]

• remove default args

[sbc100]

I fixed the DefinedData constructor args. The rest we can follow up with. Thanks for all the reviewing!

test/wasm/alias.ll

 ; CHECK-NEXT:         InitExpr:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            start_alias
+; CHECK-NEXT:       - Name:            _start
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            _start
+; CHECK-NEXT:       - Name:            start_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            __heap_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            __data_end
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           2

test/wasm/archive.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %S/Inputs/archive1.ll -o %t.a1.o
 ; RUN: llc -filetype=obj %S/Inputs/archive2.ll -o %t.a2.o
 ; RUN: llc -filetype=obj %S/Inputs/hello.ll -o %t.a3.o
 ; RUN: llvm-ar rcs %t.a %t.a1.o %t.a2.o %t.a3.o
 ; RUN: rm -f %t.imports
 ; RUN: not lld -flavor wasm --check-signatures %t.a %t.o -o %t.wasm 2>&1 | FileCheck -check-prefix=CHECK-UNDEFINED %s
 
 ; CHECK-UNDEFINED: undefined symbol: missing_func
 
 ; RUN: echo 'missing_func' > %t.imports
-; RUN: lld -flavor wasm --check-signatures %t.a %t.o -o %t.wasm
+; RUN: lld -flavor wasm --check-signatures -r %t.a %t.o -o %t.wasm
 
 ; RUN: llvm-nm -a %t.wasm | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 declare i32 @foo() local_unnamed_addr #1
 declare i32 @missing_func() local_unnamed_addr #1
 
 define void @_start() local_unnamed_addr #0 {
 entry:
   %call1 = call i32 @foo() #2
   %call2 = call i32 @missing_func() #2
   ret void
 }
 
-; Verify that multually dependant object files in an archive is handled
-; correctly.
+; Verify that mutually dependant object files in an archive is handled
+; correctly.  Since we're using llvm-nm, we must link with --relocatable.
+;
+; TODO(ncw): Update LLD so that the symbol table is written out for
+;   non-relocatable output (with an option to strip it)
 
 ; CHECK:      00000003 T _start
 ; CHECK-NEXT: 00000001 T bar
 ; CHECK-NEXT: 00000002 T foo
+; CHECK-NEXT:          U missing_func
 
 ; Verify that symbols from unused objects don't appear in the symbol table
 ; CHECK-NOT: hello
 
 ; Specifying the same archive twice is allowed.
 ; RUN: lld -flavor wasm --check-signatures %t.a %t.a %t.o -o %t.wasm

test/wasm/data-layout.ll

 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1052
 ; CHECK-NEXT:         Content:         68656C6C6F0A00
 
 
 ; RUN: lld -flavor wasm --check-signatures --relocatable -o %t_reloc.wasm %t.o %t.hello.o
 ; RUN: obj2yaml %t_reloc.wasm | FileCheck %s -check-prefix=RELOC
 
-; RELOC:        - Type:            GLOBAL
-; RELOC-NEXT:     Globals:
-; RELOC-NEXT:       - Index:           0
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           0
-; RELOC-NEXT:       - Index:           1
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           16
-
 ; RELOC:       - Type:            DATA
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
-; RELOC-NEXT:         Index:           3
+; RELOC-NEXT:         Index:           5
 ; RELOC-NEXT:         Offset:          0x00000018
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - SectionOffset:   6
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           0
 ; RELOC-NEXT:         Content:         '01000000'

 ; RELOC-NEXT:         Content:         1C000000
 ; RELOC-NEXT:       - SectionOffset:   33
 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           28
 ; RELOC-NEXT:         Content:         68656C6C6F0A00
 
-; RELOC:       - Type:            CUSTOM
+; RELOC:        - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     DataSize:        35
+; RELOC-NEXT:     SymbolTable:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            foo
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         SegmentIndex:    0
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            aligned_bar
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         SegmentIndex:    1
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            external_ref
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         SegmentIndex:    2
+; RELOC-NEXT:         Size:            4
+; RELOC:            - Index:           5
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            hello_str
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         SegmentIndex:    3
+; RELOC-NEXT:         Size:            7

test/wasm/init-fini.ll

 ; CHECK-NEXT: ...
 
 
 ; RUN: lld -flavor wasm --check-signatures -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: obj2yaml %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:          Name:            linking
 ; RELOC-NEXT:     DataSize:        0
-; RELOC-NEXT:     SymbolInfo:
-; RELOC-NEXT:       - Name:            __dso_handle
-; RELOC-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            func1
+; RELOC-NEXT:     SymbolTable:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            __dso_handle
+; RELOC-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN, UNDEFINED ]
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            func1
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            func2
+; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            func2
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            func3
+; RELOC-NEXT:         FunctionIndex:   1
+; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            func3
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            func4
+; RELOC-NEXT:         FunctionIndex:   2
+; RELOC-NEXT:       - Index:           4
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            func4
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            _start
+; RELOC-NEXT:         FunctionIndex:   3
+; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            __cxa_atexit
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   4
+; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.101
+; RELOC-NEXT:         FunctionIndex:   5
+; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.101
+; RELOC-NEXT:         FunctionIndex:   6
+; RELOC-NEXT:       - Index:           8
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lbitcast
+; RELOC-NEXT:         FunctionIndex:   7
+; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lbitcast
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.1001
+; RELOC-NEXT:         FunctionIndex:   8
+; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.1001
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.1001
+; RELOC-NEXT:         FunctionIndex:   9
+; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.1001
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            myctor
+; RELOC-NEXT:         FunctionIndex:   10
+; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:         Kind:            GLOBAL
+; RELOC-NEXT:         Name:            __stack_pointer
+; RELOC-NEXT:         Flags:           [ UNDEFINED ]
+; RELOC-NEXT:         GlobalIndex:     0
+; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            myctor
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            mydtor
+; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            mydtor
 ; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.101.1
+; RELOC-NEXT:         FunctionIndex:   12
+; RELOC-NEXT:       - Index:           15
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.101.1
+; RELOC-NEXT:         FunctionIndex:   13
+; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.101
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.202
+; RELOC-NEXT:         FunctionIndex:   14
+; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.202
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.202
+; RELOC-NEXT:         FunctionIndex:   15
+; RELOC-NEXT:       - Index:           18
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.202
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lcall_dtors.2002
+; RELOC-NEXT:         FunctionIndex:   16
+; RELOC-NEXT:       - Index:           19
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lcall_dtors.2002
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            .Lregister_call_dtors.2002
+; RELOC-NEXT:         FunctionIndex:   17
+; RELOC-NEXT:       - Index:           20
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            .Lregister_call_dtors.2002
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         FunctionIndex:   18
 ; RELOC-NEXT:     InitFunctions:
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:         Symbol:          1
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         FunctionIndex:   1
+; RELOC-NEXT:         Symbol:          2
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         FunctionIndex:   7
+; RELOC-NEXT:         Symbol:          8
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:         Symbol:          13
 ; RELOC-NEXT:       - Priority:        101
-; RELOC-NEXT:         FunctionIndex:   14
+; RELOC-NEXT:         Symbol:          16
 ; RELOC-NEXT:       - Priority:        202
-; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:         Symbol:          13
 ; RELOC-NEXT:       - Priority:        202
-; RELOC-NEXT:         FunctionIndex:   16
+; RELOC-NEXT:         Symbol:          18
 ; RELOC-NEXT:       - Priority:        1001
-; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:         Symbol:          1
 ; RELOC-NEXT:       - Priority:        1001
-; RELOC-NEXT:         FunctionIndex:   10
+; RELOC-NEXT:         Symbol:          11
 ; RELOC-NEXT:       - Priority:        2002
-; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:         Symbol:          13
 ; RELOC-NEXT:       - Priority:        2002
-; RELOC-NEXT:         FunctionIndex:   18
+; RELOC-NEXT:         Symbol:          20
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            func1
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            func2
 ; RELOC-NEXT:       - Index:           2

test/wasm/locals-duplicate.test

 ; RELOC-NEXT:       - ElemType:        ANYFUNC
 ; RELOC-NEXT:         Limits:
 ; RELOC-NEXT:           Flags:           [ HAS_MAX ]
 ; RELOC-NEXT:           Initial:         0x00000007
 ; RELOC-NEXT:           Maximum:         0x00000007
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:
 ; RELOC-NEXT:       - Initial:         0x00000001
-; RELOC-NEXT:   - Type:            GLOBAL
-; RELOC-NEXT:     Globals:
-; RELOC-NEXT:       - Index:           0
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           0
-; RELOC-NEXT:       - Index:           1
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           8
-; RELOC-NEXT:       - Index:           2
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           16
-; RELOC-NEXT:       - Index:           3
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           4
-; RELOC-NEXT:       - Index:           4
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           12
-; RELOC-NEXT:       - Index:           5
-; RELOC-NEXT:         Type:            I32
-; RELOC-NEXT:         Mutable:         false
-; RELOC-NEXT:         InitExpr:
-; RELOC-NEXT:           Opcode:          I32_CONST
-; RELOC-NEXT:           Value:           20
-; RELOC-NEXT:   - Type:            EXPORT
-; RELOC-NEXT:     Exports:
-; RELOC-NEXT:       - Name:            colliding_func1.1
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:       - Name:            colliding_func2
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:       - Name:            colliding_func3
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           2
-; RELOC-NEXT:       - Name:            get_global1A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           3
-; RELOC-NEXT:       - Name:            get_global2A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           4
-; RELOC-NEXT:       - Name:            get_global3A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           5
-; RELOC-NEXT:       - Name:            get_func1A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           6
-; RELOC-NEXT:       - Name:            get_func2A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           7
-; RELOC-NEXT:       - Name:            get_func3A
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           8
-; RELOC-NEXT:       - Name:            colliding_func1
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           9
-; RELOC-NEXT:       - Name:            colliding_func2.1
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           10
-; RELOC-NEXT:       - Name:            colliding_func3.1
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           11
-; RELOC-NEXT:       - Name:            get_global1B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           12
-; RELOC-NEXT:       - Name:            get_global2B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           13
-; RELOC-NEXT:       - Name:            get_global3B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           14
-; RELOC-NEXT:       - Name:            get_func1B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           15
-; RELOC-NEXT:       - Name:            get_func2B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           16
-; RELOC-NEXT:       - Name:            get_func3B
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           17
-; RELOC-NEXT:       - Name:            colliding_global1.1
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:       - Name:            colliding_global2
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:       - Name:            colliding_global3
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           2
-; RELOC-NEXT:       - Name:            colliding_global1
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           3
-; RELOC-NEXT:       - Name:            colliding_global2.1
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           4
-; RELOC-NEXT:       - Name:            colliding_global3.1
-; RELOC-NEXT:         Kind:            GLOBAL
-; RELOC-NEXT:         Index:           5
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 0, 1, 2, 9, 10, 11 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           4
 ; RELOC-NEXT:         Offset:          0x00000013
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           6
 ; RELOC-NEXT:         Offset:          0x0000001C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           2
+; RELOC-NEXT:         Index:           8
 ; RELOC-NEXT:         Offset:          0x00000025
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           0
 ; RELOC-NEXT:         Offset:          0x0000002E
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000037
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000040
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           3
+; RELOC-NEXT:         Index:           16
 ; RELOC-NEXT:         Offset:          0x00000058
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           4
+; RELOC-NEXT:         Index:           18
 ; RELOC-NEXT:         Offset:          0x00000061
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           5
+; RELOC-NEXT:         Index:           20
 ; RELOC-NEXT:         Offset:          0x0000006A
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           9
+; RELOC-NEXT:         Index:           12
 ; RELOC-NEXT:         Offset:          0x00000073
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           10
+; RELOC-NEXT:         Index:           13
 ; RELOC-NEXT:         Offset:          0x0000007C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           11
+; RELOC-NEXT:         Index:           14
 ; RELOC-NEXT:         Offset:          0x00000085
 ; RELOC-NEXT:     Functions:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B

 ; RELOC-NEXT:         MemoryIndex:     0
 ; RELOC-NEXT:         Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           16
 ; RELOC-NEXT:         Content:         '0000000000000000'
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     DataSize:        24
-; RELOC-NEXT:     SymbolInfo:
-; RELOC-NEXT:       - Name:            colliding_func1.1
+; RELOC-NEXT:     SymbolTable:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func1
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_func3
+; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func2
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   1
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_func2.1
+; RELOC-NEXT:         FunctionIndex:   2
+; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global1A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   3
+; RELOC-NEXT:       - Index:           4
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global1
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_func3.1
+; RELOC-NEXT:         SegmentIndex:    0
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global2A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   4
+; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global2
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         SegmentIndex:    1
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global3A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   5
+; RELOC-NEXT:       - Index:           8
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_global1.1
+; RELOC-NEXT:         SegmentIndex:    2
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func1A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   6
+; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func2A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   7
+; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func3A
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   8
+; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func1
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   9
+; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func2
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_global3
+; RELOC-NEXT:         FunctionIndex:   10
+; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            colliding_func3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_global2.1
+; RELOC-NEXT:         FunctionIndex:   11
+; RELOC-NEXT:       - Index:           15
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global1B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   12
+; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global1
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         SegmentIndex:    0
+; RELOC-NEXT:         Offset:          4
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global2B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   13
+; RELOC-NEXT:       - Index:           18
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global2
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
-; RELOC-NEXT:       - Name:            colliding_global3.1
+; RELOC-NEXT:         SegmentIndex:    1
+; RELOC-NEXT:         Offset:          4
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           19
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_global3B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   14
+; RELOC-NEXT:       - Index:           20
+; RELOC-NEXT:         Kind:            DATA
+; RELOC-NEXT:         Name:            colliding_global3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
+; RELOC-NEXT:         SegmentIndex:    2
+; RELOC-NEXT:         Offset:          4
+; RELOC-NEXT:         Size:            4
+; RELOC-NEXT:       - Index:           21
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func1B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   15
+; RELOC-NEXT:       - Index:           22
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func2B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   16
+; RELOC-NEXT:       - Index:           23
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            get_func3B
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   17
 ; RELOC-NEXT:     SegmentInfo:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            .bss.colliding_global1
 ; RELOC-NEXT:         Alignment:       4
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            .bss.colliding_global2
 ; RELOC-NEXT:         Alignment:       4

test/wasm/many-functions.ll

 ; RUN: llc -filetype=obj %p/Inputs/many-funcs.ll -o %t.many.o
 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: lld -flavor wasm --check-signatures -r -o %t.wasm %t.many.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that relocations within the CODE section correctly handle
 ; linking object with different header sizes.  many-funcs.ll has
 ; 128 function and so the final output requires a 2-byte LEB in
 ; the CODE section header to store the function count.
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 define i32 @func() {
 entry:
   %call = tail call i32 @func()
   ret i32 %call
 }
 
 ; CHECK:        - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000008
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000014
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000020
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000002C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000038
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000044
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000050
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000005C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000068
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000074
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000080
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000008C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000098
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000A4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000B0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000BC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000C8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000D4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000E0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000EC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000000F8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000104
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000110
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000011C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000128
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000134
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000140
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000014C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000158
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000164
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000170
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000017C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000188
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000194
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001A0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001AC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001B8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001C4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001D0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001DC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001E8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000001F4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000200
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000020C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000218
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000224
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000230
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000023C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000248
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000254
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000260
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000026C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000278
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000284
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000290
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000029C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002A8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002B4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002C0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002CC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002D8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002E4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002F0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000002FC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000308
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000314
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000320
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000032C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000338
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000344
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000350
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000035C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000368
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000374
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000380
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000038C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000398
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003A4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003B0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003BC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003C8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003D4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003E0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003EC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000003F8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000404
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000410
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000041C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000428
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000434
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000440
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000044C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000458
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000464
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000470
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000047C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000488
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000494
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004A0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004AC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004B8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004C4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004D0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004DC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004E8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000004F4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000500
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000050C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000518
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000524
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000530
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000053C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000548
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000554
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000560
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000056C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000578
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000584
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x00000590
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x0000059C
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005A8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005B4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005C0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005CC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005D8
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005E4
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x000005F0
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           129
 ; CHECK-NEXT:         Offset:          0x000005FC
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_LEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           129
 ; CHECK-NEXT:         Offset:          0x00000608
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           129
+; CHECK-NEXT:         Index:           131
 ; CHECK-NEXT:         Offset:          0x00000611
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4100280284808080000B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            4100280284808080000B

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           4
 ; CHECK-NEXT:         Content:         '01000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        8
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f1
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            foo
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f2
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   1
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f3
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   2
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f4
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   3
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f5
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   4
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f6
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   5
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f7
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   6
+; CHECK-NEXT:       - Index:           8
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f8
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   7
+; CHECK-NEXT:       - Index:           9
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f9
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   8
+; CHECK-NEXT:       - Index:           10
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f10
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   9
+; CHECK-NEXT:       - Index:           11
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f11
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   10
+; CHECK-NEXT:       - Index:           12
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f12
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   11
+; CHECK-NEXT:       - Index:           13
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f13
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   12
+; CHECK-NEXT:       - Index:           14
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f14
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   13
+; CHECK-NEXT:       - Index:           15
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f15
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   14
+; CHECK-NEXT:       - Index:           16
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f16
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   15
+; CHECK-NEXT:       - Index:           17
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f17
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   16
+; CHECK-NEXT:       - Index:           18
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f18
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   17
+; CHECK-NEXT:       - Index:           19
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f19
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   18
+; CHECK-NEXT:       - Index:           20
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f20
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   19
+; CHECK-NEXT:       - Index:           21
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f21
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   20
+; CHECK-NEXT:       - Index:           22
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f22
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   21
+; CHECK-NEXT:       - Index:           23
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f23
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   22
+; CHECK-NEXT:       - Index:           24
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f24
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   23
+; CHECK-NEXT:       - Index:           25
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f25
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   24
+; CHECK-NEXT:       - Index:           26
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f26
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   25
+; CHECK-NEXT:       - Index:           27
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f27
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   26
+; CHECK-NEXT:       - Index:           28
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f28
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   27
+; CHECK-NEXT:       - Index:           29
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f29
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   28
+; CHECK-NEXT:       - Index:           30
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f30
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   29
+; CHECK-NEXT:       - Index:           31
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f31
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   30
+; CHECK-NEXT:       - Index:           32
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f32
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   31
+; CHECK-NEXT:       - Index:           33
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f33
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   32
+; CHECK-NEXT:       - Index:           34
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f34
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   33
+; CHECK-NEXT:       - Index:           35
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f35
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   34
+; CHECK-NEXT:       - Index:           36
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f36
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   35
+; CHECK-NEXT:       - Index:           37
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f37
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   36
+; CHECK-NEXT:       - Index:           38
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f38
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   37
+; CHECK-NEXT:       - Index:           39
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f39
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   38
+; CHECK-NEXT:       - Index:           40
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f40
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   39
+; CHECK-NEXT:       - Index:           41
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f41
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   40
+; CHECK-NEXT:       - Index:           42
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f42
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   41
+; CHECK-NEXT:       - Index:           43
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f43
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   42
+; CHECK-NEXT:       - Index:           44
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f44
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   43
+; CHECK-NEXT:       - Index:           45
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f45
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   44
+; CHECK-NEXT:       - Index:           46
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f46
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   45
+; CHECK-NEXT:       - Index:           47
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f47
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   46
+; CHECK-NEXT:       - Index:           48
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f48
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   47
+; CHECK-NEXT:       - Index:           49
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f49
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   48
+; CHECK-NEXT:       - Index:           50
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f50
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   49
+; CHECK-NEXT:       - Index:           51
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f51
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   50
+; CHECK-NEXT:       - Index:           52
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f52
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   51
+; CHECK-NEXT:       - Index:           53
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f53
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   52
+; CHECK-NEXT:       - Index:           54
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f54
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   53
+; CHECK-NEXT:       - Index:           55
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f55
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   54
+; CHECK-NEXT:       - Index:           56
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f56
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   55
+; CHECK-NEXT:       - Index:           57
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f57
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   56
+; CHECK-NEXT:       - Index:           58
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f58
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   57
+; CHECK-NEXT:       - Index:           59
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f59
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   58
+; CHECK-NEXT:       - Index:           60
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f60
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   59
+; CHECK-NEXT:       - Index:           61
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f61
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   60
+; CHECK-NEXT:       - Index:           62
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f62
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   61
+; CHECK-NEXT:       - Index:           63
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f63
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   62
+; CHECK-NEXT:       - Index:           64
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f64
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   63
+; CHECK-NEXT:       - Index:           65
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f65
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   64
+; CHECK-NEXT:       - Index:           66
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f66
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   65
+; CHECK-NEXT:       - Index:           67
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f67
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   66
+; CHECK-NEXT:       - Index:           68
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f68
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   67
+; CHECK-NEXT:       - Index:           69
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f69
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   68
+; CHECK-NEXT:       - Index:           70
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f70
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   69
+; CHECK-NEXT:       - Index:           71
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f71
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   70
+; CHECK-NEXT:       - Index:           72
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f72
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   71
+; CHECK-NEXT:       - Index:           73
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f73
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   72
+; CHECK-NEXT:       - Index:           74
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f74
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   73
+; CHECK-NEXT:       - Index:           75
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f75
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   74
+; CHECK-NEXT:       - Index:           76
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f76
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   75
+; CHECK-NEXT:       - Index:           77
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f77
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   76
+; CHECK-NEXT:       - Index:           78
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f78
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   77
+; CHECK-NEXT:       - Index:           79
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f79
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   78
+; CHECK-NEXT:       - Index:           80
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f80
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   79
+; CHECK-NEXT:       - Index:           81
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f81
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   80
+; CHECK-NEXT:       - Index:           82
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f82
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   81
+; CHECK-NEXT:       - Index:           83
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f83
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   82
+; CHECK-NEXT:       - Index:           84
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f84
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   83
+; CHECK-NEXT:       - Index:           85
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f85
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   84
+; CHECK-NEXT:       - Index:           86
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f86
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   85
+; CHECK-NEXT:       - Index:           87
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f87
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   86
+; CHECK-NEXT:       - Index:           88
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f88
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   87
+; CHECK-NEXT:       - Index:           89
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f89
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   88
+; CHECK-NEXT:       - Index:           90
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f90
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   89
+; CHECK-NEXT:       - Index:           91
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f91
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   90
+; CHECK-NEXT:       - Index:           92
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f92
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   91
+; CHECK-NEXT:       - Index:           93
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f93
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   92
+; CHECK-NEXT:       - Index:           94
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f94
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   93
+; CHECK-NEXT:       - Index:           95
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f95
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   94
+; CHECK-NEXT:       - Index:           96
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f96
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   95
+; CHECK-NEXT:       - Index:           97
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f97
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   96
+; CHECK-NEXT:       - Index:           98
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f98
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   97
+; CHECK-NEXT:       - Index:           99
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f99
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   98
+; CHECK-NEXT:       - Index:           100
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f100
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   99
+; CHECK-NEXT:       - Index:           101
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f101
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   100
+; CHECK-NEXT:       - Index:           102
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f102
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   101
+; CHECK-NEXT:       - Index:           103
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f103
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   102
+; CHECK-NEXT:       - Index:           104
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f104
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   103
+; CHECK-NEXT:       - Index:           105
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f105
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   104
+; CHECK-NEXT:       - Index:           106
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f106
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   105
+; CHECK-NEXT:       - Index:           107
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f107
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   106
+; CHECK-NEXT:       - Index:           108
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f108
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   107
+; CHECK-NEXT:       - Index:           109
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f109
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   108
+; CHECK-NEXT:       - Index:           110
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f110
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   109
+; CHECK-NEXT:       - Index:           111
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f111
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   110
+; CHECK-NEXT:       - Index:           112
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f112
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   111
+; CHECK-NEXT:       - Index:           113
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f113
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   112
+; CHECK-NEXT:       - Index:           114
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f114
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   113
+; CHECK-NEXT:       - Index:           115
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f115
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   114
+; CHECK-NEXT:       - Index:           116
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f116
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   115
+; CHECK-NEXT:       - Index:           117
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f117
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   116
+; CHECK-NEXT:       - Index:           118
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f118
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   117
+; CHECK-NEXT:       - Index:           119
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f119
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   118
+; CHECK-NEXT:       - Index:           120
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f120
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   119
+; CHECK-NEXT:       - Index:           121
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f121
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   120
+; CHECK-NEXT:       - Index:           122
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f122
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   121
+; CHECK-NEXT:       - Index:           123
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f123
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   122
+; CHECK-NEXT:       - Index:           124
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f124
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   123
+; CHECK-NEXT:       - Index:           125
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f125
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   124
+; CHECK-NEXT:       - Index:           126
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f126
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   125
+; CHECK-NEXT:       - Index:           127
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f127
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   126
+; CHECK-NEXT:       - Index:           128
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f128
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   127
+; CHECK-NEXT:       - Index:           129
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            g0
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           130
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            f129
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   128
+; CHECK-NEXT:       - Index:           131
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            func
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   129
 ; CHECK-NEXT:     SegmentInfo:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.g0
 ; CHECK-NEXT:         Alignment:       4
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .data.foo
 ; CHECK-NEXT:         Alignment:       4
 ; CHECK-NEXT:         Flags:           [ ]

test/wasm/relocatable.ll

 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           foo_import
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           bar_import
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
-; CHECK-NEXT:       - Module:          env
-; CHECK-NEXT:         Field:           data_import
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         GlobalType:      I32
-; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 2, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000004
 ; CHECK-NEXT:           Maximum:         0x00000004
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000001
-; CHECK-NEXT:   - Type:            GLOBAL
-; CHECK-NEXT:     Globals:
-; CHECK-NEXT:       - Index:           1
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           0
-; CHECK-NEXT:       - Index:           2
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           28
-; CHECK-NEXT:       - Index:           3
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           8
-; CHECK-NEXT:       - Index:           4
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           12
-; CHECK-NEXT:       - Index:           5
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           16
-; CHECK-NEXT:       - Index:           6
-; CHECK-NEXT:         Type:            I32
-; CHECK-NEXT:         Mutable:         false
-; CHECK-NEXT:         InitExpr:
-; CHECK-NEXT:           Opcode:          I32_CONST
-; CHECK-NEXT:           Value:           24
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:
-; CHECK-NEXT:       - Name:            hello
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:       - Name:            my_func
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           4
-; CHECK-NEXT:       - Name:            func_comdat
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           5
-; CHECK-NEXT:       - Name:            hello_str
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           1
-; CHECK-NEXT:       - Name:            data_comdat
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           2
-; CHECK-NEXT:       - Name:            func_addr1
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           3
-; CHECK-NEXT:       - Name:            func_addr2
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           4
-; CHECK-NEXT:       - Name:            func_addr3
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           5
-; CHECK-NEXT:       - Name:            data_addr1
-; CHECK-NEXT:         Kind:            GLOBAL
-; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 4, 1, 2 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           2
 ; 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:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000013
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:         Offset:          0x0000001A
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_SLEB
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           8
 ; CHECK-NEXT:         Offset:          0x00000026
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:         3
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:          4180808080001080808080000B
 ; CHECK-NEXT:       - Index:         4
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:          1081808080001A1082808080001A41010B
 ; CHECK-NEXT:       - Index:         5
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:          419C808080000B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
-; CHECK-NEXT:         Index:           4
+; CHECK-NEXT:         Index:           6
 ; CHECK-NEXT:         Offset:          0x00000012
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
-; CHECK-NEXT:         Index:           1
+; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x0000001B
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_I32
-; CHECK-NEXT:         Index:           2
+; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:         Offset:          0x00000024
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_MEMORY_ADDR_I32
-; CHECK-NEXT:         Index:           0
+; CHECK-NEXT:         Index:           5
 ; CHECK-NEXT:         Offset:          0x0000002D
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:   6
 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           0
 ; CHECK-NEXT:         Content:         68656C6C6F0A00

 ; CHECK-NEXT:         MemoryIndex:     0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           28
 ; CHECK-NEXT:         Content:         '616263'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        31
-; CHECK-NEXT:     SymbolInfo:
-; CHECK-NEXT:       - Name:            bar_import
-; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:       - Name:            hello
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            puts
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]
+; CHECK-NEXT:         FunctionIndex:   0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            hello
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            my_func
+; CHECK-NEXT:         FunctionIndex:   3
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            hello_str
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         SegmentIndex:    0
+; CHECK-NEXT:         Size:            7
+; CHECK-NEXT:       - Index:           3
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            foo_import
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]
+; CHECK-NEXT:         FunctionIndex:   1
+; CHECK-NEXT:       - Index:           4
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            bar_import
+; CHECK-NEXT:         Flags:           [ BINDING_WEAK, UNDEFINED ]
+; CHECK-NEXT:         FunctionIndex:   2
+; CHECK-NEXT:       - Index:           5
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            data_import
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]
+; CHECK-NEXT:       - Index:           6
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            my_func
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            func_comdat
+; CHECK-NEXT:         FunctionIndex:   4
+; CHECK-NEXT:       - Index:           7
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            func_comdat
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:       - Name:            data_comdat
+; CHECK-NEXT:         FunctionIndex:   5
+; CHECK-NEXT:       - Index:           8
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            data_comdat
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
-; CHECK-NEXT:       - Name:            func_addr1
+; CHECK-NEXT:         SegmentIndex:    5
+; CHECK-NEXT:         Size:            3
+; CHECK-NEXT:       - Index:           9
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            func_addr1
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            func_addr2
+; CHECK-NEXT:         SegmentIndex:    1
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           10
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            func_addr2
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            func_addr3
+; CHECK-NEXT:         SegmentIndex:    2
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           11
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            func_addr3
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
-; CHECK-NEXT:       - Name:            data_addr1
+; CHECK-NEXT:         SegmentIndex:    3
+; CHECK-NEXT:         Size:            4
+; CHECK-NEXT:       - Index:           12
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            data_addr1
 ; CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; CHECK-NEXT:         SegmentIndex:    4
+; CHECK-NEXT:         Size:            4
 ; CHECK-NEXT:     SegmentInfo:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .rodata.hello_str
 ; CHECK-NEXT:         Alignment:       1
 ; CHECK-NEXT:         Flags:           [  ]
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            .data.func_addr1
 ; CHECK-NEXT:         Alignment:       4

test/wasm/signature-mismatch.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: llc -filetype=obj %s -o %t.main.o
 ; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.main.o %t.ret32.o 2>&1 | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 ; Function Attrs: nounwind
 define hidden void @_start() local_unnamed_addr #0 {
 entry:
   %call = tail call i32 @ret32(i32 1, i64 2, i32 3) #2
   ret void
 }
 
 declare i32 @ret32(i32, i64, i32) local_unnamed_addr #1
 
-; CHECK: error: function signature mismatch: ret32
+; CHECK: error: Function type mismatch: ret32
 ; CHECK-NEXT: >>> defined as (I32, I64, I32) -> I32 in {{.*}}.main.o
 ; CHECK-NEXT: >>> defined as (F32) -> I32 in {{.*}}.ret32.o

test/wasm/stack-pointer.ll

 ; CHECK-NEXT:         ReturnType:      I32
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:   - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __stack_pointer
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
-; CHECK-NEXT:         GlobalMutable:   false
+; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:
 ; CHECK-NEXT:           Flags:           [ HAS_MAX ]
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:           Maximum:         0x00000001
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x00000000
-; CHECK-NEXT:   - Type:            EXPORT
-; CHECK-NEXT:     Exports:
-; CHECK-NEXT:       - Name:            _start
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:         Offset:          0x00000004
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            23808080800041106B1A41000B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
+; CHECK-NEXT:     SymbolTable:
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            GLOBAL
+; CHECK-NEXT:         Name:            __stack_pointer
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]
+; CHECK-NEXT:         GlobalIndex:     0
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            _start
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         FunctionIndex:   0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT: ...

test/wasm/symbol-type-mismatch.ll

 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
 ; RUN: not lld -flavor wasm --check-signatures -o %t.wasm %t.o %t.ret32.o 2>&1 | FileCheck %s
 
 target triple = "wasm32-unknown-unknown-wasm"
 
 @ret32 = extern_weak global i32, align 4
 
 ; CHECK: error: symbol type mismatch: ret32
-; CHECK: >>> defined as Global in {{.*}}symbol-type-mismatch.ll.tmp.o
+; CHECK: >>> defined as Data in {{.*}}symbol-type-mismatch.ll.tmp.o
 ; CHECK: >>> defined as Function in {{.*}}.ret32.o

test/wasm/weak-alias.ll

 ; CHECK-NEXT:   - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            _start
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            alias_fn
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            direct_fn
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            call_direct
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:       - Name:            call_alias
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:       - Name:            call_alias_ptr
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:       - Name:            call_direct_ptr
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           5
+; CHECK-NEXT:       - Name:            alias_fn
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            __heap_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:       - Name:            __data_end
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:

 ; RELOC-NEXT:         ReturnType:      I32
 ; RELOC-NEXT:         ParamTypes:
 ; RELOC-NEXT:   - Type:            IMPORT
 ; RELOC-NEXT:     Imports:
 ; RELOC-NEXT:       - Module:          env
 ; RELOC-NEXT:         Field:           __stack_pointer
 ; RELOC-NEXT:         Kind:            GLOBAL
 ; RELOC-NEXT:         GlobalType:      I32
-; RELOC-NEXT:         GlobalMutable:   false
+; RELOC-NEXT:         GlobalMutable:   true
 ; RELOC-NEXT:   - Type:            FUNCTION
 ; RELOC-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1, 1 ]
 ; RELOC-NEXT:   - Type:            TABLE
 ; RELOC-NEXT:     Tables:
 ; RELOC-NEXT:       - ElemType:        ANYFUNC
 ; RELOC-NEXT:         Limits:
 ; RELOC-NEXT:           Flags:           [ HAS_MAX ]
 ; RELOC-NEXT:           Initial:         0x00000002
 ; RELOC-NEXT:           Maximum:         0x00000002
 ; RELOC-NEXT:   - Type:            MEMORY
 ; RELOC-NEXT:     Memories:
 ; RELOC-NEXT:       - Initial:         0x00000000
-; RELOC-NEXT:   - Type:            EXPORT
-; RELOC-NEXT:     Exports:
-; RELOC-NEXT:       - Name:            _start
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           0
-; RELOC-NEXT:       - Name:            alias_fn
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:       - Name:            direct_fn
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           1
-; RELOC-NEXT:       - Name:            call_direct
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           2
-; RELOC-NEXT:       - Name:            call_alias
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           3
-; RELOC-NEXT:       - Name:            call_alias_ptr
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           4
-; RELOC-NEXT:       - Name:            call_direct_ptr
-; RELOC-NEXT:         Kind:            FUNCTION
-; RELOC-NEXT:         Index:           5
 ; RELOC-NEXT:   - Type:            ELEM
 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 1 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           7
 ; RELOC-NEXT:         Offset:          0x00000004
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000013
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           7
 ; RELOC-NEXT:         Offset:          0x0000001C
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000027
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000032
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           7
 ; RELOC-NEXT:         Offset:          0x0000003A
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           7
 ; RELOC-NEXT:         Offset:          0x00000043
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000050
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x0000005D
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000068
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000070
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_FUNCTION_INDEX_LEB
-; RELOC-NEXT:         Index:           1
+; RELOC-NEXT:         Index:           2
 ; RELOC-NEXT:         Offset:          0x00000079
 ; RELOC-NEXT:       - Type:            R_WEBASSEMBLY_GLOBAL_INDEX_LEB
-; RELOC-NEXT:         Index:           0
+; RELOC-NEXT:         Index:           1
 ; RELOC-NEXT:         Offset:          0x00000086
 ; RELOC-NEXT:     Functions:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            1081808080001A0B
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41000B

 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:           - Type:            I32
 ; RELOC-NEXT:             Count:           2
 ; RELOC-NEXT:         Body:            23808080800041106B220024808080800020004181808080003602081081808080002101200041106A24808080800020010B
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            linking
 ; RELOC-NEXT:     DataSize:        0
-; RELOC-NEXT:     SymbolInfo:
-; RELOC-NEXT:       - Name:            alias_fn
+; RELOC-NEXT:     SymbolTable:
+; RELOC-NEXT:       - Index:           0
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            _start
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   0
+; RELOC-NEXT:       - Index:           1
+; RELOC-NEXT:         Kind:            GLOBAL
+; RELOC-NEXT:         Name:            __stack_pointer
+; RELOC-NEXT:         Flags:           [ UNDEFINED ]
+; RELOC-NEXT:         GlobalIndex:     0
+; RELOC-NEXT:       - Index:           2
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            direct_fn
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   1
+; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            call_direct
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   2
+; RELOC-NEXT:       - Index:           4
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            call_alias
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   3
+; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            call_alias_ptr
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   4
+; RELOC-NEXT:       - Index:           6
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            call_direct_ptr
+; RELOC-NEXT:         Flags:           [  ]
+; RELOC-NEXT:         FunctionIndex:   5
+; RELOC-NEXT:       - Index:           7
+; RELOC-NEXT:         Kind:            FUNCTION
+; RELOC-NEXT:         Name:            alias_fn
 ; RELOC-NEXT:         Flags:           [ BINDING_WEAK ]
+; RELOC-NEXT:         FunctionIndex:   1
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            direct_fn
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Name:            call_direct
 ; RELOC-NEXT:       - Index:           3
 ; RELOC-NEXT:         Name:            call_alias
 ; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Name:            call_alias_ptr
 ; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Name:            call_direct_ptr
 ; RELOC-NEXT: ...

wasm/Driver.cpp

static StringRef getEntry(opt::InputArgList &Args, StringRef Default) {
   auto *Arg = Args.getLastArg(OPT_entry, OPT_no_entry);
   if (!Arg)
     return Default;
   if (Arg->getOption().getID() == OPT_no_entry)
     return "";
   return Arg->getValue();
 }
 
-static Symbol* addUndefinedFunction(StringRef Name, const WasmSignature *Type) {
-  return Symtab->addUndefined(Name, Symbol::UndefinedFunctionKind, 0, nullptr,
+static Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type) {
+  return Symtab->addUndefined(Name, WASM_SYMBOL_TYPE_FUNCTION, 0, nullptr,
                               Type);
 }
 
 void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   WasmOptTable Parser;
   opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
 
   // Handle --help
if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Args.hasArg(OPT_undefined))
       error("-r -and --undefined may not be used together");
   }
 
   Symbol *EntrySym = nullptr;
   if (!Config->Relocatable) {
     static WasmSignature NullSignature = {{}, WASM_TYPE_NORESULT};
+    static WasmGlobalType StackPointerType = {WASM_TYPE_I32, true};
 
     // Add synthetic symbols before any others
     WasmSym::CallCtors = Symtab->addSyntheticFunction(
         "__wasm_call_ctors", &NullSignature, WASM_SYMBOL_VISIBILITY_HIDDEN);
-    WasmSym::StackPointer = Symtab->addSyntheticGlobal("__stack_pointer");
-    WasmSym::HeapBase = Symtab->addSyntheticGlobal("__heap_base");
-    WasmSym::DsoHandle = Symtab->addSyntheticGlobal("__dso_handle");
-    WasmSym::DataEnd = Symtab->addSyntheticGlobal("__data_end");
+    // Can't export the SP right now because it's mutable, and mutable
+    // globals aren't yet supported in the official binary format.
+    // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN if/when the
+    // "mutable global" proposal is accepted.
+    WasmSym::StackPointer = Symtab->addSyntheticGlobal(
+        "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, &StackPointerType);
+    WasmSym::HeapBase = Symtab->addSyntheticData("__heap_base");
+    WasmSym::DsoHandle =
+        Symtab->addSyntheticData("__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
+    WasmSym::DataEnd = Symtab->addSyntheticData("__data_end");
 
     if (!Config->Entry.empty())
       EntrySym = addUndefinedFunction(Config->Entry, &NullSignature);
 
     // Handle the `--undefined <sym>` options.
     for (auto* Arg : Args.filtered(OPT_undefined))
       addUndefinedFunction(Arg->getValue(), nullptr);
   }

wasm/InputChunks.h

 //===- InputChunks.h --------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // An input chunk represents an indivisible blocks of code or data from an input
 // file.  i.e. a single wasm data segment or a single wasm function.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_WASM_INPUT_CHUNKS_H
 #define LLD_WASM_INPUT_CHUNKS_H
 
 #include "Config.h"
 #include "InputFiles.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "llvm/Object/Wasm.h"
 
 using llvm::object::WasmSegment;
 using llvm::wasm::WasmFunction;
+using llvm::wasm::WasmGlobal;
 using llvm::wasm::WasmRelocation;
 using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmInitExpr;
 using llvm::object::WasmSection;
 
 namespace lld {
 namespace wasm {
 
 class ObjFile;
 class OutputSegment;
 
 class InputChunk {
 public:
-  enum Kind { DataSegment, Function };
+  enum Kind { DataSegment, Function, Global };
 
   Kind kind() const { return SectionKind; }
 
   uint32_t getSize() const { return data().size(); }
 
   void copyRelocations(const WasmSection &Section);
 
   void writeTo(uint8_t *SectionStart) const;
protected:
   llvm::Optional<uint32_t> OutputIndex;
   llvm::Optional<uint32_t> TableIndex;
 };
 
 class SyntheticFunction : public InputFunction {
 public:
   SyntheticFunction(const WasmSignature &S, ArrayRef<uint8_t> Body,
                     StringRef Name)
-      : InputFunction(S, nullptr, nullptr), Name(Name), Body(Body) {}
+      : InputFunction(S, nullptr, nullptr), Name(Name), Body(Body) {
+    Live = true;
+  }
 
   StringRef getName() const override { return Name; }
 
 protected:
   ArrayRef<uint8_t> data() const override { return Body; }
 
   StringRef Name;
   ArrayRef<uint8_t> Body;
 };
 
+// Represents a single Wasm Global within an input file. These are combined to
+// form the final GLOBALS section.
+class InputGlobal : public InputChunk {
+public:
+  InputGlobal(const WasmGlobal *G, ObjFile *F)
+      : InputChunk(F, InputChunk::Global), Global(G) {}
+
+  static bool classof(const InputChunk *C) {
+    return C->kind() == InputChunk::Global;
+  }
+
+  StringRef getComdat() const override { return StringRef(); }
+  uint32_t getOutputIndex() const { return OutputIndex.getValue(); }
+  bool hasOutputIndex() const { return OutputIndex.hasValue(); }
+  void setOutputIndex(uint32_t Index);
+
+  virtual const WasmInitExpr &getInitExpr() const { return Global->InitExpr; }
+  virtual const WasmGlobalType &getType() const { return Global->Type; }
+
+protected:
+  // TODO(sbc): Globals don't really belong in this class heirarchy.
+  // Refactor so to avoid this ugliness.
+  StringRef getName() const override { return {}; }
+  ArrayRef<uint8_t> data() const override { return {}; }
+  uint32_t getInputSectionOffset() const override { return 0; }
+
+  const WasmGlobal *Global;
+  llvm::Optional<uint32_t> OutputIndex;
+};
+
+class SyntheticGlobal : public InputGlobal {
+public:
+  SyntheticGlobal(const WasmGlobalType &Type, const WasmInitExpr &InitExpr)
+      : InputGlobal(nullptr, nullptr), InitExpr(InitExpr), Type(Type) {
+    Live = true;
+  }
+
+  const WasmInitExpr &getInitExpr() const override { return InitExpr; }
+  const WasmGlobalType &getType() const override { return Type; }
+
+protected:
+  WasmInitExpr InitExpr;
+  const WasmGlobalType Type;
+};
+
 } // namespace wasm
 } // namespace lld
 
 #endif // LLD_WASM_INPUT_CHUNKS_H

wasm/InputChunks.cpp

 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 uint32_t InputSegment::translateVA(uint32_t Address) const {
-  assert(Address >= startVA() && Address < endVA());
+  assert(Address >= startVA() && Address <= endVA());
   int32_t Delta = OutputSeg->StartVA + OutputSegmentOffset - startVA();
   DEBUG(dbgs() << "translateVA: " << getName() << " Delta=" << Delta
                << " Address=" << Address << "\n");
   return Address + Delta;
 }
 
 void InputChunk::copyRelocations(const WasmSection &Section) {
   if (Section.Relocations.empty())
     return;
   size_t Start = getInputSectionOffset();
   size_t Size = getSize();
   for (const WasmRelocation &R : Section.Relocations)
     if (R.Offset >= Start && R.Offset < Start + Size)
       Relocations.push_back(R);
 }
 
 static void applyRelocation(uint8_t *Buf, const OutputRelocation &Reloc) {
   DEBUG(dbgs() << "write reloc: type=" << Reloc.Reloc.Type
                << " index=" << Reloc.Reloc.Index << " value=" << Reloc.Value
                << " offset=" << Reloc.Reloc.Offset << "\n");
   Buf += Reloc.Reloc.Offset;
   int64_t ExistingValue;
   switch (Reloc.Reloc.Type) {
   case R_WEBASSEMBLY_TYPE_INDEX_LEB:
-  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
     ExistingValue = decodeULEB128(Buf);
     // Additional check to verify that the existing value that the location
     // matches our expectations.
+    // TODO(sbc): Perform this extra check for other reloc types too.
     if (ExistingValue != Reloc.Reloc.Index) {
-      DEBUG(dbgs() << "existing value: " << decodeULEB128(Buf) << "\n");
-      assert(decodeULEB128(Buf) == Reloc.Reloc.Index);
+      DEBUG(dbgs() << "existing value: " << ExistingValue << "\n");
+      assert(ExistingValue == Reloc.Reloc.Index);
     }
     LLVM_FALLTHROUGH;
+  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
+  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
     encodeULEB128(Reloc.Value, Buf, 5);
     break;
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
   case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
     encodeSLEB128(static_cast<int32_t>(Reloc.Value), Buf, 5);
     break;
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
void InputFunction::setOutputIndex(uint32_t Index) {
   OutputIndex = Index;
 }
 
 void InputFunction::setTableIndex(uint32_t Index) {
   DEBUG(dbgs() << "InputFunction::setTableIndex: " << getName() << " -> " << Index << "\n");
   assert(!hasTableIndex());
   TableIndex = Index;
 }
+
+void InputGlobal::setOutputIndex(uint32_t Index) {
+  DEBUG(dbgs() << "InputGlobal::setOutputIndex: " << getName() << " -> "
+               << Index << "\n");
+  assert(!hasOutputIndex());
+  OutputIndex = Index;
+}

wasm/InputFiles.h

 #include "WriterUtils.h"
 
 #include <vector>
 
 using llvm::object::Archive;
 using llvm::object::WasmObjectFile;
 using llvm::object::WasmSection;
 using llvm::object::WasmSymbol;
+using llvm::wasm::WasmGlobal;
 using llvm::wasm::WasmImport;
 using llvm::wasm::WasmSignature;
 using llvm::wasm::WasmRelocation;
 
 namespace lld {
 namespace wasm {
 
 class InputChunk;
 class InputFunction;
 class InputSegment;
+class InputGlobal;
 
 class InputFile {
 public:
   enum Kind {
     ObjectKind,
     ArchiveKind,
   };
 
public:
 
   void parse() override;
 
   // Returns the underlying wasm file.
   const WasmObjectFile *getWasmObj() const { return WasmObj.get(); }
 
   void dumpInfo() const;
 
-  uint32_t relocateFunctionIndex(uint32_t Original) const;
   uint32_t calcNewIndex(const WasmRelocation &Reloc) const;
   uint32_t calcNewValue(const WasmRelocation &Reloc) const;
 
   const WasmSection *CodeSection = nullptr;
   const WasmSection *DataSection = nullptr;
 
   std::vector<uint32_t> TypeMap;
   std::vector<bool> TypeIsUsed;
   std::vector<InputSegment *> Segments;
   std::vector<InputFunction *> Functions;
+  std::vector<InputGlobal *> Globals;
 
   ArrayRef<Symbol *> getSymbols() const { return Symbols; }
-
-  FunctionSymbol *getFunctionSymbol(uint32_t Index) const {
-    return cast<FunctionSymbol>(FunctionSymbols[Index]);
-  }
-
-  GlobalSymbol *getGlobalSymbol(uint32_t Index) const {
-    return cast<GlobalSymbol>(GlobalSymbols[Index]);
-  }
+  Symbol *getSymbol(uint32_t Symbol) const { return Symbols[Symbol]; }
+  FunctionSymbol *getFunctionSymbol(uint32_t Index) const;
+  DataSymbol *getDataSymbol(uint32_t Index) const;
+  GlobalSymbol *getGlobalSymbol(uint32_t Index) const;
 
 private:
   uint32_t relocateVirtualAddress(uint32_t Index) const;
+  uint32_t relocateFunctionIndex(uint32_t Original) const;
   uint32_t relocateTypeIndex(uint32_t Original) const;
   uint32_t relocateGlobalIndex(uint32_t Original) const;
   uint32_t relocateTableIndex(uint32_t Original) const;
+  uint32_t relocateSymbolIndex(uint32_t Original) const;
 
-  Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputChunk *Chunk,
-                              uint32_t Address);
+  Symbol *createDefinedData(const WasmSymbol &Sym, InputChunk *Chunk,
+                            uint32_t Address, uint32_t DataSize);
   Symbol *createDefinedFunction(const WasmSymbol &Sym, InputChunk *Chunk);
-  Symbol *createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
-                          const WasmSignature *Signature = nullptr);
+  Symbol *createDefinedGlobal(const WasmSymbol &Sym, InputChunk *Chunk);
+  Symbol *createUndefined(const WasmSymbol &Sym);
+
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym) const;
-  const WasmSignature *getFunctionSig(const WasmSymbol &Sym) const;
-  uint32_t getGlobalValue(const WasmSymbol &Sym) const;
+  std::pair<uint32_t, uint32_t>
+  getDataAddressAndSize(const WasmSymbol &WasmSym) const;
   InputFunction *getFunction(const WasmSymbol &Sym) const;
+  InputGlobal *getGlobal(const WasmSymbol &Sym) const;
   bool isExcludedByComdat(InputChunk *Chunk) const;
 
   // List of all symbols referenced or defined by this file.
   std::vector<Symbol *> Symbols;
 
-  // List of all function symbols indexed by the function index space
-  std::vector<Symbol *> FunctionSymbols;
-
-  // List of all global symbols indexed by the global index space
-  std::vector<Symbol *> GlobalSymbols;
-
   uint32_t NumGlobalImports = 0;
   uint32_t NumFunctionImports = 0;
   std::unique_ptr<WasmObjectFile> WasmObj;
 };
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
 
 } // namespace wasm
 
 std::string toString(const wasm::InputFile *File);
 
 } // namespace lld
 
 #endif

wasm/InputFiles.cpp

Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   make<std::unique_ptr<MemoryBuffer>>(std::move(MB)); // take MB ownership
 
   return MBRef;
 }
 
 void ObjFile::dumpInfo() const {
   log("info for: " + getName() + "\n" +
-      "      Total Functions : " + Twine(FunctionSymbols.size()) + "\n" +
-      "        Total Globals : " + Twine(GlobalSymbols.size()) + "\n" +
+      "              Symbols : " + Twine(Symbols.size()) + "\n" +
       "     Function Imports : " + Twine(NumFunctionImports) + "\n" +
       "       Global Imports : " + Twine(NumGlobalImports) + "\n");
 }
 
 uint32_t ObjFile::relocateVirtualAddress(uint32_t GlobalIndex) const {
-  if (auto *DG = dyn_cast<DefinedGlobal>(getGlobalSymbol(GlobalIndex)))
+  if (auto *DG = dyn_cast<DefinedData>(getDataSymbol(GlobalIndex)))
     return DG->getVirtualAddress();
   else
     return 0;
 }
 
 uint32_t ObjFile::relocateFunctionIndex(uint32_t Original) const {
   const FunctionSymbol *Sym = getFunctionSymbol(Original);
   uint32_t Index = Sym->getOutputIndex();
   DEBUG(dbgs() << "relocateFunctionIndex: " << toString(*Sym) << ": "
                << Original << " -> " << Index << "\n");
   return Index;
 }
 
 uint32_t ObjFile::relocateTypeIndex(uint32_t Original) const {
   assert(TypeIsUsed[Original]);
   return TypeMap[Original];
 }
 
 uint32_t ObjFile::relocateTableIndex(uint32_t Original) const {
   const FunctionSymbol *Sym = getFunctionSymbol(Original);
+  // The null case is possible, if you take the address of a weak function
+  // that's simply not supplied.
   uint32_t Index = Sym->hasTableIndex() ? Sym->getTableIndex() : 0;
   DEBUG(dbgs() << "relocateTableIndex: " << toString(*Sym) << ": " << Original
                << " -> " << Index << "\n");
   return Index;
 }
 
 uint32_t ObjFile::relocateGlobalIndex(uint32_t Original) const {
   const Symbol *Sym = getGlobalSymbol(Original);
   uint32_t Index = Sym->getOutputIndex();
   DEBUG(dbgs() << "relocateGlobalIndex: " << toString(*Sym) << ": " << Original
                << " -> " << Index << "\n");
   return Index;
 }
 
+uint32_t ObjFile::relocateSymbolIndex(uint32_t Original) const {
+  Symbol *Sym = getSymbol(Original);
+  uint32_t Index = Sym->getOutputSymbolIndex();
+  DEBUG(dbgs() << "relocateSymbolIndex: " << toString(*Sym) << ": " << Original
+               << " -> " << Index << "\n");
+  return Index;
+}
+
 // Relocations contain an index into the function, global or table index
 // space of the input file.  This function takes a relocation and returns the
 // relocated index (i.e. translates from the input index space to the output
 // index space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const {
-  switch (Reloc.Type) {
-  case R_WEBASSEMBLY_TYPE_INDEX_LEB:
+  if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB)
     return relocateTypeIndex(Reloc.Index);
-  case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-  case R_WEBASSEMBLY_TABLE_INDEX_I32:
-  case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-    return relocateFunctionIndex(Reloc.Index);
-  case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-  case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-  case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-  case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-    return relocateGlobalIndex(Reloc.Index);
-  default:
-    llvm_unreachable("unknown relocation type");
-  }
+
+  return relocateSymbolIndex(Reloc.Index);
 }
 
 // Translate from the relocation's index into the final linked output value.
 uint32_t ObjFile::calcNewValue(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_TABLE_INDEX_I32:
   case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
     return relocateTableIndex(Reloc.Index);
void ObjFile::parse() {
   TypeMap.resize(getWasmObj()->types().size());
   TypeIsUsed.resize(getWasmObj()->types().size(), false);
 
   initializeSymbols();
 }
 
 // Return the InputSegment in which a given symbol is defined.
 InputSegment *ObjFile::getSegment(const WasmSymbol &WasmSym) const {
-  uint32_t Address = WasmObj->getWasmSymbolValue(WasmSym);
-  for (InputSegment *Segment : Segments) {
-    if (Address >= Segment->startVA() && Address < Segment->endVA()) {
-      DEBUG(dbgs() << "Found symbol in segment: " << WasmSym.Name << " -> "
-                   << Segment->getName() << "\n");
-
-      return Segment;
-    }
-  }
-  error("symbol not found in any segment: " + WasmSym.Name);
-  return nullptr;
-}
-
-// Get the value stored in the wasm global represented by this symbol.
-// This represents the virtual address of the symbol in the input file.
-uint32_t ObjFile::getGlobalValue(const WasmSymbol &Sym) const {
-  const WasmGlobal &Global =
-      getWasmObj()->globals()[Sym.ElementIndex - NumGlobalImports];
-  assert(Global.Type.Type == llvm::wasm::WASM_TYPE_I32);
-  return Global.InitExpr.Value.Int32;
-}
-
-// Get the signature for a given function symbol, either by looking
-// it up in function sections (for defined functions), of the imports section
-// (for imported functions).
-const WasmSignature *ObjFile::getFunctionSig(const WasmSymbol &Sym) const {
-  DEBUG(dbgs() << "getFunctionSig: " << Sym.Name << "\n");
-  return &WasmObj->types()[Sym.FunctionType];
+  return Segments[WasmSym.Info.DataRef.Segment];
+}
+
+std::pair<uint32_t, uint32_t>
+ObjFile::getDataAddressAndSize(const WasmSymbol &WasmSym) const {
+  const WasmDataReference &Ref = WasmSym.Info.DataRef;
+  return std::make_pair(getSegment(WasmSym)->startVA() + Ref.Offset, Ref.Size);
 }
 
 InputFunction *ObjFile::getFunction(const WasmSymbol &Sym) const {
-  uint32_t FunctionIndex = Sym.ElementIndex - NumFunctionImports;
+  assert(Sym.Info.ElementIndex >= NumFunctionImports);
+  uint32_t FunctionIndex = Sym.Info.ElementIndex - NumFunctionImports;
   return Functions[FunctionIndex];
 }
 
+InputGlobal *ObjFile::getGlobal(const WasmSymbol &Sym) const {
+  assert(Sym.Info.ElementIndex >= NumGlobalImports);
+  uint32_t GlobalIndex = Sym.Info.ElementIndex - NumGlobalImports;
+  return Globals[GlobalIndex];
+}
+
 bool ObjFile::isExcludedByComdat(InputChunk *Chunk) const {
   StringRef Comdat = Chunk->getComdat();
   return !Comdat.empty() && Symtab->findComdat(Comdat) != this;
 }
 
-void ObjFile::initializeSymbols() {
-  Symbols.reserve(WasmObj->getNumberOfSymbols());
+FunctionSymbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
+  return dyn_cast<FunctionSymbol>(Symbols[Index]);
+}
 
-  for (const WasmImport &Import : WasmObj->imports()) {
-    switch (Import.Kind) {
-    case WASM_EXTERNAL_FUNCTION:
-      ++NumFunctionImports;
-      break;
-    case WASM_EXTERNAL_GLOBAL:
-      ++NumGlobalImports;
-      break;
-    }
-  }
+GlobalSymbol *ObjFile::getGlobalSymbol(uint32_t Index) const {
+  return dyn_cast<GlobalSymbol>(Symbols[Index]);
+
+DataSymbol *ObjFile::getDataSymbol(uint32_t Index) const {
+  return dyn_cast<DataSymbol>(Symbols[Index]);
 
-  FunctionSymbols.resize(NumFunctionImports + WasmObj->functions().size());
-  GlobalSymbols.resize(NumGlobalImports + WasmObj->globals().size());
+void ObjFile::initializeSymbols() {
+  Symbols.reserve(WasmObj->getNumberOfSymbols());
+
+  NumFunctionImports = WasmObj->getNumImportedFunctions();
+  NumGlobalImports = WasmObj->getNumImportedGlobals();
 
   ArrayRef<WasmFunction> Funcs = WasmObj->functions();
   ArrayRef<uint32_t> FuncTypes = WasmObj->functionTypes();
   ArrayRef<WasmSignature> Types = WasmObj->types();
-  ArrayRef<WasmGlobal> Globals = WasmObj->globals();
 
   for (const auto &C : WasmObj->comdats())
     Symtab->addComdat(C, this);
 
-  FunctionSymbols.resize(NumFunctionImports + Funcs.size());
-  GlobalSymbols.resize(NumGlobalImports + Globals.size());
-
   for (const WasmSegment &S : WasmObj->dataSegments()) {
     InputSegment *Seg = make<InputSegment>(S, this);
     Seg->copyRelocations(*DataSection);
     Segments.emplace_back(Seg);
   }
 
+  for (const WasmGlobal &G : WasmObj->globals()) {
+    InputGlobal *Global = make<InputGlobal>(&G, this);
+    Globals.emplace_back(Global);
+  }
+
   for (size_t I = 0; I < Funcs.size(); ++I) {
     const WasmFunction &Func = Funcs[I];
     const WasmSignature &Sig = Types[FuncTypes[I]];
     InputFunction *F = make<InputFunction>(Sig, &Func, this);
     F->copyRelocations(*CodeSection);
     Functions.emplace_back(F);
   }
 
-  // Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols
-  // in the object
+  // Populate `Symbols` based on the WasmSymbols in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
     Symbol *S;
-    switch (WasmSym.Type) {
-    case WasmSymbol::SymbolType::FUNCTION_EXPORT: {
+    switch (WasmSym.Info.Kind) {
+    case WASM_SYMBOL_TYPE_FUNCTION:
+      if (WasmSym.isDefined()) {
         InputFunction *Function = getFunction(WasmSym);
         if (!isExcludedByComdat(Function)) {
           S = createDefinedFunction(WasmSym, Function);
           break;
         } else {
           Function->Live = false;
-        LLVM_FALLTHROUGH; // Exclude function, and add the symbol as undefined
+          // Exclude function, and add the symbol as undefined
         }
       }
-    case WasmSymbol::SymbolType::FUNCTION_IMPORT:
-      S = createUndefined(WasmSym, Symbol::Kind::UndefinedFunctionKind,
-                          getFunctionSig(WasmSym));
+      S = createUndefined(WasmSym);
       break;
-    case WasmSymbol::SymbolType::GLOBAL_EXPORT: {
+    case WASM_SYMBOL_TYPE_DATA:
+      if (WasmSym.isDefined()) {
         InputSegment *Segment = getSegment(WasmSym);
         if (!isExcludedByComdat(Segment)) {
-        S = createDefinedGlobal(WasmSym, Segment, getGlobalValue(WasmSym));
+          uint32_t DataAddress, DataSize;
+          std::tie(DataAddress, DataSize) = getDataAddressAndSize(WasmSym);
+          S = createDefinedData(WasmSym, Segment, DataAddress, DataSize);
           break;
         } else {
           Segment->Live = false;
-        LLVM_FALLTHROUGH; // Exclude global, and add the symbol as undefined
+          // Exclude data, and add the symbol as undefined
         }
       }
-    case WasmSymbol::SymbolType::GLOBAL_IMPORT:
-      S = createUndefined(WasmSym, Symbol::Kind::UndefinedGlobalKind);
+      S = createUndefined(WasmSym);
+      break;
+    case WASM_SYMBOL_TYPE_GLOBAL:
+      if (WasmSym.isDefined())
+        S = createDefinedGlobal(WasmSym, getGlobal(WasmSym));
+      else
+        S = createUndefined(WasmSym);
       break;
     }
 
     Symbols.push_back(S);
-    if (WasmSym.isTypeFunction()) {
-      FunctionSymbols[WasmSym.ElementIndex] = S;
-      if (WasmSym.HasAltIndex)
-        FunctionSymbols[WasmSym.AltIndex] = S;
-    } else {
-      GlobalSymbols[WasmSym.ElementIndex] = S;
-      if (WasmSym.HasAltIndex)
-        GlobalSymbols[WasmSym.AltIndex] = S;
-    }
-  }
 
-  DEBUG(for (size_t I = 0; I < FunctionSymbols.size(); ++I)
-            assert(FunctionSymbols[I] != nullptr);
-        for (size_t I = 0; I < GlobalSymbols.size(); ++I)
-            assert(GlobalSymbols[I] != nullptr););
-
-  DEBUG(dbgs() << "Functions   : " << FunctionSymbols.size() << "\n");
-  DEBUG(dbgs() << "Globals     : " << GlobalSymbols.size() << "\n");
+static WasmSymbolType getType(const WasmSymbol &Sym) {
+  return static_cast<WasmSymbolType>(Sym.Info.Kind);
 }
 
-Symbol *ObjFile::createUndefined(const WasmSymbol &Sym, Symbol::Kind Kind,
-                                 const WasmSignature *Signature) {
-  return Symtab->addUndefined(Sym.Name, Kind, Sym.Flags, this, Signature);
+Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
+  return Symtab->addUndefined(Sym.Info.Name, getType(Sym), Sym.Info.Flags, this,
+                              Sym.FunctionType, Sym.GlobalType);
 }
 
 Symbol *ObjFile::createDefinedFunction(const WasmSymbol &Sym,
                                        InputChunk *Chunk) {
   if (Sym.isBindingLocal())
-    return make<DefinedFunction>(Sym.Name, Sym.Flags, this, Chunk);
-  return Symtab->addDefined(true, Sym.Name, Sym.Flags, this, Chunk);
+    return make<DefinedFunction>(Sym.Info.Name, Sym.Info.Flags, this, Chunk);
+  return Symtab->addDefined(Sym.Info.Name, getType(Sym), Sym.Info.Flags, this,
+                            Chunk);
+}
+
+Symbol *ObjFile::createDefinedData(const WasmSymbol &Sym, InputChunk *Chunk,
+                                   uint32_t Address, uint32_t Size) {
+  if (Sym.isBindingLocal())
+    return make<DefinedData>(Sym.Info.Name, Sym.Info.Flags, this, Chunk,
+                             Address, Size);
+  return Symtab->addDefined(Sym.Info.Name, getType(Sym), Sym.Info.Flags, this,
+                            Chunk, Address, Size);
 }
 
-Symbol *ObjFile::createDefinedGlobal(const WasmSymbol &Sym, InputChunk *Chunk,
-                                     uint32_t Address) {
+Symbol *ObjFile::createDefinedGlobal(const WasmSymbol &Sym, InputChunk *Chunk) {
   if (Sym.isBindingLocal())
-    return make<DefinedGlobal>(Sym.Name, Sym.Flags, this, Chunk, Address);
-  return Symtab->addDefined(false, Sym.Name, Sym.Flags, this, Chunk, Address);
+    return make<DefinedGlobal>(Sym.Info.Name, Sym.Info.Flags, this, Chunk);
+  return Symtab->addDefined(Sym.Info.Name, getType(Sym), Sym.Info.Flags, this,
+                            Chunk);
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.
   DEBUG(dbgs() << "Parsing library: " << toString(this) << "\n");
   File = CHECK(Archive::create(MB), toString(this));
 
   // Read the symbol table to construct Lazy symbols.

wasm/MarkLive.cpp

if (!Config->GcSections)
     return;
 
   DEBUG(dbgs() << "markLive\n");
   SmallVector<InputChunk *, 256> Q;
 
   auto Enqueue = [&](Symbol *Sym) {
     if (!Sym)
       return;
     InputChunk *Chunk = Sym->getChunk();
     if (!Chunk || Chunk->Live)
       return;
     Chunk->Live = true;
     Q.push_back(Chunk);
   };
 
   // Add GC root symbols.
   if (!Config->Entry.empty())
     Enqueue(Symtab->find(Config->Entry));
   Enqueue(WasmSym::CallCtors);
 
   // By default we export all non-hidden, so they are gc roots too
   for (Symbol *Sym : Symtab->getSymbols())
     if (!Sym->isHidden())
       Enqueue(Sym);
 
   // The ctor fuctions are all used the synthetic __wasm_call_ctors function,
   // but since this function is created in-place it doesn't contain reloctations
   // which mean we have to manually mark the ctors.
   for (const ObjFile *Obj : Symtab->ObjectFiles) {
     const WasmLinkingData &L = Obj->getWasmObj()->linkingData();
     for (const WasmInitFunc &F : L.InitFunctions)
-      Enqueue(Obj->getFunctionSymbol(F.FunctionIndex));
+      Enqueue(Obj->getFunctionSymbol(F.Symbol));
   }
 
   auto EnqueueSuccessors = [Enqueue](InputChunk &Chunk) {
     for (const WasmRelocation Reloc : Chunk.getRelocations()) {
-      switch (Reloc.Type) {
-      case R_WEBASSEMBLY_FUNCTION_INDEX_LEB:
-      case R_WEBASSEMBLY_TABLE_INDEX_I32:
-      case R_WEBASSEMBLY_TABLE_INDEX_SLEB:
-        Enqueue(Chunk.File->getFunctionSymbol(Reloc.Index));
-        break;
-      case R_WEBASSEMBLY_GLOBAL_INDEX_LEB:
-      case R_WEBASSEMBLY_MEMORY_ADDR_LEB:
-      case R_WEBASSEMBLY_MEMORY_ADDR_SLEB:
-      case R_WEBASSEMBLY_MEMORY_ADDR_I32:
-        Enqueue(Chunk.File->getGlobalSymbol(Reloc.Index));
-        break;
-      }
+      if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB)
+        continue;
+      Enqueue(Chunk.File->getSymbol(Reloc.Index));
     }
   };
 
   while (!Q.empty())
     EnqueueSuccessors(*Q.pop_back_val());
 
   // Report garbage-collected sections.
   if (Config->PrintGcSections) {
     auto CheckChunk = [](const InputChunk *C) {

wasm/OutputSegment.h

 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 class OutputSegment {
 public:
-  OutputSegment(StringRef N) : Name(N) {}
+  OutputSegment(StringRef N, uint32_t Index) : Name(N), Index(Index) {}
 
   void addInputSegment(InputSegment *Segment) {
     Alignment = std::max(Alignment, Segment->getAlignment());
     InputSegments.push_back(Segment);
     Size = llvm::alignTo(Size, Segment->getAlignment());
     Segment->setOutputSegment(this, Size);
     Size += Segment->getSize();
   }
 
   uint32_t getSectionOffset() const { return SectionOffset; }
 
   void setSectionOffset(uint32_t Offset) { SectionOffset = Offset; }
 
   StringRef Name;
+  const uint32_t Index;
   uint32_t Alignment = 0;
   uint32_t StartVA = 0;
   std::vector<InputSegment *> InputSegments;
 
   // Sum of the size of the all the input segments
   uint32_t Size = 0;
 
   // Segment header

wasm/SymbolTable.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::wasm::WasmSignature;
+using llvm::wasm::WasmGlobalType;
 
 namespace lld {
 namespace wasm {
 
 class InputSegment;
 
 // SymbolTable is a bucket of all known symbols, including defined,
 // undefined, or lazy symbols (the last one is symbols in archive
public:
 
   void reportDuplicate(Symbol *Existing, InputFile *NewFile);
   void reportRemainingUndefines();
 
   ArrayRef<Symbol *> getSymbols() const { return SymVector; }
   Symbol *find(StringRef Name);
   ObjFile *findComdat(StringRef Name) const;
 
-  Symbol *addDefined(bool IsFunction, StringRef Name, uint32_t Flags,
+  Symbol *addDefined(StringRef Name, WasmSymbolType Type, uint32_t Flags,
                      InputFile *F, InputChunk *Chunk = nullptr,
-                     uint32_t Address = 0);
-  Symbol *addUndefined(StringRef Name, Symbol::Kind Kind, uint32_t Flags,
-                       InputFile *F, const WasmSignature *Signature = nullptr);
-  Symbol *addUndefinedFunction(StringRef Name, const WasmSignature *Type);
+                     uint32_t Address = 0, uint32_t DataSize = 0);
+  Symbol *addUndefined(StringRef Name, WasmSymbolType Type, uint32_t Flags,
+                       InputFile *F, const WasmSignature *Signature = nullptr,
+                       const WasmGlobalType *GlobalType = nullptr);
+  DefinedData *addDefinedData(StringRef Name, uint32_t Flags = 0);
   void addLazy(ArchiveFile *F, const Archive::Symbol *Sym);
   bool addComdat(StringRef Name, ObjFile *);
 
-  DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags = 0);
+  DefinedData *addSyntheticData(StringRef Name, uint32_t Flags = 0);
+  DefinedGlobal *addSyntheticGlobal(StringRef Name, uint32_t Flags = 0,
+                                    const WasmGlobalType *Type = nullptr);
   DefinedFunction *addSyntheticFunction(StringRef Name,
                                         const WasmSignature *Type,
                                         uint32_t Flags = 0);
+
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
 
   llvm::DenseMap<llvm::CachedHashStringRef, ObjFile *> ComdatMap;
   llvm::DenseMap<llvm::CachedHashStringRef, Symbol *> SymMap;
   std::vector<Symbol *> SymVector;
 };
 
 extern SymbolTable *Symtab;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

wasm/SymbolTable.cpp

void SymbolTable::reportDuplicate(Symbol *Existing, InputFile *NewFile) {
   error("duplicate symbol: " + toString(*Existing) + "\n>>> defined in " +
         toString(Existing->getFile()) + "\n>>> defined in " +
         toString(NewFile));
 }
 
 // Check the type of new symbol matches that of the symbol is replacing.
 // For functions this can also involve verifying that the signatures match.
 static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
-                             bool NewIsFunction, const WasmSignature *NewSig) {
+                             WasmSymbolType NewType,
+                             const WasmSignature *NewFunctionSig,
+                             const WasmGlobalType *NewGlobalType) {
   if (Existing.isLazy())
     return;
 
+  WasmSymbolType ExistingType = toWasmType(Existing.kind());
+
   // First check the symbol types match (i.e. either both are function
   // symbols or both are data symbols).
-  if (Existing.isFunction() != NewIsFunction) {
+  if (NewType != ExistingType) {
     error("symbol type mismatch: " + Existing.getName() + "\n>>> defined as " +
-          (Existing.isFunction() ? "Function" : "Global") + " in " +
-          toString(Existing.getFile()) + "\n>>> defined as " +
-          (NewIsFunction ? "Function" : "Global") + " in " + F.getName());
+          toString(ExistingType) + " in " + toString(Existing.getFile()) +
+          "\n>>> defined as " + toString(NewType) + " in " + F.getName());
     return;
   }
 
-  // For function symbols, optionally check the function signature matches too.
-  auto *ExistingFunc = dyn_cast<FunctionSymbol>(&Existing);
-  if (!ExistingFunc || !Config->CheckSignatures)
+  // For function/global symbols, optionally check the signature matches too.
+  if (NewType == WASM_SYMBOL_TYPE_DATA || !Config->CheckSignatures)
     return;
 
+  DEBUG(dbgs() << "checkSymbolTypes: " << Existing.getName() << "\n");
+
+  std::string OldSigStr, NewSigStr;
+  if (NewType == WASM_SYMBOL_TYPE_FUNCTION) {
     // Skip the signature check if the existing function has no signature (e.g.
     // if it is an undefined symbol generated by --undefined command line flag).
-  if (!ExistingFunc->hasFunctionType())
+    auto &Sym = cast<FunctionSymbol>(Existing);
+    if (!Sym.hasFunctionType())
       return;
 
-  DEBUG(dbgs() << "checkSymbolTypes: " << ExistingFunc->getName() << "\n");
-  assert(NewSig);
+    assert(NewFunctionSig != nullptr);
+    const WasmSignature &OldSig = Sym.getFunctionType();
+    if (*NewFunctionSig == OldSig)
+      return;
+
+    OldSigStr = toString(OldSig);
+    NewSigStr = toString(*NewFunctionSig);
+  } else {
+    auto &Sym = cast<GlobalSymbol>(Existing);
 
-  const WasmSignature &OldSig = ExistingFunc->getFunctionType();
-  if (*NewSig == OldSig)
+    assert(NewGlobalType != nullptr);
+    const WasmGlobalType &OldType = Sym.getGlobalType();
+    if (*NewGlobalType == OldType)
       return;
 
-  error("function signature mismatch: " + ExistingFunc->getName() +
-        "\n>>> defined as " + toString(OldSig) + " in " +
-        toString(ExistingFunc->getFile()) + "\n>>> defined as " +
-        toString(*NewSig) + " in " + F.getName());
+    OldSigStr = toString(OldType);
+    NewSigStr = toString(*NewGlobalType);
+  }
+
+  error(toString(NewType) + " type mismatch: " + Existing.getName() +
+        "\n>>> defined as " + OldSigStr + " in " +
+        toString(Existing.getFile()) + "\n>>> defined as " + NewSigStr +
+        " in " + F.getName());
 }
 
 static void checkSymbolTypes(const Symbol &Existing, const InputFile &F,
-                             bool IsFunction, const InputChunk *Chunk) {
-  const WasmSignature *Sig = nullptr;
-  if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
-    Sig = &F->Signature;
-  return checkSymbolTypes(Existing, F, IsFunction, Sig);
+                             WasmSymbolType NewType, const InputChunk *Chunk) {
+  const WasmSignature *FunctionSig = nullptr;
+  const WasmGlobalType *GlobalType = nullptr;
+  if (auto *Function = dyn_cast_or_null<InputFunction>(Chunk))
+    FunctionSig = &Function->Signature;
+  if (auto *Global = dyn_cast_or_null<InputGlobal>(Chunk))
+    GlobalType = &Global->getType();
+  return checkSymbolTypes(Existing, F, NewType, FunctionSig, GlobalType);
 }
 
 DefinedFunction *SymbolTable::addSyntheticFunction(StringRef Name,
                                                    const WasmSignature *Type,
                                                    uint32_t Flags) {
   DEBUG(dbgs() << "addSyntheticFunction: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
   assert(WasInserted);
   return replaceSymbol<DefinedFunction>(S, Name, Flags, Type);
 }
 
-DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags) {
+DefinedData *SymbolTable::addSyntheticData(StringRef Name, uint32_t Flags) {
+  DEBUG(dbgs() << "addSyntheticData: " << Name << "\n");
+  Symbol *S;
+  bool WasInserted;
+  std::tie(S, WasInserted) = insert(Name);
+  return replaceSymbol<DefinedData>(S, Name, Flags);
+}
+
+DefinedGlobal *SymbolTable::addSyntheticGlobal(StringRef Name, uint32_t Flags,
+                                               const WasmGlobalType *Type) {
   DEBUG(dbgs() << "addSyntheticGlobal: " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
-  assert(WasInserted);
-  return replaceSymbol<DefinedGlobal>(S, Name, Flags);
+  return replaceSymbol<DefinedGlobal>(S, Name, Flags, Type);
 }
 
-Symbol *SymbolTable::addDefined(bool IsFunction, StringRef Name, uint32_t Flags,
-                                InputFile *F, InputChunk *Chunk,
-                                uint32_t Address) {
-  if (IsFunction)
+Symbol *SymbolTable::addDefined(StringRef Name, WasmSymbolType Type,
+                                uint32_t Flags, InputFile *F, InputChunk *Chunk,
+                                uint32_t Address, uint32_t DataSize) {
+  if (Type == WASM_SYMBOL_TYPE_FUNCTION)
     DEBUG(dbgs() << "addDefined: func:" << Name << "\n");
   else
     DEBUG(dbgs() << "addDefined: global:" << Name << " addr:" << Address
                  << "\n");
   Symbol *S;
   bool WasInserted;
   bool Replace = false;
   bool CheckTypes = false;
if (WasInserted) {
     CheckTypes = true;
   } else {
     // neither symbol is week. They conflict.
     reportDuplicate(S, F);
   }
 
   if (Replace) {
     if (CheckTypes)
-      checkSymbolTypes(*S, *F, IsFunction, Chunk);
-    if (IsFunction)
+      checkSymbolTypes(*S, *F, Type, Chunk);
+    switch (Type) {
+    case WASM_SYMBOL_TYPE_FUNCTION:
       replaceSymbol<DefinedFunction>(S, Name, Flags, F, Chunk);
-    else
-      replaceSymbol<DefinedGlobal>(S, Name, Flags, F, Chunk, Address);
+      break;
+    case WASM_SYMBOL_TYPE_DATA:
+      replaceSymbol<DefinedData>(S, Name, Flags, F, Chunk, Address, DataSize);
+      break;
+    case WASM_SYMBOL_TYPE_GLOBAL:
+      replaceSymbol<DefinedGlobal>(S, Name, Flags, F, Chunk);
+      break;
+      /*
+    default:
+      llvm_unreachable("unkown symbol type");
+      */
+    }
   }
   return S;
 }
 
-Symbol *SymbolTable::addUndefined(StringRef Name, Symbol::Kind Kind,
+Symbol *SymbolTable::addUndefined(StringRef Name, WasmSymbolType Type,
                                   uint32_t Flags, InputFile *F,
-                                  const WasmSignature *Type) {
-  DEBUG(dbgs() << "addUndefined: " << Name << "\n");
+                                  const WasmSignature *FunctionType,
+                                  const WasmGlobalType *GlobalType) {
+  DEBUG(dbgs() << "addUndefined type=" << Type << ": " << Name << "\n");
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name);
-  bool IsFunction = Kind == Symbol::UndefinedFunctionKind;
   if (WasInserted) {
-    if (IsFunction)
-      replaceSymbol<UndefinedFunction>(S, Name, Flags, F, Type);
-    else
-      replaceSymbol<UndefinedGlobal>(S, Name, Flags, F);
+    switch (Type) {
+    case WASM_SYMBOL_TYPE_FUNCTION:
+      replaceSymbol<UndefinedFunction>(S, Name, Flags, F, FunctionType);
+      break;
+    case WASM_SYMBOL_TYPE_GLOBAL:
+      replaceSymbol<UndefinedGlobal>(S, Name, Flags, F, GlobalType);
+      break;
+    case WASM_SYMBOL_TYPE_DATA:
+      replaceSymbol<UndefinedData>(S, Name, Flags, F);
+      break;
+      /*
+    default:
+      llvm_unreachable("unkown symbol type");
+      */
+    }
   } else if (auto *LazySym = dyn_cast<LazySymbol>(S)) {
     DEBUG(dbgs() << "resolved by existing lazy\n");
     auto *AF = cast<ArchiveFile>(LazySym->getFile());
     AF->addMember(&LazySym->getArchiveSymbol());
   } else if (S->isDefined()) {
     DEBUG(dbgs() << "resolved by existing\n");
-    checkSymbolTypes(*S, *F, IsFunction, Type);
+    checkSymbolTypes(*S, *F, Type, FunctionType, GlobalType);
   }
+
   return S;
 }
 
 void SymbolTable::addLazy(ArchiveFile *F, const Archive::Symbol *Sym) {
   DEBUG(dbgs() << "addLazy: " << Sym->getName() << "\n");
   StringRef Name = Sym->getName();
   Symbol *S;
   bool WasInserted;

wasm/Symbols.h

 #ifndef LLD_WASM_SYMBOLS_H
 #define LLD_WASM_SYMBOLS_H
 
 #include "lld/Common/LLVM.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/Wasm.h"
 
 using llvm::object::Archive;
+using llvm::object::WasmSymbol;
 using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmGlobal;
+using llvm::wasm::WasmGlobalType;
+using llvm::wasm::WasmSymbolType;
 
 namespace lld {
 namespace wasm {
 
 class InputFile;
 class InputChunk;
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind {
     DefinedFunctionKind,
+    DefinedDataKind,
     DefinedGlobalKind,
 
     LazyKind,
     UndefinedFunctionKind,
+    UndefinedDataKind,
     UndefinedGlobalKind,
 
     LastDefinedKind = DefinedGlobalKind,
     InvalidKind,
   };
 
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
 
   bool isLazy() const { return SymbolKind == LazyKind; }
   bool isDefined() const { return SymbolKind <= LastDefinedKind; }
   bool isUndefined() const {
-    return SymbolKind == UndefinedGlobalKind ||
-           SymbolKind == UndefinedFunctionKind;
+    return SymbolKind == UndefinedFunctionKind ||
+           SymbolKind == UndefinedDataKind || SymbolKind == UndefinedGlobalKind;
   }
   bool isFunction() const {
     return SymbolKind == DefinedFunctionKind ||
            SymbolKind == UndefinedFunctionKind;
   }
-  bool isGlobal() const { return !isFunction(); }
+  bool isData() const {
+    return SymbolKind == DefinedDataKind || SymbolKind == UndefinedDataKind;
+  }
+  bool isGlobal() const {
+    return SymbolKind == DefinedGlobalKind || SymbolKind == UndefinedGlobalKind;
+  }
   bool isLocal() const;
   bool isWeak() const;
   bool isHidden() const;
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   // Returns the file from which this symbol was created.
   InputFile *getFile() const { return File; }
   InputChunk *getChunk() const { return Chunk; }
 
   void setHidden(bool IsHidden);
 
   uint32_t getOutputIndex() const;
 
   // Returns true if an output index has been set for this symbol
   bool hasOutputIndex() const;
 
-  // Set the output index of the symbol (in the function or global index
-  // space of the output object.
+  // Set the output index of the symbol, in the Wasm index space of the output
+  // object - that is, for defined symbols only, its position in the list of
+  // Wasm imports+code for functions, imports+globals for globals.
   void setOutputIndex(uint32_t Index);
 
+  // Get/set the output symbol index, in the Symbol index space.  This is
+  // only used for relocatable output.
+  uint32_t getOutputSymbolIndex() const;
+  void setOutputSymbolIndex(uint32_t Index);
+
 protected:
   Symbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F, InputChunk *C)
       : Name(Name), SymbolKind(K), Flags(Flags), File(F), Chunk(C) {}
 
   StringRef Name;
   Kind SymbolKind;
   uint32_t Flags;
   InputFile *File;
   InputChunk *Chunk;
   llvm::Optional<uint32_t> OutputIndex;
+  llvm::Optional<uint32_t> OutputSymbolIndex;
 };
 
 class FunctionSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind ||
            S->kind() == UndefinedFunctionKind;
   }
protected:
   void setFunctionType(const WasmSignature *Type);
 
   FunctionSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
                  InputChunk *C)
       : Symbol(Name, K, Flags, F, C) {}
 
   llvm::Optional<uint32_t> TableIndex;
 
   // Explict function type, needed for undefined or synthetic functions only.
   const WasmSignature *FunctionType = nullptr;
 };
 
 class DefinedFunction : public FunctionSymbol {
 public:
   DefinedFunction(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
                   InputChunk *C = nullptr)
       : FunctionSymbol(Name, DefinedFunctionKind, Flags, F, C) {}
 
   DefinedFunction(StringRef Name, uint32_t Flags, const WasmSignature *Type)
       : FunctionSymbol(Name, DefinedFunctionKind, Flags, nullptr, nullptr) {
     setFunctionType(Type);
   }
 
   static bool classof(const Symbol *S) {
     return S->kind() == DefinedFunctionKind;
   }
+
+  void setChunk(InputChunk *C) { Chunk = C; }
 };
 
 class UndefinedFunction : public FunctionSymbol {
 public:
   UndefinedFunction(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
                     const WasmSignature *Type = nullptr)
       : FunctionSymbol(Name, UndefinedFunctionKind, Flags, File, nullptr) {
     setFunctionType(Type);
   }
 
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedFunctionKind;
   }
 };
 
-class GlobalSymbol : public Symbol {
+class DataSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) {
-    return S->kind() == DefinedGlobalKind || S->kind() == UndefinedGlobalKind;
+    return S->kind() == DefinedDataKind || S->kind() == UndefinedDataKind;
   }
 
 protected:
-  GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
-               InputChunk *C)
+  DataSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
       : Symbol(Name, K, Flags, F, C) {}
 };
 
-class DefinedGlobal : public GlobalSymbol {
+class DefinedData : public DataSymbol {
 public:
-  DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
-                InputChunk *C = nullptr, uint32_t Address = 0)
-      : GlobalSymbol(Name, DefinedGlobalKind, Flags, F, C),
-        VirtualAddress(Address) {}
+  DefinedData(StringRef Name, uint32_t Flags, InputFile *F = nullptr,
+              InputChunk *C = nullptr, uint32_t Address = 0, uint32_t Size = 0)
+      : DataSymbol(Name, DefinedDataKind, Flags, F, C), VirtualAddress(Address),
+        Size(Size) {}
 
-  static bool classof(const Symbol *S) {
-    return S->kind() == DefinedGlobalKind;
-  }
+  static bool classof(const Symbol *S) { return S->kind() == DefinedDataKind; }
 
+  // Returns the output virtual address of a defined data symbol.
   uint32_t getVirtualAddress() const;
 
   void setVirtualAddress(uint32_t VA);
 
+  // Returns the offset of a defined data symbol within its OutputSegment.
+  uint32_t getOutputSegmentOffset() const;
+  uint32_t getOutputSegmentIndex() const;
+  uint32_t getSize() const { return Size; }
+
 protected:
   uint32_t VirtualAddress;
+  uint32_t Size;
+};
+
+class UndefinedData : public DataSymbol {
+public:
+  UndefinedData(StringRef Name, uint32_t Flags, InputFile *File = nullptr)
+      : DataSymbol(Name, UndefinedDataKind, Flags, File, nullptr) {}
+  static bool classof(const Symbol *S) {
+    return S->kind() == UndefinedDataKind;
+  }
+};
+
+class GlobalSymbol : public Symbol {
+public:
+  static bool classof(const Symbol *S) {
+    return S->kind() == DefinedGlobalKind || S->kind() == UndefinedGlobalKind;
+  }
+
+  const WasmGlobalType &getGlobalType() const;
+
+protected:
+  void setGlobalType(const WasmGlobalType *Type);
+
+  GlobalSymbol(StringRef Name, Kind K, uint32_t Flags, InputFile *F,
+               InputChunk *C)
+      : Symbol(Name, K, Flags, F, C) {}
+
+  // Explict function type, needed for undefined or synthetic functions only.
+  const WasmGlobalType *GlobalType = nullptr;
+};
+
+class DefinedGlobal : public GlobalSymbol {
+public:
+  DefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File, InputChunk *C)
+      : GlobalSymbol(Name, DefinedGlobalKind, Flags, File, C) {}
+
+  DefinedGlobal(StringRef Name, uint32_t Flags, const WasmGlobalType *Type)
+      : GlobalSymbol(Name, DefinedGlobalKind, Flags, nullptr, nullptr) {
+    setGlobalType(Type);
+  }
+
+  void setChunk(InputChunk *C) { Chunk = C; }
 };
 
 class UndefinedGlobal : public GlobalSymbol {
 public:
-  UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr)
-      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, nullptr) {}
+  UndefinedGlobal(StringRef Name, uint32_t Flags, InputFile *File = nullptr,
+                  const WasmGlobalType *Type = nullptr)
+      : GlobalSymbol(Name, UndefinedGlobalKind, Flags, File, nullptr) {
+    setGlobalType(Type);
+  }
+
   static bool classof(const Symbol *S) {
     return S->kind() == UndefinedGlobalKind;
   }
 };
 
 class LazySymbol : public Symbol {
 public:
   LazySymbol(StringRef Name, InputFile *File, const Archive::Symbol &Sym)
       : Symbol(Name, LazyKind, 0, File, nullptr), ArchiveSymbol(Sym) {}
 
   static bool classof(const Symbol *S) { return S->kind() == LazyKind; }
 
   const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; }
 
 protected:
   Archive::Symbol ArchiveSymbol;
 };
 
 // linker-generated symbols
 struct WasmSym {
   // __stack_pointer
   // Global that holds the address of the top of the explicit value stack in
   // linear memory.
   static DefinedGlobal *StackPointer;
 
   // __data_end
   // Symbol marking the end of the data and bss.
-  static DefinedGlobal *DataEnd;
+  static DefinedData *DataEnd;
 
   // __heap_base
   // Symbol marking the end of the data, bss and explicit stack.  Any linear
   // memory following this address is not used by the linked code and can
   // therefore be used as a backing store for brk()/malloc() implementations.
-  static DefinedGlobal *HeapBase;
+  static DefinedData *HeapBase;
 
   // __wasm_call_ctors
   // Function that directly calls all ctors in priority order.
   static DefinedFunction *CallCtors;
 
   // __dso_handle
   // Global used in calls to __cxa_atexit to determine current DLL
-  static DefinedGlobal *DsoHandle;
+  static DefinedData *DsoHandle;
 };
 
 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedFunction) char A[sizeof(DefinedFunction)];
-  alignas(DefinedGlobal) char B[sizeof(DefinedGlobal)];
-  alignas(LazySymbol) char C[sizeof(LazySymbol)];
-  alignas(UndefinedFunction) char D[sizeof(UndefinedFunction)];
-  alignas(UndefinedGlobal) char E[sizeof(UndefinedFunction)];
+  alignas(DefinedData) char B[sizeof(DefinedData)];
+  alignas(DefinedGlobal) char C[sizeof(DefinedGlobal)];
+  alignas(LazySymbol) char D[sizeof(LazySymbol)];
+  alignas(UndefinedFunction) char E[sizeof(UndefinedFunction)];
+  alignas(UndefinedData) char F[sizeof(UndefinedData)];
+  alignas(UndefinedGlobal) char G[sizeof(UndefinedGlobal)];
 };
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *S, ArgT &&... Arg) {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "Symbol too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
   assert(static_cast<Symbol *>(static_cast<T *>(nullptr)) == nullptr &&
          "Not a Symbol");
   return new (S) T(std::forward<ArgT>(Arg)...);
 }
 
 } // namespace wasm
 
 // Returns a symbol name for an error message.
 std::string toString(const wasm::Symbol &Sym);
 std::string toString(wasm::Symbol::Kind Kind);
+std::string toString(WasmSymbolType Type);
+WasmSymbolType toWasmType(wasm::Symbol::Kind Kind);
 
 } // 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 "InputChunks.h"
 #include "InputFiles.h"
+#include "OutputSegment.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 using namespace lld;
 using namespace lld::wasm;
 
 DefinedFunction *WasmSym::CallCtors;
-DefinedGlobal *WasmSym::DsoHandle;
-DefinedGlobal *WasmSym::DataEnd;
-DefinedGlobal *WasmSym::HeapBase;
+DefinedData *WasmSym::DsoHandle;
+DefinedData *WasmSym::DataEnd;
+DefinedData *WasmSym::HeapBase;
 DefinedGlobal *WasmSym::StackPointer;
 
 bool Symbol::hasOutputIndex() const {
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->hasOutputIndex();
   return OutputIndex.hasValue();
 }
 
 uint32_t Symbol::getOutputIndex() const {
+  assert(!isData());
   if (auto *F = dyn_cast_or_null<InputFunction>(Chunk))
     return F->getOutputIndex();
+  if (auto *G = dyn_cast_or_null<InputGlobal>(Chunk))
+    return G->getOutputIndex();
   return OutputIndex.getValue();
 }
 
+uint32_t Symbol::getOutputSymbolIndex() const {
+  return OutputSymbolIndex.getValue();
+}
+
+void Symbol::setOutputSymbolIndex(uint32_t Index) {
+  DEBUG(dbgs() << "setOutputSymbolIndex " << Name << " -> " << Index << "\n");
+  assert(!OutputSymbolIndex.hasValue());
+  OutputSymbolIndex = Index;
+}
+
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
-  assert(!dyn_cast_or_null<InputFunction>(Chunk));
+  assert(!isData());
+  assert(!Chunk);
   assert(!OutputIndex.hasValue());
   OutputIndex = Index;
 }
 
 bool Symbol::isWeak() const {
   return (Flags & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK;
 }
 
if (auto *F = dyn_cast_or_null<InputFunction>(Chunk)) {
     F->setTableIndex(Index);
     return;
   }
   DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
   assert(!TableIndex.hasValue());
   TableIndex = Index;
 }
 
-uint32_t DefinedGlobal::getVirtualAddress() const {
-  assert(isGlobal());
+uint32_t DefinedData::getVirtualAddress() const {
   DEBUG(dbgs() << "getVirtualAddress: " << getName() << "\n");
   return Chunk ? dyn_cast<InputSegment>(Chunk)->translateVA(VirtualAddress)
                : VirtualAddress;
 }
 
-void DefinedGlobal::setVirtualAddress(uint32_t Value) {
+void DefinedData::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
-  assert(isGlobal());
+  assert(isData());
   VirtualAddress = Value;
 }
 
+uint32_t DefinedData::getOutputSegmentOffset() const {
+  DEBUG(dbgs() << "getOutputSegmentOffset: " << getName() << "\n");
+  const InputSegment *Segment = dyn_cast<InputSegment>(Chunk);
+  return Segment->OutputSegmentOffset + (VirtualAddress - Segment->startVA());
+}
+
+uint32_t DefinedData::getOutputSegmentIndex() const {
+  DEBUG(dbgs() << "getOutputSegmentIndex: " << getName() << "\n");
+  const InputSegment *Segment = dyn_cast<InputSegment>(Chunk);
+  return Segment->getOutputSegment()->Index;
+}
+
+const WasmGlobalType &GlobalSymbol::getGlobalType() const {
+  if (auto *G = dyn_cast_or_null<InputGlobal>(Chunk))
+    return G->getType();
+
+  DEBUG(dbgs() << "getGlobalType: " << getName() << "\n");
+  assert(GlobalType != nullptr);
+  return *GlobalType;
+}
+
+void GlobalSymbol::setGlobalType(const WasmGlobalType *Type) {
+  assert(GlobalType == nullptr);
+  assert(!Chunk);
+  GlobalType = Type;
+}
+
 std::string lld::toString(const wasm::Symbol &Sym) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(Sym.getName()))
       return "`" + *S + "'";
   return Sym.getName();
 }
 
 std::string lld::toString(wasm::Symbol::Kind Kind) {
   switch (Kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
+  case wasm::Symbol::DefinedDataKind:
+    return "DefinedData";
   case wasm::Symbol::DefinedGlobalKind:
     return "DefinedGlobal";
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
+  case wasm::Symbol::UndefinedDataKind:
+    return "UndefinedData";
   case wasm::Symbol::UndefinedGlobalKind:
     return "UndefinedGlobal";
   case wasm::Symbol::LazyKind:
     return "LazyKind";
   }
   llvm_unreachable("Invalid symbol kind!");
 }
+
+std::string lld::toString(WasmSymbolType Type) {
+  switch (Type) {
+  case llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION:
+    return "Function";
+  case llvm::wasm::WASM_SYMBOL_TYPE_DATA:
+    return "Data";
+  case llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL:
+    return "Global";
+  }
+  llvm_unreachable("Invalid symbol type");
+  return "";
+}
+
+WasmSymbolType lld::toWasmType(wasm::Symbol::Kind Kind) {
+  switch (Kind) {
+  case wasm::Symbol::DefinedFunctionKind:
+  case wasm::Symbol::UndefinedFunctionKind:
+    return llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION;
+  case wasm::Symbol::DefinedDataKind:
+  case wasm::Symbol::UndefinedDataKind:
+    return llvm::wasm::WASM_SYMBOL_TYPE_DATA;
+  case wasm::Symbol::DefinedGlobalKind:
+  case wasm::Symbol::UndefinedGlobalKind:
+    return llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL;
+  default:
+    llvm_unreachable("kind with no type");
+    return static_cast<WasmSymbolType>(-1);
+  }
+}

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 "Writer.h"
 
-#include "llvm/ADT/DenseSet.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Threads.h"
+#include "llvm/ADT/DenseSet.h"
+#include "llvm/BinaryFormat/Wasm.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/LEB128.h"
 
 #include <cstdarg>
 #include <map>
 
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;
   }
 };
 
-// A Wasm export to be written into the export section.
-struct WasmExportEntry {
+// An init entry to be written to either the synthetic init func or the
+// linking metadata.
+struct WasmInitEntry {
   const Symbol *Sym;
-  StringRef FieldName; // may not match the Symbol name
+  uint32_t Priority;
 };
 
 // The writer writes a SymbolTable result to a file.
 class Writer {
 public:
   void run();
 
 private:
   void openFile();
 
   uint32_t lookupType(const WasmSignature &Sig);
   uint32_t registerType(const WasmSignature &Sig);
+
   void createCtorFunction();
+  void createStackPointer(uint32_t Address);
+
   void calculateInitFunctions();
   void assignIndexes();
   void calculateImports();
   void calculateExports();
+  void assignSymtab();
   void calculateTypes();
   void createOutputSegments();
   void layoutMemory();
   void createHeader();
   void createSections();
   SyntheticSection *createSyntheticSection(uint32_t Type,
                                            StringRef Name = "");
 
private:
   void writeSections();
 
   uint64_t FileSize = 0;
   uint32_t DataSize = 0;
   uint32_t NumMemoryPages = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
-  std::vector<const FunctionSymbol *> ImportedFunctions;
-  std::vector<const GlobalSymbol *> ImportedGlobals;
-  std::vector<WasmExportEntry> ExportedSymbols;
-  std::vector<const DefinedGlobal *> DefinedGlobals;
+  std::vector<const Symbol *> ImportedSymbols;
+  unsigned NumImportedFunctions = 0;
+  unsigned NumImportedGlobals = 0;
+  std::vector<Symbol *> ExportedSymbols;
+  std::vector<const DefinedData *> DefinedFakeGlobals;
+  std::vector<InputGlobal *> DefinedGlobals;
   std::vector<InputFunction *> DefinedFunctions;
   std::vector<const FunctionSymbol *> IndirectFunctions;
-  std::vector<WasmInitFunc> InitFunctions;
+  std::vector<const Symbol *> SymtabEntries;
+  std::vector<WasmInitEntry> InitFunctions;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
   std::unique_ptr<SyntheticFunction> CtorFunction;
   std::string CtorFunctionBody;
+  std::unique_ptr<SyntheticGlobal> StackPtrGlobal;
 
   std::vector<OutputSegment *> Segments;
   llvm::SmallDenseMap<StringRef, OutputSegment *> SegmentMap;
 };
 
 } // anonymous namespace
 
 static void debugPrint(const char *fmt, ...) {
   if (!errorHandler().Verbose)
     return;
   fprintf(stderr, "lld: ");
   va_list ap;
   va_start(ap, fmt);
   vfprintf(stderr, fmt, ap);
   va_end(ap);
 }
 
 void Writer::createImportSection() {
-  uint32_t NumImports = ImportedFunctions.size() + ImportedGlobals.size();
+  uint32_t NumImports = ImportedSymbols.size();
   if (Config->ImportMemory)
     ++NumImports;
 
   if (NumImports == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_IMPORT);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, NumImports, "import count");
 
-  for (const FunctionSymbol *Sym : ImportedFunctions) {
-    WasmImport Import;
-    Import.Module = "env";
-    Import.Field = Sym->getName();
-    Import.Kind = WASM_EXTERNAL_FUNCTION;
-    Import.SigIndex = lookupType(Sym->getFunctionType());
-    writeImport(OS, Import);
-  }
-
   if (Config->ImportMemory) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = "memory";
     Import.Kind = WASM_EXTERNAL_MEMORY;
     Import.Memory.Flags = 0;
     Import.Memory.Initial = NumMemoryPages;
     writeImport(OS, Import);
   }
 
-  for (const Symbol *Sym : ImportedGlobals) {
+  for (const Symbol *Sym : ImportedSymbols) {
     WasmImport Import;
     Import.Module = "env";
     Import.Field = Sym->getName();
+    if (auto *FunctionSym = dyn_cast<FunctionSymbol>(Sym)) {
+      Import.Kind = WASM_EXTERNAL_FUNCTION;
+      Import.SigIndex = lookupType(FunctionSym->getFunctionType());
+    } else if (auto *GlobalSym = dyn_cast<GlobalSymbol>(Sym)) {
       Import.Kind = WASM_EXTERNAL_GLOBAL;
-    Import.Global.Mutable = false;
-    Import.Global.Type = WASM_TYPE_I32;
+      Import.Global = GlobalSym->getGlobalType();
+    } else {
+      llvm_unreachable("invalid import type");
+    }
     writeImport(OS, Import);
   }
 }
 
 void Writer::createTypeSection() {
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TYPE);
   raw_ostream &OS = Section->getStream();
   writeUleb128(OS, Types.size(), "type count");
void Writer::createMemorySection() {
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "memory count");
   writeUleb128(OS, 0, "memory limits flags");
   writeUleb128(OS, NumMemoryPages, "initial pages");
 }
 
 void Writer::createGlobalSection() {
-  if (DefinedGlobals.empty())
+  unsigned NumGlobals = DefinedGlobals.size() + DefinedFakeGlobals.size();
+  if (NumGlobals == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_GLOBAL);
   raw_ostream &OS = Section->getStream();
 
-  writeUleb128(OS, DefinedGlobals.size(), "global count");
-  for (const DefinedGlobal *Sym : DefinedGlobals) {
+  writeUleb128(OS, NumGlobals, "global count");
+  for (const InputGlobal *G : DefinedGlobals) {
+    WasmGlobal Global;
+    Global.Type = G->getType();
+    Global.InitExpr = G->getInitExpr();
+    writeGlobal(OS, Global);
+  }
+  for (const DefinedData *Sym : DefinedFakeGlobals) {
     WasmGlobal Global;
-    Global.Type.Type = WASM_TYPE_I32;
-    Global.Type.Mutable = Sym == WasmSym::StackPointer;
+    Global.Type = {WASM_TYPE_I32, false};
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
     writeGlobal(OS, Global);
   }
 }
 
 void Writer::createTableSection() {
   // Always output a table section, even if there are no indirect calls.
void Writer::createExportSection() {
   if (ExportMemory) {
     WasmExport MemoryExport;
     MemoryExport.Name = "memory";
     MemoryExport.Kind = WASM_EXTERNAL_MEMORY;
     MemoryExport.Index = 0;
     writeExport(OS, MemoryExport);
   }
 
-  for (const WasmExportEntry &E : ExportedSymbols) {
-    DEBUG(dbgs() << "Export: " << E.Sym->getName() << "\n");
+  unsigned FakeGlobalIndex = NumImportedGlobals + DefinedGlobals.size();
+  for (const Symbol *Sym : ExportedSymbols) {
+    DEBUG(dbgs() << "Export: " << Sym->getName() << "\n");
     WasmExport Export;
-    Export.Name = E.FieldName;
-    Export.Index = E.Sym->getOutputIndex();
-    if (E.Sym->isFunction())
+    Export.Name = Sym->getName();
+    if (Sym->isFunction()) {
+      Export.Index = Sym->getOutputIndex();
       Export.Kind = WASM_EXTERNAL_FUNCTION;
-    else
+    } else if (Sym->isGlobal()) {
+      Export.Index = Sym->getOutputIndex();
+      Export.Kind = WASM_EXTERNAL_GLOBAL;
+    } else {
+      Export.Index = FakeGlobalIndex++;
       Export.Kind = WASM_EXTERNAL_GLOBAL;
+    }
     writeExport(OS, Export);
   }
 }
 
 void Writer::createStartSection() {}
 
 void Writer::createElemSection() {
   if (IndirectFunctions.empty())
void Writer::createLinkingSection() {
   SubSection DataSizeSubSection(WASM_DATA_SIZE);
   writeUleb128(DataSizeSubSection.getStream(), DataSize, "data size");
   DataSizeSubSection.finalizeContents();
   DataSizeSubSection.writeToStream(OS);
 
   if (!Config->Relocatable)
     return;
 
-  std::vector<std::pair<StringRef, uint32_t>> SymbolInfo;
-  auto addSymInfo = [&](const Symbol *Sym, StringRef ExternalName) {
+  if (!SymtabEntries.empty()) {
+    SubSection SubSection(WASM_SYMBOL_TABLE);
+    writeUleb128(SubSection.getStream(), SymtabEntries.size(), "num symbols");
+    for (const Symbol *Sym : SymtabEntries) {
+      assert(Sym->isDefined() || Sym->isUndefined());
+      uint32_t Kind = Sym->isFunction()
+                          ? llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION
+                          : Sym->isGlobal()
+                                ? llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL
+                                : llvm::wasm::WASM_SYMBOL_TYPE_DATA;
       uint32_t Flags =
-        (Sym->isLocal() ? WASM_SYMBOL_BINDING_LOCAL :
-         Sym->isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0) |
-        (Sym->isHidden() ? WASM_SYMBOL_VISIBILITY_HIDDEN : 0);
-    if (Flags)
-      SymbolInfo.emplace_back(ExternalName, Flags);
-  };
-  // (Imports can't have internal linkage, their names don't need to be budged.)
-  for (const Symbol *Sym : ImportedFunctions)
-    addSymInfo(Sym, Sym->getName());
-  for (const Symbol *Sym : ImportedGlobals)
-    addSymInfo(Sym, Sym->getName());
-  for (const WasmExportEntry &E : ExportedSymbols)
-    addSymInfo(E.Sym, E.FieldName);
-  if (!SymbolInfo.empty()) {
-    SubSection SubSection(WASM_SYMBOL_INFO);
-    writeUleb128(SubSection.getStream(), SymbolInfo.size(), "num sym info");
-    for (auto Pair: SymbolInfo) {
-      writeStr(SubSection.getStream(), Pair.first, "sym name");
-      writeUleb128(SubSection.getStream(), Pair.second, "sym flags");
+          (Sym->isLocal() ? WASM_SYMBOL_BINDING_LOCAL
+                          : Sym->isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0) |
+          (Sym->isHidden() ? WASM_SYMBOL_VISIBILITY_HIDDEN : 0) |
+          (Sym->isUndefined() ? WASM_SYMBOL_UNDEFINED : 0);
+      writeUleb128(SubSection.getStream(), Kind, "sym kind");
+      writeUleb128(SubSection.getStream(), Flags, "sym flags");
+      switch (Kind) {
+      case llvm::wasm::WASM_SYMBOL_TYPE_FUNCTION:
+      case llvm::wasm::WASM_SYMBOL_TYPE_GLOBAL:
+        writeUleb128(SubSection.getStream(), Sym->getOutputIndex(), "index");
+        if (Sym->isDefined())
+          writeStr(SubSection.getStream(), Sym->getName(), "sym name");
+        break;
+      case llvm::wasm::WASM_SYMBOL_TYPE_DATA:
+        writeStr(SubSection.getStream(), Sym->getName(), "sym name");
+        if (auto *DataSym = dyn_cast<DefinedData>(Sym)) {
+          writeUleb128(SubSection.getStream(), DataSym->getOutputSegmentIndex(),
+                       "index");
+          writeUleb128(SubSection.getStream(),
+                       DataSym->getOutputSegmentOffset(), "data offset");
+          writeUleb128(SubSection.getStream(), DataSym->getSize(), "data size");
+        }
+        break;
+      }
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 
   if (Segments.size()) {
     SubSection SubSection(WASM_SEGMENT_INFO);
     writeUleb128(SubSection.getStream(), Segments.size(), "num data segments");
     for (const OutputSegment *S : Segments) {
       writeStr(SubSection.getStream(), S->Name, "segment name");
       writeUleb128(SubSection.getStream(), S->Alignment, "alignment");
       writeUleb128(SubSection.getStream(), 0, "flags");
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 
   if (!InitFunctions.empty()) {
     SubSection SubSection(WASM_INIT_FUNCS);
     writeUleb128(SubSection.getStream(), InitFunctions.size(),
                  "num init functions");
-    for (const WasmInitFunc &F : InitFunctions) {
+    for (const WasmInitEntry &F : InitFunctions) {
       writeUleb128(SubSection.getStream(), F.Priority, "priority");
-      writeUleb128(SubSection.getStream(), F.FunctionIndex, "function index");
+      writeUleb128(SubSection.getStream(), F.Sym->getOutputSymbolIndex(),
+                   "function index");
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 
   struct ComdatEntry { unsigned Kind; uint32_t Index; };
   std::map<StringRef,std::vector<ComdatEntry>> Comdats;
 
if (!Comdats.empty()) {
     }
     SubSection.finalizeContents();
     SubSection.writeToStream(OS);
   }
 }
 
 // Create the custom "name" section containing debug symbol names.
 void Writer::createNameSection() {
-  unsigned NumNames = ImportedFunctions.size();
+  unsigned NumNames = NumImportedFunctions;
   for (const InputFunction *F : DefinedFunctions)
     if (!F->getName().empty())
       ++NumNames;
 
   if (NumNames == 0)
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_CUSTOM, "name");
 
   SubSection FunctionSubsection(WASM_NAMES_FUNCTION);
   raw_ostream &OS = FunctionSubsection.getStream();
   writeUleb128(OS, NumNames, "name count");
 
-  // Names must appear in function index order.  As it happens ImportedFunctions
-  // and DefinedFunctions are numbers in order with imported functions coming
+  // Names must appear in function index order.  As it happens ImportedSymbols
+  // and DefinedFunctions are numbered in order with imported functions coming
   // first.
-  for (const Symbol *S : ImportedFunctions) {
+  for (const Symbol *S : ImportedSymbols) {
+    if (!S->isFunction())
+      continue;
     writeUleb128(OS, S->getOutputIndex(), "import index");
     writeStr(OS, S->getName(), "symbol name");
   }
   for (const InputFunction *F : DefinedFunctions) {
     if (!F->getName().empty()) {
       writeUleb128(OS, F->getOutputIndex(), "func index");
       writeStr(OS, F->getName(), "symbol name");
     }
void Writer::layoutMemory() {
   // Stack comes after static data and bss
   if (!Config->Relocatable) {
     MemoryPtr = alignTo(MemoryPtr, kStackAlignment);
     if (Config->ZStackSize != alignTo(Config->ZStackSize, kStackAlignment))
       error("stack size must be " + Twine(kStackAlignment) + "-byte aligned");
     debugPrint("mem: stack size  = %d\n", Config->ZStackSize);
     debugPrint("mem: stack base  = %d\n", MemoryPtr);
     MemoryPtr += Config->ZStackSize;
-    WasmSym::StackPointer->setVirtualAddress(MemoryPtr);
+    createStackPointer(MemoryPtr);
     debugPrint("mem: stack top   = %d\n", MemoryPtr);
+
     // Set `__heap_base` to directly follow the end of the stack.  We don't
     // allocate any heap memory up front, but instead really on the malloc/brk
     // implementation growing the memory at runtime.
     WasmSym::HeapBase->setVirtualAddress(MemoryPtr);
     debugPrint("mem: heap base   = %d\n", MemoryPtr);
   }
 
   uint32_t MemSize = alignTo(MemoryPtr, WasmPageSize);
for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
 void Writer::calculateImports() {
   for (Symbol *Sym : Symtab->getSymbols()) {
-    if (!Sym->isUndefined() || (Sym->isWeak() && !Config->Relocatable))
+    if (!Sym->isUndefined())
+      continue;
+    if (Sym->isData())
+      continue;
+    if (Sym->isWeak() && !Config->Relocatable)
       continue;
 
-    if (auto *F = dyn_cast<FunctionSymbol>(Sym)) {
-      F->setOutputIndex(ImportedFunctions.size());
-      ImportedFunctions.push_back(F);
-    } else if (auto *G = dyn_cast<GlobalSymbol>(Sym)) {
-      G->setOutputIndex(ImportedGlobals.size());
-      ImportedGlobals.push_back(G);
-    }
+    DEBUG(dbgs() << "import: " << Sym->getName() << "\n");
+    Sym->setOutputIndex(ImportedSymbols.size());
+    ImportedSymbols.emplace_back(Sym);
+    if (Sym->isFunction())
+      ++NumImportedFunctions;
+    else
+      ++NumImportedGlobals;
   }
 }
 
 void Writer::calculateExports() {
-  bool ExportHidden = Config->Relocatable;
-  StringSet<> UsedNames;
+  if (Config->Relocatable)
+    return;
 
-  auto BudgeLocalName = [&](const Symbol *Sym) {
-    StringRef SymName = Sym->getName();
-    // We can't budge non-local names.
-    if (!Sym->isLocal())
-      return SymName;
-    // We must budge local names that have a collision with a symbol that we
-    // haven't yet processed.
-    if (!Symtab->find(SymName) && UsedNames.insert(SymName).second)
-      return SymName;
-    for (unsigned I = 1; ; ++I) {
-      std::string NameBuf = (SymName + "." + Twine(I)).str();
-      if (!UsedNames.count(NameBuf)) {
-        StringRef Name = Saver.save(NameBuf);
-        UsedNames.insert(Name); // Insert must use safe StringRef from save()
-        return Name;
-      }
+  auto ExportSym = [&](Symbol *Sym) {
+    if (!Sym->isDefined())
+      return;
+    if (Sym->isHidden() || Sym->isLocal())
+      return;
+
+    InputChunk *Chunk = Sym->getChunk(); // null for synthetic data symbols
+    if (Chunk && !Chunk->Live)
+      return;
+
+    DEBUG(dbgs() << "exporting sym: " << Sym->getName() << "\n");
+
+    if (auto *D = dyn_cast<DefinedData>(Sym)) {
+      // TODO Remove this check here; for non-relocatable output we actually
+      // used only to create fake-global exports for the synthetic symbols.  Fix
+      // this in a future commit
+      if (Sym != WasmSym::DataEnd && Sym != WasmSym::HeapBase)
+        return;
+      DefinedFakeGlobals.emplace_back(D);
     }
+    ExportedSymbols.emplace_back(Sym);
   };
 
-  if (WasmSym::CallCtors && (!WasmSym::CallCtors->isHidden() || ExportHidden))
-    ExportedSymbols.emplace_back(
-        WasmExportEntry{WasmSym::CallCtors, WasmSym::CallCtors->getName()});
+  // TODO The two loops below should be replaced with this single loop, with
+  // ExportSym inlined:
+  //  for (Symbol *Sym : Symtab->getSymbols())
+  //    ExportSym(Sym);
+  // Making that change would reorder the output though, so it should be done as
+  // a separate commit.
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (Symbol *Sym : File->getSymbols()) {
-      if (!Sym->isDefined() || File != Sym->getFile())
-        continue;
-      if (Sym->isGlobal())
+      if (File == Sym->getFile())
+        ExportSym(Sym);
+    }
+  }
+  for (Symbol *Sym : Symtab->getSymbols()) {
+    if (Sym->getFile() == nullptr)
+      ExportSym(Sym);
+  }
+}
+
+void Writer::assignSymtab() {
+  if (!Config->Relocatable)
+    return;
+
+  unsigned SymbolIndex = SymtabEntries.size();
+  for (ObjFile *File : Symtab->ObjectFiles) {
+    DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
+    for (Symbol *Sym : File->getSymbols()) {
+      if (Sym->getFile() != File)
         continue;
+      if (Sym->isDefined()) {
         if (!Sym->getChunk()->Live)
           continue;
-
-      if ((Sym->isHidden() || Sym->isLocal()) && !ExportHidden)
-        continue;
-      ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)});
+      } else {
+        assert(Sym->isUndefined()); // Can't be lazy
       }
+      Sym->setOutputSymbolIndex(SymbolIndex++);
+      SymtabEntries.emplace_back(Sym);
     }
-
-  for (const Symbol *Sym : DefinedGlobals) {
-    // Can't export the SP right now because its mutable, and mutuable globals
-    // are yet supported in the official binary format.
-    // TODO(sbc): Remove this if/when the "mutable global" proposal is accepted.
-    if (Sym == WasmSym::StackPointer)
-      continue;
-    ExportedSymbols.emplace_back(WasmExportEntry{Sym, BudgeLocalName(Sym)});
   }
+
+  // For the moment, relocatable output doesn't contain any synthetic functions,
+  // so no need to look through the Symtab for symbols not referenced by
+  // Symtab->ObjectFiles.
 }
 
 uint32_t Writer::lookupType(const WasmSignature &Sig) {
   auto It = TypeIndices.find(Sig);
   if (It == TypeIndices.end()) {
     error("type not found: " + toString(Sig));
     return 0;
   }
void Writer::calculateTypes() {
 
   for (ObjFile *File : Symtab->ObjectFiles) {
     ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
     for (uint32_t I = 0; I < Types.size(); I++)
       if (File->TypeIsUsed[I])
         File->TypeMap[I] = registerType(Types[I]);
   }
 
-  for (const FunctionSymbol *Sym : ImportedFunctions)
-    registerType(Sym->getFunctionType());
+  for (const Symbol *Sym : ImportedSymbols)
+    if (auto *F = dyn_cast<FunctionSymbol>(Sym))
+      registerType(F->getFunctionType());
 
   for (const InputFunction *F : DefinedFunctions)
     registerType(F->Signature);
 }
 
 void Writer::assignIndexes() {
-  uint32_t GlobalIndex = ImportedGlobals.size() + DefinedGlobals.size();
-  uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
-
-  auto AddDefinedGlobal = [&](DefinedGlobal *Sym) {
-    if (Sym) {
-      DefinedGlobals.emplace_back(Sym);
-      Sym->setOutputIndex(GlobalIndex++);
-    }
-  };
-  AddDefinedGlobal(WasmSym::StackPointer);
-  AddDefinedGlobal(WasmSym::HeapBase);
-  AddDefinedGlobal(WasmSym::DataEnd);
-
-  if (Config->Relocatable)
-    DefinedGlobals.reserve(Symtab->getSymbols().size());
-
-  uint32_t TableIndex = kInitialTableOffset;
-
-  if (Config->Relocatable) {
-    for (ObjFile *File : Symtab->ObjectFiles) {
-      DEBUG(dbgs() << "Globals: " << File->getName() << "\n");
-      for (Symbol *Sym : File->getSymbols()) {
-        // Create wasm globals for data symbols defined in this file
-        if (File != Sym->getFile())
-          continue;
-        if (auto *G = dyn_cast<DefinedGlobal>(Sym))
-          AddDefinedGlobal(G);
-      }
+  uint32_t GlobalIndex = NumImportedGlobals + DefinedGlobals.size();
+    for (InputGlobal *Global : File->Globals) {
+      if (!Global->Live)
+      Global->setOutputIndex(GlobalIndex++);
+      DefinedGlobals.push_back(Global);
     }
   }
 
+  uint32_t FunctionIndex = NumImportedFunctions + DefinedFunctions.size();
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Functions: " << File->getName() << "\n");
     for (InputFunction *Func : File->Functions) {
       if (!Func->Live)
         continue;
       DefinedFunctions.emplace_back(Func);
       Func->setOutputIndex(FunctionIndex++);
     }
   }
 
+  uint32_t TableIndex = kInitialTableOffset;
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "Handle relocs: " << File->getName() << "\n");
     auto HandleRelocs = [&](InputChunk *Chunk) {
       if (!Chunk->Live)
         return;
       ArrayRef<WasmSignature> Types = File->getWasmObj()->types();
       for (const WasmRelocation& Reloc : Chunk->getRelocations()) {
         if (Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_I32 ||
             Reloc.Type == R_WEBASSEMBLY_TABLE_INDEX_SLEB) {
           FunctionSymbol *Sym = File->getFunctionSymbol(Reloc.Index);
           if (Sym->hasTableIndex() || !Sym->hasOutputIndex())
             continue;
           Sym->setTableIndex(TableIndex++);
           IndirectFunctions.emplace_back(Sym);
         } else if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB) {
           Chunk->File->TypeMap[Reloc.Index] = registerType(Types[Reloc.Index]);
           Chunk->File->TypeIsUsed[Reloc.Index] = true;
         }
       }
     };
 
     for (InputFunction* Function : File->Functions)
       HandleRelocs(Function);
     for (InputSegment* Segment : File->Segments)
       HandleRelocs(Segment);
   }
 }
 
 static StringRef getOutputDataSegmentName(StringRef Name) {
   if (Config->Relocatable)
     return Name;
 
   for (StringRef V :
        {".text.", ".rodata.", ".data.rel.ro.", ".data.", ".bss.rel.ro.",
         ".bss.", ".init_array.", ".fini_array.", ".ctors.", ".dtors.", ".tbss.",
         ".gcc_except_table.", ".tdata.", ".ARM.exidx.", ".ARM.extab."}) {
     StringRef Prefix = V.drop_back();
     if (Name.startswith(V) || Name == Prefix)
       return Prefix;
   }
 
   return Name;
 }
 
 void Writer::createOutputSegments() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (InputSegment *Segment : File->Segments) {
       if (!Segment->Live)
         continue;
       StringRef Name = getOutputDataSegmentName(Segment->getName());
       OutputSegment *&S = SegmentMap[Name];
       if (S == nullptr) {
         DEBUG(dbgs() << "new segment: " << Name << "\n");
-        S = make<OutputSegment>(Name);
+        S = make<OutputSegment>(Name, Segments.size());
         Segments.push_back(S);
       }
       S->addInputSegment(Segment);
       DEBUG(dbgs() << "added data: " << Name << ": " << S->Size << "\n");
     }
   }
 }
 
 static const int OPCODE_CALL = 0x10;
 static const int OPCODE_END = 0xb;
 
 // Create synthetic "__wasm_call_ctors" function based on ctor functions
 // in input object.
 void Writer::createCtorFunction() {
-  uint32_t FunctionIndex = ImportedFunctions.size() + DefinedFunctions.size();
+  uint32_t FunctionIndex = NumImportedFunctions + DefinedFunctions.size();
   WasmSym::CallCtors->setOutputIndex(FunctionIndex);
 
   // First write the body bytes to a string.
   std::string FunctionBody;
-  static WasmSignature Signature = {{}, WASM_TYPE_NORESULT};
+  const WasmSignature &Signature = WasmSym::CallCtors->getFunctionType();
   {
     raw_string_ostream OS(FunctionBody);
     writeUleb128(OS, 0, "num locals");
-    for (const WasmInitFunc &F : InitFunctions) {
+    for (const WasmInitEntry &F : InitFunctions) {
       writeU8(OS, OPCODE_CALL, "CALL");
-      writeUleb128(OS, F.FunctionIndex, "function index");
+      writeUleb128(OS, F.Sym->getOutputIndex(), "function index");
     }
     writeU8(OS, OPCODE_END, "END");
   }
 
   // Once we know the size of the body we can create the final function body
   raw_string_ostream OS(CtorFunctionBody);
   writeUleb128(OS, FunctionBody.size(), "function size");
   OS.flush();
   CtorFunctionBody += FunctionBody;
   ArrayRef<uint8_t> BodyArray(
       reinterpret_cast<const uint8_t *>(CtorFunctionBody.data()),
       CtorFunctionBody.size());
   CtorFunction = llvm::make_unique<SyntheticFunction>(
       Signature, BodyArray, WasmSym::CallCtors->getName());
   CtorFunction->setOutputIndex(FunctionIndex);
+  WasmSym::CallCtors->setChunk(CtorFunction.get());
   DefinedFunctions.emplace_back(CtorFunction.get());
 }
 
 // Populate InitFunctions vector with init functions from all input objects.
 // This is then used either when creating the output linking section or to
 // synthesize the "__wasm_call_ctors" function.
 void Writer::calculateInitFunctions() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     const WasmLinkingData &L = File->getWasmObj()->linkingData();
     InitFunctions.reserve(InitFunctions.size() + L.InitFunctions.size());
     for (const WasmInitFunc &F : L.InitFunctions)
-      InitFunctions.emplace_back(WasmInitFunc{
-          F.Priority, File->relocateFunctionIndex(F.FunctionIndex)});
+      InitFunctions.emplace_back(
+          WasmInitEntry{File->getFunctionSymbol(F.Symbol), F.Priority});
   }
   // Sort in order of priority (lowest first) so that they are called
   // in the correct order.
-  std::sort(InitFunctions.begin(), InitFunctions.end(),
-            [](const WasmInitFunc &L, const WasmInitFunc &R) {
+  std::stable_sort(InitFunctions.begin(), InitFunctions.end(),
+                   [](const WasmInitEntry &L, const WasmInitEntry &R) {
                      return L.Priority < R.Priority;
                    });
 }
 
+void Writer::createStackPointer(uint32_t Address) {
+  WasmInitExpr InitExpr;
+  InitExpr.Opcode = WASM_OPCODE_I32_CONST;
+  InitExpr.Value.Int32 = Address;
+  StackPtrGlobal = make_unique<SyntheticGlobal>(
+      WasmSym::StackPointer->getGlobalType(), InitExpr);
+  StackPtrGlobal->setOutputIndex(NumImportedGlobals + DefinedGlobals.size());
+  DefinedGlobals.emplace_back(StackPtrGlobal.get());
+  WasmSym::StackPointer->setChunk(StackPtrGlobal.get());
+}
+
 void Writer::run() {
   log("-- calculateImports");
   calculateImports();
   log("-- assignIndexes");
   assignIndexes();
-  log("-- calculateExports");
-  calculateExports();
   log("-- calculateInitFunctions");
   calculateInitFunctions();
   if (!Config->Relocatable)
     createCtorFunction();
   log("-- calculateTypes");
   calculateTypes();
+  log("-- layoutMemory");
+  layoutMemory();
+  log("-- calculateExports");
+  calculateExports();
+  log("-- assignSymtab");
+  assignSymtab();
 
   if (errorHandler().Verbose) {
     log("Defined Functions: " + Twine(DefinedFunctions.size()));
     log("Defined Globals  : " + Twine(DefinedGlobals.size()));
-    log("Function Imports : " + Twine(ImportedFunctions.size()));
-    log("Global Imports   : " + Twine(ImportedGlobals.size()));
-    log("Total Imports    : " +
-        Twine(ImportedFunctions.size() + ImportedGlobals.size()));
+    log("Function Imports : " + Twine(NumImportedFunctions));
+    log("Global Imports   : " + Twine(NumImportedGlobals));
     for (ObjFile *File : Symtab->ObjectFiles)
       File->dumpInfo();
   }
 
-  log("-- layoutMemory");
-  layoutMemory();
-
   createHeader();
   log("-- createSections");
   createSections();
 
   log("-- openFile");
   openFile();
   if (errorCount())
     return;

wasm/WriterUtils.h

inline bool operator==(const llvm::wasm::WasmSignature &LHS,
   return LHS.ReturnType == RHS.ReturnType && LHS.ParamTypes == RHS.ParamTypes;
 }
 
 inline bool operator!=(const llvm::wasm::WasmSignature &LHS,
                        const llvm::wasm::WasmSignature &RHS) {
   return !(LHS == RHS);
 }
 
+// Used for general comparison
+inline bool operator==(const llvm::wasm::WasmGlobalType &LHS,
+                       const llvm::wasm::WasmGlobalType &RHS) {
+  return LHS.Type == RHS.Type && LHS.Mutable == RHS.Mutable;
+}
+
+inline bool operator!=(const llvm::wasm::WasmGlobalType &LHS,
+                       const llvm::wasm::WasmGlobalType &RHS) {
+  return !(LHS == RHS);
+}
+
 namespace lld {
 namespace wasm {
 
 struct OutputRelocation {
   llvm::wasm::WasmRelocation Reloc;
   uint32_t NewIndex;
   uint32_t Value;
 };

 void writeExport(raw_ostream &OS, const llvm::wasm::WasmExport &Export);
 
 void writeReloc(raw_ostream &OS, const OutputRelocation &Reloc);
 
 } // namespace wasm
 
 std::string toString(const llvm::wasm::ValType Type);
 std::string toString(const llvm::wasm::WasmSignature &Sig);
+std::string toString(const llvm::wasm::WasmGlobalType &Sig);
 
 } // namespace lld
 
 #endif // LLD_WASM_WRITERUTILS_H

wasm/WriterUtils.cpp

std::string lld::toString(const WasmSignature &Sig) {
   }
   S += ") -> ";
   if (Sig.ReturnType == WASM_TYPE_NORESULT)
     S += "void";
   else
     S += toString(static_cast<ValType>(Sig.ReturnType));
   return S.str();
 }
+
+std::string lld::toString(const WasmGlobalType &Sig) {
+  SmallString<128> S;
+  if (Sig.Mutable)
+    S += "mutable ";
+  S += toString(static_cast<ValType>(Sig.Type));
+  return S.str();
+}