[WebAssembly] call_indirect issues table number relocs

[wingo]

Summary

If the reference-types feature is enabled, call_indirect will explicitly
reference its corresponding function table via TABLE_NUMBER
relocations against a table symbol.

Also, as before, address-taken functions can also cause the function
table to be created, only with reference-types they additionally cause a
symbol table entry to be emitted.

[wingo]

llvm/test/CodeGen/WebAssembly/function-pointer64.ll

37

I have now made it implied in parsing. For output I don't know... my instinct would be that explicit is better in this case, but happy to change it if you think implicit is better.

llvm/test/MC/WebAssembly/debug-info.ll

14

Yeah I think that's the reason, yes.

Regarding patch splitting -- The issue is that this patch does two things:

• makes call_indirect have a table operand, thus causing table relocs. Also makes call_indirect take up more space because of sleb128 relocs.
• emits the indirect function table import if and only if there are relocs against it (either implicitly via TABLE_INDEX or explicity via TABLE_NUMBER)

If you just do the first part, you have to then hack around to avoid a double-import of the indirect function table (the one that comes from the table operand, and the hard-coded import). If you just do the second, you miss references from call_indirect.

I think this change may make sense as a unit, rather than split. WDYT?

[wingo]

In D90948#2382995, @sbc100 wrote:

Regarding always generating relocations for call_indirect.. I'm not so much worried about the extra space it would take, but it does seem like unnecessary work for the linker to be doing. Are you sure they are less common than other relocation types? Do you have evidence of this?

I don't have a really representative corpus, but if you consider the old epic zen garden demo, only 6.8% of call sites are call_indirect. Tested via wasm-objdump -d $file | grep -c call_indirect and dividing that by grep -c call.

I'm also totally fine with table 0 being special, and indeed I think that linker is going to always have to treat memory 0 and table 0 as special (or at least it will always need to be aware of which table/memory is the special one).

Right now with the MVP, there will only ever be at most one table, so it will always get allocated to 0 -- no problem. If we ever have a use case for multiple function tables synthesized by the linker, perhaps for CFI reasons, perhaps we'd need another kind of reloc -- i.e. TABLE_INDEX, but with respect to a specific indirect function table.

I agree with your assessment of pros and cons of always emitting TABLE_NUMBER relocs btw.

[wingo]

Rebase and address feedback

[wingo]

Current status: CodeGen and MC tests working. Need to think about ways to get the getOrCreateWasmFunctionTableSymbol stuff out of MCContext if possible. Need to address any tests outside of CodeGen and MC. Might need to split ImportName change for globals into separate patch.

[wingo]

OMG I am such an idiot. So the call_indirect instructions had a "flags" argument. I never investigated what this was, assuming it was just some weird thing that LLVM was threading around; I just preserved it. Turns out it was just always zero -- as the table number reference was in the MVP. I.e. the flags field became the table number field. Will fix.

[sbc100]

llvm/test/MC/WebAssembly/debug-info.ll

14

I'm not clear why we can't to the second part first... why can't we emit the table if and only if there is a TABLE_INDEX relocation?

Are you suggesting that there could be some call_indirect instruction generated by MC that doesn't have a TABLE_INDEX relocation attached to it?

[wingo]

• Remove bogus "flags" operand from call_indirect

[wingo]

llvm/test/MC/WebAssembly/debug-info.ll

14

Ah I see what you mean, I was thinking that because we wouldn't have the table operand, we would miss out on the function table reference. But TABLE_INDEX relocs implicitly causing a dep on the indirect function table would be sufficient, yes.

[wingo]

Needs to rebase on top of https://reviews.llvm.org/D91870.

[wingo]

Rebase; still a WIP.

In https://reviews.llvm.org/D91637, we refrained from actually writing
out symtab entries for table symbols, as the linker couldn't handle them
yet. We will need a quick interstitial patch to turn them on after
https://reviews.llvm.org/D91870 lands.

[wingo]

All working

[wingo]

Okeydoke, finally ready for review. Probably needs more tests for multi-table linking. Probably should follow up to remove the "legacy" handling of __indirect_function_table in the linker. Or should wasm-ld support old object files for a while?

[sbc100]

In D90948#2419778, @wingo wrote:

Okeydoke, finally ready for review. Probably needs more tests for multi-table linking. Probably should follow up to remove the "legacy" handling of __indirect_function_table in the linker. Or should wasm-ld support old object files for a while?

We should avoid dropping support for older object files. If we even do that we should bump the object file version so that llvm can show a clear message when passed an old object file. However, if we can avoid that completely than I think we should.

[wingo]

Rebase

[wingo]

Rebase to address change in D92840

[wingo]

Rebase

[wingo]

Rebase

[wingo]

Well, this patch was a bit of a journey! But finally it's ready, having calved off a number of precursor patches that landed already. Notably we needed to fix wasm-ld to be able to understand table symbols, before emitting them here.

So in this patch, we add a "table" operand to call_indirect, causing call_indirect instructions to emit TABLE_NUMBER relocs. We add support for this operand in the asm parser; if the table is not given, it defaults to __indirect_function_table as usual. Likewise, lowering in codegen synthesizes a reference to the __indirect_function_table when making call_indirect MC instructions. The end result is that MC and CodeGen tests end up making more relocs, the call_indirect instructions have 5-byte LEBs for the table number, and there are symbols in the output for tables.

[sbc100]

Great!

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyInstPrinter.cpp

71–72

Is this comment correct? In the tests below it looks like the table operand is being printed.

[wingo]

Thanks, will land tomorrow if no emscripten build problems.

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyInstPrinter.cpp

71–72

I think the comment is correct because the exception applies only to the register form CALL_INDIRECT, not CALL_INDIRECT_S. The stack form has always printed the type, for example, as defined in the .td file.

[wingo]

Reopening to allow fixups for an eventual reland

[wingo]

See https://reviews.llvm.org/D95052. Also see https://reviews.llvm.org/D95005.

[wingo]

Rebase

[wingo]

Update to use feature detection to know when to emit symbolic reference or not almost ready, will upload tomorrow first thing.

[wingo]

Only emit relocs when reference-types feature is enabled

[wingo]

OK this was unexpectedly gnarly as we had to undo a number of tests. The interdiff between the two latest revisions shows what changed relative to the previously reviewed patch.

I was surprised how hard it was to get the current subtarget feature set from the places where I needed it. Since the subtarget features can change during the compilation unit apparently, I used the "used-in-reloc" flag on the symbol to indicate whether a table should be included in the symbol table or not. This works -- except in the case of function pointers, where they get emitted not as part of an instruction but rather during lowering, and the fragment has no STI. Baffling. Is there a better way?

Tested MC, CodeGen, and lld wasm tests, and all passing with this fixup, having also reapplied https://reviews.llvm.org/D92215.

[wingo]

(+aardappel back to subscribers, given he reviewed MC part earlier; +tlively)

[tlively]

llvm/lib/MC/WasmObjectWriter.cpp

498–499

What happens if reference-types is not enabled? It looks like we would still have a table number relocation and a table symbol, but the table symbol isn't marked as used. I assume the addition of if (WasmSym->isNoStrip()) above causes the symbol not to be emitted in this case, but is the relocation still emitted?

Overall the WasmObjectWriter seems like the wrong place to be checking target features. The encoding of a Wasm object's contents shouldn't depend on whether reference-types is enabled; it's the contents themselves that should depend on whether reference-types is enabled. Can we encapsulate all the target feature checking in codegen so that we only emit table number expressions/relocations/symbols if reference-types is enabled?

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

460

I have a similar comment here. IMO, if the assembly contains a table symbol, it should be unconditionally parsed as containing a table symbol. It should be the responsibility of the producer of the assembly to not use table symbols if they want to be compatible with older tools.

I'm not sure what to do about the special case of __indirect_function_table, though. When was that introduced?

llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

883

Why do we need a table symbol at all in this case (and also in DAG ISel), especially since it can't be emitted?

[wingo]

llvm/lib/MC/WasmObjectWriter.cpp

498–499

Let's say the compilation unit contains a function pointer but no call_indirect. In that case the object file will need an __indirect_function_table import. However, there is no explicit relocation against __indirect_function_table; this code handles TABLE_INDEX relocations, which are for the index of a function pointer in a table, but which don't explicitly mention which table. Hence the setNoStrip() on the __indirect_function_table symbol -- even if it's not the target of a relocation, the table import should be written to the output file. This result is the same whether reference types are enabled or not.

Additionally -- if & only if reference-types are enabled -- the table symbol will need to be written to the symbol table. We indicate that by abusing the setUsedInReloc flag. That feels like a hack in a way but perhaps a benign one.

Backing up a bit, though, and taking this opportunity to answer questions posed farther down -- when do we know if a table symbol should be emitted to the symbol table? The writer and assembler layers don't have much access to features, which can change during the compilation unit. Generally speaking it's the code that emits instructions that knows whether a feature is enabled or not. So for example when we emit call_indirect, we emit either a proper symbol reference or a hard-coded reference to table 0, depending on the feature flag.

But function pointers are a special case, because their symbol references only name their address space (the table) implicitly. What we really want to do here, in all cases, is emit a __indirect_function_table import if and only if it is needed. Whether it goes in the symbol table or not is a side question. The normal way for the compiler to know if a symbol is needed is, well, explicit references: is it used in a relocation. But here since there is no explicit reference, we make a hack and explicitly add the symbol to the "GC root set" via setNoStrip.

Do you see an earlier place in codegen or so that would be more appropriate for handling this logic? I tried to do so but did not succeed. It's not just function pointers in code; it's also static data. I found that only at this lower level would I know for sure whether there were a function pointer in code or not.

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

460

So it's OK to have .s files that use features but don't check / declare them? Fine by me.

Still, even without reference types, emitting call_indirect needs to ensure the presence of its function table -- __indirect_function_table by default. So there does need to be some logic here AFAIU.

llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

883

The table symbol has two functions:

1. Ensure that the table import is emitted to the object file.
2. When reference types are enabled, to allow the table reference in the call_indirect to be relocated, via the symbol table entry and appropriate TABLE_NUMBER relocations.

So the answer to your question is (1).

[sbc100]

I'm beginning to (re-)wonder if we should leave the current "call_indirect" as special in that it always implicitly refers the magic table zero.. then we would introduce a new instruction for call_indirect_explict that could be used if and only if reference types is enabled and would have the relocation. Data and function addresses will always be special in llvm so I think its OK to reflect that if it makes things simpler. I guess it would make things simpler in some ways and more complex in other? (Sorry if I'm re-litigating prior decisions here).

[tlively]

Thanks for your thoughtful answers, @wingo!

In D90948#2525488, @sbc100 wrote:

I'm beginning to (re-)wonder if we should leave the current "call_indirect" as special in that it always implicitly refers the magic table zero.. then we would introduce a new instruction for call_indirect_explict that could be used if and only if reference types is enabled and would have the relocation. Data and function addresses will always be special in llvm so I think its OK to reflect that if it makes things simpler. I guess it would make things simpler in some ways and more complex in other? (Sorry if I'm re-litigating prior decisions here).

I like the idea of treating table zero as a magical table that is assumed to always exist and that all "normal" function pointers and indirect calls implicitly refer to, even when reference-types is enabled. That's how the table used to work, right? This would solve the problem of making sure the table is live when there are call_indirects or function pointers present in an object -- table 0 would always be live. Then table symbols would only be used for additional user-defined tables from @pmatos's work, so they would only be used at all when reference-types is enabled. I don't think we even need a new kind of call_indirect instruction for this, since we will be able to differentiate "normal" indirect calls to table zero from other indirect calls by the address space of the called function pointer.

[wingo]

In D90948#2525488, @sbc100 wrote:

I'm beginning to (re-)wonder if we should leave the current "call_indirect" as special in that it always implicitly refers the magic table zero.. then we would introduce a new instruction for call_indirect_explict that could be used if and only if reference types is enabled and would have the relocation. Data and function addresses will always be special in llvm so I think its OK to reflect that if it makes things simpler. I guess it would make things simpler in some ways and more complex in other? (Sorry if I'm re-litigating prior decisions here).

I am having a hard time seeing what a new instruction would buy us. I would think there is already a sufficiently clear difference between call_indirect with an immediate table operand -- which was the case before I started, and is still the case now if reference-types is disabled -- and call_indirect with a symbol reference. There would only need to be a relocation in the latter case.

In D90948#2526457, @tlively wrote:

I like the idea of treating table zero as a magical table that is assumed to always exist and that all "normal" function pointers and indirect calls implicitly refer to, even when reference-types is enabled. That's how the table used to work, right? This would solve the problem of making sure the table is live when there are call_indirects or function pointers present in an object -- table 0 would always be live.

I think this goes against what was already done in D91637 and D92840. If individual object files can signal their use of the indirect function table via the presence or absence of the __indirect_function_table import, the linker can then only include it in the final linking stage when needed -- a minor win. I can see the point in treating __indirect_function_table as a good default, and which in the absence of reference-types will be table number 0, but reserving table 0 only complicates things when reference types *are* enabled -- because then you have two kinds of tables.

[wingo]

Just to be clear -- here is my use case.

https://github.com/Igalia/ref-cpp/blob/master/milestones/m3/test.S#L76

WAT version here:

https://github.com/Igalia/ref-cpp/blob/master/milestones/m3/test.wat#L47

Basically I am implementing a side table mapping externref to index, in webassembly instead of in JS. I want to have named table symbols so I can have different mappings, and to be able to table.get / table.set / etc on them, but to do this I need to solve the table linking problem. But to solve table linking I had to fix call_indirect. That's why I'm here. I can see how address spaces may relate to this on an IR level, but on the MC level (where I am right now) I think I can probably ignore it.

[tlively]

In D90948#2527413, @wingo wrote:

In D90948#2525488, @sbc100 wrote:

I'm beginning to (re-)wonder if we should leave the current "call_indirect" as special in that it always implicitly refers the magic table zero.. then we would introduce a new instruction for call_indirect_explict that could be used if and only if reference types is enabled and would have the relocation. Data and function addresses will always be special in llvm so I think its OK to reflect that if it makes things simpler. I guess it would make things simpler in some ways and more complex in other? (Sorry if I'm re-litigating prior decisions here).

I am having a hard time seeing what a new instruction would buy us. I would think there is already a sufficiently clear difference between call_indirect with an immediate table operand -- which was the case before I started, and is still the case now if reference-types is disabled -- and call_indirect with a symbol reference. There would only need to be a relocation in the latter case.

I agree that we just need a single call_indirect that can take either a constant zero table operand or a symbolic table operand. Both types of operands need to be able to coexist in the same link or even in the same object file to make MVP object files linkable with reference-types object files. I suggest that codegen only produce symbolic table operands to refer to user-defined funcref tables, not the default MVP indirect call table (table 0) because that will give us the nice property that objects will contain new table symbols and relocations only if they use reference-types features, not just if they enable reference-types features. This property should also remove the need to do any form of feature detection in the WasmObjectWriter.

In D90948#2526457, @tlively wrote:

I like the idea of treating table zero as a magical table that is assumed to always exist and that all "normal" function pointers and indirect calls implicitly refer to, even when reference-types is enabled. That's how the table used to work, right? This would solve the problem of making sure the table is live when there are call_indirects or function pointers present in an object -- table 0 would always be live.

I think this goes against what was already done in D91637 and D92840. If individual object files can signal their use of the indirect function table via the presence or absence of the __indirect_function_table import, the linker can then only include it in the final linking stage when needed -- a minor win. I can see the point in treating __indirect_function_table as a good default, and which in the absence of reference-types will be table number 0, but reserving table 0 only complicates things when reference types *are* enabled -- because then you have two kinds of tables.

Yes, I agree that it's better not to emit the table at all if it's not needed. I'm not totally clear on whether those patches to emit the table only when necessary are ABI-breaking changes, though. Do I understand correctly that they are not ABI-breaking because wasm-ld previously ignored the presence of the table import and that those patches signal whether the table is used by the presence of the import in the object file and not via new symbol or relocation types? If so, I agree that table 0 (i.e. '__indirect_function_table') should be live only if necessary. I think the crux of the matter is whether there should be two kinds of tables, though. AFAICT, wasm-ld needs to support two kinds of tables (hard-coded 0 and symbolic) if we want to keep supporting the MVP object ABI. Since we need to support both types of tables anyway, it seems simpler to let usage rather than enabled features determine when each kind of table is used. Normal function pointers and indirect calls to function pointers should use the hard-coded table 0, just as they do in MVP object files and all indirect calls into user-defined funcref tables should use symbolic tables. This scheme prevents the MC layer from having to do any feature detection and maintains compatibility with the MVP ABI.

In D90948#2527421, @wingo wrote:

Just to be clear -- here is my use case.

https://github.com/Igalia/ref-cpp/blob/master/milestones/m3/test.S#L76

WAT version here:

https://github.com/Igalia/ref-cpp/blob/master/milestones/m3/test.wat#L47

Basically I am implementing a side table mapping externref to index, in webassembly instead of in JS. I want to have named table symbols so I can have different mappings, and to be able to table.get / table.set / etc on them, but to do this I need to solve the table linking problem. But to solve table linking I had to fix call_indirect. That's why I'm here. I can see how address spaces may relate to this on an IR level, but on the MC level (where I am right now) I think I can probably ignore it.

I'm very excited for this all to come together :) You're right that address spaces won't show up in the MC layer at all. I mentioned them only to point out that the choice of whether to use a hard-coded table 0 or a symbolic table operand for call_indirect can be done in codegen rather than in the MC layer.

[wingo]

Thanks for the comments, tlively :)

In D90948#2527474, @tlively wrote:

I agree that we just need a single call_indirect that can take either a constant zero table operand or a symbolic table operand. Both types of operands need to be able to coexist in the same link or even in the same object file to make MVP object files linkable with reference-types object files.

Whoa -- is linking MVP object files with reference-types object files a requirement? This was totally not on my radar. Note that with feature flags, we can prohibit linking between MVP and reftypes object files.

I think this goes against what was already done in D91637 and D92840. If individual object files can signal their use of the indirect function table via the presence or absence of the __indirect_function_table import, the linker can then only include it in the final linking stage when needed -- a minor win. I can see the point in treating __indirect_function_table as a good default, and which in the absence of reference-types will be table number 0, but reserving table 0 only complicates things when reference types *are* enabled -- because then you have two kinds of tables.

Yes, I agree that it's better not to emit the table at all if it's not needed. I'm not totally clear on whether those patches to emit the table only when necessary are ABI-breaking changes, though. Do I understand correctly that they are not ABI-breaking because wasm-ld previously ignored the presence of the table import and that those patches signal whether the table is used by the presence of the import in the object file and not via new symbol or relocation types? If so, I agree that table 0 (i.e. '__indirect_function_table') should be live only if necessary.

This is correct, yes. Old object files always have an __indirect_function_table import, and the old linker always produces __indirect_function_table. Newer object files may omit __indirect_function_table if it is not needed, and newer linkers may omit __indirect_function_table in the output if no imput file requires it. It is always safe (but can be suboptimal) to emit an indirect function table, so old linkers can work with new object files. New linkers can also work with old object files, because the __indirect_function_table import is always present, so the table will not be omitted. So no ABI break AFAIU.

[tlively]

In D90948#2527474, @tlively wrote:

I agree that we just need a single call_indirect that can take either a constant zero table operand or a symbolic table operand. Both types of operands need to be able to coexist in the same link or even in the same object file to make MVP object files linkable with reference-types object files.

Whoa -- is linking MVP object files with reference-types object files a requirement? This was totally not on my radar. Note that with feature flags, we can prohibit linking between MVP and reftypes object files.

Yes, I expect we will receive bug reports from confused users if we don't allow linking MVP and reftypes object files together. Consider a library author who has no use for reference types and wants their library to run on as many engines as possible, including those that may not support reference types. That library author might distribute just a single build of their library that does not have the reference-types feature enabled. An application author who does use reference types should still be able to link against that library without requiring a separate build. Although you're right that we could just make that an error, that would inconvenience the library author who now has to distribute two builds of their library, even though the builds do not differ in the features they use.

I think this goes against what was already done in D91637 and D92840. If individual object files can signal their use of the indirect function table via the presence or absence of the __indirect_function_table import, the linker can then only include it in the final linking stage when needed -- a minor win. I can see the point in treating __indirect_function_table as a good default, and which in the absence of reference-types will be table number 0, but reserving table 0 only complicates things when reference types *are* enabled -- because then you have two kinds of tables.

Yes, I agree that it's better not to emit the table at all if it's not needed. I'm not totally clear on whether those patches to emit the table only when necessary are ABI-breaking changes, though. Do I understand correctly that they are not ABI-breaking because wasm-ld previously ignored the presence of the table import and that those patches signal whether the table is used by the presence of the import in the object file and not via new symbol or relocation types? If so, I agree that table 0 (i.e. '__indirect_function_table') should be live only if necessary.

This is correct, yes. Old object files always have an __indirect_function_table import, and the old linker always produces __indirect_function_table. Newer object files may omit __indirect_function_table if it is not needed, and newer linkers may omit __indirect_function_table in the output if no imput file requires it. It is always safe (but can be suboptimal) to emit an indirect function table, so old linkers can work with new object files. New linkers can also work with old object files, because the __indirect_function_table import is always present, so the table will not be omitted. So no ABI break AFAIU.

Thanks for confirming!

[wingo]

Thanks again for comments!

I would like to preserve the property that allows the linker to omit __indirect_function_table if it is not needed. Right now the linker has two ways it treats incoming files: if the input has table symtab entries, the input is assumed to have symbols for all tables and relocs for all table references. Otherwise, if the input has tables (import or not) but no symbols, it is an MVP input which requires an indirect function table. It would be sufficient to link the two if we ensure that the indirect function table is allocated table number 0.

Is the suggestion that for reftypes objects, we would omit the symbol for __indirect_function_table, and omit relocations against it? It would mean that the linker would have to grovel reftypes inputs for table imports that aren't in the symtab, in order to know if a reftypes object uses the indirect function table. This is doable but it is less optimal: since the linker doesn't have a precise idea of where the indirect function table is used, it has to assume that if it's live in the input, it's live in the output. If each table reference has a reloc, this isn't the case, and we can have more precise GC. But given the tradeoffs, do you prefer that solution?

[sbc100]

In D90948#2527616, @wingo wrote:

Thanks again for comments!

I would like to preserve the property that allows the linker to omit __indirect_function_table if it is not needed. Right now the linker has two ways it treats incoming files: if the input has table symtab entries, the input is assumed to have symbols for all tables and relocs for all table references. Otherwise, if the input has tables (import or not) but no symbols, it is an MVP input which requires an indirect function table. It would be sufficient to link the two if we ensure that the indirect function table is allocated table number 0.

Is the suggestion that for reftypes objects, we would omit the symbol for __indirect_function_table, and omit relocations against it? It would mean that the linker would have to grovel reftypes inputs for table imports that aren't in the symtab, in order to know if a reftypes object uses the indirect function table. This is doable but it is less optimal: since the linker doesn't have a precise idea of where the indirect function table is used, it has to assume that if it's live in the input, it's live in the output. If each table reference has a reloc, this isn't the case, and we can have more precise GC. But given the tradeoffs, do you prefer that solution?

When you say "the linker would have to grovel reftypes inputs for table imports that aren't in the symtab" are you referring to the way things work today with MVP object files? I can't remember exactly how the mechanism works but we currently have to imply the existence of the table based on TABLE_INDEX relocations right? Sorry I've not been following all the comments here. Are you saying you want to improve on the status quo (make this more precise), or are you concerned about a regression (i.e. becoming less precise about the GC of the table in the final output).

[tlively]

I'm also not 100% sure of how things work today, but I hope it wouldn't be too difficult to emit the MVP table precisely when necessary by seeing whether or not it would be empty immediately before writing out the final binary. I'm perfectly willing to believe that I'm missing something that prevents that from working, though.

[wingo]

In D90948#2528890, @tlively wrote:

I'm also not 100% sure of how things work today, but I hope it wouldn't be too difficult to emit the MVP table precisely when necessary by seeing whether or not it would be empty immediately before writing out the final binary. I'm perfectly willing to believe that I'm missing something that prevents that from working, though.

Unfortunately this is not the case. You can still have

void call(void (*f)(void)) {
  f();
}

in the compilation unit, causing call_indirect to be emitted but no function pointer definition.

[tlively]

In D90948#2530061, @wingo wrote:

In D90948#2528890, @tlively wrote:

I'm also not 100% sure of how things work today, but I hope it wouldn't be too difficult to emit the MVP table precisely when necessary by seeing whether or not it would be empty immediately before writing out the final binary. I'm perfectly willing to believe that I'm missing something that prevents that from working, though.

Unfortunately this is not the case. You can still have

void call(void (*f)(void)) {
  f();
}

in the compilation unit, causing call_indirect to be emitted but no function pointer definition.

I meant that the linker should choose whether to emit the table into the final binary by checking whether it would be empty or not. So in this example, whether or not this compilation unit had a table in its object file, the linker would see that some function has its address taken (in the caller of call) and needs to be allocated a table slot. Since the table wouldn't be empty, the linker emits the table in the final binary.

[wingo]

In D90948#2528695, @sbc100 wrote:

In D90948#2527616, @wingo wrote:

Is the suggestion that for reftypes objects, we would omit the symbol for __indirect_function_table, and omit relocations against it? It would mean that the linker would have to grovel reftypes inputs for table imports that aren't in the symtab, in order to know if a reftypes object uses the indirect function table. This is doable but it is less optimal: since the linker doesn't have a precise idea of where the indirect function table is used, it has to assume that if it's live in the input, it's live in the output. If each table reference has a reloc, this isn't the case, and we can have more precise GC. But given the tradeoffs, do you prefer that solution?

When you say "the linker would have to grovel reftypes inputs for table imports that aren't in the symtab" are you referring to the way things work today with MVP object files?

Yes. I thought it would be a stopgap mechanism but this would make it be more permanent, happening both for reftypes and non-reftypes binaries.

I can't remember exactly how the mechanism works but we currently have to imply the existence of the table based on TABLE_INDEX relocations right?

No, the linker can be a bit more dumb than that -- it implies the existence of a table based on whether an input needs it. MVP inputs declare that they need a table by having a table import. An input needs the function table if it has an indirect call or a function pointer (bitcast). The latter case coresponds to TABLE_INDEX relocs, but the former has no relocs in MVP inputs.

Sorry I've not been following all the comments here. Are you saying you want to improve on the status quo (make this more precise), or are you concerned about a regression (i.e. becoming less precise about the GC of the table in the final output).

AFAIU Thomas was initially suggesting always reserving table 0 -- always having a table import in input object files, the linker always includes a table in the output. Then no symbols or relocations are needed to refer to the indirect function table; it's just assumed that the linker will assign it table number 0. I was saying that as long as inputs signal their need for a table, the linker shouldn't have to write a table output. The linker would just have to assign table number 0 to __indirect_function_table, if it is there; otherwise table 0 could be assigned to no table at all, if there are no tables, or some other table, for reftypes inputs that declare other tables.

If this works for you all I can hack this up. Will be Monday though as I have a day of meetings today.

[wingo]

In D90948#2530072, @tlively wrote:

In D90948#2530061, @wingo wrote:

In D90948#2528890, @tlively wrote:

I'm also not 100% sure of how things work today, but I hope it wouldn't be too difficult to emit the MVP table precisely when necessary by seeing whether or not it would be empty immediately before writing out the final binary. I'm perfectly willing to believe that I'm missing something that prevents that from working, though.

Unfortunately this is not the case. You can still have

void call(void (*f)(void)) {
  f();
}

in the compilation unit, causing call_indirect to be emitted but no function pointer definition.

I meant that the linker should choose whether to emit the table into the final binary by checking whether it would be empty or not. So in this example, whether or not this compilation unit had a table in its object file, the linker would see that some function has its address taken (in the caller of call) and needs to be allocated a table slot. Since the table wouldn't be empty, the linker emits the table in the final binary.

This doesn't work. You can have a file with call_indirect but no declared function pointers. In that case the final binary will not validate.

[sbc100]

In D90948#2530072, @tlively wrote:

In D90948#2530061, @wingo wrote:

In D90948#2528890, @tlively wrote:

I'm also not 100% sure of how things work today, but I hope it wouldn't be too difficult to emit the MVP table precisely when necessary by seeing whether or not it would be empty immediately before writing out the final binary. I'm perfectly willing to believe that I'm missing something that prevents that from working, though.

Unfortunately this is not the case. You can still have

void call(void (*f)(void)) {
  f();
}

in the compilation unit, causing call_indirect to be emitted but no function pointer definition.

I meant that the linker should choose whether to emit the table into the final binary by checking whether it would be empty or not. So in this example, whether or not this compilation unit had a table in its object file, the linker would see that some function has its address taken (in the caller of call) and needs to be allocated a table slot. Since the table wouldn't be empty, the linker emits the table in the final binary.

Ah yes I remember what that doesn't work.

Because you can have this code:

a.o

void call(void (*f)(void)) {
   if (f) {
      f();
   }
}

b.o:

void foo() { 
  call(NULL);
}

Now you have a program that contains call_indirect but no function pointers. Its kind of annoying that the wasm standard makes this invalid but that is the current state. I think I have bought this up before in the standards discussions but perhaps we could re-litigate? WTYT tlively, would this make sense as a spec change?

[tlively]

Ah tricky. I understand why we can't just look at whether the table would have any non-null contents now. Thanks for explanations!

AFAIU Thomas was initially suggesting always reserving table 0 -- always having a table import in input object files, the linker always includes a table in the output. Then no symbols or relocations are needed to refer to the indirect function table; it's just assumed that the linker will assign it table number 0. I was saying that as long as inputs signal their need for a table, the linker shouldn't have to write a table output. The linker would just have to assign table number 0 to __indirect_function_table, if it is there; otherwise table 0 could be assigned to no table at all, if there are no tables, or some other table, for reftypes inputs that declare other tables.

If this works for you all I can hack this up. Will be Monday though as I have a day of meetings today.

Yes, this sounds good, although you're right that purely using the imports is not as precise as using relocations because they don't allow the linker to GC unnecessary tables. What do you think about this scheme:

• MVP object files signal table usage by importing or not importing a table.
• Reftypes object files signal table usage by a table symbol and relocations, even for the default table (table 0).
• The linker emits table zero if any non-reftypes object imports a table or if the default table symbol is live.

This scheme has the following valuable properties:

• The MVP object file ABI is not changed. MVP object files do not use new symbol or relocation types.
• MVP and reftypes object files can be linked together.
• If all objects that use the default table have reftypes enabled, we get the full precision of emitting the table only if its symbol is live.
• All feature detection happens in codegen, not in object writing.

I know this has somewhat come full circle and this scheme is close to what you've already implemented. Thanks for bearing with me as I've wrapped my head around all the issues!

[sbc100]

• Reftypes object files signal table usage by a table symbol and relocations, even for the default table (table 0).

Any reason this has to happen right away? why not leave normal call_indirect to the default table alone for now (so reftypes object and MVP objects are the same in this regard for now)? We can always change our mind later and add this if we want to increase the GC precision (this can be done as a followup or not at all).

[tlively]

Leaving that part as a follow-on sounds fine to me. No need to stabilize the reference-types object ABI any time soon. My impression is that the table symbols and relocations are mostly implemented already, though, so if @wingo's interested in getting that part working, I don't see a reason to delay.

[wingo]

Hi :)

In D90948#2531119, @tlively wrote:

What do you think about this scheme:

• MVP object files signal table usage by importing or not importing a table.
• Reftypes object files signal table usage by a table symbol and relocations, even for the default table (table 0).
• The linker emits table zero if any non-reftypes object imports a table or if the default table symbol is live.

Just for clarity, this differs from where I was initially going in two ways:

• I had made it so that MVP object files could have symbols and TABLE_NUMBER relocs, but this proved incompatible with old linkers. Therefore table symbols and TABLE_NUMBER relocs will be emitted only if reftypes is enabled.
• I didn't have any special logic to keep __indirect_function_table assigned to table number 0, assuming that either all inputs or no inputs had table symbols and relocatable table references. This is incompatible with linking to old MVP object files whose table references are not relocatable.

So I will first add the logic to the linker that it will assign table number 0 to __indirect_function_table, if it is present.

This scheme has the following valuable properties:

• The MVP object file ABI is not changed. MVP object files do not use new symbol or relocation types.
• MVP and reftypes object files can be linked together.

Agreed.

• If all objects that use the default table have reftypes enabled, we get the full precision of emitting the table only if its symbol is live.

It's "fullish" precision. TABLE_INDEX relocations for function pointer bitcasts don't explicitly reference the table, so instead they setNoStrip on the indirect function table. There can be cases where the linker omits the function pointer, causing the function table to no longer be necessary, but the linker can't know that.

• All feature detection happens in codegen, not in object writing.

Yes, for call_indirect. But when we emit a function pointer at the MC layer -- either in data or in code -- we need that to cause the function table to be present. For function pointers in code, i think we can find the feature set just fine, so that for reftypes we cause a symtab entry to be emitted for the function table. But for function pointers in data I don't know a good way to do feature detection; do you have any ideas here?

Thanks for your patience with this small but gnarly problem!

[wingo]

In D90948#2533714, @wingo wrote:

• All feature detection happens in codegen, not in object writing.

Yes, for call_indirect. But when we emit a function pointer at the MC layer -- either in data or in code -- we need that to cause the function table to be present. For function pointers in code, i think we can find the feature set just fine, so that for reftypes we cause a symtab entry to be emitted for the function table. But for function pointers in data I don't know a good way to do feature detection; do you have any ideas here?

Gentle ping regarding this point -- this is why I was mucking with features in the writer. I plan on having another look in lowering but if you have other ideas they are welcome.

[wingo]

OK one nit I just realized. It would be nice to allow linking MVP and reftypes inputs. However this will not be possible if the reftypes input imports a table. This is because table numbers are assigned first to imports, then to module-local definitions. The MVP input would have call_indirect against table 0, expecting it to be the indirect function table, but instead it is an import from the reftypes module. I guess the linker just emits an error in that case.

It would be possible to have a command-line tool to migrate an MVP object file to a reftypes object file, parsing function code and reconstructing relocs. I guess the linker itself isn't the right place for that though.

[sbc100]

In D90948#2538707, @wingo wrote:

OK one nit I just realized. It would be nice to allow linking MVP and reftypes inputs. However this will not be possible if the reftypes input imports a table. This is because table numbers are assigned first to imports, then to module-local definitions. The MVP input would have call_indirect against table 0, expecting it to be the indirect function table, but instead it is an import from the reftypes module. I guess the linker just emits an error in that case.

It would be possible to have a command-line tool to migrate an MVP object file to a reftypes object file, parsing function code and reconstructing relocs. I guess the linker itself isn't the right place for that though.

Yup that does sounds like a showstopper for linking mixed inputs. Should we have the linker error out in only cases were there are imported tables? Or should error out on any kind of mixed inputs? I guess it depends how useful linking mixed object files is, and how often folks will be using table imports.

I think maybe we should start out by making mixed inputs a hard error. We could try to relax it later if there is demand. Does that sounds reasonable @tlively ?

[tlively]

In D90948#2538597, @wingo wrote:

In D90948#2533714, @wingo wrote:

• All feature detection happens in codegen, not in object writing.

Yes, for call_indirect. But when we emit a function pointer at the MC layer -- either in data or in code -- we need that to cause the function table to be present. For function pointers in code, i think we can find the feature set just fine, so that for reftypes we cause a symtab entry to be emitted for the function table. But for function pointers in data I don't know a good way to do feature detection; do you have any ideas here?

Gentle ping regarding this point -- this is why I was mucking with features in the writer. I plan on having another look in lowering but if you have other ideas they are welcome.

Would it be possible to do this feature detection and addition of a table in WebAssemblyAsmPrinter.cpp, which is the transition from the MachineInstr layer to the MC layer? This is the last point where the original LLVM Module is still available, so in the worst case you could traverse the Module's global data to find function pointers.

[tlively]

In D90948#2539419, @sbc100 wrote:

In D90948#2538707, @wingo wrote:

OK one nit I just realized. It would be nice to allow linking MVP and reftypes inputs. However this will not be possible if the reftypes input imports a table. This is because table numbers are assigned first to imports, then to module-local definitions. The MVP input would have call_indirect against table 0, expecting it to be the indirect function table, but instead it is an import from the reftypes module. I guess the linker just emits an error in that case.

It would be possible to have a command-line tool to migrate an MVP object file to a reftypes object file, parsing function code and reconstructing relocs. I guess the linker itself isn't the right place for that though.

Yup that does sounds like a showstopper for linking mixed inputs. Should we have the linker error out in only cases were there are imported tables? Or should error out on any kind of mixed inputs? I guess it depends how useful linking mixed object files is, and how often folks will be using table imports.

I think maybe we should start out by making mixed inputs a hard error. We could try to relax it later if there is demand. Does that sounds reasonable @tlively ?

I would prefer to error out only when a reftypes object imports a table. This seems similar to what we do when linking MVP and atomics-enabled objects, i.e. allow the link when we know it to be safe and possible. That's certainly been useful in practice, so I expect that allowing MVP+reftypes links will be useful as well as reftypes picks up adoption. Being permissive and having good error messages from the start will save us a lot of support emails and Emscripten issues down the line :) Of course this relaxation doesn't have to be in the initial patch, but I don't think we should wait to implement it until users complain.

[wingo]

Thanks for patience with the delay here. Paging this back in -- I will move the logic from MC/WasmObjectWriter.cpp to WebAssemblyAsmPrinter.cpp -- there I will iterate over all functions in the module, and if any of them hasAddressTaken, then I will ensure an __indirect_function_table definition exists and will be written to the output (setNoStrip). We keep the hack that table symbols only go to the symbol table if they are marked as used in relocations. If the reference types feature is enabled and an address-taken function is present in the module, the indirect function table will be explicitly marked isUsedInReloc. Just broadcasting intention here so that there are no more late surprises :)

[tlively]

Sounds good! Thanks for your patience with the previous late surprises :)

[tlively]

Actually, one question.

We keep the hack that table symbols only go to the symbol table if they are marked as used in relocations.

It seems like it would be simpler to not create a symbol table in the first place in cases where it will not be emitted into the binary anyway. In LowerCallResults, can we do

MIB.addSym(WebAssembly::getOrCreateFunctionTableSymbol(
    MF.getContext(), "__indirect_function_table"));

only if MF.getSubtarget<WebAssemblySubtarget>().hasReferenceTypes() and otherwise continue doing MIB.addImm(0)?

[wingo]

In D90948#2558286, @tlively wrote:

Actually, one question.

We keep the hack that table symbols only go to the symbol table if they are marked as used in relocations.

It seems like it would be simpler to not create a symbol table in the first place in cases where it will not be emitted into the binary anyway. In LowerCallResults, can we do

MIB.addSym(WebAssembly::getOrCreateFunctionTableSymbol(
    MF.getContext(), "__indirect_function_table"));

only if MF.getSubtarget<WebAssemblySubtarget>().hasReferenceTypes() and otherwise continue doing MIB.addImm(0)?

This could work, but the issue comes as to whether or not to emit the __indirect_function_table import. Currently the mechanism from D91637 (which, looking at it now, landed in November already -- how has this task gone on for so long???) is that the __indirect_function_table import is added the output file only if needed. We need some way for a compilation unit to record that it actually needs the indirect function table. Currently we use the presence of the table symbol in the symtab.

[wingo]

Squish with D92215

[wingo]

Logic ensuring function-to-pointer casts cause __indirect_function_table to be present moved to WebAssemblyAsmPrinter; bug pending for WebAssemblyAsmParser though.

[wingo]

In D90948#2556789, @wingo wrote:

Thanks for patience with the delay here. Paging this back in -- I will move the logic from MC/WasmObjectWriter.cpp to WebAssemblyAsmPrinter.cpp -- there I will iterate over all functions in the module, and if any of them hasAddressTaken, then I will ensure an __indirect_function_table definition exists and will be written to the output (setNoStrip). We keep the hack that table symbols only go to the symbol table if they are marked as used in relocations. If the reference types feature is enabled and an address-taken function is present in the module, the indirect function table will be explicitly marked isUsedInReloc. Just broadcasting intention here so that there are no more late surprises :)

@tlively: So, this appears to work. However I ran into a problem in WebAssemblyAsmParser -- it needs to do this same logic, if a function-to-pointer cast happens in assembly, we should ensure that the indirect function table is present in the output. Before, this case was caught by WasmObjectWriter. E.g. test/MC/WebAssembly/weak-alias.s has:

load_hidden_func:
    .functype   load_hidden_func () -> (i32)
    global.get  __table_base
    i32.const   hidden_func@TBREL
    i32.add
    end_function

But with no call_indirect, the output doesn't have __indirect_function_table, as it should.

I could check if any instruction is i32.const or i64.const with the operand being a symbol, and check that the symbol is a function, but that is gross :/ I will continue to think about this but any pointers you might have would be welcome. I lean towards my previous solution, fwiw.

[wingo]

Thinking about this a bit more after a nap -- how about I put some ensure-there's-a-function-table logic back to WasmObjectWriter in response to a TABLE_INDEX reloc, but I remove the feature detection from there. I remove the logic from AsmPrinter (maybe; see below).

I have a new idea about how to determine when to write a symtab entry for __indirect_function_table. How about, in WasmObjectWriter, we only write table symtab entries if they are needed. If any table symtab entry is needed, all tables should have symtab entries.
A table needs a symtab entry if:

• it is used in a reloc (call_indirect issued a symbol reference); or
• it is not the indirect function table (check via name and isFunctionTable())

With this strategy, we may get a reference-types file which needs a __indirect_function_table because of a function bitcast, but it's not used in a reloc so no symtab entry is emitted. That's fine with the linker logic from D96001. The indirect function table will not be relocatable in that case but that's fine; the indirect function table will be assigned table number 0 anyway. Only way that can fail is if the linker output defines __indirect_function_table locally but some other compilation unit imports a table; perhaps that is an argument for not removing the AsmPrinter case.

[wingo]

In D90948#2563258, @wingo wrote:

A table needs a symtab entry if:

• it is used in a reloc (call_indirect issued a symbol reference); or
• it is not the indirect function table (check via name and isFunctionTable())

Thinking again. Apologies for the late tergiversations -- if you have a compilation unit with a function bitcast but no call_indirect and no other tables, in practice you have a relocatable table. The linker can assign __indirect_function_table to any table number because there are no uses to relocate. (I had locally added a hasNonRelocatableUses flag to the MCSymbolWasm for tracking this.) But, a linker would only assign non-zero table numbers if there is a table symtab entry, and old linkers won't accept table symtab entries, so you really need to gate the presence of the symtab entry on the reference-types feature. You can't decide automatically :/

I think this problem is important to solve so I will continue to think about it. The previous feature-detection-in-the-writer appeared to solve the problem fwiw.

[wingo]

Rework how we determine when a table should have a symtab entry.

[wingo]

OK this thing is horrible in many ways but it does pass tests. @tlively would you mind having a look to see if especially the WasmObjectWriter, MCSymbolWasm, WebAssemblyAsmPrinter, and WebAssemblyAsmParser changes look right to you? @sbc100 input also very welcome of course!

[wingo]

Fix clang-tidy nits; remove a vestigial call to setUsedInReloc

[wingo]

Gently ping here; this is the next patch to land, and as we have few overnights left in the week it would be great to get review tonight. I know it's long; my apologies!

[tlively]

Sorry for the delay, @wingo. I'm taking a look now.

[tlively]

I have two remaining concerns about this patch:

1. I still feel that creating a table symbol that won't be emitted into the binary is an overly complex way of signaling that a table import is needed. I would prefer a simple shouldImportTable boolean somewhere to record that information. However, I don't want to hold this patch up any further on that concern because I don't have a good idea of where that boolean should go. I would be happy if we could return to this point once things are working end-to-end.
2. The comment I left on the "magic" table operand insertion this patch adds to the assembler. As I wrote, I would prefer to error out instead of implicitly inserting the missing operand, but that's a relatively minor detail that is unrelated to most of the work done in this patch, so I would happy to leave further discussion of that to a follow-up as well.

I do want to continue discussing those points, but I know this is a largish patch that has been outstanding for a while and is blocking further work. If you feel it would be more efficient, I would be fine landing this as-is and addressing those points in follow-ups.

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

212–219

The code in this patch fixes up the user's assembly by adding in table operands that did not appear in the source. IIUC, the motivation for this is to maintain backward compatibility with existing assembly that does not contain explicit table operands. IMO, rather than magically fixing the user's code, it would be better to error out on any call_indirect without an explicit table operand when reference-types is enabled. The downside would be that users would need to edit their assembly code when they enable reference-types, but I think the benefit of removing this "magic" from the assembler would be worth it.

623

In the text format the table index appears first. I think it would be good to be consistent with that rather than the binary format.

llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

871

[wingo]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

212–219

Context was https://reviews.llvm.org/D90948#inline-849046, FWIW. Sure, I can make this change, but note that the other downside is that reference-types compilation units that want to link to MVP objects will need to correctly spell "__indirect_function_table" in their call_indirect instances, otherwise you could accidentally use the wrong table.

623

Sure.

[wingo]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

623

Just to confirm, we want the text format to have a different operand order than the CALL_INDIRECT instruction from WebAssemblyCall.td -- can do.

[wingo]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

623

Hummm, I will have to write a dedicated printer in WebAssemblyInstrPrint.cpp for {RET_,}CALL_INDIRECT_S, to invert the operand order. Really sorry to bother but @tlively can you confirm this is the right thing? Thanks :)

[tlively]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

623

Yes, confirmed. I hadn't thought about how this will need a custom printer, but I still think it is the right thing to do. Folks who read and write this assembly format will probably also be spending time at least reading standard wat/wast files and probably not much time looking at the raw binaries, so I think it would be most helpful to the user for us to match the text format rather than the binary format here.

[tlively]

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

212–219

Acknowledged. I asked @aardappel and he didn't feel strongly about it and I'd like to get feedback from @sbc100 about it but he's out of office today. I'd be ok landing this as-is and potentially revisiting it with feedback from more stakeholders. (The more I think about it, the less strongly I feel about this, too.)

[wingo]

Moin :) Revisiting -- as you suggest I am going to land as-is, then follow up with a patch to not "magically" refer to __indirect_function_table in +reference-types files. If you reach a conclusion about argument order in this evening's wasm-tools meeting, please let me know and I can follow up as necessary there too.

[wingo]

Yaargh, bit by the "phab description is not necessarily what gets committed" issue -- patch committed is fine but description was outdated. In mozilla for example they land patches instead via "lando", a phab service that applies the patch as reviewed instead of opening space for errors like this one. Anyway, my apologies for the commit note mismatch.

[kripken]

I think this broke the LLVM roll on Emscripten CI. I don't have time to bisect atm, but this is the only wasm-related commit in the range, and the compiler crash is on a file and function modified in this patch:

llvm::WebAssembly::getOrCreateFunctionTableSymbol(llvm::MCContext&, llvm::WebAssemblySubtarget const*) WebAssemblyUtilities.cpp

Crash details: https://logs.chromium.org/logs/emscripten-releases/buildbucket/cr-buildbucket.appspot.com/8854596160871978800/+/steps/Build_Emscripten__upstream_/0/stdout

Regression range: https://chromium-review.googlesource.com/c/emscripten-releases/+/2711978

Crash is when building system/lib/libc/musl/src/stdio/stderr.c in libc.

[dmajor]

In D90948#2578843, @kripken wrote:

I think this broke the LLVM roll on Emscripten CI. I don't have time to bisect atm, but this is the only wasm-related commit in the range, and the compiler crash is on a file and function modified in this patch:

We're also seeing this in Mozilla's build of https://github.com/WebAssembly/wasi-sdk, and our bisect indeed pointed to this commit.

In case having a second set of repro steps helps, we're doing a relatively vanilla make : https://searchfox.org/mozilla-central/source/taskcluster/scripts/misc/build-wasi-sysroot.sh#9

[wingo]

Thanks for the reports, I will revert this patch and reland when I test against emscripten.

[wingo]

Subtarget may be NULL in getOrCreateFunctionTableSymbol

[wingo]

llvm/lib/Target/WebAssembly/WebAssemblyUtilities.cpp

115 ↗

(On Diff #327107)

Relative to the previously landed patch, this is the change -- Subtarget may be NULL. This is what was causing the crash. I don't really know in what circumstances this happens -- it happens that the file that causes the error defines no functions, so perhaps the "subtarget" field of the module was never set. Relanding as I've tested against emscripten and it seems like an obvious change.

[sbc100]

We have an internal codebase the triggers an error after this change. We have a repro case in https://bugs.llvm.org/show_bug.cgi?id=50408

llvm/include/llvm/MC/MCContext.h

public:
     MCSymbol *getInlineAsmLabel(StringRef Name) const {
       return InlineAsmUsedLabelNames.lookup(Name);
     }
 
     /// registerInlineAsmLabel - Records that the name is a label referenced in
     /// inline assembly.
     void registerInlineAsmLabel(MCSymbol *Sym);
 
+    /// getOrCreateWasmFunctionTableSymbol - Gets or creates a symbol denoting a
+    /// WebAssembly table holding elements of type funcref.
+    MCSymbol *getOrCreateWasmFunctionTableSymbol(StringRef TableName);
+
+    /// getOrCreateWasmDefaultFunctionTableSymbol - By default, all WebAssembly
+    /// functions that can be called indirectly are put into a single well-known
+    /// function table, conventionally called __indirect_function_table.  This
+    /// table's definition is synthesized by the linker.
+    MCSymbol *getOrCreateWasmDefaultFunctionTableSymbol();
+
     /// @}
 
     /// \name Section Management
     /// @{
 
     enum : unsigned {
       /// Pass this value as the UniqueID during section creation to get the
       /// generic section with the given name and characteristics. The usual

llvm/include/llvm/MC/MCSymbolWasm.h

StringRef getImportName() const {
     return getName();
   }
   void setImportName(StringRef Name) { ImportName = Name; }
 
   bool hasExportName() const { return ExportName.hasValue(); }
   StringRef getExportName() const { return ExportName.getValue(); }
   void setExportName(StringRef Name) { ExportName = Name; }
 
+  bool isFunctionTable() const {
+    return isTable() && hasTableType() &&
+           getTableType() == wasm::ValType::FUNCREF;
+  }
+  void setFunctionTable() {
+    setType(wasm::WASM_SYMBOL_TYPE_TABLE);
+    setTableType(wasm::ValType::FUNCREF);
+  }
+
   void setUsedInGOT() const { IsUsedInGOT = true; }
   bool isUsedInGOT() const { return IsUsedInGOT; }
 
   void setUsedInInitArray() const { IsUsedInInitArray = true; }
   bool isUsedInInitArray() const { return IsUsedInInitArray; }
 
   const wasm::WasmSignature *getSignature() const { return Signature; }
   void setSignature(wasm::WasmSignature *Sig) { Signature = Sig; }
 
   const wasm::WasmGlobalType &getGlobalType() const {
     assert(GlobalType.hasValue());
     return GlobalType.getValue();
   }
   void setGlobalType(wasm::WasmGlobalType GT) { GlobalType = GT; }
 
-  const wasm::ValType &getTableType() const {
-    assert(TableType.hasValue());
+  bool hasTableType() const { return TableType.hasValue(); }
+  wasm::ValType getTableType() const {
+    assert(hasTableType());
     return TableType.getValue();
   }
   void setTableType(wasm::ValType TT) { TableType = TT; }
 
   const wasm::WasmEventType &getEventType() const {
     assert(EventType.hasValue());
     return EventType.getValue();
   }
   void setEventType(wasm::WasmEventType ET) { EventType = ET; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSYMBOLWASM_H

llvm/include/llvm/MC/MCWasmStreamer.h

public:
   void emitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                              unsigned ByteAlignment) override;
 
   void emitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
                     uint64_t Size = 0, unsigned ByteAlignment = 0,
                     SMLoc Loc = SMLoc()) override;
   void emitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
                       unsigned ByteAlignment = 0) override;
-  void emitValueImpl(const MCExpr *Value, unsigned Size,
-                     SMLoc Loc = SMLoc()) override;
 
   void emitIdent(StringRef IdentString) override;
 
   void emitValueToAlignment(unsigned, int64_t, unsigned, unsigned) override;
 
   void finishImpl() override;
 
 private:

llvm/include/llvm/Object/Wasm.h

private:
   uint32_t NumImportedGlobals = 0;
   uint32_t NumImportedTables = 0;
   uint32_t NumImportedFunctions = 0;
   uint32_t NumImportedEvents = 0;
   uint32_t CodeSection = 0;
   uint32_t DataSection = 0;
   uint32_t EventSection = 0;
   uint32_t GlobalSection = 0;
+  uint32_t TableSection = 0;
 };
 
 class WasmSectionOrderChecker {
 public:
   // We define orders for all core wasm sections and known custom sections.
   enum : int {
     // Sentinel, must be zero
     WASM_SEC_ORDER_NONE = 0,

llvm/lib/MC/MCContext.cpp

void MCContext::setSymbolValue(MCStreamer &Streamer,
   auto Symbol = getOrCreateSymbol(Sym);
   Streamer.emitAssignment(Symbol, MCConstantExpr::create(Val, *this));
 }
 
 void MCContext::registerInlineAsmLabel(MCSymbol *Sym) {
   InlineAsmUsedLabelNames[Sym->getName()] = Sym;
 }
 
+MCSymbol *MCContext::getOrCreateWasmFunctionTableSymbol(StringRef TableName) {
+  if (auto Sym = cast_or_null<MCSymbolWasm>(Symbols.lookup(TableName))) {
+    if (!Sym->isFunctionTable())
+      reportError(SMLoc(), "symbol is not a wasm funcref table");
+    return Sym;
+  }
+  auto Sym = cast<MCSymbolWasm>(getOrCreateSymbol(TableName));
+  Sym->setFunctionTable();
+  return Sym;
+}
+
+MCSymbol *MCContext::getOrCreateWasmDefaultFunctionTableSymbol() {
+  auto Sym = getOrCreateWasmFunctionTableSymbol("__indirect_function_table");
+  // The default function table is synthesized by the linker.
+  Sym->setUndefined();
+  return Sym;
+}
+
 MCSymbolXCOFF *
 MCContext::createXCOFFSymbolImpl(const StringMapEntry<bool> *Name,
                                  bool IsTemporary) {
   if (!Name)
     return new (nullptr, *this) MCSymbolXCOFF(nullptr, IsTemporary);
 
   StringRef OriginalName = Name->first();
   if (OriginalName.startswith("._Renamed..") ||

llvm/lib/MC/MCWasmStreamer.cpp

void MCWasmStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
   cast<MCSymbolWasm>(Symbol)->setSize(Value);
 }
 
 void MCWasmStreamer::emitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
                                            unsigned ByteAlignment) {
   llvm_unreachable("Local common symbols are not yet implemented for Wasm");
 }
 
-void MCWasmStreamer::emitValueImpl(const MCExpr *Value, unsigned Size,
-                                   SMLoc Loc) {
-  MCObjectStreamer::emitValueImpl(Value, Size, Loc);
-}
-
 void MCWasmStreamer::emitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                                           unsigned ValueSize,
                                           unsigned MaxBytesToEmit) {
   MCObjectStreamer::emitValueToAlignment(ByteAlignment, Value, ValueSize,
                                          MaxBytesToEmit);
 }
 
 void MCWasmStreamer::emitIdent(StringRef IdentString) {

llvm/lib/MC/WasmObjectWriter.cpp

 #include <vector>
 
 using namespace llvm;
 
 #define DEBUG_TYPE "mc"
 
 namespace {
 
-// Went we ceate the indirect function table we start at 1, so that there is
-// and emtpy slot at 0 and therefore calling a null function pointer will trap.
+// When we create the indirect function table we start at 1, so that there is
+// and empty slot at 0 and therefore calling a null function pointer will trap.
 static const uint32_t InitialTableOffset = 1;
 
 // For patching purposes, we need to remember where each section starts, both
 // for patching up the section size field, and for patching up references to
 // locations within the section.
 struct SectionBookkeeping {
   // Where the size of the section is written.
   uint64_t SizeOffset;
class WasmObjectWriter : public MCObjectWriter {
   // Map from section to defining function symbol.
   DenseMap<const MCSection *, const MCSymbol *> SectionFunctions;
 
   DenseMap<wasm::WasmSignature, uint32_t> SignatureIndices;
   SmallVector<wasm::WasmSignature, 4> Signatures;
   SmallVector<WasmDataSegment, 4> DataSegments;
   unsigned NumFunctionImports = 0;
   unsigned NumGlobalImports = 0;
-  // NumTableImports is initialized to 1 to account for the hardcoded import of
-  // __indirect_function_table
-  unsigned NumTableImports = 1;
+  unsigned NumTableImports = 0;
   unsigned NumEventImports = 0;
   uint32_t SectionCount = 0;
 
   enum class DwoMode {
     AllSections,
     NonDwoOnly,
     DwoOnly,
   };
void reset() override {
     TargetFeaturesSection.reset();
     CustomSectionsRelocations.clear();
     SignatureIndices.clear();
     Signatures.clear();
     DataSegments.clear();
     SectionFunctions.clear();
     NumFunctionImports = 0;
     NumGlobalImports = 0;
-    NumTableImports = 1;
+    NumTableImports = 0;
     MCObjectWriter::reset();
   }
 
   void writeHeader(const MCAssembler &Asm);
 
   void recordRelocation(MCAssembler &Asm, const MCAsmLayout &Layout,
                         const MCFragment *Fragment, const MCFixup &Fixup,
                         MCValue Target, uint64_t &FixedValue) override;
else
       SectionSymbol = SecA.getBeginSymbol();
     if (!SectionSymbol)
       report_fatal_error("section symbol is required for relocation");
 
     C += Layout.getSymbolOffset(*SymA);
     SymA = cast<MCSymbolWasm>(SectionSymbol);
   }
 
+  if (Type == wasm::R_WASM_TABLE_INDEX_REL_SLEB ||
+      Type == wasm::R_WASM_TABLE_INDEX_SLEB ||
+      Type == wasm::R_WASM_TABLE_INDEX_SLEB64 ||
+      Type == wasm::R_WASM_TABLE_INDEX_I32 ||
+      Type == wasm::R_WASM_TABLE_INDEX_I64) {
+    // TABLE_INDEX relocs implicitly use the default indirect function table.
+    auto BaseSym = Ctx.getOrCreateWasmDefaultFunctionTableSymbol();
+    BaseSym->setUsedInReloc();
+    Asm.registerSymbol(*BaseSym);
+  }
+
   // Relocation other than R_WASM_TYPE_INDEX_LEB are required to be
   // against a named symbol.
   if (Type != wasm::R_WASM_TYPE_INDEX_LEB) {
     if (SymA->getName().empty())
       report_fatal_error("relocations against un-named temporaries are not yet "
                          "supported by wasm");
 
     SymA->setUsedInReloc();
void WasmObjectWriter::prepareImports(
   wasm::WasmImport MemImport;
   MemImport.Module = "env";
   MemImport.Field = "__linear_memory";
   MemImport.Kind = wasm::WASM_EXTERNAL_MEMORY;
   MemImport.Memory.Flags = is64Bit() ? wasm::WASM_LIMITS_FLAG_IS_64
                                      : wasm::WASM_LIMITS_FLAG_NONE;
   Imports.push_back(MemImport);
 
-  // For now, always emit the table section, since indirect calls are not
-  // valid without it. In the future, we could perhaps be more clever and omit
-  // it if there are no indirect calls.
-  wasm::WasmImport TableImport;
-  TableImport.Module = "env";
-  TableImport.Field = "__indirect_function_table";
-  TableImport.Kind = wasm::WASM_EXTERNAL_TABLE;
-  TableImport.Table.ElemType = wasm::WASM_TYPE_FUNCREF;
-  Imports.push_back(TableImport);
-
   // Populate SignatureIndices, and Imports and WasmIndices for undefined
   // symbols.  This must be done before populating WasmIndices for defined
   // symbols.
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
 
     // Register types for all functions, including those with private linkage
     // (because wasm always needs a type signature).
if (!WS.isDefined() && !WS.isComdat()) {
         Import.Module = WS.getImportModule();
         Import.Field = WS.getImportName();
         Import.Kind = wasm::WASM_EXTERNAL_EVENT;
         Import.Event.Attribute = wasm::WASM_EVENT_ATTRIBUTE_EXCEPTION;
         Import.Event.SigIndex = getEventType(WS);
         Imports.push_back(Import);
         assert(WasmIndices.count(&WS) == 0);
         WasmIndices[&WS] = NumEventImports++;
+      } else if (WS.isTable()) {
+        if (WS.isWeak())
+          report_fatal_error("undefined table symbol cannot be weak");
+
+        wasm::WasmImport Import;
+        Import.Module = WS.getImportModule();
+        Import.Field = WS.getImportName();
+        Import.Kind = wasm::WASM_EXTERNAL_TABLE;
+        Import.Table.Index = NumTableImports;
+        wasm::ValType ElemType = WS.getTableType();
+        Import.Table.ElemType = uint8_t(ElemType);
+        // FIXME: ?
+        Import.Table.Limits = {wasm::WASM_LIMITS_FLAG_NONE, 0, 0};
+        Imports.push_back(Import);
+        assert(WasmIndices.count(&WS) == 0);
+        WasmIndices[&WS] = NumTableImports++;
       }
     }
   }
 
   // Add imports for GOT globals
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
     if (WS.isUsedInGOT()) {

llvm/lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   LinkingData.SymbolTable.reserve(Count);
   Symbols.reserve(Count);
   StringSet<> SymbolNames;
 
   std::vector<wasm::WasmImport *> ImportedGlobals;
   std::vector<wasm::WasmImport *> ImportedFunctions;
   std::vector<wasm::WasmImport *> ImportedEvents;
+  std::vector<wasm::WasmImport *> ImportedTables;
   ImportedGlobals.reserve(Imports.size());
   ImportedFunctions.reserve(Imports.size());
   ImportedEvents.reserve(Imports.size());
+  ImportedTables.reserve(Imports.size());
   for (auto &I : Imports) {
     if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
       ImportedFunctions.emplace_back(&I);
     else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
       ImportedGlobals.emplace_back(&I);
     else if (I.Kind == wasm::WASM_EXTERNAL_EVENT)
       ImportedEvents.emplace_back(&I);
+    else if (I.Kind == wasm::WASM_EXTERNAL_TABLE)
+      ImportedTables.emplace_back(&I);
   }
 
   while (Count--) {
     wasm::WasmSymbolInfo Info;
     const wasm::WasmSignature *Signature = nullptr;
     const wasm::WasmGlobalType *GlobalType = nullptr;
     uint8_t TableType = 0;
     const wasm::WasmEventType *EventType = nullptr;
case wasm::WASM_SYMBOL_TYPE_GLOBAL:
         wasm::WasmImport &Import = *ImportedGlobals[Info.ElementIndex];
         if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
           Info.Name = readString(Ctx);
           Info.ImportName = Import.Field;
         } else {
           Info.Name = Import.Field;
         }
         GlobalType = &Import.Global;
-        Info.ImportName = Import.Field;
         if (!Import.Module.empty()) {
           Info.ImportModule = Import.Module;
         }
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_TABLE:
       Info.ElementIndex = readVaruint32(Ctx);
       if (!isValidTableIndex(Info.ElementIndex) ||
           IsDefined != isDefinedTableIndex(Info.ElementIndex))
         return make_error<GenericBinaryError>("invalid table symbol index",
                                               object_error::parse_failed);
       if (!IsDefined && (Info.Flags & wasm::WASM_SYMBOL_BINDING_MASK) ==
                             wasm::WASM_SYMBOL_BINDING_WEAK)
         return make_error<GenericBinaryError>("undefined weak table symbol",
                                               object_error::parse_failed);
       if (IsDefined) {
         Info.Name = readString(Ctx);
         unsigned TableIndex = Info.ElementIndex - NumImportedTables;
         wasm::WasmTable &Table = Tables[TableIndex];
         TableType = Table.ElemType;
       } else {
-        return make_error<GenericBinaryError>("undefined table symbol",
-                                              object_error::parse_failed);
+        wasm::WasmImport &Import = *ImportedTables[Info.ElementIndex];
+        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
+          Info.Name = readString(Ctx);
+          Info.ImportName = Import.Field;
+        } else {
+          Info.Name = Import.Field;
+        }
+        TableType = Import.Table.ElemType;
+        // FIXME: Parse limits here too.
+        if (!Import.Module.empty()) {
+          Info.ImportModule = Import.Module;
+        }
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_DATA:
       Info.Name = readString(Ctx);
       if (IsDefined) {
         auto Index = readVaruint32(Ctx);
         if (Index >= DataSegments.size())
Error WasmObjectFile::parseFunctionSection(ReadContext &Ctx) {
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Function section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
+  TableSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   Tables.reserve(Count);
   while (Count--) {
     wasm::WasmTable T = readTable(Ctx);
     T.Index = NumImportedTables + Tables.size();
     Tables.push_back(T);
     auto ElemType = Tables.back().ElemType;
     if (ElemType != wasm::WASM_TYPE_FUNCREF &&
uint32_t WasmObjectFile::getSymbolSectionIdImpl(const WasmSymbol &Sym) const {
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     return GlobalSection;
   case wasm::WASM_SYMBOL_TYPE_DATA:
     return DataSection;
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return Sym.Info.ElementIndex;
   case wasm::WASM_SYMBOL_TYPE_EVENT:
     return EventSection;
+  case wasm::WASM_SYMBOL_TYPE_TABLE:
+    return TableSection;
   default:
     llvm_unreachable("Unknown WasmSymbol::SymbolType");
   }
 }
 
 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
 
 Expected<StringRef> WasmObjectFile::getSectionName(DataRefImpl Sec) const {

llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmParser.cpp

 public:
   WebAssemblyAsmParser(const MCSubtargetInfo &STI, MCAsmParser &Parser,
                        const MCInstrInfo &MII, const MCTargetOptions &Options)
       : MCTargetAsmParser(Options, STI, MII), Parser(Parser),
         Lexer(Parser.getLexer()) {
     setAvailableFeatures(ComputeAvailableFeatures(STI.getFeatureBits()));
   }
 
 #define GET_ASSEMBLER_HEADER
 #include "WebAssemblyGenAsmMatcher.inc"
 
   // TODO: This is required to be implemented, but appears unused.
   bool ParseRegister(unsigned & /*RegNo*/, SMLoc & /*StartLoc*/,
                      SMLoc & /*EndLoc*/) override {
     llvm_unreachable("ParseRegister is not implemented.");
   }
   OperandMatchResultTy tryParseRegister(unsigned & /*RegNo*/,
                                         SMLoc & /*StartLoc*/,
                                         SMLoc & /*EndLoc*/) override {
     llvm_unreachable("tryParseRegister is not implemented.");
   }
 
   bool error(const Twine &Msg, const AsmToken &Tok) {
     return Parser.Error(Tok.getLoc(), Msg + Tok.getString());
#include "WebAssemblyGenAsmMatcher.inc"
 
   void addBlockTypeOperand(OperandVector &Operands, SMLoc NameLoc,
                            WebAssembly::BlockType BT) {
     Operands.push_back(std::make_unique<WebAssemblyOperand>(
         WebAssemblyOperand::Integer, NameLoc, NameLoc,
         WebAssemblyOperand::IntOp{static_cast<int64_t>(BT)}));
   }
 
+  void addFunctionTableOperand(OperandVector &Operands, StringRef TableName,
+                               SMLoc StartLoc, SMLoc EndLoc) {
+    auto *Sym = getContext().getOrCreateWasmFunctionTableSymbol(TableName);
+    auto *Val = MCSymbolRefExpr::create(Sym, getContext());
+    Operands.push_back(std::make_unique<WebAssemblyOperand>(
+        WebAssemblyOperand::Symbol, StartLoc, EndLoc,
+        WebAssemblyOperand::SymOp{Val}));
+  }
+
   bool ParseInstruction(ParseInstructionInfo & /*Info*/, StringRef Name,
                         SMLoc NameLoc, OperandVector &Operands) override {
     // Note: Name does NOT point into the sourcecode, but to a local, so
     // use NameLoc instead.
     Name = StringRef(NameLoc.getPointer(), Name.size());
 
     // WebAssembly has instructions with / in them, which AsmLexer parses
     // as separate tokens, so if we find such tokens immediately adjacent (no
Operands.push_back(std::make_unique<WebAssemblyOperand>(
         WebAssemblyOperand::Token, NameLoc, SMLoc::getFromPointer(Name.end()),
         WebAssemblyOperand::TokOp{Name}));
 
     // If this instruction is part of a control flow structure, ensure
     // proper nesting.
     bool ExpectBlockType = false;
     bool ExpectFuncType = false;
     bool ExpectHeapType = false;
+    bool ExpectFunctionTable = false;
     if (Name == "block") {
       push(Block);
       ExpectBlockType = true;
     } else if (Name == "loop") {
       push(Loop);
       ExpectBlockType = true;
     } else if (Name == "try") {
       push(Try);
if (Name == "block") {
         return true;
     } else if (Name == "end_function") {
       ensureLocals(getStreamer());
       CurrentState = EndFunction;
       if (pop(Name, Function) || ensureEmptyNestingStack())
         return true;
     } else if (Name == "call_indirect" || Name == "return_call_indirect") {
       ExpectFuncType = true;
+      ExpectFunctionTable = true;
     } else if (Name == "ref.null") {
       ExpectHeapType = true;
     }
 
     if (ExpectFuncType || (ExpectBlockType && Lexer.is(AsmToken::LParen))) {
       // This has a special TYPEINDEX operand which in text we
       // represent as a signature, such that we can re-build this signature,
       // attach it to an anonymous symbol, which is what WasmObjectWriter
       // expects to be able to recreate the actual unique-ified type indices.
       auto Loc = Parser.getTok();
       auto Signature = std::make_unique<wasm::WasmSignature>();
       if (parseSignature(Signature.get()))
         return true;
       // Got signature as block type, don't need more
       ExpectBlockType = false;
-      auto &Ctx = getStreamer().getContext();
+      auto &Ctx = getContext();
       // The "true" here will cause this to be a nameless symbol.
       MCSymbol *Sym = Ctx.createTempSymbol("typeindex", true);
       auto *WasmSym = cast<MCSymbolWasm>(Sym);
       WasmSym->setSignature(Signature.get());
       addSignature(std::move(Signature));
       WasmSym->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
       const MCExpr *Expr = MCSymbolRefExpr::create(
           WasmSym, MCSymbolRefExpr::VK_WASM_TYPEINDEX, Ctx);
       Operands.push_back(std::make_unique<WebAssemblyOperand>(
           WebAssemblyOperand::Symbol, Loc.getLoc(), Loc.getEndLoc(),
           WebAssemblyOperand::SymOp{Expr}));
+
+      // Allow additional operands after the signature, notably for
+      // call_indirect against a named table.
+      if (Lexer.isNot(AsmToken::EndOfStatement)) {
+        if (expect(AsmToken::Comma, ","))
+          return true;
+        if (Lexer.is(AsmToken::EndOfStatement)) {
+          return error("Unexpected trailing comma");
+        }
+      }
     }
 
     while (Lexer.isNot(AsmToken::EndOfStatement)) {
       auto &Tok = Lexer.getTok();
       switch (Tok.getKind()) {
       case AsmToken::Identifier: {
         if (!parseSpecialFloatMaybe(false, Operands))
           break;
while (Lexer.isNot(AsmToken::EndOfStatement)) {
           auto HeapType = parseHeapType(Id.getString());
           if (HeapType == WebAssembly::HeapType::Invalid) {
             return error("Expected a heap type: ", Id);
           }
           Operands.push_back(std::make_unique<WebAssemblyOperand>(
               WebAssemblyOperand::Integer, Id.getLoc(), Id.getEndLoc(),
               WebAssemblyOperand::IntOp{static_cast<int64_t>(HeapType)}));
           Parser.Lex();
+        } else if (ExpectFunctionTable) {
+          addFunctionTableOperand(Operands, Id.getString(), Id.getLoc(),
+                                  Id.getEndLoc());
+          Parser.Lex();
         } else {
-          // Assume this identifier is a label.
           const MCExpr *Val;
           SMLoc End;
           if (Parser.parseExpression(Val, End))
             return error("Cannot parse symbol: ", Lexer.getTok());
           Operands.push_back(std::make_unique<WebAssemblyOperand>(
               WebAssemblyOperand::Symbol, Id.getLoc(), Id.getEndLoc(),
               WebAssemblyOperand::SymOp{Val}));
           if (checkForP2AlignIfLoadStore(Operands, Name))
             return true;
         }
         break;
       }
       case AsmToken::Minus:
         Parser.Lex();
         if (Lexer.is(AsmToken::Integer)) {
           parseSingleInteger(true, Operands);
           if (checkForP2AlignIfLoadStore(Operands, Name))
             return true;
         } else if(Lexer.is(AsmToken::Real)) {
           if (parseSingleFloat(true, Operands))
             return true;
         } else if (!parseSpecialFloatMaybe(true, Operands)) {
while (Lexer.isNot(AsmToken::EndOfStatement)) {
         if (expect(AsmToken::Comma, ","))
           return true;
       }
     }
     if (ExpectBlockType && Operands.size() == 1) {
       // Support blocks with no operands as default to void.
       addBlockTypeOperand(Operands, NameLoc, WebAssembly::BlockType::Void);
     }
+    if (ExpectFunctionTable && Operands.size() == 2) {
+      // If call_indirect doesn't specify a target table, supply one.
+      addFunctionTableOperand(Operands, "__indirect_function_table", NameLoc,
+                              SMLoc::getFromPointer(Name.end()));
+    }
     Parser.Lex();
     return false;
   }
 
   void onLabelParsed(MCSymbol *Symbol) override {
     LastLabel = Symbol;
     CurrentState = Label;
   }

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyInstPrinter.cpp

if (Desc.variadicOpsAreDefs()) {
       // The number of variadic defs is encoded in an immediate by MCInstLower
       NumVariadicDefs = MI->getOperand(0).getImm();
       Start = 1;
     }
     bool NeedsComma = Desc.getNumOperands() > 0 && !Desc.variadicOpsAreDefs();
     for (auto I = Start, E = MI->getNumOperands(); I < E; ++I) {
       if (MI->getOpcode() == WebAssembly::CALL_INDIRECT &&
           I - Start == NumVariadicDefs) {
-        // Skip type and flags arguments when printing for tests
+        // Skip type, table, and flags arguments when printing for tests
+        ++I;
         ++I;
         continue;
       }
       if (NeedsComma)
         OS << ", ";
       printOperand(MI, I, OS, I - Start < NumVariadicDefs);
       NeedsComma = true;
     }

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyMCTargetDesc.h

inline bool isCallIndirect(unsigned Opc) {
   case WebAssembly::RET_CALL_INDIRECT:
   case WebAssembly::RET_CALL_INDIRECT_S:
     return true;
   default:
     return false;
   }
 }
 
+inline bool isRetCallIndirect(unsigned Opc) {
+  switch (Opc) {
+  case WebAssembly::RET_CALL_INDIRECT:
+  case WebAssembly::RET_CALL_INDIRECT_S:
+    return true;
+  default:
+    return false;
+  }
+}
+
 inline bool isBrTable(const MachineInstr &MI) {
   switch (MI.getOpcode()) {
   case WebAssembly::BR_TABLE_I32:
   case WebAssembly::BR_TABLE_I32_S:
   case WebAssembly::BR_TABLE_I64:
   case WebAssembly::BR_TABLE_I64_S:
     return true;
   default:

llvm/lib/Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp

 /// This file defines WebAssembly-specific target streamer classes.
 /// These are for implementing support for target-specific assembly directives.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "MCTargetDesc/WebAssemblyTargetStreamer.h"
 #include "MCTargetDesc/WebAssemblyInstPrinter.h"
 #include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
+#include "WebAssemblyUtilities.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCSectionWasm.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbolWasm.h"
+#include "llvm/MC/MCWasmStreamer.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 using namespace llvm;
 
 WebAssemblyTargetStreamer::WebAssemblyTargetStreamer(MCStreamer &S)
     : MCTargetStreamer(S) {}
 

llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

 #include "WebAssemblySubtarget.h"
 #include "WebAssemblyTargetMachine.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/CodeGen/FastISel.h"
 #include "llvm/CodeGen/FunctionLoweringInfo.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
 #include "llvm/CodeGen/MachineFrameInfo.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"
bool WebAssemblyFastISel::selectCall(const Instruction *I) {
   auto MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc));
 
   if (!IsVoid)
     MIB.addReg(ResultReg, RegState::Define);
 
   if (IsDirect) {
     MIB.addGlobalAddress(Func);
   } else {
-    // Add placeholders for the type index and immediate flags
+    // Placehoder for the type index.
     MIB.addImm(0);
+    // The table into which this call_indirect indexes.
+    auto &Context = MF->getMMI().getContext();
+    MIB.addSym(Context.getOrCreateWasmDefaultFunctionTableSymbol());
+    // Placeholder for immediate flags.
     MIB.addImm(0);
   }
 
   for (unsigned ArgReg : Args)
     MIB.addReg(ArgReg);
 
   if (!IsDirect)
     MIB.addReg(CalleeReg);
 
   if (!IsVoid)
     updateValueMap(Call, ResultReg);
   return true;
 }
 
 bool WebAssemblyFastISel::selectSelect(const Instruction *I) {

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

if (IsIndirect) {
     auto FnPtr = CallParams.getOperand(0);
     CallParams.RemoveOperand(0);
     CallParams.addOperand(FnPtr);
   }
 
   for (auto Def : CallResults.defs())
     MIB.add(Def);
 
-  // Add placeholders for the type index and immediate flags
   if (IsIndirect) {
+    // Placehoder for the type index.
     MIB.addImm(0);
+    // The table into which this call_indirect indexes.
+    auto &Context = MF.getContext();
+    MIB.addSym(Context.getOrCreateWasmDefaultFunctionTableSymbol());
+    // Placeholder for immediate flags.
     MIB.addImm(0);
   }
 
   for (auto Use : CallParams.uses())
     MIB.add(Use);
 
   BB->insert(CallResults.getIterator(), MIB);
   CallParams.eraseFromParent();

llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td

defm CALL_RESULTS :
   I<(outs), (ins variable_ops), (outs), (ins), [],
      "call_results", "call_results", -1>;
 
 let variadicOpsAreDefs = 1, usesCustomInserter = 1, isPseudo = 1 in
 defm RET_CALL_RESULTS :
   I<(outs), (ins variable_ops), (outs), (ins), [],
      "return_call_results", "return_call_results", -1>;
 
+// Note that instructions with variable_ops have custom printers in
+// WebAssemblyInstPrinter.cpp.
+
 let variadicOpsAreDefs = 1 in
 defm CALL :
   I<(outs), (ins function32_op:$callee, variable_ops),
     (outs), (ins function32_op:$callee), [],
     "call", "call\t$callee", 0x10>;
 
 let variadicOpsAreDefs = 1 in
 defm CALL_INDIRECT :
- I<(outs), (ins TypeIndex:$type, i32imm:$flags, variable_ops),
-   (outs), (ins TypeIndex:$type, i32imm:$flags), [],
-   "call_indirect", "call_indirect\t$type", 0x11>;
+  I<(outs),
+    (ins TypeIndex:$type, table32_op:$table, i32imm:$flags, variable_ops),
+    (outs),
+    (ins TypeIndex:$type, table32_op:$table, i32imm:$flags),
+    [],
+    "call_indirect", "call_indirect\t$type, $table", 0x11>;
 
 let isReturn = 1, isTerminator = 1, hasCtrlDep = 1, isBarrier = 1 in
 defm RET_CALL :
   I<(outs), (ins function32_op:$callee, variable_ops),
     (outs), (ins function32_op:$callee), [],
     "return_call    \t$callee", "return_call\t$callee", 0x12>,
   Requires<[HasTailCall]>;
 
 let isReturn = 1 in
 defm RET_CALL_INDIRECT :
-  I<(outs), (ins TypeIndex:$type, i32imm:$flags, variable_ops),
-    (outs), (ins TypeIndex:$type, i32imm:$flags), [],
-    "return_call_indirect\t", "return_call_indirect\t$type",
+  I<(outs), (ins TypeIndex:$type, table32_op:$table, i32imm:$flags, variable_ops),
+    (outs), (ins TypeIndex:$type, table32_op:$table, i32imm:$flags), [],
+    "return_call_indirect\t", "return_call_indirect\t$type, $table",
     0x13>,
   Requires<[HasTailCall]>;
 
 } // Uses = [SP32,SP64], isCall = 1

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

if (MO.getOffset() != 0) {
     if (TargetFlags == WebAssemblyII::MO_GOT)
       report_fatal_error("GOT symbol references do not support offsets");
     if (WasmSym->isFunction())
       report_fatal_error("Function addresses with offsets not supported");
     if (WasmSym->isGlobal())
       report_fatal_error("Global indexes with offsets not supported");
     if (WasmSym->isEvent())
       report_fatal_error("Event indexes with offsets not supported");
+    if (WasmSym->isTable())
+      report_fatal_error("Table indexes with offsets not supported");
 
     Expr = MCBinaryExpr::createAdd(
         Expr, MCConstantExpr::create(MO.getOffset(), Ctx), Ctx);
   }
 
   return MCOperand::createExpr(Expr);
 }
 
case MachineOperand::MO_Immediate: {
 
           // call_indirect instructions have a callee operand at the end which
           // doesn't count as a param.
           if (WebAssembly::isCallIndirect(MI->getOpcode()))
             Params.pop_back();
 
           // return_call_indirect instructions have the return type of the
           // caller
-          if (MI->getOpcode() == WebAssembly::RET_CALL_INDIRECT)
+          if (WebAssembly::isRetCallIndirect(MI->getOpcode()))
             getFunctionReturns(MI, Returns);
 
           MCOp = lowerTypeIndexOperand(std::move(Returns), std::move(Params));
           break;
         } else if (Info.OperandType == WebAssembly::OPERAND_SIGNATURE) {
           auto BT = static_cast<WebAssembly::BlockType>(MO.getImm());
           assert(BT != WebAssembly::BlockType::Invalid);
           if (BT == WebAssembly::BlockType::Multivalue) {

llvm/test/CodeGen/WebAssembly/function-pointer64.ll

 ; For simplicity (and compatibility with UB C/C++ code) we keep all types
 ; of pointers the same size, so function pointers (which are 32-bit indices
 ; in Wasm) are represented as 64-bit until called.
 
 ; CHECK:      .functype foo (i64) -> ()
 ; CHECK-NEXT: i32.const 1
 ; CHECK-NEXT: local.get 0
 ; CHECK-NEXT: i32.wrap_i64
-; CHECK-NEXT: call_indirect (i32) -> ()
+; CHECK-NEXT: call_indirect (i32) -> (), __indirect_function_table
 
 ; CHECK:      .functype test () -> ()
 ; CHECK-NEXT: i64.const bar
 ; CHECK-NEXT: call foo
 
 
 ; Check we're emitting a 64-bit reloc for `i64.const bar` and the global.
 
 ; YAML:      Memory:
 ; YAML-NEXT:   Flags:   [ IS_64 ]
 ; YAML-NEXT:   Initial: 0x00000001
 
 ; YAML:      - Type:   CODE
 ; YAML:      - Type:   R_WASM_TABLE_INDEX_SLEB64
 ; YAML-NEXT:   Index:  0
-; YAML-NEXT:   Offset: 0x00000016
+; YAML-NEXT:   Offset: 0x0000001B
 
 ; YAML:      - Type:   DATA
 ; YAML:      - Type:   R_WASM_TABLE_INDEX_I64
 ; YAML-NEXT:   Index:  0
 ; YAML-NEXT:   Offset: 0x00000006

llvm/test/CodeGen/WebAssembly/multivalue.ll

 define %pair @pair_call_return() {
   %p = call %pair @pair_const()
   ret %pair %p
 }
 
 ; CHECK-LABEL: pair_call_indirect:
 ; CHECK-NEXT: .functype pair_call_indirect (i32) -> (i32, i64)
 ; CHECK-NEXT: local.get 0{{$}}
-; CHECK-NEXT: call_indirect () -> (i32, i64){{$}}
+; CHECK-NEXT: call_indirect () -> (i32, i64), __indirect_function_table{{$}}
 ; CHECK-NEXT: end_function{{$}}
 ; REGS: call_indirect $push{{[0-9]+}}=, $push{{[0-9]+}}=, $0{{$}}
 define %pair @pair_call_indirect(%pair()* %f) {
   %p = call %pair %f()
   ret %pair %p
 }
 
 ; CHECK-LABEL: pair_tail_call:

llvm/test/MC/WebAssembly/assembler-binary.ll

 ; CHECK-NEXT:   - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
 ; CHECK-NEXT:           Initial:         0x00000000
 ; CHECK-NEXT:       - Module:          env
-; CHECK-NEXT:         Field:           __indirect_function_table
-; CHECK-NEXT:         Kind:            TABLE
-; CHECK-NEXT:         Table:
-; CHECK-NEXT:           Index:           0
-; CHECK-NEXT:           ElemType:        FUNCREF
-; CHECK-NEXT:           Limits:
-; CHECK-NEXT:             Initial:         0x00000000
-; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           bar
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WASM_FUNCTION_INDEX_LEB

llvm/test/MC/WebAssembly/basic-assembly.s

 # CHECK-NEXT:      i32.ge_s
 # CHECK-NEXT:      br_if       0       # 0: down to label0
 # CHECK-NEXT:  .LBB0_1:
 # CHECK-NEXT:      loop        i32     # label1:
 # CHECK-NEXT:      call        something1
 # CHECK-NEXT:      i64.const   1234
 # CHECK-NEXT:      call        something2
 # CHECK-NEXT:      i32.const   0
-# CHECK-NEXT:      call_indirect (i32, f64) -> ()
+# CHECK-NEXT:      call_indirect (i32, f64) -> (), __indirect_function_table
 # CHECK-NEXT:      i32.const   1
 # CHECK-NEXT:      i32.add
 # CHECK-NEXT:      local.tee   0
 # CHECK-NEXT:      local.get   0
 # CHECK-NEXT:      i32.lt_s
 # CHECK-NEXT:      br_if       0       # 0: up to label1
 # CHECK-NEXT:  .LBB0_2:
 # CHECK-NEXT:      end_loop

llvm/test/MC/WebAssembly/call-indirect-relocs.s

+# RUN: llvm-mc -triple=wasm32-unknown-unknown < %s | FileCheck %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj < %s | obj2yaml | FileCheck -check-prefix=BIN %s
+
+test0:
+    .functype   test0 () -> ()
+    i32.const 42
+    f64.const 2.5
+    i32.const   0
+    call_indirect (i32, f64) -> (), empty_fref_table
+    end_function
+
+.tabletype empty_fref_table, funcref
+empty_fref_table:
+
+
+# CHECK:           .text
+# CHECK-LABEL: test0:
+# CHECK-NEXT:      .functype   test0 () -> ()
+# CHECK-NEXT:      i32.const   42
+# CHECK-NEXT:      f64.const   0x1.4p1
+# CHECK-NEXT:      i32.const   0
+# CHECK-NEXT:      call_indirect (i32, f64) -> (), empty_fref_table
+# CHECK-NEXT:      end_function
+
+# CHECK:           .tabletype empty_fref_table, funcref
+# CHECK: empty_fref_table:
+
+# BIN: --- !WASM
+# BIN-NEXT: FileHeader:
+# BIN-NEXT:   Version:         0x00000001
+# BIN-NEXT: Sections:
+# BIN-NEXT:   - Type:            TYPE
+# BIN-NEXT:     Signatures:
+# BIN-NEXT:       - Index:           0
+# BIN-NEXT:         ParamTypes:      []
+# BIN-NEXT:         ReturnTypes:     []
+# BIN-NEXT:       - Index:           1
+# BIN-NEXT:         ParamTypes:
+# BIN-NEXT:           - I32
+# BIN-NEXT:           - F64
+# BIN-NEXT:         ReturnTypes:     []
+# BIN-NEXT:   - Type:            IMPORT
+# BIN-NEXT:     Imports:
+# BIN-NEXT:       - Module:          env
+# BIN-NEXT:         Field:           __linear_memory
+# BIN-NEXT:         Kind:            MEMORY
+# BIN-NEXT:         Memory:
+# BIN-NEXT:           Initial:         0x00000000
+# BIN-NEXT:   - Type:            FUNCTION
+# BIN-NEXT:     FunctionTypes:   [ 0 ]
+# BIN-NEXT:   - Type:            TABLE
+# BIN-NEXT:     Tables:
+# BIN-NEXT:       - Index:           0
+# BIN-NEXT:         ElemType:        FUNCREF
+# BIN-NEXT:         Limits:
+# BIN-NEXT:           Initial:         0x00000000
+# BIN-NEXT:   - Type:            CODE
+# BIN-NEXT:     Relocations:
+# BIN-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
+# BIN-NEXT:         Index:           1
+# BIN-NEXT:         Offset:          0x00000011
+# BIN-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
+# BIN-NEXT:         Index:           1
+# BIN-NEXT:         Offset:          0x00000016
+# BIN-NEXT:     Functions:
+# BIN-NEXT:       - Index:           0
+# BIN-NEXT:         Locals:          []
+# BIN-NEXT:         Body:            412A44000000000000044041001181808080008080808000000B
+# BIN-NEXT:   - Type:            CUSTOM
+# BIN-NEXT:     Name:            linking
+# BIN-NEXT:     Version:         2
+# BIN-NEXT:     SymbolTable:
+# BIN-NEXT:       - Index:           0
+# BIN-NEXT:         Kind:            FUNCTION
+# BIN-NEXT:         Name:            test0
+# BIN-NEXT:         Flags:           [ BINDING_LOCAL ]
+# BIN-NEXT:         Function:        0
+# BIN-NEXT:       - Index:           1
+# BIN-NEXT:         Kind:            TABLE
+# BIN-NEXT:         Name:            empty_fref_table
+# BIN-NEXT:         Flags:           [ BINDING_LOCAL ]
+# BIN-NEXT:         Table:           0
+# BIN-NEXT: ...

llvm/test/MC/WebAssembly/comdat.ll

 ; CHECK-NEXT:   - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:       - Module:          env
-; CHECK-NEXT:         Field:           __indirect_function_table
-; CHECK-NEXT:         Kind:            TABLE
-; CHECK-NEXT:         Table:
-; CHECK-NEXT:           Index:           0
-; CHECK-NEXT:           ElemType:        FUNCREF
-; CHECK-NEXT:           Limits:
-; CHECK-NEXT:             Initial:         0x00000000
-; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           funcImport
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0 ]
 ; CHECK-NEXT:  - Type:            DATACOUNT
 ; CHECK-NEXT:    Count:           1
 ; CHECK-NEXT:  - Type:            CODE

llvm/test/MC/WebAssembly/custom-sections.ll

 !wasm.custom_sections = !{ !0, !1, !2 }
 
 !3 = !{ !"clang version 123"}
 !llvm.ident = !{!3}
 
 ; CHECK:  Section {
 ; CHECK:    Type: CUSTOM (0x0)
 ; CHECK:    Size: 3
-; CHECK:    Offset: 72
+; CHECK:    Offset: 38
 ; CHECK:    Name: red
 ; CHECK:  }
 ; CHECK:  Section {
 ; CHECK:    Type: CUSTOM (0x0)
 ; CHECK:    Size: 6
-; CHECK:    Offset: 85
+; CHECK:    Offset: 51
 ; CHECK:    Name: green
 ; CHECK:  }
 ; CHECK:  Section {
 ; CHECK:    Type: CUSTOM (0x0)
 ; CHECK:    Size: 25
-; CHECK:    Offset: 118
+; CHECK:    Offset: 84
 ; CHECK:    Name: producers
 ; CHECK:  }

llvm/test/MC/WebAssembly/data-section.s

 # BIN-NEXT:           - I32
 # BIN-NEXT:   - Type:            IMPORT
 # BIN-NEXT:     Imports:
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __linear_memory
 # BIN-NEXT:         Kind:            MEMORY
 # BIN-NEXT:         Memory:
 # BIN-NEXT:           Initial:         0x00000001
-# BIN-NEXT:       - Module:          env
-# BIN-NEXT:         Field:           __indirect_function_table
-# BIN-NEXT:         Kind:            TABLE
-# BIN-NEXT:         Table:
-# BIN-NEXT:           Index:           0
-# BIN-NEXT:           ElemType:        FUNCREF
-# BIN-NEXT:           Limits:
-# BIN-NEXT:             Initial:         0x00000000
 # BIN-NEXT:   - Type:            FUNCTION
 # BIN-NEXT:     FunctionTypes:   [ 0 ]
 # BIN-NEXT:   - Type:            DATACOUNT
 # BIN-NEXT:     Count:           1
 # BIN-NEXT:   - Type:            CODE
 # BIN-NEXT:     Relocations:
 # BIN-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
 # BIN-NEXT:         Index:           1

llvm/test/MC/WebAssembly/debug-info.ll

 ; RUN: llc -filetype=obj %s -o - | llvm-readobj -r -S --symbols - | FileCheck %s
 
 ; CHECK: Format: WASM
 ; CHECK-NEXT:Arch: wasm32
 ; CHECK-NEXT:AddressSize: 32bit
 ; CHECK-NEXT:Sections [
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: TYPE (0x1)
 ; CHECK-NEXT:    Size: 4
 ; CHECK-NEXT:    Offset: 8
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: IMPORT (0x2)
 ; CHECK-NEXT:    Size: 81
 ; CHECK-NEXT:    Offset: 18
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: FUNCTION (0x3)
 ; CHECK-NEXT:    Size: 2
 ; CHECK-NEXT:    Offset: 105
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {

 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 57
 ; CHECK-NEXT:    Offset: 656
 ; CHECK-NEXT:    Name: .debug_line
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
-; CHECK-NEXT:    Size: 91
+; CHECK-NEXT:    Size: 94
 ; CHECK-NEXT:    Offset: 731
 ; CHECK-NEXT:    Name: linking
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 9
-; CHECK-NEXT:    Offset: 836
+; CHECK-NEXT:    Offset: 839
 ; CHECK-NEXT:    Name: reloc.DATA
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 61
-; CHECK-NEXT:    Offset: 862
+; CHECK-NEXT:    Offset: 865
 ; CHECK-NEXT:    Name: reloc..debug_info
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 947
+; CHECK-NEXT:    Offset: 950
 ; CHECK-NEXT:    Name: reloc..debug_pubnames
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 981
+; CHECK-NEXT:    Offset: 984
 ; CHECK-NEXT:    Name: reloc..debug_pubtypes
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 6
-; CHECK-NEXT:    Offset: 1015
+; CHECK-NEXT:    Offset: 1018
 ; CHECK-NEXT:    Name: reloc..debug_line
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Section {
 ; CHECK-NEXT:    Type: CUSTOM (0x0)
 ; CHECK-NEXT:    Size: 77
-; CHECK-NEXT:    Offset: 1045
+; CHECK-NEXT:    Offset: 1048
 ; CHECK-NEXT:    Name: producers
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 ; CHECK-NEXT:Relocations [
 ; CHECK-NEXT:  Section (7) DATA {
 ; CHECK-NEXT:    0x6 R_WASM_MEMORY_ADDR_I32 myextern 0
 ; CHECK-NEXT:    0xF R_WASM_TABLE_INDEX_I32 f2
 ; CHECK-NEXT:  }

 ; CHECK-NEXT:    ElementIndex: 0x8
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
 ; CHECK-NEXT:    Name: __stack_pointer
 ; CHECK-NEXT:    Type: GLOBAL (0x2)
 ; CHECK-NEXT:    Flags [ (0x10)
 ; CHECK-NEXT:      UNDEFINED (0x10)
 ; CHECK-NEXT:    ]
-; CHECK-NEXT:    ImportName: __stack_pointer
 ; CHECK-NEXT:    ImportModule: env
 ; CHECK-NEXT:    ElementIndex: 0x0
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
 ; CHECK-NEXT:    Name: .debug_str
 ; CHECK-NEXT:    Type: SECTION (0x3)
 ; CHECK-NEXT:    Flags [ (0x2)
 ; CHECK-NEXT:      BINDING_LOCAL (0x2)
 ; CHECK-NEXT:    ]
 ; CHECK-NEXT:    ElementIndex: 0x9
 ; CHECK-NEXT:  }
 ; CHECK-NEXT:  Symbol {
 ; CHECK-NEXT:    Name: .debug_line
 ; CHECK-NEXT:    Type: SECTION (0x3)
 ; CHECK-NEXT:    Flags [ (0x2)
 ; CHECK-NEXT:      BINDING_LOCAL (0x2)
 ; CHECK-NEXT:    ]
 ; CHECK-NEXT:    ElementIndex: 0xC
 ; CHECK-NEXT:  }
+; CHECK-NEXT:  Symbol {
+; CHECK-NEXT:    Name: __indirect_function_table
+; CHECK-NEXT:    Type: 0x5
+; CHECK-NEXT:    Flags [ (0x10)
+; CHECK-NEXT:      UNDEFINED (0x10)
+; CHECK-NEXT:    ]
+; CHECK-NEXT:    ImportModule: env
+; CHECK-NEXT:    ElementIndex: 0x0
+; CHECK-NEXT:  }
 ; CHECK-NEXT:]
 
 ; generated from the following C code using: clang --target=wasm32 -g -O0 -S -emit-llvm test.c
 ; extern int myextern;
 ; void f2(void) { return; }
 ;
 ; int* foo = &myextern;
 ; void (*ptr2)(void) = f2;

llvm/test/MC/WebAssembly/event-section.ll

 ; CHECK:            - Index:           1
 ; CHECK-NEXT:         Kind:            EVENT
 ; CHECK-NEXT:         Name:            __cpp_exception
 ; CHECK-NEXT:         Flags:           [ BINDING_WEAK ]
 ; CHECK-NEXT:         Event:           0
 
 ; SEC:          Type: EVENT (0xD)
 ; SEC-NEXT:     Size: 3
-; SEC-NEXT:     Offset: 97
+; SEC-NEXT:     Offset: 63

llvm/test/MC/WebAssembly/external-func-address.ll

 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:         ReturnTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK:            - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK:            - Module:          env
-; CHECK-NEXT:         Field:           __indirect_function_table
-; CHECK:            - Module:          env
 ; CHECK-NEXT:         Field:           varargs
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK:            - Module:          somewhere
 ; CHECK-NEXT:         Field:           something
 ; CHECK:            - Module:          env
 ; CHECK-NEXT:         Field:           f1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        0
+; CHECK:            - Module:          env
+; CHECK-NEXT:         Field:           __indirect_function_table
 ; CHECK:        - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 1, 2 ]
 ; CHECK:        - Type:            DATA{{$}}
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 ; CHECK-NEXT:         Index:           3
 ; CHECK-NEXT:         Offset:          0x00000006

llvm/test/MC/WebAssembly/function-alias.ll

 ; CHECK-NEXT:   }
 ; CHECK-NEXT:   Symbol {
 ; CHECK-NEXT:     Name: bar
 ; CHECK-NEXT:     Type: FUNCTION (0x0)
 ; CHECK-NEXT:     Flags [ (0x0)
 ; CHECK-NEXT:     ]
 ; CHECK-NEXT:     ElementIndex: 0x0
 ; CHECK-NEXT:   }
+; CHECK-NEXT:   Symbol {
+; CHECK-NEXT:     Name: __indirect_function_table
+; CHECK-NEXT:     Type: 0x5
+; CHECK-NEXT:     Flags [ (0x10)
+; CHECK-NEXT:       UNDEFINED (0x10)
+; CHECK-NEXT:     ]
+; CHECK-NEXT:     ImportModule: env
+; CHECK-NEXT:     ElementIndex: 0x0
+; CHECK-NEXT:   }
 ; CHECK-NEXT: ]

llvm/test/MC/WebAssembly/global-ctor-dtor.ll

 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __linear_memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
 ; CHECK-NEXT:           Initial:         0x00000001
 ; CHECK-NEXT:       - Module:          env
-; CHECK-NEXT:         Field:           __indirect_function_table
-; CHECK-NEXT:         Kind:            TABLE
-; CHECK-NEXT:         Table:
-; CHECK-NEXT:           Index:           0
-; CHECK-NEXT:           ElemType:        FUNCREF
-; CHECK-NEXT:           Limits:
-; CHECK-NEXT:             Initial:         0x00000002
-; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func3
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __cxa_atexit
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        2
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func2
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func1
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func0
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         SigIndex:        1
+; CHECK-NEXT:       - Module:          env
+; CHECK-NEXT:         Field:           __indirect_function_table
+; CHECK-NEXT:         Kind:            TABLE
+; CHECK-NEXT:         Table:
+; CHECK-NEXT:           Index:           0
+; CHECK-NEXT:           ElemType:        FUNCREF
+; CHECK-NEXT:           Limits:
+; CHECK-NEXT:             Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 1 ]
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
 ; CHECK-NEXT:         Functions:       [ 5, 7 ]

 ; CHECK-NEXT:         Name:            func1
 ; CHECK-NEXT:         Flags:           [ UNDEFINED ]
 ; CHECK-NEXT:         Function:        3
 ; CHECK-NEXT:       - Index:           10
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Name:            func0
 ; CHECK-NEXT:         Flags:           [ UNDEFINED ]
 ; CHECK-NEXT:         Function:        4
+; CHECK-NEXT:       - Index:           11
+; CHECK-NEXT:         Kind:            TABLE
+; CHECK-NEXT:         Name:            __indirect_function_table
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]
+; CHECK-NEXT:         Table:           0
 ; CHECK-NEXT:     SegmentInfo:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            .data.global1
 ; CHECK-NEXT:         Alignment:       3
 ; CHECK-NEXT:         Flags:           [ ]
 ; CHECK-NEXT:     InitFunctions:
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         Symbol: 9
 ; CHECK-NEXT:       - Priority: 42
 ; CHECK-NEXT:         Symbol: 2
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         Symbol: 10
 ; CHECK-NEXT:       - Priority: 65535
 ; CHECK-NEXT:         Symbol: 7
 ; CHECK-NEXT: ...

llvm/test/MC/WebAssembly/reloc-code.ll

 ; CHECK-NEXT:       Addend: 0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WASM_TYPE_INDEX_LEB (6)
 ; CHECK-NEXT:       Offset: 0x1A
 ; CHECK-NEXT:       Index: 0x1
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
+; CHECK-NEXT:       Type: R_WASM_TABLE_NUMBER_LEB (20)
+; CHECK-NEXT:       Offset: 0x1F
+; CHECK-NEXT:       Symbol: __indirect_function_table
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WASM_TYPE_INDEX_LEB (6)
-; CHECK-NEXT:       Offset: 0x24
+; CHECK-NEXT:       Offset: 0x29
 ; CHECK-NEXT:       Index: 0x0
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
+; CHECK-NEXT:       Type: R_WASM_TABLE_NUMBER_LEB (20)
+; CHECK-NEXT:       Offset: 0x2E
+; CHECK-NEXT:       Symbol: __indirect_function_table
+; CHECK-NEXT:     }
+; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
-; CHECK-NEXT:       Offset: 0x2D
+; CHECK-NEXT:       Offset: 0x37
 ; CHECK-NEXT:       Symbol: c
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:     Relocation {
 ; CHECK-NEXT:       Type: R_WASM_FUNCTION_INDEX_LEB (0)
-; CHECK-NEXT:       Offset: 0x34
+; CHECK-NEXT:       Offset: 0x3E
 ; CHECK-NEXT:       Symbol: d
 ; CHECK-NEXT:     }
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: ]

llvm/test/MC/WebAssembly/reloc-pic.s

 # CHECK-NEXT:   - Type:            IMPORT
 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __linear_memory
 # CHECK-NEXT:         Kind:            MEMORY
 # CHECK-NEXT:         Memory:
 # CHECK-NEXT:           Initial:         0x00000001
 # CHECK-NEXT:       - Module:          env
+# CHECK-NEXT:         Field:           default_func
+# CHECK-NEXT:         Kind:            FUNCTION
+# CHECK-NEXT:         SigIndex:        0
+# CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __indirect_function_table
 # CHECK-NEXT:         Kind:            TABLE
 # CHECK-NEXT:         Table:
 # CHECK-NEXT:           Index:           0
 # CHECK-NEXT:           ElemType:        FUNCREF
 # CHECK-NEXT:           Limits:
 # CHECK-NEXT:             Initial:         0x00000001
-# CHECK-NEXT:       - Module:          env
-# CHECK-NEXT:         Field:           default_func
-# CHECK-NEXT:         Kind:            FUNCTION
-# CHECK-NEXT:         SigIndex:        0
 # CHECK-NEXT:       - Module:          GOT.mem
 # CHECK-NEXT:         Field:           default_data
 # CHECK-NEXT:         Kind:            GLOBAL
 # CHECK-NEXT:         GlobalType:      I32
 # CHECK-NEXT:         GlobalMutable:   true
 # CHECK-NEXT:       - Module:          GOT.func
 # CHECK-NEXT:         Field:           default_func
 # CHECK-NEXT:         Kind:            GLOBAL
 # CHECK-NEXT:         GlobalType:      I32
 # CHECK-NEXT:         GlobalMutable:   true
 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0, 0, 0, 0, 0 ]
 # CHECK-NEXT:   - Type:            ELEM
 # CHECK-NEXT:     Segments:
-# CHECK-NEXT:        Offset:
-# CHECK-NEXT:          Opcode:          I32_CONST
-# CHECK-NEXT:          Value:           1
-# CHECK-NEXT:        Functions:       [ 5 ]
+# CHECK-NEXT:       - Offset:
+# CHECK-NEXT:           Opcode:          I32_CONST
+# CHECK-NEXT:           Value:           1
+# CHECK-NEXT:         Functions:       [ 5 ]
 # CHECK-NEXT:   - Type:            DATACOUNT
 # CHECK-NEXT:     Count:           1
 # CHECK-NEXT:   - Type:            CODE
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:         Offset:          0x00000004
 # CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB

 # CHECK-NEXT:         Kind:            DATA
 # CHECK-NEXT:         Name:            __table_base
 # CHECK-NEXT:         Flags:           [ UNDEFINED ]
 # CHECK-NEXT:       - Index:           9
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            hidden_func
 # CHECK-NEXT:         Flags:           [ BINDING_LOCAL ]
 # CHECK-NEXT:         Function:        5
+# CHECK-NEXT:       - Index:           10
+# CHECK-NEXT:         Kind:            TABLE
+# CHECK-NEXT:         Name:            __indirect_function_table
+# CHECK-NEXT:         Flags:           [ UNDEFINED ]
+# CHECK-NEXT:         Table:           0
 # CHECK-NEXT:     SegmentInfo:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Name:            .rodata.hidden_data
 # CHECK-NEXT:         Alignment:       0
 # CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT: ...

llvm/test/MC/WebAssembly/tables.s

table_fill:
     local.get 1
 
     # ENC: table.fill table1                  # encoding: [0xfc,0x11,0x80'A',0x80'A',0x80'A',0x80'A',A]
     table.fill table1
     end_function
 
 #      BIN:  - Type:            TABLE
 # BIN-NEXT:    Tables:
-# BIN-NEXT:      - Index:           1
+# BIN-NEXT:      - Index:           0
 # BIN-NEXT:        ElemType:        EXTERNREF
 # BIN-NEXT:        Limits:
 # BIN-NEXT:          Initial:         0x00000000
+# BIN-NEXT:      - Index:           1
+# BIN-NEXT:        ElemType:        FUNCREF
+# BIN-NEXT:        Limits:
+# BIN-NEXT:          Initial:         0x00000000
 # BIN-NEXT:      - Index:           2
 # BIN-NEXT:        ElemType:        FUNCREF
 # BIN-NEXT:        Limits:
 # BIN-NEXT:          Initial:         0x00000000
+# BIN-NEXT:      - Index:           3
+# BIN-NEXT:        ElemType:        FUNCREF
+# BIN-NEXT:        Limits:
+# BIN-NEXT:          Initial:         0x00000000
 
 #      BIN:  - Type:            CODE
 # BIN-NEXT:    Relocations:
 # BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
 # BIN-NEXT:        Index:           2
 # BIN-NEXT:        Offset:          0x00000009
 # BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
 # BIN-NEXT:        Index:           2

 # BIN-NEXT:        Index:           2
 # BIN-NEXT:        Offset:          0x00000051
 # BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
 # BIN-NEXT:        Index:           2
 # BIN-NEXT:        Offset:          0x0000005A
 # BIN-NEXT:    Functions:
 # BIN-NEXT:      - Index:           0
 # BIN-NEXT:        Locals:          []
-# BIN-NEXT:        Body:            20002001FC108380808000FC0E838080800084808080000B
+# BIN-NEXT:        Body:            20002001FC108280808000FC0E828080800083808080000B
 # BIN-NEXT:      - Index:           1
 # BIN-NEXT:        Locals:          []
-# BIN-NEXT:        Body:            20002581808080000B
+# BIN-NEXT:        Body:            20002580808080000B
 # BIN-NEXT:      - Index:           2
 # BIN-NEXT:        Locals:          []
-# BIN-NEXT:        Body:            200020012681808080000B
+# BIN-NEXT:        Body:            200020012680808080000B
 # BIN-NEXT:      - Index:           3
 # BIN-NEXT:        Locals:          []
-# BIN-NEXT:        Body:            41002581808080002000FC0F818080800020006A0B
+# BIN-NEXT:        Body:            41002580808080002000FC0F808080800020006A0B
 # BIN-NEXT:      - Index:           4
 # BIN-NEXT:        Locals:          []
-# BIN-NEXT:        Body:            200041002583808080002001FC1183808080000B
+# BIN-NEXT:        Body:            200041002582808080002001FC1182808080000B
 
 #      BIN:  - Type:            CUSTOM
 # BIN-NEXT:    Name:            linking
 # BIN-NEXT:    Version:         2
 # BIN-NEXT:    SymbolTable:
 # BIN-NEXT:      - Index:           0
 # BIN-NEXT:        Kind:            TABLE
 # BIN-NEXT:        Name:            foo
 # BIN-NEXT:        Flags:           [ BINDING_LOCAL ]
-# BIN-NEXT:        Table:           1
+# BIN-NEXT:        Table:           0
 # BIN-NEXT:      - Index:           1
 # BIN-NEXT:        Kind:            TABLE
 # BIN-NEXT:        Name:            bar
 # BIN-NEXT:        Flags:           [ BINDING_LOCAL ]
+# BIN-NEXT:        Table:           1
+# BIN-NEXT:      - Index:           2
+# BIN-NEXT:        Kind:            TABLE
+# BIN-NEXT:        Name:            table1
+# BIN-NEXT:        Flags:           [ BINDING_LOCAL ]
 # BIN-NEXT:        Table:           2
+# BIN-NEXT:      - Index:           3
+# BIN-NEXT:        Kind:            TABLE
+# BIN-NEXT:        Name:            table2
+# BIN-NEXT:        Flags:           [ BINDING_LOCAL ]
+# BIN-NEXT:        Table:           3
+# BIN-NEXT:      - Index:           4

llvm/test/MC/WebAssembly/tail-call-encodings.s

foo1:
     # CHECK-NEXT: fixup A - offset: 1, value: bar1, kind: fixup_uleb128_i32
     return_call bar1
 
     end_function
 
 foo2:
     .functype foo2 () -> ()
 
-    # CHECK: return_call_indirect (i32) -> (i32) # encoding: [0x13,
+    # CHECK: return_call_indirect (i32) -> (i32), __indirect_function_table # encoding: [0x13,
     # CHECK-NEXT: fixup A - offset: 1, value: .Ltypeindex0@TYPEINDEX, kind: fixup_uleb128_i32
     return_call_indirect (i32) -> (i32)
 
     end_function

llvm/test/MC/WebAssembly/type-index.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors:
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+unimplemented-simd128,+nontrapping-fptoint,+exception-handling < %s | obj2yaml | FileCheck -check-prefix=BIN %s
 
 # Minimal test for type indices in call_indirect.
 
 test0:
     .functype   test0 (i32) -> (i32)
     call_indirect (f64) -> (f64)
     end_function
 
 # CHECK:  .text
 # CHECK-LABEL: test0:
 # CHECK-NEXT: .functype test0 (i32) -> (i32)
 # CHECK-NEXT: call_indirect (f64) -> (f64)
 # CHECK-NEXT: end_function
 

 # BIN-NEXT:             Initial:         0x00000000
 # BIN-NEXT:   - Type:            FUNCTION
 # BIN-NEXT:     FunctionTypes:   [ 0 ]
 # BIN-NEXT:   - Type:            CODE
 # BIN-NEXT:     Relocations:
 # BIN-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # BIN-NEXT:         Index:           1
 # BIN-NEXT:         Offset:          0x00000004
+# BIN-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
+# BIN-NEXT:         Index:           1
+# BIN-NEXT:         Offset:          0x00000009
 # BIN-NEXT:     Functions:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         Locals:          []
-# BIN-NEXT:         Body:            118180808000000B
+# BIN-NEXT:         Body:            1181808080008080808000000B
 # BIN-NEXT:   - Type:            CUSTOM
 # BIN-NEXT:     Name:            linking
 # BIN-NEXT:     Version:         2
 # BIN-NEXT:     SymbolTable:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         Kind:            FUNCTION
 # BIN-NEXT:         Name:            test0
 # BIN-NEXT:         Flags:           [ BINDING_LOCAL ]
 # BIN-NEXT:         Function:        0
+# BIN-NEXT:       - Index:           1
+# BIN-NEXT:         Kind:            TABLE
+# BIN-NEXT:         Name:            __indirect_function_table
+# BIN-NEXT:         Flags:           [ UNDEFINED ]
+# BIN-NEXT:         Table:           0
 # BIN-NEXT: ...

llvm/test/MC/WebAssembly/wasm64.s

 # BIN-NEXT:     Imports:
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __linear_memory
 # BIN-NEXT:         Kind:            MEMORY
 # BIN-NEXT:         Memory:
 # BIN-NEXT:           Flags:           [ IS_64 ]
 # BIN-NEXT:           Initial:         0x00000001
 # BIN-NEXT:       - Module:          env
-# BIN-NEXT:         Field:           __indirect_function_table
-# BIN-NEXT:         Kind:            TABLE
-# BIN-NEXT:         Table:
-# BIN-NEXT:           Index:           0
-# BIN-NEXT:           ElemType:        FUNCREF
-# BIN-NEXT:           Limits:
-# BIN-NEXT:             Initial:         0x00000000
-# BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           myglob64
 # BIN-NEXT:         Kind:            GLOBAL
 # BIN-NEXT:         GlobalType:      I64
 # BIN-NEXT:         GlobalMutable:   true
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __stack_pointer
 # BIN-NEXT:         Kind:            GLOBAL
 # BIN-NEXT:         GlobalType:      I64

llvm/test/MC/WebAssembly/weak-alias.s

 
 .set bar_alias, bar
   .weak   bar_alias
   .hidden bar_alias
 
 # CHECK:        - Type:            TYPE
 # CHECK-NEXT:     Signatures:
 # CHECK-NEXT:       - Index:           0
-# CHECK-NEXT:         ParamTypes:
+# CHECK-NEXT:         ParamTypes:      []
 # CHECK-NEXT:         ReturnTypes:
 # CHECK-NEXT:           - I32
 # CHECK-NEXT:   - Type:            IMPORT
 # CHECK-NEXT:     Imports:
 # CHECK-NEXT:       - Module:          env
 # CHECK-NEXT:         Field:           __linear_memory
 # CHECK-NEXT:         Kind:            MEMORY
 # CHECK-NEXT:         Memory:

 # CHECK-NEXT:         Index:           3
 # CHECK-NEXT:         Offset:          0x00000012
 # CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
 # CHECK-NEXT:         Index:           5
 # CHECK-NEXT:         Offset:          0x0000001E
 # CHECK-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:         Offset:          0x00000024
+# CHECK-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
+# CHECK-NEXT:         Index:           6
+# CHECK-NEXT:         Offset:          0x00000029
 # CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
-# CHECK-NEXT:         Index:           7
-# CHECK-NEXT:         Offset:          0x00000031
+# CHECK-NEXT:         Index:           8
+# CHECK-NEXT:         Offset:          0x00000036
 # CHECK-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # CHECK-NEXT:         Index:           0
-# CHECK-NEXT:         Offset:          0x00000037
+# CHECK-NEXT:         Offset:          0x0000003C
+# CHECK-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
+# CHECK-NEXT:         Index:           6
+# CHECK-NEXT:         Offset:          0x00000041
 # CHECK-NEXT:     Functions:
 # CHECK-NEXT:       - Index:           0
-# CHECK-NEXT:         Locals:
+# CHECK-NEXT:         Locals:          []
 # CHECK-NEXT:         Body:            41000B
 # CHECK-NEXT:       - Index:           1
-# CHECK-NEXT:         Locals:
+# CHECK-NEXT:         Locals:          []
 # CHECK-NEXT:         Body:            1080808080000B
 # CHECK-NEXT:       - Index:           2
-# CHECK-NEXT:         Locals:
+# CHECK-NEXT:         Locals:          []
 # CHECK-NEXT:         Body:            1080808080000B
 # CHECK-NEXT:       - Index:           3
-# CHECK-NEXT:         Locals:
-# CHECK-NEXT:         Body:            410028028880808000118080808000000B
+# CHECK-NEXT:         Locals:          []
+# CHECK-NEXT:         Body:            4100280288808080001180808080008080808000000B
 # CHECK-NEXT:       - Index:           4
-# CHECK-NEXT:         Locals:
-# CHECK-NEXT:         Body:            410028029080808000118080808000000B
+# CHECK-NEXT:         Locals:          []
+# CHECK-NEXT:         Body:            4100280290808080001180808080008080808000000B
 # CHECK-NEXT:   - Type:            DATA
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:         Offset:          0x00000013
 # CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 # CHECK-NEXT:         Index:           3
 # CHECK-NEXT:         Offset:          0x00000020

 # CHECK-NEXT:         Function:        3
 # CHECK-NEXT:       - Index:           5
 # CHECK-NEXT:         Kind:            DATA
 # CHECK-NEXT:         Name:            direct_address
 # CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT:         Segment:         1
 # CHECK-NEXT:         Size:            4
 # CHECK-NEXT:       - Index:           6
+# CHECK-NEXT:         Kind:            TABLE
+# CHECK-NEXT:         Name:            __indirect_function_table
+# CHECK-NEXT:         Flags:           [ UNDEFINED ]
+# CHECK-NEXT:         Table:           0
+# CHECK-NEXT:       - Index:           7
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Name:            call_alias_ptr
 # CHECK-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
 # CHECK-NEXT:         Function:        4
-# CHECK-NEXT:       - Index:           7
+# CHECK-NEXT:       - Index:           8
 # CHECK-NEXT:         Kind:            DATA
 # CHECK-NEXT:         Name:            alias_address
 # CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT:         Segment:         2
 # CHECK-NEXT:         Size:            4
-# CHECK-NEXT:       - Index:           8
+# CHECK-NEXT:       - Index:           9
 # CHECK-NEXT:         Kind:            DATA
 # CHECK-NEXT:         Name:            bar
 # CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT:         Segment:         0
 # CHECK-NEXT:         Size:            4
-# CHECK-NEXT:       - Index:           9
+# CHECK-NEXT:       - Index:           10
 # CHECK-NEXT:         Kind:            DATA
 # CHECK-NEXT:         Name:            bar_alias
 # CHECK-NEXT:         Flags:           [ BINDING_WEAK, VISIBILITY_HIDDEN, NO_STRIP ]
 # CHECK-NEXT:         Segment:         0
 # CHECK-NEXT:         Size:            4
 # CHECK-NEXT:     SegmentInfo:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Name:            .data.bar
 # CHECK-NEXT:         Alignment:       3
-# CHECK-NEXT:         Flags:           [ ]
+# CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT:       - Index:           1
 # CHECK-NEXT:         Name:            .data.direct_address
 # CHECK-NEXT:         Alignment:       3
-# CHECK-NEXT:         Flags:           [ ]
+# CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT:       - Index:           2
 # CHECK-NEXT:         Name:            .data.alias_address
 # CHECK-NEXT:         Alignment:       3
-# CHECK-NEXT:         Flags:           [ ]
+# CHECK-NEXT:         Flags:           [  ]
 # CHECK-NEXT: ...
 
 # CHECK-SYMS: SYMBOL TABLE:
 # CHECK-SYMS-NEXT: 00000001 g     F CODE  .hidden foo
 # CHECK-SYMS-NEXT: 00000006 g     F CODE  .hidden call_direct
 # CHECK-SYMS-NEXT: 0000000f g     F CODE  .hidden call_alias
 # CHECK-SYMS-NEXT: 00000001 gw    F CODE  .hidden foo_alias
 # CHECK-SYMS-NEXT: 00000018 g     F CODE  .hidden call_direct_ptr
 # CHECK-SYMS-NEXT: 00000008 g     O DATA  direct_address
 # CHECK-SYMS-NEXT: 0000002b g     F CODE  .hidden call_alias_ptr
 # CHECK-SYMS-NEXT: 00000010 g     O DATA  alias_address
 # CHECK-SYMS-NEXT: 00000000 g     O DATA  bar
 # CHECK-SYMS-NEXT: 00000000 gw    O DATA  .hidden bar_alias