[WebAssembly] Add support for table linking to wasm-ld

[wingo]

Summary

This patch adds support to wasm-ld for linking multiple table references together, in a manner similar to wasm globals. The indirect function table is synthesized as needed.

To manage the transitional period in which the compiler doesn't yet produce TABLE_NUMBER relocations and doesn't residualize table symbols, the linker will detect object files which have table imports or definitions, but no table symbols. In that case it will synthesize symbols for the defined and imported tables.

As a change, relocatable objects are now written with table symbols, which can cause symbol renumbering in some of the tests. If no object file requires an indirect function table, none will be written to the file. Note that for legacy ObjFile inputs, this test is conservative: as we don't have relocs for each use of the indirecy function table, we just assume that any incoming indirect function table should be propagated to the output.

[wingo]

Marking as revisions planned, as it's still a wip. LLD tests not passing yet. Just a savepoint before the weekend ~~

[wingo]

Finish implementation, update tests

[wingo]

Update summary

[wingo]

• Remove unused InputTable "synthetic" flag

[wingo]

Rebase

[wingo]

Rebase

[wingo]

Fix a couple missing / bogus places where TABLE_NUMBER relocs were incorrectly handled in the linker

[wingo]

I will assume that all of the clang-tidy feedback is valid and will adjust accordingly. Otherwise I think this is ready for review @sbc100. If it is too big, I think there may be small pieces I can split off, or it could just make sense as-is.

[sbc100]

Maybe there are two logical parts we can separate here:

1. Support for first class tables in input files

2. Support for the special __indirect_function_table

I guess they are somewhat intertwined by I can imagine landing (1) without changing the way we handle the special table 0. Maybe its not worth the work to split up?

lld/wasm/Driver.cpp

803

We use a slightly different naming convention in lld.

I think the plan is to transition all of llvm eventually to this style and we are trying it out. So locals and parameters start with lowercase, but are otherwise camelcase.

lld/wasm/InputFiles.cpp

490

Could we make this separate function just to split it up?

How about:

if (!haveTableSymbol)
  synthesizeTableSymbols();

lld/wasm/SymbolTable.h

110

The other globally-known symbols are kept in Symbols.h:WasmSym .. seems like maybe this should go there too?

lld/wasm/Symbols.cpp

19

Why this new include?

[sbc100]

lld/wasm/SyntheticSections.h

369

This looks unused.

lld/wasm/Writer.cpp

787

This last seems a little out of place since its not assigning indexes. Would this make more sense alongside wherever out.elemSec is populated once we know its complete?

[sbc100]

lld/wasm/SyntheticSections.h

156

How is (2) handled after this change?

Imagine a program that contains just this code:

EXPORT_OR_OTHERWISE_KEEP_ALIVE
 void call_func(func_ptr f) {
    f()
}

Now we a call_indirect instruction but no TABLE_INDEX relocations.

In fact we have no relocations at all, but the resulting program needs to have a table in order to validate.

I guess once you move to new relocation model to call_indirect this program *will* have a TABLE_NUMBER relocation. But we need to support the case where this code was compiled with the old model too.

The change to lld/test/wasm/stack-pointer.ll looks a little suspicious because it removes the table from the object file which would potentially make it fail to validate.

[wingo]

lld/wasm/SyntheticSections.h

156

Humm this is a head-scratcher! I think https://reviews.llvm.org/D91637 may have introduced a bad state.

Backing up -- The intention with the change here is that any object file that needs an indirect function table should either

• have a TABLE_NUMBER reloc against the table ("new" object file with call_indirect)
• have the table marked as no-strip ("new" object file, caused by assembler recording a TABLE_INDEX reloc)
• or, if the incoming object file is "old" (has table import or definition but no table symbols), then those tables are treated as having no-strip symbols.

For new files, this works fine. For very old files, also fine -- they always have an __indirect_function_table import. But since https://reviews.llvm.org/D91637, there can be object files which refer to __indirect_function_table via call_indirect, but which don't have TABLE_INDEX relocs. In that case the object file will lack the __indirect_function_table import.

The problem is mitigated in that if any other linker input imports __indirect_function_table, then the result is an output file that validates.

[wingo]

New patch addresses micro-feedback, but still thinking if a patch split is possible. Probably also want to land a precursor also to ensure that the compiler produces __indirect_function_table imports for object files with call_indirect but no TABLE_INDEX relocs.

lld/wasm/Symbols.cpp

19

We can't fit a WasmTableType in a TableSymbol without growing the symbol size, so instead TableSymbol has a WasmTableType*, with the precondition that the symbol's lifespan is a subset of the WasmTableType's lifespan.

But in TableSymbol::setLimits, we can't just fiddle the limits in place, because they are embedded in a WasmTableType that doesn't belong to the symbol; we need to allocate a fresh table type in the arena. So Memory.h allow us to allocate a new WasmTableType using make<>.

Did I get the memory management right? Feedback very welcome.

lld/wasm/Writer.cpp

787

Sure. I tried initially putting it in TableSection::finalizeContents but of course this symbol might be imported, so I instead arranged to call it just after populating elemSec.

[wingo]

Address feedback

[wingo]

lld/wasm/SyntheticSections.h

156

Fixed via https://reviews.llvm.org/D92840.

[wingo]

Rebase

[wingo]

In D91870#2426358, @sbc100 wrote:

Maybe there are two logical parts we can separate here:

1. Support for first class tables in input files

2. Support for the special __indirect_function_table

I guess they are somewhat intertwined by I can imagine landing (1) without changing the way we handle the special table 0. Maybe its not worth the work to split up?

For what it is worth, this was the first tack that I took, but I couldn't find a useful intermediate point where we still had consistent files. Simple things like whether __indirect_function_table is imported, exported, or neither end up propagating into special cases all over the place -- at least that was my conclusion at the time and I think it might still hold. It seemed cleaner to me to make something more conventional using symbols and relocs like everything else in the linker, and then adapt the current input files to that newer more conventional machinery. Dunno. WDYT?

[wingo]

Rebase

[wingo]

Will split this one.

[wingo]

Split from D94075

[wingo]

Rebase to include synthetic tables

[wingo]

I think this one is ready for review @sbc100, when you have a moment :)

[sbc100]

Nice. I like that we were able to delete almost as much code as was added here.

Just a few more comments but mostly lgtm.

lld/wasm/Driver.cpp

803

provide seems like a slightly odd verb. (Or is it just me?) How about calling this createIndirectFunctionTable or defineIndirectFunctionTable?

Or maybe creatDefinedIndirectFunctionTable to match the function below?

817

I don't think it ever make sense to pass StringRef by reference does it?

834

I guess this is existing behaviour. However I wonder if it would be better (in the future) to have --import-table and --export-table only effect the table if exists?

835

Can you just use functionTableName directly below rather than adding this local?

lld/wasm/InputFiles.cpp

311

Could you add a comment about the purpose of this function either in the header or here. IIUC this can be removed if ever drop support for older objects files, is that right?

312

Hoa

321

In other places we use saver which is StringSaver defined in lld/include/lld/Common/Memory.h

439

Ah.. I see you added a comment here rather than in the definition. Seems reasonable.

lld/wasm/SymbolTable.h

108

IIUC this is only need to support legacy object files? Perhaps add a TODO or a note here that to that effect?

lld/wasm/Writer.cpp

742

Can/should we call this after scanRelocations in the caller?

There are many other things that need to happen only after relocations are scanned. I don't see why this one should inlined, unless I'm missing something?

[wingo]

Address feedback

lld/wasm/Driver.cpp

817

Good point :)

834

Good question. Is it reasonable to make the rest of the toolchain inspect the output module to see if it actually needed a table? My initial thought was "well they asked for it, let's give them what they expect" but perhaps this is not the right thing.

lld/wasm/InputFiles.cpp

311

Good point! And yes it could be dropped in some future.

312

What does this mean? :)

321

Good tip, thanks. Though, I think the comment was actually erroneous; shouldn't the name be just (e.g.) "__indirect_function_table" ?

439

The updated patch includes a comment both places; lmk if i should remove one / change something / etc.

lld/wasm/SymbolTable.h

108

I think not, actually -- before, there was some custom logic to reify an __indirect_function_table as part of the writer. Now, for all files, if an indirect function table definition is needed, it will be made with respect to a synthesized InputTable. So this vector will only ever have 1 or 0 elements.

lld/wasm/Writer.cpp

742

Sure, no prob.

[sbc100]

Would you mind formatting the commit message to wrap at 80 chars? I know llvm commits are bit all over the place on the style used but I find wrapped commit message easier to read myself.

[wingo]

Thanks for the review!

In D91870#2498403, @sbc100 wrote:

Would you mind formatting the commit message to wrap at 80 chars? I know llvm commits are bit all over the place on the style used but I find wrapped commit message easier to read myself.

Yeah no problem -- actually the local commit message is wrapped, I just unwrapped it for phab. Incidentally I find it weird that we can land patches from local commits where the message doesn't have to correspond with what was in phab!

[dschuff]

This seems to have a bug that we discovered on the emscripten builders where it's exporting the table twice.
The output (from wasm-objdump):

Export[14]:
 - memory[0] -> "memory"
 - table[0] -> "__indirect_function_table"
 - func[3] <__wasm_call_ctors> -> "__wasm_call_ctors"
 - func[5] <main> -> "main"
 - table[0] -> "__indirect_function_table"
 - func[6] <stackSave> -> "stackSave"
 - func[7] <stackRestore> -> "stackRestore"
 - func[8] <stackAlloc> -> "stackAlloc"
 - func[9] <emscripten_stack_init> -> "emscripten_stack_init"
 - func[10] <emscripten_stack_get_free> -> "emscripten_stack_get_free"
 - func[11] <emscripten_stack_get_end> -> "emscripten_stack_get_end"
 - func[12] <saveSetjmp> -> "saveSetjmp"
 - func[13] <testSetjmp> -> "testSetjmp"
 - func[14] <setThrew> -> "setThrew"

I'll see if I can find a more useful reproducer

[dschuff]

it's funny, since this CL doesn't really modify the export behavior.
I'm going to go ahead and revert it though ("revert first and ask questions later" being the usual LLVM practice), until we can figure out what's happening.

[wingo]

Thanks for the sherriffing, I'll get on it :)

[wingo]

Reopening, as that will let the diff to the previously landed patch be legible; lmk if you prefer a new rev.

[wingo]

Fix double-export of __indirect_function_table

[wingo]

PTAL @sbc100 -- the problem was that I had neglected to remove some special logic regarding export of the indirect function table. Instead it's now handled in the usual way, as a flag on the symbol.

Added a test that succeeds either way with the current patch, but which starts failing once MC writes table symbols in https://reviews.llvm.org/D92215 with the older version of this patch.

Tested llvm-lit on MC, CodeGen, and LLD with this change with the whole patch series, and all pass.

[sbc100]

Thanks andy! Still lgtm.

I think re-using the same review makes sense (although I don't know the conventions/rules are around that).

lld/test/wasm/export-table-test-2.test

1 ↗

(On Diff #317287)

Can we come up with a better name for this new test? I don't have any great idea but just calling it "-test-2" doesn't seem useful.

How about export-table-explicit.test? Since this test includes and explicit declaration of the __indirect_function_table?

[wingo]

Rename new test to export-table-explicit.test

[wingo]

lld/test/wasm/export-table-test-2.test

1 ↗

(On Diff #317287)

Good idea; done :)

[sbc100]

It looks like this change once again broke some emscripten tests. This time it made it past our auto-rollers because they run the tests in questions.

The only real issue looks like a crash:

https://app.circleci.com/pipelines/github/emscripten-core/emscripten/10572/workflows/c3d06117-e1a6-4c55-95b0-80333209ad10

See the browsers tests log:

https://circleci.com/api/v1.1/project/github/emscripten-core/emscripten/388624/output/107/0?file=true&allocation-id=6006f0022f4f9c06d96ced0d-0-build%2F7C3546A8

/tmp/emscripten_test_browser_ixzsc8j6/building/glbook/Chapter_2/Hello_Triangle/CH02_HelloTriangle.o
wasm-ld: /b/s/w/ir/cache/builder/emscripten-releases/llvm-project/lld/wasm/SymbolTable.cpp:278: lld::wasm::DefinedTable *lld::wasm::SymbolTable::addSyntheticTable(llvm::StringRef, uint32_t, lld::wasm::InputTable *): Assertion `!s || s->isUndefined()' failed.
PLEASE submit a bug report to https://bugs.llvm.org/ and include the crash backtrace.
Stack dump:
0.	Program arguments: /root/emsdk/upstream/bin/wasm-ld -o test.wasm /tmp/emscripten_test_browser_ixzsc8j6/building/glbook/Chapter_2/Hello_Triangle/CH02_HelloTriangle.o /tmp/emscripten_temp_eu76mn7s/report_result_0.o -L/root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libc.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libcompiler_rt.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libc++-noexcept.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libc++abi-noexcept.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libdlmalloc.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libc_rt_wasm.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libsockets.a -mllvm -combiner-global-alias-analysis=false -mllvm -enable-emscripten-sjlj -mllvm -disable-lsr --allow-undefined --strip-debug --export-table --export main --export emscripten_stack_get_end --export emscripten_stack_get_free --export emscripten_stack_init --export stackSave --export stackRestore --export stackAlloc --export __wasm_call_ctors --export fflush --export __errno_location -z stack-size=5242880 --initial-memory=16777216 --no-entry --max-memory=16777216 --global-base=1024
 #0 0x00007f93c0d537f3 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/root/emsdk/upstream/bin/../lib/libLLVM-12git.so+0x84f7f3)
 #1 0x00007f93c0d5153e llvm::sys::RunSignalHandlers() (/root/emsdk/upstream/bin/../lib/libLLVM-12git.so+0x84d53e)
 #2 0x00007f93c0d53cbf SignalHandler(int) (/root/emsdk/upstream/bin/../lib/libLLVM-12git.so+0x84fcbf)
 #3 0x00007f93c43a6890 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x12890)
 #4 0x00007f93bfb9be97 raise (/lib/x86_64-linux-gnu/libc.so.6+0x3ee97)
 #5 0x00007f93bfb9d801 abort (/lib/x86_64-linux-gnu/libc.so.6+0x40801)
 #6 0x00007f93bfb8d39a (/lib/x86_64-linux-gnu/libc.so.6+0x3039a)
 #7 0x00007f93bfb8d412 (/lib/x86_64-linux-gnu/libc.so.6+0x30412)
 #8 0x00000000007caba2 (/root/emsdk/upstream/bin/wasm-ld+0x7caba2)
 #9 0x00000000007b43f3 lld::wasm::(anonymous namespace)::LinkerDriver::linkerMain(llvm::ArrayRef<char const*>) (/root/emsdk/upstream/bin/wasm-ld+0x7b43f3)
#10 0x00000000007ad836 lld::wasm::link(llvm::ArrayRef<char const*>, bool, llvm::raw_ostream&, llvm::raw_ostream&) (/root/emsdk/upstream/bin/wasm-ld+0x7ad836)
#11 0x000000000048df76 lldMain(int, char const**, llvm::raw_ostream&, llvm::raw_ostream&, bool) (/root/emsdk/upstream/bin/wasm-ld+0x48df76)
#12 0x000000000048db00 main (/root/emsdk/upstream/bin/wasm-ld+0x48db00)
#13 0x00007f93bfb7eb97 __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x21b97)
#14 0x000000000048d7da _start (/root/emsdk/upstream/bin/wasm-ld+0x48d7da)
emcc: error: '/root/emsdk/upstream/bin/wasm-ld -o test.wasm /tmp/emscripten_test_browser_ixzsc8j6/building/glbook/Chapter_2/Hello_Triangle/CH02_HelloTriangle.o /tmp/emscripten_temp_eu76mn7s/report_result_0.o -L/root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libc.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libcompiler_rt.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libc++-noexcept.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libc++abi-noexcept.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libdlmalloc.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libc_rt_wasm.a /root/emsdk/upstream/emscripten/cache/sysroot/lib/wasm32-emscripten/libsockets.a -mllvm -combiner-global-alias-analysis=false -mllvm -enable-emscripten-sjlj -mllvm -disable-lsr --allow-undefined --strip-debug --export-table --export main --export emscripten_stack_get_end --export emscripten_stack_get_free --export emscripten_stack_init --export stackSave --export stackRestore --export stackAlloc --export __wasm_call_ctors --export fflush --export __errno_location -z stack-size=5242880 --initial-memory=16777216 --no-entry --max-memory=16777216 --global-base=1024' failed (-6)

I'm pretty sure thse test uses partial linking (wasm-ld -r) so I guess that is the problem. We are probably generating the __indirect_function_table in the relocatable case when we should no be. It should only be the final link to an executable that generates it, right?

[wingo]

Sadly I need to run out but can look again early in the morning. I am not sure how relocatable results should work; if the intention is that they need to pass a subsequent final link pass, then I think it's reasonable to want the indirect function table to only be built by the final link, and not in the--relocatable case. Feel very free to back out patches as necessary.

[wingo]

I see the bug was fixed in https://reviews.llvm.org/D94993. That patch LGTM, fwiw. Thank you!

lld/include/lld/Common/LLVM.h

 } // namespace object
 
 namespace wasm {
 struct WasmEvent;
 struct WasmEventType;
 struct WasmFunction;
 struct WasmGlobal;
 struct WasmGlobalType;
+struct WasmLimits;
 struct WasmRelocation;
 struct WasmSignature;
+struct WasmTable;
+struct WasmTableType;
 } // namespace wasm
 } // namespace llvm
 
 namespace lld {
 llvm::raw_ostream &outs();
 llvm::raw_ostream &errs();
 
 // Casting operators.

 using llvm::object::WasmSection;
 using llvm::object::WasmSegment;
 using llvm::object::WasmSymbol;
 using llvm::wasm::WasmEvent;
 using llvm::wasm::WasmEventType;
 using llvm::wasm::WasmFunction;
 using llvm::wasm::WasmGlobal;
 using llvm::wasm::WasmGlobalType;
+using llvm::wasm::WasmLimits;
 using llvm::wasm::WasmRelocation;
 using llvm::wasm::WasmSignature;
+using llvm::wasm::WasmTable;
+using llvm::wasm::WasmTableType;
 } // end namespace lld.
 
 namespace std {
 template <> struct hash<llvm::StringRef> {
 public:
   size_t operator()(const llvm::StringRef &s) const {
     return llvm::hash_value(s);
   }
 };
 } // namespace std
 
 #endif

lld/test/wasm/alias.s

 # CHECK-NEXT: Sections:
 # CHECK-NEXT:   - Type:            TYPE
 # CHECK-NEXT:     Signatures:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         ParamTypes:
 # CHECK-NEXT:         ReturnTypes:     []
 # CHECK-NEXT:   - Type:            FUNCTION
 # CHECK-NEXT:     FunctionTypes:   [ 0 ]
-# CHECK-NEXT:   - Type:            TABLE
-# CHECK-NEXT:     Tables:
-# CHECK-NEXT:       - Index:           0
-# CHECK-NEXT:         ElemType:        FUNCREF
-# CHECK-NEXT:         Limits:
-# CHECK-NEXT:           Flags:           [ HAS_MAX ]
-# CHECK-NEXT:           Initial:         0x1
-# CHECK-NEXT:           Maximum:         0x1
 # CHECK-NEXT:   - Type:            MEMORY
 # CHECK-NEXT:     Memories:
 # CHECK-NEXT:       - Initial:         0x2
 # CHECK-NEXT:   - Type:            GLOBAL
 # CHECK-NEXT:     Globals:
 # CHECK-NEXT:       - Index:           0
 # CHECK-NEXT:         Type:            I32
 # CHECK-NEXT:         Mutable:         true

lld/test/wasm/init-fini.ll

 
 ; RUN: wasm-ld -r %t.o %t.global-ctor-dtor.o -o %t.reloc.wasm
 ; RUN: llvm-readobj --symbols --sections %t.reloc.wasm | FileCheck -check-prefix=RELOC %s
 
 ; RELOC:       Name: linking
 ; RELOC-NEXT:  InitFunctions [
 ; RELOC-NEXT:    0 (priority=101)
 ; RELOC-NEXT:    1 (priority=101)
-; RELOC-NEXT:    14 (priority=101)
-; RELOC-NEXT:    10 (priority=101)
-; RELOC-NEXT:    20 (priority=101)
-; RELOC-NEXT:    10 (priority=202)
-; RELOC-NEXT:    22 (priority=202)
+; RELOC-NEXT:    15 (priority=101)
+; RELOC-NEXT:    11 (priority=101)
+; RELOC-NEXT:    21 (priority=101)
+; RELOC-NEXT:    11 (priority=202)
+; RELOC-NEXT:    23 (priority=202)
 ; RELOC-NEXT:    0 (priority=1001)
-; RELOC-NEXT:    16 (priority=1001)
-; RELOC-NEXT:    10 (priority=2002)
-; RELOC-NEXT:    24 (priority=2002)
+; RELOC-NEXT:    17 (priority=1001)
+; RELOC-NEXT:    11 (priority=2002)
+; RELOC-NEXT:    25 (priority=2002)
 ; RELOC-NEXT:    9 (priority=4000)
-; RELOC-NEXT:    18 (priority=4000)
+; RELOC-NEXT:    19 (priority=4000)
 ; RELOC-NEXT:  ]

lld/test/wasm/local-symbols.ll

 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:         ReturnTypes:
 ; CHECK-NEXT:           - I32
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         ParamTypes:
 ; CHECK-NEXT:         ReturnTypes:     []
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1 ]
-; CHECK-NEXT:   - Type:            TABLE
-; CHECK-NEXT:     Tables:
-; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         ElemType:        FUNCREF
-; CHECK-NEXT:         Limits:
-; CHECK-NEXT:           Flags:           [ HAS_MAX ]
-; CHECK-NEXT:           Initial:         0x1
-; CHECK-NEXT:           Maximum:         0x1
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x2
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Type:            I32
 ; CHECK-NEXT:         Mutable:         true

lld/test/wasm/locals-duplicate.test

 ; RELOC-NEXT:     Segments:
 ; RELOC-NEXT:       - Offset:
 ; RELOC-NEXT:           Opcode:          I32_CONST
 ; RELOC-NEXT:           Value:           1
 ; RELOC-NEXT:         Functions:       [ 0, 1, 2, 9, 10, 11 ]
 ; RELOC-NEXT:   - Type:            CODE
 ; RELOC-NEXT:     Relocations:
 ; RELOC-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           18
+; RELOC-NEXT:         Index:           19
 ; RELOC-NEXT:         Offset:          0x13
 ; RELOC-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
 ; RELOC-NEXT:         Index:           3
 ; RELOC-NEXT:         Offset:          0x1C
 ; RELOC-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           19
+; RELOC-NEXT:         Index:           20
 ; RELOC-NEXT:         Offset:          0x25
 ; RELOC-NEXT:       - Type:            R_WASM_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           16
+; RELOC-NEXT:         Index:           17
 ; RELOC-NEXT:         Offset:          0x2E
 ; RELOC-NEXT:       - Type:            R_WASM_TABLE_INDEX_SLEB
 ; RELOC-NEXT:         Index:           0
 ; RELOC-NEXT:         Offset:          0x37
 ; RELOC-NEXT:       - Type:            R_WASM_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           17
+; RELOC-NEXT:         Index:           18
 ; RELOC-NEXT:         Offset:          0x40
 ; RELOC-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           10
+; RELOC-NEXT:         Index:           11
 ; RELOC-NEXT:         Offset:          0x58
 ; RELOC-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           22
+; RELOC-NEXT:         Index:           23
 ; RELOC-NEXT:         Offset:          0x61
 ; RELOC-NEXT:       - Type:            R_WASM_MEMORY_ADDR_SLEB
-; RELOC-NEXT:         Index:           23
+; RELOC-NEXT:         Index:           24
 ; RELOC-NEXT:         Offset:          0x6A
 ; RELOC-NEXT:       - Type:            R_WASM_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           8
+; RELOC-NEXT:         Index:           9
 ; RELOC-NEXT:         Offset:          0x73
 ; RELOC-NEXT:       - Type:            R_WASM_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           20
+; RELOC-NEXT:         Index:           21
 ; RELOC-NEXT:         Offset:          0x7C
 ; RELOC-NEXT:       - Type:            R_WASM_TABLE_INDEX_SLEB
-; RELOC-NEXT:         Index:           21
+; RELOC-NEXT:         Index:           22
 ; RELOC-NEXT:         Offset:          0x85
 ; RELOC-NEXT:     Functions:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Locals:
 ; RELOC-NEXT:         Body:            41020B

 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        7
 ; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func3A
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        8
 ; RELOC-NEXT:       - Index:           8
+; RELOC-NEXT:         Kind:            TABLE
+; RELOC-NEXT:         Name:            __indirect_function_table
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         Table:           0
+; RELOC-NEXT:       - Index:           9
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            colliding_func1
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        9
-; RELOC-NEXT:       - Index:           9
+; RELOC-NEXT:       - Index:           10
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global1B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        12
-; RELOC-NEXT:       - Index:           10
+; RELOC-NEXT:       - Index:           11
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            colliding_global1
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Segment:         0
 ; RELOC-NEXT:         Offset:          4
 ; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           11
+; RELOC-NEXT:       - Index:           12
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global2B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        13
-; RELOC-NEXT:       - Index:           12
+; RELOC-NEXT:       - Index:           13
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_global3B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        14
-; RELOC-NEXT:       - Index:           13
+; RELOC-NEXT:       - Index:           14
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func1B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        15
-; RELOC-NEXT:       - Index:           14
+; RELOC-NEXT:       - Index:           15
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func2B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        16
-; RELOC-NEXT:       - Index:           15
+; RELOC-NEXT:       - Index:           16
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            get_func3B
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        17
-; RELOC-NEXT:       - Index:           16
+; RELOC-NEXT:       - Index:           17
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            colliding_func1
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        0
-; RELOC-NEXT:       - Index:           17
+; RELOC-NEXT:       - Index:           18
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            colliding_func3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        2
-; RELOC-NEXT:       - Index:           18
+; RELOC-NEXT:       - Index:           19
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            colliding_global1
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Segment:         0
 ; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           19
+; RELOC-NEXT:       - Index:           20
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            colliding_global3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Segment:         2
 ; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           20
+; RELOC-NEXT:       - Index:           21
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            colliding_func2
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        10
-; RELOC-NEXT:       - Index:           21
+; RELOC-NEXT:       - Index:           22
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            colliding_func3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        11
-; RELOC-NEXT:       - Index:           22
+; RELOC-NEXT:       - Index:           23
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            colliding_global2
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Segment:         1
 ; RELOC-NEXT:         Offset:          4
 ; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           23
+; RELOC-NEXT:       - Index:           24
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            colliding_global3
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Segment:         2
 ; RELOC-NEXT:         Offset:          4
 ; RELOC-NEXT:         Size:            4
 ; RELOC-NEXT:     SegmentInfo:
 ; RELOC-NEXT:       - Index:           0

lld/test/wasm/pie.ll

 ; CHECK-NEXT:     MemoryAlignment: 2
 ; CHECK-NEXT:     TableSize:       1
 ; CHECK-NEXT:     TableAlignment:  0
 ; CHECK-NEXT:     Needed:          []
 
 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; 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:         0x1
-; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __stack_pointer
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __memory_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __table_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
+; 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:         0x1
 
 

lld/test/wasm/section-symbol-relocs.yaml

 # RELOC-NEXT:         Offset:          0xB
 # RELOC-NEXT:         Addend:          3
 # RELOC-NEXT:    Name:            green
 #
 # RELOC:        SymbolTable:
 # RELOC-NEXT:     - Index:           0
 # RELOC-NEXT:       Kind:            SECTION
 # RELOC-NEXT:       Flags:           [ BINDING_LOCAL ]
-# RELOC-NEXT:       Section:         2
+# RELOC-NEXT:       Section:         1
 # RELOC-NEXT:     - Index:           1
 # RELOC-NEXT:       Kind:            SECTION
 # RELOC-NEXT:       Flags:           [ BINDING_LOCAL ]
-# RELOC-NEXT:       Section:         3
+# RELOC-NEXT:       Section:         2

lld/test/wasm/shared.ll

 ; CHECK:        - Type:            IMPORT
 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Memory:
 ; CHECK-NEXT:           Initial:       0x0
 ; 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:         0x2
-; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __stack_pointer
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __memory_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __table_base
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   false
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           func_external
 ; 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:         0x2
 ; CHECK-NEXT:       - Module:          GOT.mem
 ; CHECK-NEXT:         Field:           indirect_func
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:       - Module:          GOT.func
 ; CHECK-NEXT:         Field:           func_external
 ; CHECK-NEXT:         Kind:            GLOBAL

lld/test/wasm/signature-mismatch.ll

 ; RELOC-NEXT:         Function:        2
 ; RELOC-NEXT:       - Index:           2
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            ret32_address_main
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Segment:         0
 ; RELOC-NEXT:         Size:            4
 ; RELOC-NEXT:       - Index:           3
+; RELOC-NEXT:         Kind:            TABLE
+; RELOC-NEXT:         Name:            __indirect_function_table
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         Table:           0
+; RELOC-NEXT:       - Index:           4
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            call_ret32
 ; RELOC-NEXT:         Flags:           [ ]
 ; RELOC-NEXT:         Function:        3
-; RELOC-NEXT:       - Index:           4
+; RELOC-NEXT:       - Index:           5
 ; RELOC-NEXT:         Kind:            DATA
 ; RELOC-NEXT:         Name:            ret32_address
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Segment:         1
 ; RELOC-NEXT:         Size:            4
-; RELOC-NEXT:       - Index:           5
+; RELOC-NEXT:       - Index:           6
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            'signature_mismatch:ret32'
 ; RELOC-NEXT:         Flags:           [ BINDING_LOCAL ]
 ; RELOC-NEXT:         Function:        0

lld/test/wasm/stack-pointer.ll

 ; CHECK-NEXT:     Imports:
 ; CHECK-NEXT:       - Module:          env
 ; CHECK-NEXT:         Field:           __stack_pointer
 ; CHECK-NEXT:         Kind:            GLOBAL
 ; CHECK-NEXT:         GlobalType:      I32
 ; CHECK-NEXT:         GlobalMutable:   true
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0 ]
-; CHECK-NEXT:   - Type:            TABLE
-; CHECK-NEXT:     Tables:
-; CHECK-NEXT:       - Index:           0
-; CHECK-NEXT:         ElemType:        FUNCREF
-; CHECK-NEXT:         Limits:
-; CHECK-NEXT:           Flags:           [ HAS_MAX ]
-; CHECK-NEXT:           Initial:         0x1
-; CHECK-NEXT:           Maximum:         0x1
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:
 ; CHECK-NEXT:       - Initial:         0x0
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Relocations:
 ; CHECK-NEXT:       - Type:            R_WASM_GLOBAL_INDEX_LEB
 ; CHECK-NEXT:         Index:           1
 ; CHECK-NEXT:         Offset:          0x4

lld/test/wasm/weak-alias.ll

 ; RELOC-NEXT:         Name:            __stack_pointer
 ; RELOC-NEXT:         Flags:           [ UNDEFINED ]
 ; RELOC-NEXT:         Global:          0
 ; RELOC-NEXT:       - Index:           7
 ; RELOC-NEXT:         Kind:            FUNCTION
 ; RELOC-NEXT:         Name:            call_direct_ptr
 ; RELOC-NEXT:         Flags:           [  ]
 ; RELOC-NEXT:         Function:        5
+; RELOC-NEXT:       - Index:           8
+; RELOC-NEXT:         Kind:            TABLE
+; RELOC-NEXT:         Name:            __indirect_function_table
+; RELOC-NEXT:         Flags:           [ VISIBILITY_HIDDEN ]
+; RELOC-NEXT:         Table:           0
 ; RELOC-NEXT:   - Type:            CUSTOM
 ; RELOC-NEXT:     Name:            name
 ; RELOC-NEXT:     FunctionNames:
 ; RELOC-NEXT:       - Index:           0
 ; RELOC-NEXT:         Name:            _start
 ; RELOC-NEXT:       - Index:           1
 ; RELOC-NEXT:         Name:            direct_fn
 ; RELOC-NEXT:       - Index:           2

lld/wasm/Driver.cpp

 //===- Driver.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lld/Common/Driver.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputGlobal.h"
+#include "InputTable.h"
 #include "MarkLive.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "lld/Common/Args.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Filesystem.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
for (size_t i = 0, e = syms.size(); i != e; ++i)
         syms[i] = s;
   });
 
   // Update pointers in the symbol table.
   for (const WrappedSymbol &w : wrapped)
     symtab->wrap(w.sym, w.real, w.wrap);
 }
 
+static TableSymbol *provideIndirectFunctionTable(const StringRef &Name) {
+  const uint32_t InvalidIndex = -1;
+  WasmLimits limits{0, 0, 0}; // Set by the writer.
+  WasmTableType type{uint8_t(ValType::FUNCREF), limits};
+  WasmTable desc{InvalidIndex, type, Name};
+  InputTable *table = make<InputTable>(desc, nullptr);
+  uint32_t flags = config->exportTable ? 0 : WASM_SYMBOL_VISIBILITY_HIDDEN;
+  TableSymbol *sym = symtab->addSyntheticTable(Name, flags, table);
+  sym->markLive();
+  sym->forceExport = config->exportTable;
+  return sym;
+}
+
+static TableSymbol *
+createUndefinedIndirectFunctionTable(const StringRef &Name) {
+  WasmLimits limits{0, 0, 0}; // Set by the writer.
+  WasmTableType *type = make<WasmTableType>();
+  type->ElemType = uint8_t(ValType::FUNCREF);
+  type->Limits = limits;
+  StringRef module(defaultModule);
+  uint32_t flags = config->exportTable ? 0 : WASM_SYMBOL_VISIBILITY_HIDDEN;
+  flags |= WASM_SYMBOL_UNDEFINED;
+  Symbol *sym =
+      symtab->addUndefinedTable(Name, Name, module, flags, nullptr, type);
+  sym->markLive();
+  sym->forceExport = config->exportTable;
+  return cast<TableSymbol>(sym);
+}
+
+static TableSymbol *resolveIndirectFunctionTable() {
+  // Even though we may not need a table, if the user explicitly specified
+  // --import-table or --export-table, ensure a table is residualized.
+  const StringRef Name(functionTableName);
+  if (config->importTable)
+    return createUndefinedIndirectFunctionTable(Name);
+  if (config->exportTable)
+    return provideIndirectFunctionTable(Name);
+
+  // Otherwise, check to the symtab to find the indirect function table.
+  if (Symbol *sym = symtab->find(Name)) {
+    if (sym->isLive()) {
+      if (auto *t = dyn_cast<TableSymbol>(sym)) {
+        return t->isDefined() ? t : provideIndirectFunctionTable(Name);
+      }
+    }
+  }
+
+  // An indirect function table will only be present in the symbol table if
+  // needed by a reloc; if we get here, we don't need one.
+  return nullptr;
+}
+
 void LinkerDriver::link(ArrayRef<const char *> argsArr) {
   WasmOptTable parser;
   opt::InputArgList args = parser.parse(argsArr.slice(1));
 
   // Handle --help
   if (args.hasArg(OPT_help)) {
     parser.PrintHelp(lld::outs(),
                      (std::string(argsArr[0]) + " [options] file...").c_str(),
if (entrySym)
     entrySym->setHidden(false);
 
   if (errorCount())
     return;
 
   // Do size optimizations: garbage collection
   markLive();
 
+  // Provide the indirect funciton table if needed.
+  symtab->indirectFunctionTableSymbol = resolveIndirectFunctionTable();
+
+  if (errorCount())
+    return;
+
   // Write the result to the file.
   writeResult();
 }
 
 } // namespace wasm
 } // namespace lld

lld/wasm/InputChunks.cpp

for (const WasmRelocation &rel : relocations) {
     auto offset = rel.Offset - getInputSectionOffset();
     const uint8_t *loc = data().data() + offset;
     switch (rel.Type) {
     case R_WASM_TYPE_INDEX_LEB:
     case R_WASM_FUNCTION_INDEX_LEB:
     case R_WASM_GLOBAL_INDEX_LEB:
     case R_WASM_EVENT_INDEX_LEB:
     case R_WASM_MEMORY_ADDR_LEB:
+    case R_WASM_TABLE_NUMBER_LEB:
       existingValue = decodeULEB128(loc, &bytesRead);
       break;
     case R_WASM_MEMORY_ADDR_LEB64:
       existingValue = decodeULEB128(loc, &bytesRead);
       paddedLEBWidth = 10;
       break;
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
LLVM_DEBUG(dbgs() << " addend=" << rel.Addend << " index=" << rel.Index
                       << "\n");
 
     switch (rel.Type) {
     case R_WASM_TYPE_INDEX_LEB:
     case R_WASM_FUNCTION_INDEX_LEB:
     case R_WASM_GLOBAL_INDEX_LEB:
     case R_WASM_EVENT_INDEX_LEB:
     case R_WASM_MEMORY_ADDR_LEB:
+    case R_WASM_TABLE_NUMBER_LEB:
       encodeULEB128(value, loc, 5);
       break;
     case R_WASM_MEMORY_ADDR_LEB64:
       encodeULEB128(value, loc, 10);
       break;
     case R_WASM_TABLE_INDEX_SLEB:
     case R_WASM_TABLE_INDEX_REL_SLEB:
     case R_WASM_MEMORY_ADDR_SLEB:
static unsigned writeCompressedReloc(uint8_t *buf, const WasmRelocation &rel,
                                      uint64_t value) {
   switch (rel.Type) {
   case R_WASM_TYPE_INDEX_LEB:
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_EVENT_INDEX_LEB:
   case R_WASM_MEMORY_ADDR_LEB:
   case R_WASM_MEMORY_ADDR_LEB64:
+  case R_WASM_TABLE_NUMBER_LEB:
     return encodeULEB128(value, buf);
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_TABLE_INDEX_SLEB64:
   case R_WASM_MEMORY_ADDR_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB64:
     return encodeSLEB128(static_cast<int64_t>(value), buf);
   default:
     llvm_unreachable("unexpected relocation type");
   }
 }
 
 static unsigned getRelocWidthPadded(const WasmRelocation &rel) {
   switch (rel.Type) {
   case R_WASM_TYPE_INDEX_LEB:
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_EVENT_INDEX_LEB:
   case R_WASM_MEMORY_ADDR_LEB:
+  case R_WASM_TABLE_NUMBER_LEB:
   case R_WASM_TABLE_INDEX_SLEB:
   case R_WASM_MEMORY_ADDR_SLEB:
     return 5;
   case R_WASM_TABLE_INDEX_SLEB64:
   case R_WASM_MEMORY_ADDR_LEB64:
   case R_WASM_MEMORY_ADDR_SLEB64:
     return 10;
   default:

lld/wasm/InputFiles.h

 namespace lld {
 namespace wasm {
 
 class InputChunk;
 class InputFunction;
 class InputSegment;
 class InputGlobal;
 class InputEvent;
+class InputTable;
 class InputSection;
 
 // If --reproduce option is given, all input files are written
 // to this tar archive.
 extern std::unique_ptr<llvm::TarWriter> tar;
 
 class InputFile {
 public:
public:
   // Maps function indices to table indices
   std::vector<uint32_t> tableEntries;
   std::vector<uint32_t> tableEntriesRel;
   std::vector<bool> keptComdats;
   std::vector<InputSegment *> segments;
   std::vector<InputFunction *> functions;
   std::vector<InputGlobal *> globals;
   std::vector<InputEvent *> events;
+  std::vector<InputTable *> tables;
   std::vector<InputSection *> customSections;
   llvm::DenseMap<uint32_t, InputSection *> customSectionsByIndex;
 
   Symbol *getSymbol(uint32_t index) const { return symbols[index]; }
   FunctionSymbol *getFunctionSymbol(uint32_t index) const;
   DataSymbol *getDataSymbol(uint32_t index) const;
   GlobalSymbol *getGlobalSymbol(uint32_t index) const;
   SectionSymbol *getSectionSymbol(uint32_t index) const;
   EventSymbol *getEventSymbol(uint32_t index) const;
+  TableSymbol *getTableSymbol(uint32_t index) const;
 
 private:
   Symbol *createDefined(const WasmSymbol &sym);
   Symbol *createUndefined(const WasmSymbol &sym, bool isCalledDirectly);
 
   bool isExcludedByComdat(InputChunk *chunk) const;
 
   std::unique_ptr<WasmObjectFile> wasmObj;

lld/wasm/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
+#include "InputTable.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/Object/Binary.h"
 #include "llvm/Object/Wasm.h"
 #include "llvm/Support/TarWriter.h"
InputFile *createObjectFile(MemoryBufferRef mb, StringRef archiveName) {
   fatal("unknown file type: " + mb.getBufferIdentifier());
 }
 
 void ObjFile::dumpInfo() const {
   log("info for: " + toString(this) +
       "\n              Symbols : " + Twine(symbols.size()) +
       "\n     Function Imports : " + Twine(wasmObj->getNumImportedFunctions()) +
       "\n       Global Imports : " + Twine(wasmObj->getNumImportedGlobals()) +
-      "\n        Event Imports : " + Twine(wasmObj->getNumImportedEvents()));
+      "\n        Event Imports : " + Twine(wasmObj->getNumImportedEvents()) +
+      "\n        Table Imports : " + Twine(wasmObj->getNumImportedTables()));
 }
 
 // Relocations contain either symbol or type indices.  This function takes a
 // relocation and returns relocated index (i.e. translates from the input
 // symbol/type space to the output symbol/type space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &reloc) const {
   if (reloc.Type == R_WASM_TYPE_INDEX_LEB) {
     assert(typeIsUsed[reloc.Index]);
uint64_t ObjFile::calcExpectedValue(const WasmRelocation &reloc) const {
   }
   case R_WASM_SECTION_OFFSET_I32:
     return reloc.Addend;
   case R_WASM_TYPE_INDEX_LEB:
     return reloc.Index;
   case R_WASM_FUNCTION_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_LEB:
   case R_WASM_GLOBAL_INDEX_I32:
-  case R_WASM_EVENT_INDEX_LEB: {
+  case R_WASM_EVENT_INDEX_LEB:
+  case R_WASM_TABLE_NUMBER_LEB: {
     const WasmSymbol &sym = wasmObj->syms()[reloc.Index];
     return sym.Info.ElementIndex;
   }
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
uint64_t ObjFile::calcNewValue(const WasmRelocation &reloc) const {
   case R_WASM_FUNCTION_OFFSET_I32:
   case R_WASM_FUNCTION_OFFSET_I64: {
     auto *f = cast<DefinedFunction>(sym);
     return f->function->outputOffset +
            (f->function->getFunctionCodeOffset() + reloc.Addend);
   }
   case R_WASM_SECTION_OFFSET_I32:
     return getSectionSymbol(reloc.Index)->section->outputOffset + reloc.Addend;
+  case R_WASM_TABLE_NUMBER_LEB:
+    return getTableSymbol(reloc.Index)->getTableNumber();
   default:
     llvm_unreachable("unknown relocation type");
   }
 }
 
 template <class T>
 static void setRelocs(const std::vector<T *> &chunks,
                       const WasmSection *section) {
auto relocsStart = std::lower_bound(relocsNext, relocsEnd,
                                         c->getInputSectionOffset(), relocLess);
     relocsNext = std::lower_bound(
         relocsStart, relocsEnd, c->getInputSectionOffset() + c->getInputSize(),
         relocLess);
     c->setRelocations(ArrayRef<WasmRelocation>(relocsStart, relocsNext));
   }
 }
 
 void ObjFile::parse(bool ignoreComdats) {
   // Parse a memory buffer as a wasm file.
   LLVM_DEBUG(dbgs() << "Parsing object: " << toString(this) << "\n");
   std::unique_ptr<Binary> bin = CHECK(createBinary(mb), toString(this));
 
   auto *obj = dyn_cast<WasmObjectFile>(bin.get());
   if (!obj)
     fatal(toString(this) + ": not a wasm file");
   if (!obj->isRelocatableObject())
     fatal(toString(this) + ": not a relocatable wasm file");
 
   bin.release();
   wasmObj.reset(obj);
 
   checkArch(obj->getArch());
 
   // Build up a map of function indices to table indices for use when
   // verifying the existing table index relocations
   uint32_t totalFunctions =
void ObjFile::parse(bool ignoreComdats) {
 
   for (size_t i = 0, e = funcs.size(); i != e; ++i) {
     auto* func = make<InputFunction>(types[funcTypes[i]], &funcs[i], this);
     func->discarded = isExcludedByComdat(func);
     functions.emplace_back(func);
   }
   setRelocs(functions, codeSection);
 
+  // Populate `Tables`.
+  for (const WasmTable &t : wasmObj->tables()) {
+    tables.emplace_back(make<InputTable>(t, this));
+  }
+
   // Populate `Globals`.
   for (const WasmGlobal &g : wasmObj->globals())
     globals.emplace_back(make<InputGlobal>(g, this));
 
   // Populate `Events`.
   for (const WasmEvent &e : wasmObj->events())
     events.emplace_back(make<InputEvent>(types[e.Type.SigIndex], e, this));
 
   // Populate `Symbols` based on the symbols in the object.
   symbols.reserve(wasmObj->getNumberOfSymbols());
+  bool haveTableSymbol = false;
   for (const SymbolRef &sym : wasmObj->symbols()) {
     const WasmSymbol &wasmSym = wasmObj->getWasmSymbol(sym.getRawDataRefImpl());
+    if (wasmSym.isTypeTable())
+      haveTableSymbol = true;
     if (wasmSym.isDefined()) {
       // createDefined may fail if the symbol is comdat excluded in which case
       // we fall back to creating an undefined symbol
       if (Symbol *d = createDefined(wasmSym)) {
         symbols.push_back(d);
         continue;
       }
     }
     size_t idx = symbols.size();
     symbols.push_back(createUndefined(wasmSym, isCalledDirectly[idx]));
   }
+
+  // As a stopgap measure while implementing table support, if the object file
+  // has table definitions or imports but no table symbols, synthesize symbols
+  // for those tables.  Mark as NO_STRIP to ensure they reach the output file,
+  // even if there are no TABLE_NUMBER relocs against them.
+  if (!haveTableSymbol) {
+    uint32_t tableNumber = 0;
+    const WasmGlobalType *GlobalType = nullptr;
+    const WasmEventType *EventType = nullptr;
+    const WasmSignature *Signature = nullptr;
+    if (wasmObj->getNumImportedTables()) {
+      for (auto &Import : wasmObj->imports()) {
+        if (Import.Kind == WASM_EXTERNAL_TABLE) {
+          auto *Info = make<WasmSymbolInfo>();
+          // FIXME: Synthesize as Module.Field.  Need somewhere to put the
+          // string backing buffer though.
+          Info->Name = Import.Field;
+          Info->Kind = WASM_SYMBOL_TYPE_TABLE;
+          Info->ImportModule = Import.Module;
+          Info->ImportName = Import.Field;
+          Info->Flags = WASM_SYMBOL_UNDEFINED;
+          Info->Flags |= WASM_SYMBOL_NO_STRIP;
+          Info->ElementIndex = tableNumber++;
+          LLVM_DEBUG(dbgs() << "Synthesizing symbol for table import: "
+                            << Info->Name << "\n");
+          auto *WasmSym = make<WasmSymbol>(*Info, GlobalType, &Import.Table,
+                                           EventType, Signature);
+          symbols.push_back(createUndefined(*WasmSym, false));
+          // Because there are no TABLE_NUMBER relocs in this case, we can't
+          // compute accurate liveness info; instead, just mark the symbol as
+          // always live.
+          symbols.back()->markLive();
+        }
+      }
+    }
+    for (auto &Table : tables) {
+      auto *Info = make<llvm::wasm::WasmSymbolInfo>();
+      // Empty name.
+      Info->Kind = WASM_SYMBOL_TYPE_TABLE;
+      Info->Flags = WASM_SYMBOL_BINDING_LOCAL;
+      Info->Flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
+      Info->Flags |= WASM_SYMBOL_NO_STRIP;
+      Info->ElementIndex = tableNumber++;
+      LLVM_DEBUG(dbgs() << "Synthesizing symbol for table definition: "
+                        << Info->Name << "\n");
+      auto *WasmSym = make<WasmSymbol>(*Info, GlobalType, &Table->getType(),
+                                       EventType, Signature);
+      symbols.push_back(createDefined(*WasmSym));
+      // Mark live, for the same reasons as for imported tables.
+      symbols.back()->markLive();
+    }
+  }
 }
 
 bool ObjFile::isExcludedByComdat(InputChunk *chunk) const {
   uint32_t c = chunk->getComdat();
   if (c == UINT32_MAX)
     return false;
   return !keptComdats[c];
 }
 
 FunctionSymbol *ObjFile::getFunctionSymbol(uint32_t index) const {
   return cast<FunctionSymbol>(symbols[index]);
 }
 
 GlobalSymbol *ObjFile::getGlobalSymbol(uint32_t index) const {
   return cast<GlobalSymbol>(symbols[index]);
 }
 
 EventSymbol *ObjFile::getEventSymbol(uint32_t index) const {
   return cast<EventSymbol>(symbols[index]);
 }
 
+TableSymbol *ObjFile::getTableSymbol(uint32_t index) const {
+  return cast<TableSymbol>(symbols[index]);
+}
+
 SectionSymbol *ObjFile::getSectionSymbol(uint32_t index) const {
   return cast<SectionSymbol>(symbols[index]);
 }
 
 DataSymbol *ObjFile::getDataSymbol(uint32_t index) const {
   return cast<DataSymbol>(symbols[index]);
 }
 
Symbol *ObjFile::createDefined(const WasmSymbol &sym) {
   }
   case WASM_SYMBOL_TYPE_EVENT: {
     InputEvent *event =
         events[sym.Info.ElementIndex - wasmObj->getNumImportedEvents()];
     if (sym.isBindingLocal())
       return make<DefinedEvent>(name, flags, this, event);
     return symtab->addDefinedEvent(name, flags, this, event);
   }
+  case WASM_SYMBOL_TYPE_TABLE: {
+    InputTable *table =
+        tables[sym.Info.ElementIndex - wasmObj->getNumImportedTables()];
+    if (sym.isBindingLocal())
+      return make<DefinedTable>(name, flags, this, table);
+    return symtab->addDefinedTable(name, flags, this, table);
+  }
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &sym, bool isCalledDirectly) {
   StringRef name = sym.Info.Name;
   uint32_t flags = sym.Info.Flags | WASM_SYMBOL_UNDEFINED;
 
Symbol *ObjFile::createUndefined(const WasmSymbol &sym, bool isCalledDirectly) {
   case WASM_SYMBOL_TYPE_GLOBAL:
     if (sym.isBindingLocal())
       return make<UndefinedGlobal>(name, sym.Info.ImportName,
                                    sym.Info.ImportModule, flags, this,
                                    sym.GlobalType);
     return symtab->addUndefinedGlobal(name, sym.Info.ImportName,
                                       sym.Info.ImportModule, flags, this,
                                       sym.GlobalType);
+  case WASM_SYMBOL_TYPE_TABLE:
+    if (sym.isBindingLocal())
+      return make<UndefinedTable>(name, sym.Info.ImportName,
+                                  sym.Info.ImportModule, flags, this,
+                                  sym.TableType);
+    return symtab->addUndefinedTable(name, sym.Info.ImportName,
+                                     sym.Info.ImportModule, flags, this,
+                                     sym.TableType);
   case WASM_SYMBOL_TYPE_SECTION:
     llvm_unreachable("section symbols cannot be undefined");
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 void ArchiveFile::parse() {
   // Parse a MemoryBufferRef as an archive file.

lld/wasm/InputTable.h

+//===- InputTable.h --------------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLD_WASM_INPUT_TABLE_H
+#define LLD_WASM_INPUT_TABLE_H
+
+#include "Config.h"
+#include "InputFiles.h"
+#include "WriterUtils.h"
+#include "lld/Common/ErrorHandler.h"
+#include "llvm/Object/Wasm.h"
+
+namespace lld {
+namespace wasm {
+
+// Represents a single Wasm Table within an input file. These are combined to
+// form the final TABLES section.
+class InputTable {
+public:
+  InputTable(const WasmTable &t, ObjFile *f)
+      : file(f), table(t), live(!config->gcSections) {}
+
+  StringRef getName() const { return table.SymbolName; }
+  const WasmTableType &getType() const { return table.Type; }
+
+  // Somewhat confusingly, we generally use the term "table index" to refer to
+  // the offset of a function in the well-known indirect function table.  We
+  // refer to different tables instead by "table numbers".
+  uint32_t getTableNumber() const { return tableNumber.getValue(); }
+  bool hasTableNumber() const { return tableNumber.hasValue(); }
+  void setTableNumber(uint32_t n) {
+    assert(!hasTableNumber());
+    tableNumber = n;
+  }
+
+  void setLimits(const WasmLimits &Limits) { table.Type.Limits = Limits; }
+
+  ObjFile *file;
+  WasmTable table;
+
+  bool live = false;
+
+protected:
+  llvm::Optional<uint32_t> tableNumber;
+};
+
+} // namespace wasm
+
+inline std::string toString(const wasm::InputTable *t) {
+  return (toString(t->file) + ":(" + t->getName() + ")").str();
+}
+
+} // namespace lld
+
+#endif // LLD_WASM_INPUT_TABLE_H

lld/wasm/MarkLive.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "MarkLive.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
+#include "InputTable.h"
 #include "SymbolTable.h"
 #include "Symbols.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
for (const ObjFile *obj : symtab->objectFiles) {
         if (!c->live)
           message("removing unused section " + toString(c));
       for (InputGlobal *g : obj->globals)
         if (!g->live)
           message("removing unused section " + toString(g));
       for (InputEvent *e : obj->events)
         if (!e->live)
           message("removing unused section " + toString(e));
+      for (InputTable *t : obj->tables)
+        if (!t->live)
+          message("removing unused section " + toString(t));
     }
     for (InputChunk *c : symtab->syntheticFunctions)
       if (!c->live)
         message("removing unused section " + toString(c));
     for (InputGlobal *g : symtab->syntheticGlobals)
       if (!g->live)
         message("removing unused section " + toString(g));
+    for (InputTable *t : symtab->syntheticTables)
+      if (!t->live)
+        message("removing unused section " + toString(t));
   }
 }
 
 bool MarkLive::isCallCtorsLive() {
   // In a reloctable link, we don't call `__wasm_call_ctors`.
   if (config->relocatable)
     return false;
 

lld/wasm/SymbolTable.h

Symbol *addDefinedFunction(StringRef name, uint32_t flags, InputFile *file,
                              InputFunction *function);
   Symbol *addDefinedData(StringRef name, uint32_t flags, InputFile *file,
                          InputSegment *segment, uint64_t address,
                          uint64_t size);
   Symbol *addDefinedGlobal(StringRef name, uint32_t flags, InputFile *file,
                            InputGlobal *g);
   Symbol *addDefinedEvent(StringRef name, uint32_t flags, InputFile *file,
                           InputEvent *e);
+  Symbol *addDefinedTable(StringRef name, uint32_t flags, InputFile *file,
+                          InputTable *t);
 
   Symbol *addUndefinedFunction(StringRef name,
                                llvm::Optional<StringRef> importName,
                                llvm::Optional<StringRef> importModule,
                                uint32_t flags, InputFile *file,
                                const WasmSignature *signature,
                                bool isCalledDirectly);
   Symbol *addUndefinedData(StringRef name, uint32_t flags, InputFile *file);
   Symbol *addUndefinedGlobal(StringRef name,
                              llvm::Optional<StringRef> importName,
                              llvm::Optional<StringRef> importModule,
                              uint32_t flags, InputFile *file,
                              const WasmGlobalType *type);
+  Symbol *addUndefinedTable(StringRef name,
+                            llvm::Optional<StringRef> importName,
+                            llvm::Optional<StringRef> importModule,
+                            uint32_t flags, InputFile *file,
+                            const WasmTableType *type);
 
   void addLazy(ArchiveFile *f, const llvm::object::Archive::Symbol *sym);
 
   bool addComdat(StringRef name);
 
   DefinedData *addSyntheticDataSymbol(StringRef name, uint32_t flags);
   DefinedGlobal *addSyntheticGlobal(StringRef name, uint32_t flags,
                                     InputGlobal *global);
   DefinedFunction *addSyntheticFunction(StringRef name, uint32_t flags,
                                         InputFunction *function);
   DefinedData *addOptionalDataSymbol(StringRef name, uint64_t value = 0);
   DefinedGlobal *addOptionalGlobalSymbols(StringRef name, uint32_t flags,
                                           InputGlobal *global);
+  DefinedTable *addSyntheticTable(StringRef name, uint32_t flags,
+                                  InputTable *global);
 
   void handleSymbolVariants();
   void handleWeakUndefines();
   DefinedFunction *createUndefinedStub(const WasmSignature &sig);
 
   std::vector<ObjFile *> objectFiles;
   std::vector<SharedFile *> sharedFiles;
   std::vector<BitcodeFile *> bitcodeFiles;
   std::vector<InputFunction *> syntheticFunctions;
   std::vector<InputGlobal *> syntheticGlobals;
+  std::vector<InputTable *> syntheticTables;
+
+  TableSymbol *indirectFunctionTableSymbol = nullptr;
 
 private:
   std::pair<Symbol *, bool> insert(StringRef name, const InputFile *file);
   std::pair<Symbol *, bool> insertName(StringRef name);
 
   bool getFunctionVariant(Symbol* sym, const WasmSignature *sig,
                           const InputFile *file, Symbol **out);
   InputFunction *replaceWithUnreachable(Symbol *sym, const WasmSignature &sig,

lld/wasm/SymbolTable.cpp

 //===- SymbolTable.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
+#include "InputTable.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/SetVector.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
error("Event type mismatch: " + existing->getName() + "\n>>> defined as " +
           "\n>>> defined as " + toString(*newType) + " in " + toString(file));
   if (*newSig != *oldSig)
     warn("Event signature mismatch: " + existing->getName() +
          "\n>>> defined as " + toString(*oldSig) + " in " +
          toString(existing->getFile()) + "\n>>> defined as " +
          toString(*newSig) + " in " + toString(file));
 }
 
+static void checkTableType(const Symbol *existing, const InputFile *file,
+                           const WasmTableType *newType) {
+  if (!isa<TableSymbol>(existing)) {
+    reportTypeError(existing, file, WASM_SYMBOL_TYPE_TABLE);
+    return;
+  }
+
+  const WasmTableType *oldType = cast<TableSymbol>(existing)->getTableType();
+  if (newType->ElemType != oldType->ElemType) {
+    error("Table type mismatch: " + existing->getName() + "\n>>> defined as " +
+          toString(*oldType) + " in " + toString(existing->getFile()) +
+          "\n>>> defined as " + toString(*newType) + " in " + toString(file));
+  }
+  // FIXME: No assertions currently on the limits.
+}
+
 static void checkDataType(const Symbol *existing, const InputFile *file) {
   if (!isa<DataSymbol>(existing))
     reportTypeError(existing, file, WASM_SYMBOL_TYPE_DATA);
 }
 
 DefinedFunction *SymbolTable::addSyntheticFunction(StringRef name,
                                                    uint32_t flags,
                                                    InputFunction *function) {
LLVM_DEBUG(dbgs() << "addOptionalGlobalSymbols: " << name << " -> " << global
                     << "\n");
   Symbol *s = find(name);
   if (!s || s->isDefined())
     return nullptr;
   syntheticGlobals.emplace_back(global);
   return replaceSymbol<DefinedGlobal>(s, name, flags, nullptr, global);
 }
 
+DefinedTable *SymbolTable::addSyntheticTable(StringRef name, uint32_t flags,
+                                             InputTable *table) {
+  LLVM_DEBUG(dbgs() << "addSyntheticTable: " << name << " -> " << table
+                    << "\n");
+  Symbol *s = find(name);
+  assert(!s || s->isUndefined());
+  if (!s)
+    s = insertName(name).first;
+  syntheticTables.emplace_back(table);
+  return replaceSymbol<DefinedTable>(s, name, flags, nullptr, table);
+}
+
 static bool shouldReplace(const Symbol *existing, InputFile *newFile,
                           uint32_t newFlags) {
   // If existing symbol is undefined, replace it.
   if (!existing->isDefined()) {
     LLVM_DEBUG(dbgs() << "resolving existing undefined symbol: "
                       << existing->getName() << "\n");
     return true;
   }
Symbol *SymbolTable::addDefinedEvent(StringRef name, uint32_t flags,
 
   checkEventType(s, file, &event->getType(), &event->signature);
 
   if (shouldReplace(s, file, flags))
     replaceSym();
   return s;
 }
 
+Symbol *SymbolTable::addDefinedTable(StringRef name, uint32_t flags,
+                                     InputFile *file, InputTable *table) {
+  LLVM_DEBUG(dbgs() << "addDefinedTable:" << name << "\n");
+
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(name, file);
+
+  auto replaceSym = [&]() {
+    replaceSymbol<DefinedTable>(s, name, flags, file, table);
+  };
+
+  if (wasInserted || s->isLazy()) {
+    replaceSym();
+    return s;
+  }
+
+  checkTableType(s, file, &table->getType());
+
+  if (shouldReplace(s, file, flags))
+    replaceSym();
+  return s;
+}
+
 // This function get called when an undefined symbol is added, and there is
 // already an existing one in the symbols table.  In this case we check that
 // custom 'import-module' and 'import-field' symbol attributes agree.
 // With LTO these attributes are not available when the bitcode is read and only
 // become available when the LTO object is read.  In this case we silently
 // replace the empty attributes with the valid ones.
 template <typename T>
 static void setImportAttributes(T *existing, Optional<StringRef> importName,
replaceSymbol<UndefinedGlobal>(s, name, importName, importModule, flags,
                                    file, type);
   else if (auto *lazy = dyn_cast<LazySymbol>(s))
     lazy->fetch();
   else if (s->isDefined())
     checkGlobalType(s, file, type);
   return s;
 }
 
+Symbol *SymbolTable::addUndefinedTable(StringRef name,
+                                       Optional<StringRef> importName,
+                                       Optional<StringRef> importModule,
+                                       uint32_t flags, InputFile *file,
+                                       const WasmTableType *type) {
+  LLVM_DEBUG(dbgs() << "addUndefinedTable: " << name << "\n");
+  assert(flags & WASM_SYMBOL_UNDEFINED);
+
+  Symbol *s;
+  bool wasInserted;
+  std::tie(s, wasInserted) = insert(name, file);
+  if (s->traced)
+    printTraceSymbolUndefined(name, file);
+
+  if (wasInserted)
+    replaceSymbol<UndefinedTable>(s, name, importName, importModule, flags,
+                                  file, type);
+  else if (auto *lazy = dyn_cast<LazySymbol>(s))
+    lazy->fetch();
+  else if (s->isDefined())
+    checkTableType(s, file, type);
+  return s;
+}
+
 void SymbolTable::addLazy(ArchiveFile *file, const Archive::Symbol *sym) {
   LLVM_DEBUG(dbgs() << "addLazy: " << sym->getName() << "\n");
   StringRef name = sym->getName();
 
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insertName(name);
 

lld/wasm/Symbols.h

 
 // The default module name to use for symbol imports.
 extern const char *defaultModule;
 
 // The name under which to import or export the wasm table.
 extern const char *functionTableName;
 
 using llvm::wasm::WasmSymbolType;
+using llvm::wasm::WasmTable;
 
 class InputFile;
 class InputChunk;
 class InputSegment;
 class InputFunction;
 class InputGlobal;
 class InputEvent;
 class InputSection;
+class InputTable;
 class OutputSection;
 
 #define INVALID_INDEX UINT32_MAX
 
 // The base class for real symbol classes.
 class Symbol {
 public:
   enum Kind : uint8_t {
     DefinedFunctionKind,
     DefinedDataKind,
     DefinedGlobalKind,
     DefinedEventKind,
+    DefinedTableKind,
     SectionKind,
     OutputSectionKind,
     UndefinedFunctionKind,
     UndefinedDataKind,
     UndefinedGlobalKind,
+    UndefinedTableKind,
     LazyKind,
   };
 
   Kind kind() const { return symbolKind; }
 
   bool isDefined() const { return !isLazy() && !isUndefined(); }
 
   bool isUndefined() const {
     return symbolKind == UndefinedFunctionKind ||
-           symbolKind == UndefinedDataKind || symbolKind == UndefinedGlobalKind;
+           symbolKind == UndefinedDataKind ||
+           symbolKind == UndefinedGlobalKind ||
+           symbolKind == UndefinedTableKind;
   }
 
   bool isLazy() const { return symbolKind == LazyKind; }
 
   bool isLocal() const;
   bool isWeak() const;
   bool isHidden() const;
 
public:
   static bool classof(const Symbol *s) {
     return s->kind() == UndefinedGlobalKind;
   }
 
   llvm::Optional<StringRef> importName;
   llvm::Optional<StringRef> importModule;
 };
 
+class TableSymbol : public Symbol {
+public:
+  static bool classof(const Symbol *s) {
+    return s->kind() == DefinedTableKind || s->kind() == UndefinedTableKind;
+  }
+
+  const WasmTableType *getTableType() const { return tableType; }
+  void setLimits(const WasmLimits &Limits);
+
+  // Get/set the table number
+  uint32_t getTableNumber() const;
+  void setTableNumber(uint32_t number);
+  bool hasTableNumber() const;
+
+protected:
+  TableSymbol(StringRef name, Kind k, uint32_t flags, InputFile *f,
+              const WasmTableType *type)
+      : Symbol(name, k, flags, f), tableType(type) {}
+
+  const WasmTableType *tableType;
+  uint32_t tableNumber = INVALID_INDEX;
+};
+
+class DefinedTable : public TableSymbol {
+public:
+  DefinedTable(StringRef name, uint32_t flags, InputFile *file,
+               InputTable *table);
+
+  static bool classof(const Symbol *s) { return s->kind() == DefinedTableKind; }
+
+  InputTable *table;
+};
+
+class UndefinedTable : public TableSymbol {
+public:
+  UndefinedTable(StringRef name, llvm::Optional<StringRef> importName,
+                 llvm::Optional<StringRef> importModule, uint32_t flags,
+                 InputFile *file, const WasmTableType *type)
+      : TableSymbol(name, UndefinedTableKind, flags, file, type),
+        importName(importName), importModule(importModule) {}
+
+  static bool classof(const Symbol *s) {
+    return s->kind() == UndefinedTableKind;
+  }
+
+  llvm::Optional<StringRef> importName;
+  llvm::Optional<StringRef> importModule;
+};
+
 // Wasm events are features that suspend the current execution and transfer the
 // control flow to a corresponding handler. Currently the only supported event
 // kind is exceptions.
 //
 // Event tags are values to distinguish different events. For exceptions, they
 // can be used to distinguish different language's exceptions, i.e., all C++
 // exceptions have the same tag. Wasm can generate code capable of doing
 // different handling actions based on the tag of caught exceptions.

 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(DefinedFunction) char a[sizeof(DefinedFunction)];
   alignas(DefinedData) char b[sizeof(DefinedData)];
   alignas(DefinedGlobal) char c[sizeof(DefinedGlobal)];
   alignas(DefinedEvent) char d[sizeof(DefinedEvent)];
-  alignas(LazySymbol) char e[sizeof(LazySymbol)];
-  alignas(UndefinedFunction) char f[sizeof(UndefinedFunction)];
-  alignas(UndefinedData) char g[sizeof(UndefinedData)];
-  alignas(UndefinedGlobal) char h[sizeof(UndefinedGlobal)];
-  alignas(SectionSymbol) char i[sizeof(SectionSymbol)];
+  alignas(DefinedTable) char e[sizeof(DefinedTable)];
+  alignas(LazySymbol) char f[sizeof(LazySymbol)];
+  alignas(UndefinedFunction) char g[sizeof(UndefinedFunction)];
+  alignas(UndefinedData) char h[sizeof(UndefinedData)];
+  alignas(UndefinedGlobal) char i[sizeof(UndefinedGlobal)];
+  alignas(UndefinedTable) char j[sizeof(UndefinedTable)];
+  alignas(SectionSymbol) char k[sizeof(SectionSymbol)];
 };
 
 // It is important to keep the size of SymbolUnion small for performance and
 // memory usage reasons. 96 bytes is a soft limit based on the size of
 // UndefinedFunction on a 64-bit system.
 static_assert(sizeof(SymbolUnion) <= 120, "SymbolUnion too large");
 
 void printTraceSymbol(Symbol *sym);

lld/wasm/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputFiles.h"
 #include "InputGlobal.h"
+#include "InputTable.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::wasm;
 

 std::string toString(wasm::Symbol::Kind kind) {
   switch (kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
   case wasm::Symbol::DefinedDataKind:
     return "DefinedData";
   case wasm::Symbol::DefinedGlobalKind:
     return "DefinedGlobal";
+  case wasm::Symbol::DefinedTableKind:
+    return "DefinedTable";
   case wasm::Symbol::DefinedEventKind:
     return "DefinedEvent";
   case wasm::Symbol::UndefinedFunctionKind:
     return "UndefinedFunction";
   case wasm::Symbol::UndefinedDataKind:
     return "UndefinedData";
   case wasm::Symbol::UndefinedGlobalKind:
     return "UndefinedGlobal";
+  case wasm::Symbol::UndefinedTableKind:
+    return "UndefinedTable";
   case wasm::Symbol::LazyKind:
     return "LazyKind";
   case wasm::Symbol::SectionKind:
     return "SectionKind";
   case wasm::Symbol::OutputSectionKind:
     return "OutputSectionKind";
   }
   llvm_unreachable("invalid symbol kind");
WasmSymbolType Symbol::getWasmType() const {
   if (isa<FunctionSymbol>(this))
     return WASM_SYMBOL_TYPE_FUNCTION;
   if (isa<DataSymbol>(this))
     return WASM_SYMBOL_TYPE_DATA;
   if (isa<GlobalSymbol>(this))
     return WASM_SYMBOL_TYPE_GLOBAL;
   if (isa<EventSymbol>(this))
     return WASM_SYMBOL_TYPE_EVENT;
+  if (isa<TableSymbol>(this))
+    return WASM_SYMBOL_TYPE_TABLE;
   if (isa<SectionSymbol>(this) || isa<OutputSectionSymbol>(this))
     return WASM_SYMBOL_TYPE_SECTION;
   llvm_unreachable("invalid symbol kind");
 }
 
 const WasmSignature *Symbol::getSignature() const {
   if (auto* f = dyn_cast<FunctionSymbol>(this))
     return f->signature;
bool Symbol::isDiscarded() const {
   return false;
 }
 
 bool Symbol::isLive() const {
   if (auto *g = dyn_cast<DefinedGlobal>(this))
     return g->global->live;
   if (auto *e = dyn_cast<DefinedEvent>(this))
     return e->event->live;
+  if (auto *t = dyn_cast<DefinedTable>(this))
+    return t->table->live;
   if (InputChunk *c = getChunk())
     return c->live;
   return referenced;
 }
 
 void Symbol::markLive() {
   assert(!isDiscarded());
   if (file != NULL)
     file->markLive();
   if (auto *g = dyn_cast<DefinedGlobal>(this))
     g->global->live = true;
   if (auto *e = dyn_cast<DefinedEvent>(this))
     e->event->live = true;
+  if (auto *t = dyn_cast<DefinedTable>(this))
+    t->table->live = true;
   if (InputChunk *c = getChunk())
     c->live = true;
   referenced = true;
 }
 
 uint32_t Symbol::getOutputSymbolIndex() const {
   assert(outputSymbolIndex != INVALID_INDEX);
   return outputSymbolIndex;

 
 DefinedEvent::DefinedEvent(StringRef name, uint32_t flags, InputFile *file,
                            InputEvent *event)
     : EventSymbol(name, DefinedEventKind, flags, file,
                   event ? &event->getType() : nullptr,
                   event ? &event->signature : nullptr),
       event(event) {}
 
+void TableSymbol::setLimits(const WasmLimits &Limits) {
+  if (auto *t = dyn_cast<DefinedTable>(this))
+    t->table->setLimits(Limits);
+  auto *newType = make<WasmTableType>(*tableType);
+  newType->Limits = Limits;
+  tableType = newType;
+}
+
+uint32_t TableSymbol::getTableNumber() const {
+  if (auto *t = dyn_cast<DefinedTable>(this))
+    return t->table->getTableNumber();
+  assert(tableNumber != INVALID_INDEX);
+  return tableNumber;
+}
+
+void TableSymbol::setTableNumber(uint32_t number) {
+  LLVM_DEBUG(dbgs() << "setTableNumber " << name << " -> " << number << "\n");
+  assert(tableNumber == INVALID_INDEX);
+  tableNumber = number;
+}
+
+bool TableSymbol::hasTableNumber() const {
+  if (auto *t = dyn_cast<DefinedTable>(this))
+    return t->table->hasTableNumber();
+  return tableNumber != INVALID_INDEX;
+}
+
+DefinedTable::DefinedTable(StringRef name, uint32_t flags, InputFile *file,
+                           InputTable *table)
+    : TableSymbol(name, DefinedTableKind, flags, file,
+                  table ? &table->getType() : nullptr),
+      table(table) {}
+
 const OutputSectionSymbol *SectionSymbol::getOutputSectionSymbol() const {
   assert(section->outputSec && section->outputSec->sectionSym);
   return section->outputSec->sectionSym;
 }
 
 void LazySymbol::fetch() { cast<ArchiveFile>(file)->addMember(&archiveSymbol); }
 
 void LazySymbol::setWeak() {

lld/wasm/SyntheticSections.h

public:
   uint32_t getNumImportedFunctions() const {
     assert(isSealed);
     return numImportedFunctions;
   }
   uint32_t getNumImportedEvents() const {
     assert(isSealed);
     return numImportedEvents;
   }
+  uint32_t getNumImportedTables() const {
+    assert(isSealed);
+    return numImportedTables;
+  }
 
   std::vector<const Symbol *> importedSymbols;
   std::vector<const Symbol *> gotSymbols;
 
 protected:
   bool isSealed = false;
   unsigned numImportedGlobals = 0;
   unsigned numImportedFunctions = 0;
   unsigned numImportedEvents = 0;
+  unsigned numImportedTables = 0;
 };
 
 class FunctionSection : public SyntheticSection {
 public:
   FunctionSection() : SyntheticSection(llvm::wasm::WASM_SEC_FUNCTION) {}
 
   bool isNeeded() const override { return inputFunctions.size() > 0; };
   void writeBody() override;
   void addFunction(InputFunction *func);
 
   std::vector<InputFunction *> inputFunctions;
 
 protected:
 };
 
 class TableSection : public SyntheticSection {
 public:
   TableSection() : SyntheticSection(llvm::wasm::WASM_SEC_TABLE) {}
 
-  bool isNeeded() const override {
-    // Always output a table section (or table import), even if there are no
-    // indirect calls.  There are two reasons for this:
-    //  1. For executables it is useful to have an empty table slot at 0
-    //     which can be filled with a null function call handler.
-    //  2. If we don't do this, any program that contains a call_indirect but
-    //     no address-taken function will fail at validation time since it is
-    //     a validation error to include a call_indirect instruction if there
-    //     is not table.
-    return !config->importTable;
-  }
-
+  bool isNeeded() const override { return inputTables.size() > 0; };
   void writeBody() override;
+  void addTable(InputTable *table);
+
+  std::vector<InputTable *> inputTables;
 };
 
 class MemorySection : public SyntheticSection {
 public:
   MemorySection() : SyntheticSection(llvm::wasm::WASM_SEC_MEMORY) {}
 
   bool isNeeded() const override { return !config->importMemory; }
   void writeBody() override;
struct OutStruct {
   ExportSection *exportSec;
   StartSection *startSec;
   ElemSection *elemSec;
   DataCountSection *dataCountSec;
   LinkingSection *linkingSec;
   NameSection *nameSec;
   ProducersSection *producersSec;
   TargetFeaturesSection *targetFeaturesSec;
+
+  TableSymbol *indirectFunctionTableSymbol;
 };
 
 extern OutStruct out;
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/wasm/SyntheticSections.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "SyntheticSections.h"
 
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
+#include "InputTable.h"
 #include "OutputSegment.h"
 #include "SymbolTable.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 using namespace llvm::wasm;
 
 namespace lld {
for (const WasmSignature *sig : types)
     writeSig(bodyOutputStream, *sig);
 }
 
 uint32_t ImportSection::getNumImports() const {
   assert(isSealed);
   uint32_t numImports = importedSymbols.size() + gotSymbols.size();
   if (config->importMemory)
     ++numImports;
-  if (config->importTable)
-    ++numImports;
   return numImports;
 }
 
 void ImportSection::addGOTEntry(Symbol *sym) {
   assert(!isSealed);
   if (sym->hasGOTIndex())
     return;
   LLVM_DEBUG(dbgs() << "addGOTEntry: " << toString(*sym) << "\n");
   sym->setGOTIndex(numImportedGlobals++);
   gotSymbols.push_back(sym);
 }
 
 void ImportSection::addImport(Symbol *sym) {
   assert(!isSealed);
   importedSymbols.emplace_back(sym);
   if (auto *f = dyn_cast<FunctionSymbol>(sym))
     f->setFunctionIndex(numImportedFunctions++);
   else if (auto *g = dyn_cast<GlobalSymbol>(sym))
     g->setGlobalIndex(numImportedGlobals++);
+  else if (auto *e = dyn_cast<EventSymbol>(sym))
+    e->setEventIndex(numImportedEvents++);
   else
-    cast<EventSymbol>(sym)->setEventIndex(numImportedEvents++);
+    cast<TableSymbol>(sym)->setTableNumber(numImportedTables++);
 }
 
 void ImportSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   writeUleb128(os, getNumImports(), "import count");
 
   if (config->importMemory) {
if (config->importMemory) {
     }
     if (config->sharedMemory)
       import.Memory.Flags |= WASM_LIMITS_FLAG_IS_SHARED;
     if (config->is64.getValueOr(false))
       import.Memory.Flags |= WASM_LIMITS_FLAG_IS_64;
     writeImport(os, import);
   }
 
-  if (config->importTable) {
-    uint32_t tableSize = config->tableBase + out.elemSec->numEntries();
-    WasmImport import;
-    import.Module = defaultModule;
-    import.Field = functionTableName;
-    import.Kind = WASM_EXTERNAL_TABLE;
-    import.Table.ElemType = WASM_TYPE_FUNCREF;
-    import.Table.Limits = {0, tableSize, 0};
-    writeImport(os, import);
-  }
-
   for (const Symbol *sym : importedSymbols) {
     WasmImport import;
     if (auto *f = dyn_cast<UndefinedFunction>(sym)) {
       import.Field = f->importName ? *f->importName : sym->getName();
       import.Module = f->importModule ? *f->importModule : defaultModule;
     } else if (auto *g = dyn_cast<UndefinedGlobal>(sym)) {
       import.Field = g->importName ? *g->importName : sym->getName();
       import.Module = g->importModule ? *g->importModule : defaultModule;
+    } else if (auto *t = dyn_cast<UndefinedTable>(sym)) {
+      import.Field = t->importName ? *t->importName : sym->getName();
+      import.Module = t->importModule ? *t->importModule : defaultModule;
     } else {
       import.Field = sym->getName();
       import.Module = defaultModule;
     }
 
     if (auto *functionSym = dyn_cast<FunctionSymbol>(sym)) {
       import.Kind = WASM_EXTERNAL_FUNCTION;
       import.SigIndex = out.typeSec->lookupType(*functionSym->signature);
     } else if (auto *globalSym = dyn_cast<GlobalSymbol>(sym)) {
       import.Kind = WASM_EXTERNAL_GLOBAL;
       import.Global = *globalSym->getGlobalType();
-    } else {
-      auto *eventSym = cast<EventSymbol>(sym);
+    } else if (auto *eventSym = dyn_cast<EventSymbol>(sym)) {
       import.Kind = WASM_EXTERNAL_EVENT;
       import.Event.Attribute = eventSym->getEventType()->Attribute;
       import.Event.SigIndex = out.typeSec->lookupType(*eventSym->signature);
+    } else {
+      auto *tableSym = cast<TableSymbol>(sym);
+      import.Kind = WASM_EXTERNAL_TABLE;
+      import.Table = *tableSym->getTableType();
     }
     writeImport(os, import);
   }
 
   for (const Symbol *sym : gotSymbols) {
     WasmImport import;
     import.Kind = WASM_EXTERNAL_GLOBAL;
     import.Global = {WASM_TYPE_I32, true};
if (!func->live)
     return;
   uint32_t functionIndex =
       out.importSec->getNumImportedFunctions() + inputFunctions.size();
   inputFunctions.emplace_back(func);
   func->setFunctionIndex(functionIndex);
 }
 
 void TableSection::writeBody() {
-  uint32_t tableSize = config->tableBase + out.elemSec->numEntries();
-
   raw_ostream &os = bodyOutputStream;
-  writeUleb128(os, 1, "table count");
-  WasmLimits limits;
-  if (config->growableTable)
-    limits = {0, tableSize, 0};
-  else
-    limits = {WASM_LIMITS_FLAG_HAS_MAX, tableSize, tableSize};
-  writeTableType(os, WasmTableType{WASM_TYPE_FUNCREF, limits});
+
+  writeUleb128(os, inputTables.size(), "table count");
+  for (const InputTable *table : inputTables)
+    writeTableType(os, table->getType());
+}
+
+void TableSection::addTable(InputTable *table) {
+  if (!table->live)
+    return;
+  uint32_t tableNumber =
+      out.importSec->getNumImportedTables() + inputTables.size();
+  inputTables.push_back(table);
+  table->setTableNumber(tableNumber);
 }
 
 void MemorySection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   bool hasMax = maxMemoryPages != 0 || config->sharedMemory;
   writeUleb128(os, 1, "memory count");
   unsigned flags = 0;
for (const Symbol *sym : symtabEntries) {
       } else if (auto *g = dyn_cast<GlobalSymbol>(sym)) {
         writeUleb128(sub.os, g->getGlobalIndex(), "index");
         if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(sub.os, sym->getName(), "sym name");
       } else if (auto *e = dyn_cast<EventSymbol>(sym)) {
         writeUleb128(sub.os, e->getEventIndex(), "index");
         if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(sub.os, sym->getName(), "sym name");
+      } else if (auto *t = dyn_cast<TableSymbol>(sym)) {
+        writeUleb128(sub.os, t->getTableNumber(), "table number");
+        if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
+          writeStr(sub.os, sym->getName(), "sym name");
       } else if (isa<DataSymbol>(sym)) {
         writeStr(sub.os, sym->getName(), "sym name");
         if (auto *dataSym = dyn_cast<DefinedData>(sym)) {
           writeUleb128(sub.os, dataSym->getOutputSegmentIndex(), "index");
           writeUleb128(sub.os, dataSym->getOutputSegmentOffset(),
                        "data offset");
           writeUleb128(sub.os, dataSym->getSize(), "data size");
         }

lld/wasm/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "InputChunks.h"
 #include "InputEvent.h"
 #include "InputGlobal.h"
+#include "InputTable.h"
 #include "MapFile.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "Relocations.h"
 #include "SymbolTable.h"
 #include "SyntheticSections.h"
 #include "WriterUtils.h"
 #include "lld/Common/ErrorHandler.h"
if (config->relocatable ||
       config->unresolvedSymbols == UnresolvedPolicy::ImportFuncs)
     return true;
   if (config->allowUndefinedSymbols.count(sym->getName()) != 0)
     return true;
   if (auto *g = dyn_cast<UndefinedGlobal>(sym))
     return g->importName.hasValue();
   if (auto *f = dyn_cast<UndefinedFunction>(sym))
     return f->importName.hasValue();
+  if (auto *t = dyn_cast<UndefinedTable>(sym))
+    return t->importName.hasValue();
 
   return false;
 }
 
 void Writer::calculateImports() {
   for (Symbol *sym : symtab->getSymbols()) {
     if (!sym->isUndefined())
       continue;
if (auto *f = dyn_cast<DefinedFunction>(sym)) {
         // Without this check `--export-all` would cause any program using the
         // stack pointer to export a mutable global even if none of the input
         // files were built with the `mutable-globals` feature.
         continue;
       }
       export_ = {name, WASM_EXTERNAL_GLOBAL, g->getGlobalIndex()};
     } else if (auto *e = dyn_cast<DefinedEvent>(sym)) {
       export_ = {name, WASM_EXTERNAL_EVENT, e->getEventIndex()};
-    } else {
-      auto *d = cast<DefinedData>(sym);
+    } else if (auto *d = dyn_cast<DefinedData>(sym)) {
       out.globalSec->dataAddressGlobals.push_back(d);
       export_ = {name, WASM_EXTERNAL_GLOBAL, globalIndex++};
+    } else {
+      auto *t = cast<DefinedTable>(sym);
+      export_ = {name, WASM_EXTERNAL_TABLE, t->getTableNumber()};
     }
 
     LLVM_DEBUG(dbgs() << "Export: " << name << "\n");
     out.exportSec->exports.push_back(export_);
     out.exportSec->exportedSymbols.push_back(sym);
   }
 }
 
for (InputChunk *chunk : file->segments)
       scanRelocations(chunk);
     for (auto &p : file->customSections)
       scanRelocations(p);
   }
 }
 
 void Writer::assignIndexes() {
   // Seal the import section, since other index spaces such as function and
   // global are effected by the number of imports.
   out.importSec->seal();
 
   for (InputFunction *func : symtab->syntheticFunctions)
     out.functionSec->addFunction(func);
 
   for (ObjFile *file : symtab->objectFiles) {
     LLVM_DEBUG(dbgs() << "Functions: " << file->getName() << "\n");
     for (InputFunction *func : file->functions)
void Writer::assignIndexes() {
   }
 
   for (ObjFile *file : symtab->objectFiles) {
     LLVM_DEBUG(dbgs() << "Events: " << file->getName() << "\n");
     for (InputEvent *event : file->events)
       out.eventSec->addEvent(event);
   }
 
+  for (ObjFile *file : symtab->objectFiles) {
+    LLVM_DEBUG(dbgs() << "Tables: " << file->getName() << "\n");
+    for (InputTable *table : file->tables)
+      out.tableSec->addTable(table);
+  }
+
+  for (InputTable *table : symtab->syntheticTables)
+    out.tableSec->addTable(table);
+
+  if (symtab->indirectFunctionTableSymbol) {
+    uint32_t tableSize = config->tableBase + out.elemSec->numEntries();
+    WasmLimits limits = {0, tableSize, 0};
+    if (symtab->indirectFunctionTableSymbol->isDefined() &&
+        !config->growableTable) {
+      limits.Flags |= WASM_LIMITS_FLAG_HAS_MAX;
+      limits.Maximum = limits.Initial;
+    }
+    symtab->indirectFunctionTableSymbol->setLimits(limits);
+  }
+
   out.globalSec->assignIndexes();
 }
 
 static StringRef getOutputDataSegmentName(StringRef name) {
   // We only support one thread-local segment, so we must merge the segments
   // despite --no-merge-data-segments.
   // We also need to merge .tbss into .tdata so they share the same offsets.
   if (name.startswith(".tdata") || name.startswith(".tbss"))
void Writer::run() {
   populateTargetFeatures();
   log("-- addSections");
   addSections();
 
   if (errorHandler().verbose) {
     log("Defined Functions: " + Twine(out.functionSec->inputFunctions.size()));
     log("Defined Globals  : " + Twine(out.globalSec->numGlobals()));
     log("Defined Events   : " + Twine(out.eventSec->inputEvents.size()));
+    log("Defined Tables   : " + Twine(out.tableSec->inputTables.size()));
     log("Function Imports : " +
         Twine(out.importSec->getNumImportedFunctions()));
     log("Global Imports   : " + Twine(out.importSec->getNumImportedGlobals()));
     log("Event Imports    : " + Twine(out.importSec->getNumImportedEvents()));
+    log("Table Imports    : " + Twine(out.importSec->getNumImportedTables()));
     for (ObjFile *file : symtab->objectFiles)
       file->dumpInfo();
   }
 
   createHeader();
   log("-- finalizeSections");
   finalizeSections();
 

lld/wasm/WriterUtils.h

 void writeExport(raw_ostream &os, const llvm::wasm::WasmExport &export_);
 
 } // namespace wasm
 
 std::string toString(llvm::wasm::ValType type);
 std::string toString(const llvm::wasm::WasmSignature &sig);
 std::string toString(const llvm::wasm::WasmGlobalType &type);
 std::string toString(const llvm::wasm::WasmEventType &type);
+std::string toString(const llvm::wasm::WasmTableType &type);
 
 } // namespace lld
 
 #endif // LLD_WASM_WRITERUTILS_H

lld/wasm/WriterUtils.cpp

 }
 
 std::string toString(const WasmEventType &type) {
   if (type.Attribute == WASM_EVENT_ATTRIBUTE_EXCEPTION)
     return "exception";
   return "unknown";
 }
 
+static std::string toString(const llvm::wasm::WasmLimits &limits) {
+  std::string ret;
+  ret += "flags=0x" + std::to_string(limits.Flags);
+  ret += "; initial=" + std::to_string(limits.Initial);
+  if (limits.Flags & WASM_LIMITS_FLAG_HAS_MAX)
+    ret += "; max=" + std::to_string(limits.Maximum);
+  return ret;
+}
+
+std::string toString(const WasmTableType &type) {
+  SmallString<128> ret("");
+  return "type=" + toString(static_cast<ValType>(type.ElemType)) +
+         "; limits=[" + toString(type.Limits) + "]";
+}
+
 namespace wasm {
 void debugWrite(uint64_t offset, const Twine &msg) {
   LLVM_DEBUG(dbgs() << format("  | %08lld: ", offset) << msg << "\n");
 }
 
 void writeUleb128(raw_ostream &os, uint64_t number, const Twine &msg) {
   debugWrite(os.tell(), msg + "[" + utohexstr(number) + "]");
   encodeULEB128(number, os);
void writeEventType(raw_ostream &os, const WasmEventType &type) {
   writeUleb128(os, type.SigIndex, "sig index");
 }
 
 void writeEvent(raw_ostream &os, const WasmEvent &event) {
   writeEventType(os, event.Type);
 }
 
 void writeTableType(raw_ostream &os, const WasmTableType &type) {
-  writeU8(os, WASM_TYPE_FUNCREF, "table type");
+  writeValueType(os, ValType(type.ElemType), "table type");
   writeLimits(os, type.Limits);
 }
 
 void writeImport(raw_ostream &os, const WasmImport &import) {
   writeStr(os, import.Module, "import module name");
   writeStr(os, import.Field, "import field name");
   writeU8(os, import.Kind, "import kind");
   switch (import.Kind) {

llvm/include/llvm/BinaryFormat/Wasm.h

struct WasmSymbolInfo {
   uint32_t Flags;
   // For undefined symbols the module of the import
   Optional<StringRef> ImportModule;
   // For undefined symbols the name of the import
   Optional<StringRef> ImportName;
   // For symbols to be exported from the final module
   Optional<StringRef> ExportName;
   union {
-    // For function or global symbols, the index in function or global index
-    // space.
+    // For function, table, or global symbols, the index in function, table, or
+    // global index space.
     uint32_t ElementIndex;
     // For a data symbols, the address of the data relative to segment.
     WasmDataReference DataRef;
   };
 };
 
 enum class NameType {
   FUNCTION,

llvm/include/llvm/Object/Wasm.h

 #include <vector>
 
 namespace llvm {
 namespace object {
 
 class WasmSymbol {
 public:
   WasmSymbol(const wasm::WasmSymbolInfo &Info,
-             const wasm::WasmGlobalType *GlobalType, const uint8_t TableType,
+             const wasm::WasmGlobalType *GlobalType,
+             const wasm::WasmTableType *TableType,
              const wasm::WasmEventType *EventType,
              const wasm::WasmSignature *Signature)
       : Info(Info), GlobalType(GlobalType), TableType(TableType),
         EventType(EventType), Signature(Signature) {}
 
   const wasm::WasmSymbolInfo &Info;
   const wasm::WasmGlobalType *GlobalType;
-  const uint8_t TableType;
+  const wasm::WasmTableType *TableType;
   const wasm::WasmEventType *EventType;
   const wasm::WasmSignature *Signature;
 
   bool isTypeFunction() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION;
   }
 
   bool isTypeTable() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_TABLE; }

llvm/lib/Object/WasmObjectFile.cpp

for (auto &I : Imports) {
     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::WasmTableType *TableType = nullptr;
     const wasm::WasmEventType *EventType = nullptr;
 
     Info.Kind = readUint8(Ctx);
     Info.Flags = readVaruint32(Ctx);
     bool IsDefined = (Info.Flags & wasm::WASM_SYMBOL_UNDEFINED) == 0;
 
     switch (Info.Kind) {
     case wasm::WASM_SYMBOL_TYPE_FUNCTION:
case wasm::WASM_SYMBOL_TYPE_TABLE:
       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.Type.ElemType;
+        TableType = &Table.Type;
         if (Table.SymbolName.empty())
           Table.SymbolName = Info.Name;
       } else {
         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.
+        TableType = &Import.Table;
         if (!Import.Module.empty()) {
           Info.ImportModule = Import.Module;
         }
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_DATA:
       Info.Name = readString(Ctx);

llvm/tools/llvm-readobj/WasmDumper.cpp

 using namespace object;
 
 namespace {
 
 static const EnumEntry<unsigned> WasmSymbolTypes[] = {
 #define ENUM_ENTRY(X)                                                          \
   { #X, wasm::WASM_SYMBOL_TYPE_##X }
     ENUM_ENTRY(FUNCTION), ENUM_ENTRY(DATA),  ENUM_ENTRY(GLOBAL),
-    ENUM_ENTRY(SECTION),  ENUM_ENTRY(EVENT),
+    ENUM_ENTRY(SECTION),  ENUM_ENTRY(EVENT), ENUM_ENTRY(TABLE),
 #undef ENUM_ENTRY
 };
 
 static const EnumEntry<uint32_t> WasmSectionTypes[] = {
 #define ENUM_ENTRY(X)                                                          \
   { #X, wasm::WASM_SEC_##X }
     ENUM_ENTRY(CUSTOM),   ENUM_ENTRY(TYPE),      ENUM_ENTRY(IMPORT),
     ENUM_ENTRY(FUNCTION), ENUM_ENTRY(TABLE),     ENUM_ENTRY(MEMORY),