[WebAssembly] De-dup indirect function table

[sbc100]

Summary

Create the indirect function table based on symbols rather
than just duplicating the input entries. This has the
effect of de-duplicating the table.

This is a followup to the equivalent change made for globals:

https://reviews.llvm.org/D40859

Parially based on a patch by Nicholas Wilson:

https://reviews.llvm.org/D40845

[sbc100]

• remove comment

[ruiu]

wasm/InputFiles.cpp

85–89

nit: we don't use const in such a short function as it is obvious that it is not re-assigned.

195–214

Can you add a comment to describe what this code block is expected to do?

wasm/InputFiles.h

115

Forgot to mention in previous review threads, but we have ArrayRef class, and we usually use that class instead of const std::vector<T> &. You don't need to update it in this patch, but do you mind if I ask you update it in a follow-up patch?

wasm/Writer.cpp

238

always

240

useful

339

nit: pre-increment is more conventional.

[sbc100]

• feedback

[ncw]

Fantastic! You've saved me some work, thanks. It's on my todo list for today to start splitting up the WIP Comdat reviews into smaller chunks. Plus, you've tidied it up along the way.

Could there be a test for a weakly-exported symbol, defined in two translation units, and which has its address taken in both? Something like this:

=== file 1
define weak void @weakFn() {
entry:
  ret void
}

define i32 @exportFn1() {
entry:
  ret i32 ptrtoint (void ()* @weakFn to i32)
}

=== file2

define weak void @weakFn() {
entry:
  ret void
}

define i32 @exportFn2() {
entry:
  ret i32 ptrtoint (void ()* @weakFn to i32)
}

=== Expected
  exportFn1() == exportFn2()

wasm/InputFiles.cpp

204

In my patch, I'd added support for multiple element segments. It was probably a bit overkill, but the more Wasm syntax we can support, the smaller the linking conventions can be. Doesn't really matter, this is fine.

You're checking the segment offset is zero, but for completeness do you need to check Segment.Offset.Opcode == WASM_OPCODE_I32_CONST before reading from Segment.Offset.Value.Int32?

(Finally, a couple of typos: "with all symbols that are called indirectly", "contains more than one element segment".)

[sbc100]

Good call regarding that test, I added it here in a separate change so we can see how this change effects it:
https://reviews.llvm.org/D41024

wasm/InputFiles.cpp

204

I'd rather limit support for multiple segments or non-zero-based segments because:
a) it simpler
b) clang has no use for it yet so always writes a single segment
c) its hard to produce test inputs because of (b).
d) we can always remove restrictions later

[sbc100]

• rebase

[sbc100]

• remove unused member

[ruiu]

lld/trunk/wasm/InputFiles.cpp

142 ↗

(On Diff #126443)

This function is getting longer. Please consider splitting it into multiple functions in a follow-up patch.

200–209 ↗

(On Diff #126443)

Could you add blank lines more often to split code into meaningful code blocks? For example, I'd add two blank lines at line 201 and line 207 so that the code is organized as (1) initialization, (2) error checking and (3) TableSymbols initialization.

test/wasm/call-indirect.ll

 ; CHECK-NEXT:         ParamTypes:      
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 0, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:          
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:          
 ; CHECK-NEXT:           Flags:           0x00000001
-; CHECK-NEXT:           Initial:         0x00000004
-; CHECK-NEXT:           Maximum:         0x00000004
+; CHECK-NEXT:           Initial:         0x00000003
+; CHECK-NEXT:           Maximum:         0x00000003
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:        
 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        

 ; CHECK-NEXT:       - Name:            call_bar_indirect
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           1
 ; CHECK:        - Type:            ELEM
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
-; CHECK-NEXT:         Functions:       [ 0, 2, 2 ]
+; CHECK-NEXT:         Functions:       [ 0, 2 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:       
 ; CHECK:            - Locals:          
 ; CHECK:            - Locals:          
 ; CHECK:            - Locals:          
 ; CHECK:        - Type:            DATA
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - SectionOffset:    7
 ; CHECK-NEXT:         MemoryIndex:      0
 ; CHECK-NEXT:         Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
-; CHECK-NEXT:         Content:         '010000000200000003000000'
+; CHECK-NEXT:         Content:         '010000000200000002000000'
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        12
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            bar
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Name:            call_bar_indirect
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            foo
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Name:            _start

test/wasm/weak-symbols.ll

 ; CHECK-NEXT:         ParamTypes:      
 ; CHECK-NEXT:   - Type:            FUNCTION
 ; CHECK-NEXT:     FunctionTypes:   [ 0, 1, 1, 1, 1 ]
 ; CHECK-NEXT:   - Type:            TABLE
 ; CHECK-NEXT:     Tables:          
 ; CHECK-NEXT:       - ElemType:        ANYFUNC
 ; CHECK-NEXT:         Limits:          
 ; CHECK-NEXT:           Flags:           0x00000001
-; CHECK-NEXT:           Initial:         0x00000003
-; CHECK-NEXT:           Maximum:         0x00000003
+; CHECK-NEXT:           Initial:         0x00000002
+; CHECK-NEXT:           Maximum:         0x00000002
 ; CHECK-NEXT:   - Type:            MEMORY
 ; CHECK-NEXT:     Memories:        
 ; CHECK-NEXT:       - Initial:         0x00000002
 ; CHECK-NEXT:   - Type:            GLOBAL
 ; CHECK-NEXT:     Globals:         
 ; CHECK-NEXT:       - Type:            I32
 ; CHECK-NEXT:         Mutable:         true
 ; CHECK-NEXT:         InitExpr:        

 ; CHECK-NEXT:       - Name:            exportWeak2
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           4
 ; CHECK-NEXT:   - Type:            ELEM
 ; CHECK-NEXT:     Segments:        
 ; CHECK-NEXT:       - Offset:          
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1
-; CHECK-NEXT:         Functions:       [ 1, 1 ]
+; CHECK-NEXT:         Functions:       [ 1 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:       
 ; CHECK-NEXT:       - Locals:          
 ; CHECK-NEXT:         Body:            1081808080001A0B
 ; CHECK-NEXT:       - Locals:          
 ; CHECK-NEXT:         Body:            41010B
 ; CHECK-NEXT:       - Locals:          
 ; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:       - Locals:          
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Locals:          
-; CHECK-NEXT:         Body:            4182808080000B
+; CHECK-NEXT:         Body:            4181808080000B
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            linking
 ; CHECK-NEXT:     DataSize:        0
 ; CHECK-NEXT:   - Type:            CUSTOM
 ; CHECK-NEXT:     Name:            name
 ; CHECK-NEXT:     FunctionNames:   
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Name:            _start
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Name:            exportWeak1
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Name:            exportWeak2
 ; CHECK-NEXT: ...

wasm/InputFiles.h

public:
   // Returns true if the given function index is an imported function,
   // as opposed to the locally defined function.
   bool isImportedFunction(uint32_t Index) const;
 
   size_t NumFunctionImports() const { return FunctionImports; }
   size_t NumGlobalImports() const { return GlobalImports; }
 
   int32_t FunctionIndexOffset = 0;
-  int32_t TableIndexOffset = 0;
   const WasmSection *CodeSection = nullptr;
   std::vector<OutputRelocation> CodeRelocations;
   int32_t CodeOffset = 0;
   const WasmSection *DataSection = nullptr;
 
   std::vector<uint32_t> TypeMap;
   std::vector<InputSegment *> Segments;
 
   ArrayRef<Symbol *> getSymbols() { return Symbols; }
+  ArrayRef<Symbol *> getTableSymbols() { return TableSymbols; }
 
 private:
   Symbol *createDefined(const WasmSymbol &Sym,
                         const InputSegment *Segment = nullptr);
   Symbol *createUndefined(const WasmSymbol &Sym);
   void initializeSymbols();
   InputSegment *getSegment(const WasmSymbol &WasmSym);
-  const Symbol *getFunctionSymbol(uint32_t Index) const;
-  const Symbol *getGlobalSymbol(uint32_t Index) const;
+  Symbol *getFunctionSymbol(uint32_t FunctionIndex) const;
+  Symbol *getTableSymbol(uint32_t TableIndex) const;
+  Symbol *getGlobalSymbol(uint32_t GlobalIndex) const;
 
   // List of all symbols referenced or defined by this file.
   std::vector<Symbol *> Symbols;
 
   // List of all function symbols indexed by the function index space
-  std::vector<const Symbol *> FunctionSymbols;
+  std::vector<Symbol *> FunctionSymbols;
 
   // List of all global symbols indexed by the global index space
-  std::vector<const Symbol *> GlobalSymbols;
+  std::vector<Symbol *> GlobalSymbols;
+
+  // List of all indirect symbols indexed by table index space.
+  std::vector<Symbol *> TableSymbols;
 
   uint32_t GlobalImports = 0;
   uint32_t FunctionImports = 0;
   std::unique_ptr<WasmObjectFile> WasmObj;
 };
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
 
 } // namespace wasm
 
 std::string toString(const wasm::InputFile *File);
 
 } // namespace lld
 
 #endif

wasm/InputFiles.cpp

Optional<MemoryBufferRef> lld::wasm::readFile(StringRef Path) {
 
   return MBRef;
 }
 
 void ObjFile::dumpInfo() const {
   log("reloc info for: " + getName() + "\n" +
       "        FunctionIndexOffset : " + Twine(FunctionIndexOffset) + "\n" +
       "         NumFunctionImports : " + Twine(NumFunctionImports()) + "\n" +
-      "           TableIndexOffset : " + Twine(TableIndexOffset) + "\n" +
       "           NumGlobalImports : " + Twine(NumGlobalImports()) + "\n");
 }
 
 bool ObjFile::isImportedFunction(uint32_t Index) const {
   return Index < NumFunctionImports();
 }
 
-const Symbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
+Symbol *ObjFile::getFunctionSymbol(uint32_t Index) const {
   return FunctionSymbols[Index];
 }
 
-const Symbol *ObjFile::getGlobalSymbol(uint32_t Index) const {
+Symbol *ObjFile::getTableSymbol(uint32_t Index) const {
+  return TableSymbols[Index];
+}
+
+Symbol *ObjFile::getGlobalSymbol(uint32_t Index) const {
   return GlobalSymbols[Index];
 }
 
 uint32_t ObjFile::getRelocatedAddress(uint32_t Index) const {
   return getGlobalSymbol(Index)->getVirtualAddress();
 }
 
 uint32_t ObjFile::relocateFunctionIndex(uint32_t Original) const {
-  const Symbol *Sym = getFunctionSymbol(Original);
+  Symbol *Sym = getFunctionSymbol(Original);
   uint32_t Index = Sym->getOutputIndex();
   DEBUG(dbgs() << "relocateFunctionIndex: " << toString(*Sym) << ": "
                << Original << " -> " << Index << "\n");
   return Index;
 }
 
 uint32_t ObjFile::relocateTypeIndex(uint32_t Original) const {
   return TypeMap[Original];
 }
 
 uint32_t ObjFile::relocateTableIndex(uint32_t Original) const {
-  return Original + TableIndexOffset;
+  Symbol *Sym = getTableSymbol(Original);
+  uint32_t Index = Sym->getTableIndex();
+  DEBUG(dbgs() << "relocateTableIndex: " << toString(*Sym) << ": " << Original
+               << " -> " << Index << "\n");
+  return Index;
 }
 
 uint32_t ObjFile::relocateGlobalIndex(uint32_t Original) const {
-  const Symbol *Sym = getGlobalSymbol(Original);
+  Symbol *Sym = getGlobalSymbol(Original);
   uint32_t Index = Sym->getOutputIndex();
   DEBUG(dbgs() << "relocateGlobalIndex: " << toString(*Sym) << ": " << Original
                << " -> " << Index << "\n");
   return Index;
 }
 
 void ObjFile::parse() {
   // Parse a memory buffer as a wasm file.
void ObjFile::initializeSymbols() {
   }
 
   FunctionSymbols.resize(FunctionImports + WasmObj->functions().size());
   GlobalSymbols.resize(GlobalImports + WasmObj->globals().size());
 
   for (const WasmSegment &Seg : WasmObj->dataSegments())
     Segments.emplace_back(make<InputSegment>(&Seg, this));
 
-  Symbol *S;
+  // Populate `FunctionSymbols` and `GlobalSymbols` based on the WasmSymbols
+  // in the object
   for (const SymbolRef &Sym : WasmObj->symbols()) {
     const WasmSymbol &WasmSym = WasmObj->getWasmSymbol(Sym.getRawDataRefImpl());
+    Symbol *S;
     switch (WasmSym.Type) {
     case WasmSymbol::SymbolType::FUNCTION_IMPORT:
     case WasmSymbol::SymbolType::GLOBAL_IMPORT:
       S = createUndefined(WasmSym);
       break;
     case WasmSymbol::SymbolType::GLOBAL_EXPORT:
       S = createDefined(WasmSym, getSegment(WasmSym));
       break;
if (WasmSym.isFunction()) {
       FunctionSymbols[WasmSym.ElementIndex] = S;
     } else {
       DEBUG(dbgs() << "Global: " << WasmSym.ElementIndex << " -> "
                    << toString(*S) << "\n");
       GlobalSymbols[WasmSym.ElementIndex] = S;
     }
   }
 
-  DEBUG(dbgs() << "Functions: " << FunctionSymbols.size() << "\n");
-  DEBUG(dbgs() << "Globals  : " << GlobalSymbols.size() << "\n");
+  // Populate `TableSymbols` with all symbols that are called indirectly
+  uint32_t SegmentCount = WasmObj->elements().size();
+  if (SegmentCount) {
+    if (SegmentCount > 1)
+      fatal(getName() + ": contains more than one element segment");
+    const WasmElemSegment &Segment = WasmObj->elements()[0];
+    if (Segment.Offset.Opcode != WASM_OPCODE_I32_CONST)
+      fatal(getName() + ": unsupported element segment");
+    if (Segment.TableIndex != 0)
+      fatal(getName() + ": unsupported table index in elem segment");
+    if (Segment.Offset.Value.Int32 != 0)
+      fatal(getName() + ": unsupported element segment offset");
+    TableSymbols.reserve(Segment.Functions.size());
+    for (uint64_t FunctionIndex : Segment.Functions)
+      TableSymbols.push_back(getFunctionSymbol(FunctionIndex));
+  }
+
+  DEBUG(dbgs() << "TableSymbols: " << TableSymbols.size() << "\n");
+  DEBUG(dbgs() << "Functions   : " << FunctionSymbols.size() << "\n");
+  DEBUG(dbgs() << "Globals     : " << GlobalSymbols.size() << "\n");
 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &Sym) {
   return Symtab->addUndefined(this, &Sym);
 }
 
 Symbol *ObjFile::createDefined(const WasmSymbol &Sym,
                                const InputSegment *Segment) {

wasm/Symbols.h

public:
   InputFile *getFile() const { return File; }
 
   uint32_t getGlobalIndex() const;
   uint32_t getFunctionIndex() const;
 
   bool hasFunctionType() const { return FunctionType != nullptr; }
   const WasmSignature &getFunctionType() const;
   uint32_t getOutputIndex() const;
+  uint32_t getTableIndex() const { return TableIndex.getValue(); }
 
   // Returns the virtual address of a defined global.
   // Only works for globals, not functions.
   uint32_t getVirtualAddress() const;
 
   // Returns true if an output index has been set for this symbol
   bool hasOutputIndex() const { return OutputIndex.hasValue(); }
 
   // Set the output index of the symbol (in the function or global index
   // space of the output object.
   void setOutputIndex(uint32_t Index);
 
+  // Returns true if a table index has been set for this symbol
+  bool hasTableIndex() const { return TableIndex.hasValue(); }
+
+  // Set the table index of the symbol
+  void setTableIndex(uint32_t Index);
+
   void setVirtualAddress(uint32_t VA);
 
   void update(Kind K, InputFile *F = nullptr, const WasmSymbol *Sym = nullptr,
               const InputSegment *Segment = nullptr,
               const WasmSignature *Sig = nullptr);
 
   void setArchiveSymbol(const Archive::Symbol &Sym) { ArchiveSymbol = Sym; }
   const Archive::Symbol &getArchiveSymbol() { return ArchiveSymbol; }
 
   // This bit is used by Writer::writeNameSection() to prevent
   // symbols from being written to the symbol table more than once.
   unsigned WrittenToSymtab : 1;
   unsigned WrittenToNameSec : 1;
 
 protected:
   unsigned IsLocal : 1;
 
   StringRef Name;
   Archive::Symbol ArchiveSymbol = {nullptr, 0, 0};
   Kind SymbolKind = InvalidKind;
   InputFile *File = nullptr;
   const WasmSymbol *Sym = nullptr;
   const InputSegment *Segment = nullptr;
   llvm::Optional<uint32_t> OutputIndex;
+  llvm::Optional<uint32_t> TableIndex;
   llvm::Optional<uint32_t> VirtualAddress;
   const WasmSignature *FunctionType;
 };
 
 } // namespace wasm
 
 // Returns a symbol name for an error message.
 std::string toString(const wasm::Symbol &Sym);
 std::string toString(wasm::Symbol::Kind Kind);
 
 } // namespace lld
 
 #endif

wasm/Symbols.cpp

 void Symbol::setVirtualAddress(uint32_t Value) {
   DEBUG(dbgs() << "setVirtualAddress " << Name << " -> " << Value << "\n");
   assert(!VirtualAddress.hasValue());
   VirtualAddress = Value;
 }
 
 void Symbol::setOutputIndex(uint32_t Index) {
   DEBUG(dbgs() << "setOutputIndex " << Name << " -> " << Index << "\n");
-  assert(!hasOutputIndex());
+  assert(!OutputIndex.hasValue());
   OutputIndex = Index;
 }
 
+void Symbol::setTableIndex(uint32_t Index) {
+  DEBUG(dbgs() << "setTableIndex " << Name << " -> " << Index << "\n");
+  assert(!TableIndex.hasValue());
+  TableIndex = Index;
+}
+
 void Symbol::update(Kind K, InputFile *F, const WasmSymbol *WasmSym,
                     const InputSegment *Seg, const WasmSignature *Sig) {
   SymbolKind = K;
   File = F;
   Sym = WasmSym;
   Segment = Seg;
   FunctionType = Sig;
 }

wasm/Writer.cpp

private:
   void writeHeader();
   void writeSections();
 
   uint64_t FileSize = 0;
   uint32_t DataSize = 0;
   uint32_t NumFunctions = 0;
   uint32_t NumGlobals = 0;
   uint32_t NumMemoryPages = 0;
-  uint32_t NumTableElems = 0;
-  uint32_t NumElements = 0;
   uint32_t InitialTableOffset = 0;
 
   std::vector<const WasmSignature *> Types;
   DenseMap<WasmSignature, int32_t, WasmSignatureDenseMapInfo> TypeIndices;
   std::vector<const Symbol *> FunctionImports;
   std::vector<const Symbol *> GlobalImports;
   std::vector<const Symbol *> DefinedGlobals;
+  std::vector<const Symbol *> IndirectFunctions;
 
   // Elements that are used to construct the final output
   std::string Header;
   std::vector<OutputSection *> OutputSections;
 
   std::unique_ptr<FileOutputBuffer> Buffer;
 
   std::vector<OutputSegment *> Segments;
for (const Symbol *Sym : DefinedGlobals) {
     Global.Mutable = Sym == Config->StackPointerSymbol;
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.InitExpr.Value.Int32 = Sym->getVirtualAddress();
     writeGlobal(OS, Global);
   }
 }
 
 void Writer::createTableSection() {
+  // Always output a table section, even if there are no indirect calls.
+  // 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.
+  uint32_t TableSize = InitialTableOffset + IndirectFunctions.size();
+
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_TABLE);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "table count");
   writeSleb128(OS, WASM_TYPE_ANYFUNC, "table type");
   writeUleb128(OS, WASM_LIMITS_FLAG_HAS_MAX, "table flags");
-  writeUleb128(OS, NumTableElems, "table initial size");
-  writeUleb128(OS, NumTableElems, "table max size");
+  writeUleb128(OS, TableSize, "table initial size");
+  writeUleb128(OS, TableSize, "table max size");
 }
 
 void Writer::createExportSection() {
   bool ExportMemory = !Config->Relocatable && !Config->ImportMemory;
   Symbol *EntrySym = Symtab->find(Config->Entry);
   bool ExportEntry = !Config->Relocatable && EntrySym && EntrySym->isDefined();
   bool ExportHidden = Config->EmitRelocs;
 
else
       Export.Kind = WASM_EXTERNAL_GLOBAL;
     writeExport(OS, Export);
   }
 }
 
 void Writer::createStartSection() {}
 
 void Writer::createElemSection() {
-  if (!NumElements)
+  if (IndirectFunctions.empty())
     return;
 
   SyntheticSection *Section = createSyntheticSection(WASM_SEC_ELEM);
   raw_ostream &OS = Section->getStream();
 
   writeUleb128(OS, 1, "segment count");
   writeUleb128(OS, 0, "table index");
   WasmInitExpr InitExpr;
   InitExpr.Opcode = WASM_OPCODE_I32_CONST;
   InitExpr.Value.Int32 = InitialTableOffset;
   writeInitExpr(OS, InitExpr);
-  writeUleb128(OS, NumElements, "elem count");
+  writeUleb128(OS, IndirectFunctions.size(), "elem count");
 
-  for (ObjFile *File : Symtab->ObjectFiles)
-    for (const WasmElemSegment &Segment : File->getWasmObj()->elements())
-      for (uint64_t FunctionIndex : Segment.Functions)
-        writeUleb128(OS, File->relocateFunctionIndex(FunctionIndex),
-                     "function index");
+  uint32_t TableIndex = InitialTableOffset;
+  for (const Symbol *Sym : IndirectFunctions) {
+    assert(Sym->getTableIndex() == TableIndex);
+    writeUleb128(OS, Sym->getOutputIndex(), "function index");
+    ++TableIndex;
+  }
 }
 
 void Writer::createCodeSection() {
   if (!NumFunctions)
     return;
 
   log("createCodeSection");
 
void Writer::createSections() {
   for (OutputSection *S : OutputSections) {
     S->setOffset(FileSize);
     S->finalizeContents();
     FileSize += S->getSize();
   }
 }
 
 void Writer::calculateOffsets() {
-  NumTableElems = InitialTableOffset;
-
   for (ObjFile *File : Symtab->ObjectFiles) {
     const WasmObjectFile *WasmFile = File->getWasmObj();
 
     // Function Index
     File->FunctionIndexOffset =
         FunctionImports.size() - File->NumFunctionImports() + NumFunctions;
     NumFunctions += WasmFile->functions().size();
 
     // Memory
-    if (WasmFile->memories().size()) {
-      if (WasmFile->memories().size() > 1) {
-        fatal(File->getName() + ": contains more than one memory");
-      }
-    }
+    if (WasmFile->memories().size() > 1)
 
-    // Table
-    uint32_t TableCount = WasmFile->tables().size();
-    if (TableCount) {
-      if (TableCount > 1)
-        fatal(File->getName() + ": contains more than one table");
-      File->TableIndexOffset = NumTableElems;
-      NumTableElems += WasmFile->tables()[0].Limits.Initial;
-    }
-
-    // Elem
-    uint32_t SegmentCount = WasmFile->elements().size();
-    if (SegmentCount) {
-      if (SegmentCount > 1)
-        fatal(File->getName() + ": contains more than element segment");
-
-      const WasmElemSegment &Segment = WasmFile->elements()[0];
-      if (Segment.TableIndex != 0)
-        fatal(File->getName() + ": unsupported table index");
-      if (Segment.Offset.Value.Int32 != 0)
-        fatal(File->getName() + ": unsupported segment offset");
-      NumElements += Segment.Functions.size();
-    }
-  }
-}
-
 void Writer::calculateImports() {
   for (ObjFile *File : Symtab->ObjectFiles) {
     for (Symbol *Sym : File->getSymbols()) {
       if (Sym->hasOutputIndex() || Sym->isDefined() || Sym->isWeak())
         continue;
 
       if (Sym->isFunction()) {
         Sym->setOutputIndex(FunctionImports.size());
void Writer::assignSymbolIndexes() {
   if (Config->StackPointerSymbol) {
     DefinedGlobals.emplace_back(Config->StackPointerSymbol);
     Config->StackPointerSymbol->setOutputIndex(GlobalIndex++);
   }
 
   if (Config->EmitRelocs)
     DefinedGlobals.reserve(Symtab->getSymbols().size());
 
+  uint32_t TableIndex = InitialTableOffset;
+
   for (ObjFile *File : Symtab->ObjectFiles) {
     DEBUG(dbgs() << "assignSymbolIndexes: " << File->getName() << "\n");
+
     for (Symbol *Sym : File->getSymbols()) {
       if (Sym->hasOutputIndex() || !Sym->isDefined())
         continue;
 
       if (Sym->isFunction()) {
         if (Sym->getFile() && isa<ObjFile>(Sym->getFile())) {
           auto *Obj = cast<ObjFile>(Sym->getFile());
           Sym->setOutputIndex(Obj->FunctionIndexOffset +
                               Sym->getFunctionIndex());
         }
       } else if (Config->EmitRelocs) {
         DefinedGlobals.emplace_back(Sym);
         Sym->setOutputIndex(GlobalIndex++);
       }
     }
+
+    for (Symbol *Sym : File->getTableSymbols()) {
+      if (!Sym->hasTableIndex()) {
+        Sym->setTableIndex(TableIndex++);
+        IndirectFunctions.emplace_back(Sym);
+      }
+    }
   }
 }
 
 static StringRef getOutputDataSegmentName(StringRef Name) {
   if (Config->Relocatable)
     return Name;
 
   for (StringRef V :