[WebAssembly] Only emit indirect function table import if needed

[wingo]

Summary

The indirect function table, synthesized by the linker, is needed if and
only if there are TABLE_INDEX relocs.

[wingo]

I have run CodeGen/WebAssembly, MC/WebAssembly, and lld/test/wasm tests, which pass. Split off from https://reviews.llvm.org/D90948.

[wingo]

Still has the bad aspect of doing function table symbol creation in MCContext. Will look deeper there tomorrow. Does this size of the change look OK to you, @sbc100 ?

[sbc100]

This looks pretty much like I was suggesting, although I was hoping we could make it more isolated by just making the creation of the existing table import conditional rather than creating a new MC symbol.

llvm/lib/MC/WasmObjectWriter.cpp

506

Can we just move the code below, or make it conditional to avoid the MCConteext changes?

(i.e. can we make this change local to this file?)

[sbc100]

What I was hoping for here is minimal change to the object writer to remove the table from object files that don't reference it. This seem separable from the question of whether the indirection function table should be first class MC symbol .. although maybe I'm taking this CL splitting thing to far.

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

242 ↗

(On Diff #305814)

Why did these changes occur? Do you have some tool to automatically updating the expected output?

[wingo]

In D91637#2400474, @sbc100 wrote:

What I was hoping for here is minimal change to the object writer to remove the table from object files that don't reference it. This seem separable from the question of whether the indirection function table should be first class MC symbol .. although maybe I'm taking this CL splitting thing to far.

Just backing up a bit for context -- the end goal to add support to wasm-ld for linking object files that reference tables; pruning needless __indirect_function_table imports is a "side quest". To link tables, I need relocs for all table references written to object files, and linker symtab entries for all tables. Do you agree that a first-class MCSymbol is a part of that final pipeline? If so, I think we're on the good path here, and that using a different mechanism would just require more testing when we put the MCSymbol mechanism in place. Anyway, just a gentle argument that it seems to me that this is about the right patch size, though whether we have the symbol creation in MCContext is another question of course.

llvm/lib/MC/WasmObjectWriter.cpp

506

We certainly can. However, with the next patch, we will need to call getOrCreateWasmDefaultFunctionTableSymbol from three places in Target/WebAssembly: the asm parser and from the two instruction selectors. Do you prefer to duplicate this code there?

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

242 ↗

(On Diff #305814)

I just checked and these changes are unnecessary. I will remove this change from this patch.

What is going on here fwiw is that the weak-alias test will change when table numbers get encoded as 5-byte relocs, so this file was on the changeset for the TABLE_NUMBER patch. I updated that test by pasting in the output of the obj2yaml with the prefix. That's where these extraneous bits come in.

When I removed the test changes corresponding to the TABLE_NUMBER patch, we're just left with this meaningless update.

[wingo]

• Remove needless change to weak-alias.s

[sbc100]

In D91637#2404799, @wingo wrote:

In D91637#2400474, @sbc100 wrote:

What I was hoping for here is minimal change to the object writer to remove the table from object files that don't reference it. This seem separable from the question of whether the indirection function table should be first class MC symbol .. although maybe I'm taking this CL splitting thing to far.

Just backing up a bit for context -- the end goal to add support to wasm-ld for linking object files that reference tables; pruning needless __indirect_function_table imports is a "side quest". To link tables, I need relocs for all table references written to object files, and linker symtab entries for all tables. Do you agree that a first-class MCSymbol is a part of that final pipeline? If so, I think we're on the good path here, and that using a different mechanism would just require more testing when we put the MCSymbol mechanism in place. Anyway, just a gentle argument that it seems to me that this is about the right patch size, though whether we have the symbol creation in MCContext is another question of course.

Yes, I was thinking we could just land the side quest (I like that term!) quickly without too much discussion. If you want to include the MCSymbol creation in addtion then I'm not averse to that.. but as you say, that means we have to figure if the target-independent MCContext is the right place for the two new function (getOrCreateWasmFunctionTableSymbol). My gut tells me it not, but I'm also no an expert in these areas... @tlively @aardappel might have some idea where the right place for this kind of thing is.

[wingo]

• Move __indirect_function_table reference to WasmObjectWriter

[wingo]

llvm/lib/MC/WasmObjectWriter.cpp

506

In the end I think you are right and that in this patch, no need to muck with MCContext.h. If we should factor out a function, it will become obvious in future patches.

[sbc100]

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

97

What happened here?

llvm/test/MC/WebAssembly/tables.s

211

Where these here before but just not being checked for I guess?

[sbc100]

llvm/lib/MC/WasmObjectWriter.cpp

503

Perhaps add a TODO here since we probably don't to keep this here long right?

[wingo]

llvm/lib/MC/WasmObjectWriter.cpp

503

We keep this one, I think. Currently call_indirect has no relocs. In the future it will have TABLE_NUMBER relocs. TABLE_INDEX relocs will stay around, used for function pointers.

In some future it might be useful to have the TABLE_INDEX relocs specify an "address space" in the form of a table number (table symbol reference); i.e. the EXTENDED_TABLE_INDEX reloc would be against both a function symbol and a table symbol. But until then, and until such a use case arises, I think TABLE_INDEX relocs still implicitly use __indirect_function_table. WDYT?

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

97

This is the result of replacing the whole CHECK+CHECK_NEXT* block with the output of the command in question. Harmless AFAIU, but extraneous also, so I have removed it.

llvm/test/MC/WebAssembly/tables.s

211

I just checked and yes, they were here before and not being checked for.

[wingo]

Remove extraneous test change

[wingo]

If this looks good to you, feel very free to land :)

[sbc100]

This patch doesn't seem to apply to the master branch of llvm.

It also says this when I run arc patch:

This diff is against commit e0257d84325828a4faddfaf48512358aa9681632, but
 the commit is nowhere in the working copy. Try to apply it against the
 current working copy state? (1a036e9cc82a7f6d6f4675d631fa5eecd8748784)
 [Y/n]

Perhaps you need to rebase?

[wingo]

In D91637#2414112, @sbc100 wrote:

This patch doesn't seem to apply to the master branch of llvm.

Conflicts with https://reviews.llvm.org/D90930 apparently; will fix.

It also says this when I run arc patch:

This diff is against commit e0257d84325828a4faddfaf48512358aa9681632, but
 the commit is nowhere in the working copy. Try to apply it against the
 current working copy state? (1a036e9cc82a7f6d6f4675d631fa5eecd8748784)
 [Y/n]

Perhaps you need to rebase?

Yeah the patch was on a local copy of the already-landed https://reviews.llvm.org/D91635. Will rebase,

[wingo]

Rebase

[sbc100]

llvm/lib/Object/WasmObjectFile.cpp

491

We should probably get smarter about these over allocations now that we have so many different import types here.

Unrelated to this CL though.

[sbc100]

Looks like we need one more rebase now that https://reviews.llvm.org/D91849 has landed.

[wingo]

Rebase

[wingo]

In D91637#2416402, @sbc100 wrote:

Looks like we need one more rebase now that https://reviews.llvm.org/D91849 has landed.

done, thanks for your patience; MC, CodeGen, and lld WebAssembly tests checked and passing.

llvm/include/llvm/MC/MCSymbolWasm.h

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

llvm/include/llvm/Object/Wasm.h

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

llvm/lib/MC/WasmObjectWriter.cpp

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

llvm/lib/Object/WasmObjectFile.cpp

Error WasmObjectFile::parseLinkingSectionSymtab(ReadContext &Ctx) {
   uint32_t Count = readVaruint32(Ctx);
   LinkingData.SymbolTable.reserve(Count);
   Symbols.reserve(Count);
   StringSet<> SymbolNames;
 
   std::vector<wasm::WasmImport *> ImportedGlobals;
   std::vector<wasm::WasmImport *> ImportedFunctions;
   std::vector<wasm::WasmImport *> ImportedEvents;
+  std::vector<wasm::WasmImport *> ImportedTables;
   ImportedGlobals.reserve(Imports.size());
   ImportedFunctions.reserve(Imports.size());
   ImportedEvents.reserve(Imports.size());
+  ImportedTables.reserve(Imports.size());
   for (auto &I : Imports) {
     if (I.Kind == wasm::WASM_EXTERNAL_FUNCTION)
       ImportedFunctions.emplace_back(&I);
     else if (I.Kind == wasm::WASM_EXTERNAL_GLOBAL)
       ImportedGlobals.emplace_back(&I);
     else if (I.Kind == wasm::WASM_EXTERNAL_EVENT)
       ImportedEvents.emplace_back(&I);
+    else if (I.Kind == wasm::WASM_EXTERNAL_TABLE)
+      ImportedTables.emplace_back(&I);
   }
 
   while (Count--) {
     wasm::WasmSymbolInfo Info;
     const wasm::WasmSignature *Signature = nullptr;
     const wasm::WasmGlobalType *GlobalType = nullptr;
     uint8_t TableType = 0;
     const wasm::WasmEventType *EventType = nullptr;
case wasm::WASM_SYMBOL_TYPE_TABLE:
         return make_error<GenericBinaryError>("undefined weak table symbol",
                                               object_error::parse_failed);
       if (IsDefined) {
         Info.Name = readString(Ctx);
         unsigned TableIndex = Info.ElementIndex - NumImportedTables;
         wasm::WasmTable &Table = Tables[TableIndex];
         TableType = Table.ElemType;
       } else {
-        return make_error<GenericBinaryError>("undefined table symbol",
-                                              object_error::parse_failed);
+        wasm::WasmImport &Import = *ImportedTables[Info.ElementIndex];
+        if ((Info.Flags & wasm::WASM_SYMBOL_EXPLICIT_NAME) != 0) {
+          Info.Name = readString(Ctx);
+          Info.ImportName = Import.Field;
+        } else {
+          Info.Name = Import.Field;
+        }
+        TableType = Import.Table.ElemType;
+        // FIXME: Parse limits here too.
+        if (!Import.Module.empty()) {
+          Info.ImportModule = Import.Module;
+        }
       }
       break;
 
     case wasm::WASM_SYMBOL_TYPE_DATA:
       Info.Name = readString(Ctx);
       if (IsDefined) {
         auto Index = readVaruint32(Ctx);
         if (Index >= DataSegments.size())
Error WasmObjectFile::parseFunctionSection(ReadContext &Ctx) {
   }
   if (Ctx.Ptr != Ctx.End)
     return make_error<GenericBinaryError>("Function section ended prematurely",
                                           object_error::parse_failed);
   return Error::success();
 }
 
 Error WasmObjectFile::parseTableSection(ReadContext &Ctx) {
+  TableSection = Sections.size();
   uint32_t Count = readVaruint32(Ctx);
   Tables.reserve(Count);
   while (Count--) {
     wasm::WasmTable T = readTable(Ctx);
     T.Index = NumImportedTables + Tables.size();
     Tables.push_back(T);
     auto ElemType = Tables.back().ElemType;
     if (ElemType != wasm::WASM_TYPE_FUNCREF &&
else
     return getSymbolValue(Symb);
 }
 
 uint64_t WasmObjectFile::getWasmSymbolValue(const WasmSymbol &Sym) const {
   switch (Sym.Info.Kind) {
   case wasm::WASM_SYMBOL_TYPE_FUNCTION:
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
   case wasm::WASM_SYMBOL_TYPE_EVENT:
+  case wasm::WASM_SYMBOL_TYPE_TABLE:
     return Sym.Info.ElementIndex;
   case wasm::WASM_SYMBOL_TYPE_DATA: {
     // The value of a data symbol is the segment offset, plus the symbol
     // offset within the segment.
     uint32_t SegmentIndex = Sym.Info.DataRef.Segment;
     const wasm::WasmDataSegment &Segment = DataSegments[SegmentIndex].Data;
     if (Segment.Offset.Opcode == wasm::WASM_OPCODE_I32_CONST) {
       return Segment.Offset.Value.Int32 + Sym.Info.DataRef.Offset;
WasmObjectFile::getSymbolType(DataRefImpl Symb) const {
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     return SymbolRef::ST_Other;
   case wasm::WASM_SYMBOL_TYPE_DATA:
     return SymbolRef::ST_Data;
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return SymbolRef::ST_Debug;
   case wasm::WASM_SYMBOL_TYPE_EVENT:
     return SymbolRef::ST_Other;
+  case wasm::WASM_SYMBOL_TYPE_TABLE:
+    return SymbolRef::ST_Other;
   }
 
   llvm_unreachable("Unknown WasmSymbol::SymbolType");
   return SymbolRef::ST_Other;
 }
 
 Expected<section_iterator>
 WasmObjectFile::getSymbolSection(DataRefImpl Symb) const {
uint32_t WasmObjectFile::getSymbolSectionIdImpl(const WasmSymbol &Sym) const {
   case wasm::WASM_SYMBOL_TYPE_GLOBAL:
     return GlobalSection;
   case wasm::WASM_SYMBOL_TYPE_DATA:
     return DataSection;
   case wasm::WASM_SYMBOL_TYPE_SECTION:
     return Sym.Info.ElementIndex;
   case wasm::WASM_SYMBOL_TYPE_EVENT:
     return EventSection;
+  case wasm::WASM_SYMBOL_TYPE_TABLE:
+    return TableSection;
   default:
     llvm_unreachable("Unknown WasmSymbol::SymbolType");
   }
 }
 
 void WasmObjectFile::moveSectionNext(DataRefImpl &Sec) const { Sec.d.a++; }
 
 Expected<StringRef> WasmObjectFile::getSectionName(DataRefImpl Sec) const {

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

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

llvm/test/MC/WebAssembly/comdat.ll

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

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

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

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

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

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

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

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

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

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

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

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

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

llvm/test/MC/WebAssembly/tables.s

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

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

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

 # BIN-NEXT:           - F64
 # BIN-NEXT:   - Type:            IMPORT
 # BIN-NEXT:     Imports:
 # BIN-NEXT:       - Module:          env
 # BIN-NEXT:         Field:           __linear_memory
 # BIN-NEXT:         Kind:            MEMORY
 # BIN-NEXT:         Memory:
 # BIN-NEXT:           Initial:         0x00000000
-# BIN-NEXT:       - Module:          env
-# BIN-NEXT:         Field:           __indirect_function_table
-# BIN-NEXT:         Kind:            TABLE
-# BIN-NEXT:         Table:
-# BIN-NEXT:           Index:           0
-# BIN-NEXT:           ElemType:        FUNCREF
-# BIN-NEXT:           Limits:
-# BIN-NEXT:             Initial:         0x00000000
 # BIN-NEXT:   - Type:            FUNCTION
 # BIN-NEXT:     FunctionTypes:   [ 0 ]
 # BIN-NEXT:   - Type:            CODE
 # BIN-NEXT:     Relocations:
 # BIN-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # BIN-NEXT:         Index:           1
 # BIN-NEXT:         Offset:          0x00000004
 # BIN-NEXT:     Functions:

llvm/test/MC/WebAssembly/wasm64.s

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