Revert "[WebAssembly] call_indirect issues table number relocs"

[sbc100]

Summary

This reverts commit 418df4a6ab35d343cc0f2608c90a73dd9b8d0ab1.

This change broke emscripten tests, I believe because it started
generating 5-byte a wide table index in the call_indirect instruction.
Neither v8 nor wabt seem to be able to handle that. The spec
currently says that this is single 0x0 byte and:

"In future versions of WebAssembly, the zero byte occurring in the
encoding of the call_indirectcall_indirect instruction may be used to
index additional tables."

So we need to revisit this change. For backwards compat I guess
we need to guarantee that __indirect_function_table is always at
address zero. We could also consider making this a single-byte
relocation with and assert if have more than 127 tables (for now).

[dschuff]

actually, is the problem that the reftypes proposal isn't on by default yet?

[dschuff]

oh, i see what you mean. for MVP compat the 0 has to be one byte and not 5

[wingo]

:-(

I checked FWIW and all browsers I had access to read the table index as a uleb, and simply assert that it's 0.

[wingo]

Furthermore the table index should always be 0 unless you define more tables, so I thought I had MVP compat handled. Evidently not :(

[wingo]

I see, V8 decodes as a uleb, but asserts that the length is 1: https://chromium.googlesource.com/v8/v8.git/+/refs/heads/master/src/wasm/function-body-decoder-impl.h#616

[sbc100]

In D95005#2508950, @wingo wrote:

Furthermore the table index should always be 0 unless you define more tables, so I thought I had MVP compat handled. Evidently not :(

Perhaps you were using wasm-opt after linking? (or some other binaryen tool) Round-tripping through binaryen will always shrink the wide LEBs.

lld/test/wasm/call-indirect.ll

 ; CHECK-NEXT:         Functions:       [ 0, 2 ]
 ; CHECK-NEXT:   - Type:            CODE
 ; CHECK-NEXT:     Functions:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            42010B
 ; CHECK-NEXT:       - Index:           1
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            41002802808880800011808080800080808080001A41002802848880800011818080800080808080001A0B
+; CHECK-NEXT:         Body:            410028028088808000118080808000001A410028028488808000118180808000001A0B
 ; CHECK-NEXT:       - Index:           2
 ; CHECK-NEXT:         Locals:
 ; CHECK-NEXT:         Body:            41020B
 ; CHECK-NEXT:       - Index:           3
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            41002802888880800011818080800080808080001A0B
+; CHECK-NEXT:         Body:            410028028888808000118180808000001A0B
 ; CHECK-NEXT:       - Index:           4
 ; CHECK-NEXT:         Locals:
-; CHECK-NEXT:         Body:            4201200011828080800080808080001A0B
+; CHECK-NEXT:         Body:            42012000118280808000001A0B
 ; CHECK-NEXT:   - Type:            DATA
 ; CHECK-NEXT:     Segments:
 ; CHECK-NEXT:       - SectionOffset:    7
 ; CHECK-NEXT:         InitFlags:        0
 ; CHECK-NEXT:         Offset:
 ; CHECK-NEXT:           Opcode:          I32_CONST
 ; CHECK-NEXT:           Value:           1024
 ; CHECK-NEXT:         Content:         '010000000200000002000000'

lld/test/wasm/compress-relocs.ll

 
 define void @_start() local_unnamed_addr {
 entry:
   ret void
 }
 
 ; ERROR: wasm-ld: error: --compress-relocations is incompatible with output debug information. Please pass --strip-debug or --strip-all
 
-; CHECK:    Body:            41002802808880800011808080800080808080001A41002802848880800011818080800080808080001A0B
+; CHECK:    Body:            410028028088808000118080808000001A410028028488808000118180808000001A0B
 ; COMPRESS: Body:            4100280280081100001A4100280284081101001A0B

lld/test/wasm/shared.ll

 ; 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:          env
-; CHECK-NEXT:         Field:           func_external
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         SigIndex:        1
 ; 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

llvm/lib/MC/WasmObjectWriter.cpp

 // Emit the Wasm header.
 void WasmObjectWriter::writeHeader(const MCAssembler &Asm) {
   W->OS.write(wasm::WasmMagic, sizeof(wasm::WasmMagic));
   W->write<uint32_t>(wasm::WasmVersion);
 }
 
 void WasmObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
                                                 const MCAsmLayout &Layout) {
+  // As a stopgap measure until call_indirect instructions start explicitly
+  // referencing the indirect function table via TABLE_NUMBER relocs, ensure
+  // that the indirect function table import makes it to the output if anything
+  // in the compilation unit has caused it to be present.
+  if (auto *Sym = Asm.getContext().lookupSymbol("__indirect_function_table"))
+    Asm.registerSymbol(*Sym);
+
   // Build a map of sections to the function that defines them, for use
   // in recordRelocation.
   for (const MCSymbol &S : Asm.symbols()) {
     const auto &WS = static_cast<const MCSymbolWasm &>(S);
     if (WS.isDefined() && WS.isFunction() && !WS.isVariable()) {
       const auto &Sec = static_cast<const MCSectionWasm &>(S.getSection());
       auto Pair = SectionFunctions.insert(std::make_pair(&Sec, &S));
       if (!Pair.second)

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

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

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

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

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

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

llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

bool WebAssemblyFastISel::selectCall(const Instruction *I) {
   auto MIB = BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, DbgLoc, TII.get(Opc));
 
   if (!IsVoid)
     MIB.addReg(ResultReg, RegState::Define);
 
   if (IsDirect) {
     MIB.addGlobalAddress(Func);
   } else {
-    // Placehoder for the type index.
+    // Add placeholders for the type index and immediate flags
     MIB.addImm(0);
-    // The table into which this call_indirect indexes.
-    MIB.addSym(WebAssembly::getOrCreateFunctionTableSymbol(
-        MF->getMMI().getContext(), "__indirect_function_table"));
+    MIB.addImm(0);
+
+    // Ensure that the object file has a __indirect_function_table import, as we
+    // call_indirect against it.
+    MCSymbolWasm *Sym = WebAssembly::getOrCreateFunctionTableSymbol(
+        MF->getMMI().getContext(), "__indirect_function_table");
+    // Until call_indirect emits TABLE_NUMBER relocs against this symbol, mark
+    // it as NO_STRIP so as to ensure that the indirect function table makes it
+    // to linked output.
+    Sym->setNoStrip();
   }
 
   for (unsigned ArgReg : Args)
     MIB.addReg(ArgReg);
 
   if (!IsDirect)
     MIB.addReg(CalleeReg);
 

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

if (IsIndirect) {
     auto FnPtr = CallParams.getOperand(0);
     CallParams.RemoveOperand(0);
     CallParams.addOperand(FnPtr);
   }
 
   for (auto Def : CallResults.defs())
     MIB.add(Def);
 
+  // Add placeholders for the type index and immediate flags
   if (IsIndirect) {
-    // Placehoder for the type index.
     MIB.addImm(0);
-    // The table into which this call_indirect indexes.
-    MIB.addSym(WebAssembly::getOrCreateFunctionTableSymbol(
-        MF.getContext(), "__indirect_function_table"));
+    MIB.addImm(0);
+
+    // Ensure that the object file has a __indirect_function_table import, as we
+    // call_indirect against it.
+    MCSymbolWasm *Sym = WebAssembly::getOrCreateFunctionTableSymbol(
+        MF.getContext(), "__indirect_function_table");
+    // Until call_indirect emits TABLE_NUMBER relocs against this symbol, mark
+    // it as NO_STRIP so as to ensure that the indirect function table makes it
+    // to linked output.
+    Sym->setNoStrip();
   }
 
   for (auto Use : CallParams.uses())
     MIB.add(Use);
 
   BB->insert(CallResults.getIterator(), MIB);
   CallParams.eraseFromParent();
   CallResults.eraseFromParent();

llvm/lib/Target/WebAssembly/WebAssemblyInstrCall.td

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

llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp

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

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

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

llvm/test/CodeGen/WebAssembly/multivalue.ll

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

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

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

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

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

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

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

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

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

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

 # BIN-NEXT:             Initial:         0x0
 # 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:          0x4
-# BIN-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
-# BIN-NEXT:         Index:           1
-# BIN-NEXT:         Offset:          0x9
 # BIN-NEXT:     Functions:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         Locals:          []
-# BIN-NEXT:         Body:            11818080800080808080000B
+# BIN-NEXT:         Body:            118180808000000B
 # BIN-NEXT:   - Type:            CUSTOM
 # BIN-NEXT:     Name:            linking
 # BIN-NEXT:     Version:         2
 # BIN-NEXT:     SymbolTable:
 # BIN-NEXT:       - Index:           0
 # BIN-NEXT:         Kind:            FUNCTION
 # BIN-NEXT:         Name:            test0
 # BIN-NEXT:         Flags:           [ BINDING_LOCAL ]
 # BIN-NEXT:         Function:        0
 # BIN-NEXT:       - Index:           1
 # BIN-NEXT:         Kind:            TABLE
 # BIN-NEXT:         Name:            __indirect_function_table
-# BIN-NEXT:         Flags:           [ UNDEFINED ]
+# BIN-NEXT:         Flags:           [ UNDEFINED, NO_STRIP ]
 # BIN-NEXT:         Table:           0
 # BIN-NEXT: ...

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

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

 # CHECK-NEXT:         Index:           3
 # CHECK-NEXT:         Offset:          0x12
 # CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
 # CHECK-NEXT:         Index:           5
 # CHECK-NEXT:         Offset:          0x1E
 # CHECK-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:         Offset:          0x24
-# CHECK-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
-# CHECK-NEXT:         Index:           6
-# CHECK-NEXT:         Offset:          0x29
 # CHECK-NEXT:       - Type:            R_WASM_MEMORY_ADDR_LEB
-# CHECK-NEXT:         Index:           8
-# CHECK-NEXT:         Offset:          0x35
+# CHECK-NEXT:         Index:           7
+# CHECK-NEXT:         Offset:          0x31
 # CHECK-NEXT:       - Type:            R_WASM_TYPE_INDEX_LEB
 # CHECK-NEXT:         Index:           0
-# CHECK-NEXT:         Offset:          0x3B
-# CHECK-NEXT:       - Type:            R_WASM_TABLE_NUMBER_LEB
-# CHECK-NEXT:         Index:           6
-# CHECK-NEXT:         Offset:          0x40
+# CHECK-NEXT:         Offset:          0x37
 # CHECK-NEXT:     Functions:
 # CHECK-NEXT:       - Index:           0
-# CHECK-NEXT:         Locals:          []
+# CHECK-NEXT:         Locals:
 # CHECK-NEXT:         Body:            41000B
 # CHECK-NEXT:       - Index:           1
-# CHECK-NEXT:         Locals:          []
+# CHECK-NEXT:         Locals:
 # CHECK-NEXT:         Body:            1080808080000B
 # CHECK-NEXT:       - Index:           2
-# CHECK-NEXT:         Locals:          []
+# CHECK-NEXT:         Locals:
 # CHECK-NEXT:         Body:            1080808080000B
 # CHECK-NEXT:       - Index:           3
-# CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            41002802888080800011808080800080808080000B
+# CHECK-NEXT:         Locals:
+# CHECK-NEXT:         Body:            410028028880808000118080808000000B
 # CHECK-NEXT:       - Index:           4
-# CHECK-NEXT:         Locals:          []
-# CHECK-NEXT:         Body:            41002802908080800011808080800080808080000B
+# CHECK-NEXT:         Locals:
+# CHECK-NEXT:         Body:            410028029080808000118080808000000B
 # CHECK-NEXT:   - Type:            DATA
 # CHECK-NEXT:     Relocations:
 # CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:         Offset:          0x13
 # CHECK-NEXT:       - Type:            R_WASM_TABLE_INDEX_I32
 # CHECK-NEXT:         Index:           3
 # CHECK-NEXT:         Offset:          0x20

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