[WebAssembly] Implementation of (most) table instructions

[pmatos]

Summary

Implementation of instructions table.get, table.set, table.grow,
table.size, table.fill, table.copy.

Missing instructions are table.init and elem.drop as they deal with
element sections which are not yet implemented.

Added more tests to tables.s

[pmatos]

So the goal here is to add most of the table instructions. This introduces some table relocations, which (in a following patch) we will resolve in the linker.

I have some concerns with this patch. The tests here are testing that instructions table.* written in .s files will be assembled properly into an object file. However, there are no tests actually testing the register based part of the instruction definitions.

So, for example for table.grow, I am unsure that

(outs i32imm_op:$sz), (ins table32_op:$table, i32imm_op:$n, reftype_op:$val)

actually makes sense for the register based version of the instruction and I have no tests actually looking into it since I have been mostly concerned at assembler level.
I assume that we cannot test this atm since register-level is relevant at the codegen part and we have no way to represent in IR a table.grow operation.

Should we add intrinsics for these? and try to test this at codegen level? or just add a comment pointing out that register-level instruction definitions are currently untested? or something else? Suggestions welcome.

[tlively]

In D89797#2341916, @pmatos wrote:

Should we add intrinsics for these? and try to test this at codegen level? or just add a comment pointing out that register-level instruction definitions are currently untested? or something else? Suggestions welcome.

Yes, I would typically add intrinsics for something like this and test codegen from them. This would require being able to represent reference types in LLVM IR, though, so I would be ok with leaving that to the future. For now if you pass -show-encoding to llvm-mc you can at least test that the binary encoding is what you expect it to be. See simd-encodings.s for an example of that.

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

169–170

Rather than a new Operand, this should probably be a new register class defined in WebAssemblyRegisterInfo.td. It will also probably make sense for now to have two new register types, one for externref and one for funcref rather than trying to combine them. Then there should be two versions of each table instruction, one for externref and one for tableref, even though those will lower to the same WebAssembly instruction. For an example of something similar, see LOCAL_GET_* in WebAssemblyInstrInfo.td.

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

25

$i should be an I32 (i.e. an i32 stack value), not an i32imm_op (i.e. a constant immediate argument). Same for i32s in the instructions below. Similarly, $val should be either EXTERNREF or FUNCREF once those register classes are defined.

[sbc100]

In general I'm loving how small this change is. I don't really grok the tablegen stuff but everything else looks pretty good to me.

llvm/lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

201

This doesn't need the 32 suffix.. i think its more like OPERAND_GLOBAL. I can't imagine us ever needing 2^^64 different tables... touch wood.

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

79

I think "table index" in ambiguous. Maybe "table number"?

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

15

These two comments above can probably just be a single comment, no? (unless I'm missing something?)

66

Remove trailing newlines.

llvm/test/MC/WebAssembly/tables.s

39

I think its common to put the expectations for each function inside or alongside the function itself.

But I admit we are not very consistent in this directory.

What do you think about the style uses in MC/WebAssembly/bulk-memory-encodings.sor simd-encodings.s.

@tlively probably knows more about the right and wrong way to do this stuff.

[tlively]

llvm/test/MC/WebAssembly/tables.s

39

Yeah, I would probably put the expected assembly output for each function just above that function and leave all the YAML at the bottom, but I agree that we aren't too consistent with this.

[pmatos]

Thanks for the review - I will submit a new revision.

llvm/lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

201

Ah - didn't Gates once said something similar regarding amount of required RAM? ;-)
Famous last words...

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

79

Agree.

[pmatos]

These changes reflect the first set of comments. High on the list is quite a few changes related to setting registers for funcrefs and externrefs. A few things might not be strictly necessary but pave the way for future work.

I was tempted to implement the intrinsics, but I think I will leave for a next patch. Sam mentions one of the things he likes about the patch is that it's small, so lets not mess with that. :)

[pmatos]

Regarding linter clang-format suggestions - should I reformat the code as suggested or leave it?
Some suggested changes are not necessarily on code I wrote, which is why I ask.

[sbc100]

No I wouldn't format any code you didn't write.. nor assume that clang-format always knows best in all cases.

I normally run git clang-format origin/master to ensure that the lines I've touched are formatted correctly.

[sbc100]

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

316

How is that we were able to get away without these types of changes when implementing the global.get and global.set of externref symbols in llvm/test/MC/WebAssembly/externref.s?

There is have instructions that take externref such as global.set my_global.

[pmatos]

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

316

Yes - at first glance, that shouldn't work. But it does work without the changes in this patch so I am stumped and might have to do some looking up to understand it. Maybe @tlively knows more?

[tlively]

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

316

Ah, this is interesting! Remember that llvm-mc only ever uses the stack version of instructions at the MC layer, so in that test the global.get and global.set instructions never actually have any operands of any register class. We also never use global.get or global.set of reference types in any of our instruction selection, so this never came up.

At a deeper level, this worked because register classes in the WebAssembly backend are fundamentally nothing more than a debugging tool. Since we don't do register allocations and because all register values are erased before we emit modules, everything would continue working correctly if just had a single register class covering all value types. The benefit of having separate register classes is that it enables the MachineInstrVerifier to catch type errors for us. If we actually had a wasm validator in the backend, the separate register classes would not be useful for anything except documentation.

[pmatos]

Is this good to merge?

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

316

That makes sense. Thanks for the thorough explanation.

[pmatos]

Remove unused operand type.

[sbc100]

This mostly lgtm. I would love it if we could avoid adding the new MVT value for now since then we could avoid changing the shared code on llvm/lib/CodeGen/ValueTypes.cpp.. but perhaps that absolutely needed for this change?

lgtm if @tlively is OK with the .td changes.

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

316

So can we get away without adding these for now?

llvm/utils/TableGen/CodeGenTarget.cpp

218

Maybe use the local style of putting these on single line?

[tlively]

Looks good to me with @sbc100's final comment addressed 🎉

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

316

I think it would be better to land the new MVTs and register classes before or at the same time as instructions that are going to use them. Even if they aren't fundamentally important, we've been treating them as no less important than they would be in other backends and being properly consistent with their usage will avoid any future surprises.

[pmatos]

llvm/utils/TableGen/CodeGenTarget.cpp

218

I will do that but this was a lint suggested change, so I accepted it. I will revert.

[pmatos]

Align with local indent style

[pmatos]

@sbc100 if it's ok for you, feel free to merge, thanks.

llvm/include/llvm/BinaryFormat/WasmRelocs.def

 WASM_RELOC(R_WASM_TABLE_INDEX_REL_SLEB,   12)
 WASM_RELOC(R_WASM_GLOBAL_INDEX_I32,       13)
 WASM_RELOC(R_WASM_MEMORY_ADDR_LEB64,      14)
 WASM_RELOC(R_WASM_MEMORY_ADDR_SLEB64,     15)
 WASM_RELOC(R_WASM_MEMORY_ADDR_I64,        16)
 WASM_RELOC(R_WASM_MEMORY_ADDR_REL_SLEB64, 17)
 WASM_RELOC(R_WASM_TABLE_INDEX_SLEB64,     18)
 WASM_RELOC(R_WASM_TABLE_INDEX_I64,        19)
+WASM_RELOC(R_WASM_TABLE_NUMBER_LEB,       20)

llvm/include/llvm/CodeGen/ValueTypes.td

 def nxv4f64  : ValueType<256, 155>; // n x  4 x f64 vector value
 def nxv8f64  : ValueType<512, 156>; // n x  8 x f64 vector value
 
 def x86mmx : ValueType<64 , 157>;   // X86 MMX value
 def FlagVT : ValueType<0  , 158>;   // Pre-RA sched glue
 def isVoid : ValueType<0  , 159>;   // Produces no value
 def untyped: ValueType<8  , 160>;   // Produces an untyped value
 def exnref : ValueType<0  , 161>;   // WebAssembly's exnref type
+def funcref : ValueType<0  , 162>;   // WebAssembly's funcref type
+def externref : ValueType<0  , 163>;   // WebAssembly's externref type
+
 
 def token  : ValueType<0  , 248>;   // TokenTy
 def MetadataVT: ValueType<0, 249>;  // Metadata
 
 // Pseudo valuetype mapped to the current pointer size to any address space.
 // Should only be used in TableGen.
 def iPTRAny   : ValueType<0, 250>;
 

llvm/include/llvm/Object/Wasm.h

public:
   const uint8_t TableType;
   const wasm::WasmEventType *EventType;
   const wasm::WasmSignature *Signature;
 
   bool isTypeFunction() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_FUNCTION;
   }
 
+  bool isTypeTable() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_TABLE; }
+
   bool isTypeData() const { return Info.Kind == wasm::WASM_SYMBOL_TYPE_DATA; }
 
   bool isTypeGlobal() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_GLOBAL;
   }
 
   bool isTypeSection() const {
     return Info.Kind == wasm::WASM_SYMBOL_TYPE_SECTION;
private:
   bool isDefinedFunctionIndex(uint32_t Index) const;
   bool isValidGlobalIndex(uint32_t Index) const;
   bool isValidTableIndex(uint32_t Index) const;
   bool isDefinedGlobalIndex(uint32_t Index) const;
   bool isDefinedTableIndex(uint32_t Index) const;
   bool isValidEventIndex(uint32_t Index) const;
   bool isDefinedEventIndex(uint32_t Index) const;
   bool isValidFunctionSymbol(uint32_t Index) const;
+  bool isValidTableSymbol(uint32_t Index) const;
   bool isValidGlobalSymbol(uint32_t Index) const;
   bool isValidEventSymbol(uint32_t Index) const;
   bool isValidDataSymbol(uint32_t Index) const;
   bool isValidSectionSymbol(uint32_t Index) const;
   wasm::WasmFunction &getDefinedFunction(uint32_t Index);
   const wasm::WasmFunction &getDefinedFunction(uint32_t Index) const;
   wasm::WasmGlobal &getDefinedGlobal(uint32_t Index);
   wasm::WasmEvent &getDefinedEvent(uint32_t Index);

llvm/include/llvm/Support/MachineValueType.h

enum SimpleValueType : uint8_t {
 
       isVoid         = 159,   // This has no value
 
       Untyped        = 160,   // This value takes a register, but has
                               // unspecified type.  The register class
                               // will be determined by the opcode.
 
       exnref         = 161,   // WebAssembly's exnref type
+      funcref        = 162,   // WebAssembly's funcref type
+      externref      = 163,   // WebAssembly's externref type
 
       FIRST_VALUETYPE =  1,   // This is always the beginning of the list.
-      LAST_VALUETYPE = 162,   // This always remains at the end of the list.
+      LAST_VALUETYPE = 164,   // This always remains at the end of the list.
 
       // This is the current maximum for LAST_VALUETYPE.
       // MVT::MAX_ALLOWED_VALUETYPE is used for asserts and to size bit vectors
       // This value must be a multiple of 32.
       MAX_ALLOWED_VALUETYPE = 192,
 
       // A value of type llvm::TokenTy
       token          = 248,
TypeSize getSizeInBits() const {
       case v512i32:
       case v256i64:
       case v512f32:
       case v256f64:  return TypeSize::Fixed(16384);
       case v1024i32:
       case v1024f32:  return TypeSize::Fixed(32768);
       case v2048i32:
       case v2048f32:  return TypeSize::Fixed(65536);
-      case exnref: return TypeSize::Fixed(0); // opaque type
+      case exnref:
+      case funcref:
+      case externref: return TypeSize::Fixed(0); // opaque type
       }
     }
 
     /// Return the size of the specified fixed width value type in bits. The
     /// function will assert if the type is scalable.
     uint64_t getFixedSizeInBits() const {
       return getSizeInBits().getFixedSize();
     }

llvm/lib/CodeGen/ValueTypes.cpp

if (isVector())
       return (isScalableVector() ? "nxv" : "v") +
              utostr(getVectorElementCount().getKnownMinValue()) +
              getVectorElementType().getEVTString();
     if (isInteger())
       return "i" + utostr(getSizeInBits());
     if (isFloatingPoint())
       return "f" + utostr(getSizeInBits());
     llvm_unreachable("Invalid EVT!");
-  case MVT::bf16:    return "bf16";
-  case MVT::ppcf128: return "ppcf128";
-  case MVT::isVoid:  return "isVoid";
-  case MVT::Other:   return "ch";
-  case MVT::Glue:    return "glue";
-  case MVT::x86mmx:  return "x86mmx";
-  case MVT::Metadata:return "Metadata";
-  case MVT::Untyped: return "Untyped";
-  case MVT::exnref : return "exnref";
+  case MVT::bf16:      return "bf16";
+  case MVT::ppcf128:   return "ppcf128";
+  case MVT::isVoid:    return "isVoid";
+  case MVT::Other:     return "ch";
+  case MVT::Glue:      return "glue";
+  case MVT::x86mmx:    return "x86mmx";
+  case MVT::Metadata:  return "Metadata";
+  case MVT::Untyped:   return "Untyped";
+  case MVT::exnref:    return "exnref";
+  case MVT::funcref:   return "funcref";
+  case MVT::externref: return "externref";
   }
 }
 
 /// getTypeForEVT - This method returns an LLVM type corresponding to the
 /// specified EVT.  For integer types, this returns an unsigned type.  Note
 /// that this will abort for types that cannot be represented.
 Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   switch (V.SimpleTy) {

llvm/lib/MC/WasmObjectWriter.cpp

WasmObjectWriter::getProvisionalValue(const WasmRelocationEntry &RelEntry,
   }
   case wasm::R_WASM_TYPE_INDEX_LEB:
     // Provisional value is same as the index
     return getRelocationIndexValue(RelEntry);
   case wasm::R_WASM_FUNCTION_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
+  case wasm::R_WASM_TABLE_NUMBER_LEB:
     // Provisional value is function/global/event Wasm index
     assert(WasmIndices.count(RelEntry.Symbol) > 0 && "symbol not found in wasm index space");
     return WasmIndices[RelEntry.Symbol];
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32: {
     const auto &Section =
         static_cast<const MCSectionWasm &>(RelEntry.Symbol->getSection());
     return Section.getSectionOffset() + RelEntry.Addend;
for (const WasmRelocationEntry &RelEntry : Relocations) {
     auto Value = getProvisionalValue(RelEntry, Layout);
 
     switch (RelEntry.Type) {
     case wasm::R_WASM_FUNCTION_INDEX_LEB:
     case wasm::R_WASM_TYPE_INDEX_LEB:
     case wasm::R_WASM_GLOBAL_INDEX_LEB:
     case wasm::R_WASM_MEMORY_ADDR_LEB:
     case wasm::R_WASM_EVENT_INDEX_LEB:
+    case wasm::R_WASM_TABLE_NUMBER_LEB:
       writePatchableLEB<5>(Stream, Value, Offset);
       break;
     case wasm::R_WASM_MEMORY_ADDR_LEB64:
       writePatchableLEB<10>(Stream, Value, Offset);
       break;
     case wasm::R_WASM_TABLE_INDEX_I32:
     case wasm::R_WASM_MEMORY_ADDR_I32:
     case wasm::R_WASM_FUNCTION_OFFSET_I32:

llvm/lib/Object/RelocationResolver.cpp

static bool supportsWasm32(uint64_t Type) {
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
+  case wasm::R_WASM_TABLE_NUMBER_LEB:
     return true;
   default:
     return false;
   }
 }
 
 static bool supportsWasm64(uint64_t Type) {
   switch (Type) {
static uint64_t resolveWasm32(RelocationRef R, uint64_t S, uint64_t A) {
   case wasm::R_WASM_MEMORY_ADDR_SLEB:
   case wasm::R_WASM_MEMORY_ADDR_I32:
   case wasm::R_WASM_TYPE_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_LEB:
   case wasm::R_WASM_FUNCTION_OFFSET_I32:
   case wasm::R_WASM_SECTION_OFFSET_I32:
   case wasm::R_WASM_EVENT_INDEX_LEB:
   case wasm::R_WASM_GLOBAL_INDEX_I32:
+  case wasm::R_WASM_TABLE_NUMBER_LEB:
     // For wasm section, its offset at 0 -- ignoring Value
     return A;
   default:
     llvm_unreachable("Invalid relocation type");
   }
 }
 
 static uint64_t resolveWasm64(RelocationRef R, uint64_t S, uint64_t A) {

llvm/lib/Object/WasmObjectFile.cpp

while (RelocCount--) {
     case wasm::R_WASM_TABLE_INDEX_SLEB64:
     case wasm::R_WASM_TABLE_INDEX_I32:
     case wasm::R_WASM_TABLE_INDEX_I64:
     case wasm::R_WASM_TABLE_INDEX_REL_SLEB:
       if (!isValidFunctionSymbol(Reloc.Index))
         return make_error<GenericBinaryError>("Bad relocation function index",
                                               object_error::parse_failed);
       break;
+    case wasm::R_WASM_TABLE_NUMBER_LEB:
+      if (!isValidTableSymbol(Reloc.Index))
+        return make_error<GenericBinaryError>("Bad relocation table index",
+                                              object_error::parse_failed);
+      break;
     case wasm::R_WASM_TYPE_INDEX_LEB:
       if (Reloc.Index >= Signatures.size())
         return make_error<GenericBinaryError>("Bad relocation type index",
                                               object_error::parse_failed);
       break;
     case wasm::R_WASM_GLOBAL_INDEX_LEB:
       // R_WASM_GLOBAL_INDEX_LEB are can be used against function and data
       // symbols to refer to their GOT entries.

 bool WasmObjectFile::isDefinedEventIndex(uint32_t Index) const {
   return Index >= NumImportedEvents && isValidEventIndex(Index);
 }
 
 bool WasmObjectFile::isValidFunctionSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeFunction();
 }
 
+bool WasmObjectFile::isValidTableSymbol(uint32_t Index) const {
+  return Index < Symbols.size() && Symbols[Index].isTypeTable();
+}
+
 bool WasmObjectFile::isValidGlobalSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeGlobal();
 }
 
 bool WasmObjectFile::isValidEventSymbol(uint32_t Index) const {
   return Index < Symbols.size() && Symbols[Index].isTypeEvent();
 }
 

llvm/lib/Target/WebAssembly/Disassembler/WebAssemblyDisassembler.cpp

MCDisassembler::DecodeStatus WebAssemblyDisassembler::getInstruction(
   for (uint8_t OPI = 0; OPI < WasmInst->NumOperands; OPI++) {
     auto OT = OperandTable[WasmInst->OperandStart + OPI];
     switch (OT) {
     // ULEB operands:
     case WebAssembly::OPERAND_BASIC_BLOCK:
     case WebAssembly::OPERAND_LOCAL:
     case WebAssembly::OPERAND_GLOBAL:
     case WebAssembly::OPERAND_FUNCTION32:
+    case WebAssembly::OPERAND_TABLE:
     case WebAssembly::OPERAND_OFFSET32:
     case WebAssembly::OPERAND_OFFSET64:
     case WebAssembly::OPERAND_P2ALIGN:
     case WebAssembly::OPERAND_TYPEINDEX:
     case WebAssembly::OPERAND_EVENT:
     case MCOI::OPERAND_IMMEDIATE: {
       if (!parseLEBImmediate(MI, Size, Bytes, false))
         return MCDisassembler::Fail;

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

if (MO.isReg()) {
       case WebAssembly::OPERAND_I32IMM:
         FixupKind = MCFixupKind(WebAssembly::fixup_sleb128_i32);
         break;
       case WebAssembly::OPERAND_I64IMM:
         FixupKind = MCFixupKind(WebAssembly::fixup_sleb128_i64);
         PaddedSize = 10;
         break;
       case WebAssembly::OPERAND_FUNCTION32:
+      case WebAssembly::OPERAND_TABLE:
       case WebAssembly::OPERAND_OFFSET32:
       case WebAssembly::OPERAND_SIGNATURE:
       case WebAssembly::OPERAND_TYPEINDEX:
       case WebAssembly::OPERAND_GLOBAL:
       case WebAssembly::OPERAND_EVENT:
         FixupKind = MCFixupKind(WebAssembly::fixup_uleb128_i32);
         break;
       case WebAssembly::OPERAND_OFFSET64:

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

enum OperandType {
   /// signature immediate for block/loop.
   OPERAND_SIGNATURE,
   /// type signature immediate for call_indirect.
   OPERAND_TYPEINDEX,
   /// Event index.
   OPERAND_EVENT,
   /// A list of branch targets for br_list.
   OPERAND_BRLIST,
+  /// 32-bit unsigned table number.
+  OPERAND_TABLE,
 };
 } // end namespace WebAssembly
 
 namespace WebAssemblyII {
 
 /// Target Operand Flag enum.
 enum TOF {
   MO_NO_FLAG = 0,

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

case WebAssembly::fixup_sleb128_i64:
     return wasm::R_WASM_MEMORY_ADDR_SLEB64;
   case WebAssembly::fixup_uleb128_i32:
     if (SymA.isGlobal())
       return wasm::R_WASM_GLOBAL_INDEX_LEB;
     if (SymA.isFunction())
       return wasm::R_WASM_FUNCTION_INDEX_LEB;
     if (SymA.isEvent())
       return wasm::R_WASM_EVENT_INDEX_LEB;
+    if (SymA.isTable())
+      return wasm::R_WASM_TABLE_NUMBER_LEB;
     return wasm::R_WASM_MEMORY_ADDR_LEB;
   case WebAssembly::fixup_uleb128_i64:
     assert(SymA.isData());
     return wasm::R_WASM_MEMORY_ADDR_LEB64;
   case FK_Data_4:
     if (SymA.isFunction())
       return wasm::R_WASM_TABLE_INDEX_I32;
     if (SymA.isGlobal())

llvm/lib/Target/WebAssembly/WebAssemblyExplicitLocals.cpp

static unsigned getLocalGetOpcode(const TargetRegisterClass *RC) {
   if (RC == &WebAssembly::F32RegClass)
     return WebAssembly::LOCAL_GET_F32;
   if (RC == &WebAssembly::F64RegClass)
     return WebAssembly::LOCAL_GET_F64;
   if (RC == &WebAssembly::V128RegClass)
     return WebAssembly::LOCAL_GET_V128;
   if (RC == &WebAssembly::EXNREFRegClass)
     return WebAssembly::LOCAL_GET_EXNREF;
+  if (RC == &WebAssembly::FUNCREFRegClass)
+    return WebAssembly::LOCAL_GET_FUNCREF;
+  if (RC == &WebAssembly::EXTERNREFRegClass)
+    return WebAssembly::LOCAL_GET_EXTERNREF;
   llvm_unreachable("Unexpected register class");
 }
 
 /// Get the appropriate local.set opcode for the given register class.
 static unsigned getLocalSetOpcode(const TargetRegisterClass *RC) {
   if (RC == &WebAssembly::I32RegClass)
     return WebAssembly::LOCAL_SET_I32;
   if (RC == &WebAssembly::I64RegClass)
     return WebAssembly::LOCAL_SET_I64;
   if (RC == &WebAssembly::F32RegClass)
     return WebAssembly::LOCAL_SET_F32;
   if (RC == &WebAssembly::F64RegClass)
     return WebAssembly::LOCAL_SET_F64;
   if (RC == &WebAssembly::V128RegClass)
     return WebAssembly::LOCAL_SET_V128;
   if (RC == &WebAssembly::EXNREFRegClass)
     return WebAssembly::LOCAL_SET_EXNREF;
+  if (RC == &WebAssembly::FUNCREFRegClass)
+    return WebAssembly::LOCAL_SET_FUNCREF;
+  if (RC == &WebAssembly::EXTERNREFRegClass)
+    return WebAssembly::LOCAL_SET_EXTERNREF;
   llvm_unreachable("Unexpected register class");
 }
 
 /// Get the appropriate local.tee opcode for the given register class.
 static unsigned getLocalTeeOpcode(const TargetRegisterClass *RC) {
   if (RC == &WebAssembly::I32RegClass)
     return WebAssembly::LOCAL_TEE_I32;
   if (RC == &WebAssembly::I64RegClass)
     return WebAssembly::LOCAL_TEE_I64;
   if (RC == &WebAssembly::F32RegClass)
     return WebAssembly::LOCAL_TEE_F32;
   if (RC == &WebAssembly::F64RegClass)
     return WebAssembly::LOCAL_TEE_F64;
   if (RC == &WebAssembly::V128RegClass)
     return WebAssembly::LOCAL_TEE_V128;
   if (RC == &WebAssembly::EXNREFRegClass)
     return WebAssembly::LOCAL_TEE_EXNREF;
+  if (RC == &WebAssembly::FUNCREFRegClass)
+    return WebAssembly::LOCAL_TEE_FUNCREF;
+  if (RC == &WebAssembly::EXTERNREFRegClass)
+    return WebAssembly::LOCAL_TEE_EXTERNREF;
   llvm_unreachable("Unexpected register class");
 }
 
 /// Get the type associated with the given register class.
 static MVT typeForRegClass(const TargetRegisterClass *RC) {
   if (RC == &WebAssembly::I32RegClass)
     return MVT::i32;
   if (RC == &WebAssembly::I64RegClass)
     return MVT::i64;
   if (RC == &WebAssembly::F32RegClass)
     return MVT::f32;
   if (RC == &WebAssembly::F64RegClass)
     return MVT::f64;
   if (RC == &WebAssembly::V128RegClass)
     return MVT::v16i8;
   if (RC == &WebAssembly::EXNREFRegClass)
     return MVT::exnref;
+  if (RC == &WebAssembly::FUNCREFRegClass)
+    return MVT::funcref;
+  if (RC == &WebAssembly::EXTERNREFRegClass)
+    return MVT::externref;
   llvm_unreachable("unrecognized register class");
 }
 
 /// Given a MachineOperand of a stackified vreg, return the instruction at the
 /// start of the expression tree.
 static MachineInstr *findStartOfTree(MachineOperand &MO,
                                      MachineRegisterInfo &MRI,
                                      const WebAssemblyFunctionInfo &MFI) {

llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp

MVT::SimpleValueType getLegalType(MVT::SimpleValueType VT) {
     case MVT::i8:
     case MVT::i16:
       return MVT::i32;
     case MVT::i32:
     case MVT::i64:
     case MVT::f32:
     case MVT::f64:
     case MVT::exnref:
+    case MVT::funcref:
+    case MVT::externref:
       return VT;
     case MVT::f16:
       return MVT::f32;
     case MVT::v16i8:
     case MVT::v8i16:
     case MVT::v4i32:
     case MVT::v4f32:
       if (Subtarget->hasSIMD128())
case MVT::v4f32:
       ResultReg = createResultReg(&WebAssembly::V128RegClass);
       break;
     case MVT::v2f64:
       ResultReg = createResultReg(&WebAssembly::V128RegClass);
       break;
     case MVT::exnref:
       ResultReg = createResultReg(&WebAssembly::EXNREFRegClass);
       break;
+    case MVT::funcref:
+      ResultReg = createResultReg(&WebAssembly::FUNCREFRegClass);
+      break;
+    case MVT::externref:
+      ResultReg = createResultReg(&WebAssembly::EXTERNREFRegClass);
+      break;
     default:
       return false;
     }
   }
 
   SmallVector<unsigned, 8> Args;
   for (unsigned I = 0, E = Call->getNumArgOperands(); I < E; ++I) {
     Value *V = Call->getArgOperand(I);

llvm/lib/Target/WebAssembly/WebAssemblyInstrInfo.td

 def vec_i32imm_op : Operand<i32>;
 
 let OperandType = "OPERAND_VEC_I64IMM" in
 def vec_i64imm_op : Operand<i64>;
 
 let OperandType = "OPERAND_FUNCTION32" in
 def function32_op : Operand<i32>;
 
+let OperandType = "OPERAND_TABLE" in
+def table32_op : Operand<i32>;
+
 let OperandType = "OPERAND_OFFSET32" in
 def offset32_op : Operand<i32>;
 
 let OperandType = "OPERAND_OFFSET64" in
 def offset64_op : Operand<i64>;
 
 let OperandType = "OPERAND_P2ALIGN" in {
 def P2Align : Operand<i32> {
   let PrintMethod = "printWebAssemblyP2AlignOperand";
 }
defm ARGUMENT_#vt :
     I<(outs reg:$res), (ins i32imm:$argno), (outs), (ins i32imm:$argno),
       [(set (vt reg:$res), (WebAssemblyargument timm:$argno))]>;
 }
 defm "": ARGUMENT<I32, i32>;
 defm "": ARGUMENT<I64, i64>;
 defm "": ARGUMENT<F32, f32>;
 defm "": ARGUMENT<F64, f64>;
 defm "": ARGUMENT<EXNREF, exnref>;
+defm "": ARGUMENT<FUNCREF, funcref>;
+defm "": ARGUMENT<EXTERNREF, externref>;
 
 // local.get and local.set are not generated by instruction selection; they
 // are implied by virtual register uses and defs.
 multiclass LOCAL<WebAssemblyRegClass vt> {
   let hasSideEffects = 0 in {
   // COPY is not an actual instruction in wasm, but since we allow local.get and
   // local.set to be implicit during most of codegen, we can have a COPY which
   // is actually a no-op because all the work is done in the implied local.get

 } // hasSideEffects = 0
 }
 defm "" : LOCAL<I32>;
 defm "" : LOCAL<I64>;
 defm "" : LOCAL<F32>;
 defm "" : LOCAL<F64>;
 defm "" : LOCAL<V128>, Requires<[HasSIMD128]>;
 defm "" : LOCAL<EXNREF>, Requires<[HasExceptionHandling]>;
+defm "" : LOCAL<FUNCREF>, Requires<[HasReferenceTypes]>;
+defm "" : LOCAL<EXTERNREF>, Requires<[HasReferenceTypes]>;
 
 let isMoveImm = 1, isAsCheapAsAMove = 1, isReMaterializable = 1 in {
 defm CONST_I32 : I<(outs I32:$res), (ins i32imm_op:$imm),
                    (outs), (ins i32imm_op:$imm),
                    [(set I32:$res, imm:$imm)],
                    "i32.const\t$res, $imm", "i32.const\t$imm", 0x41>;
 defm CONST_I64 : I<(outs I64:$res), (ins i64imm_op:$imm),
                    (outs), (ins i64imm_op:$imm),

 include "WebAssemblyInstrControl.td"
 include "WebAssemblyInstrInteger.td"
 include "WebAssemblyInstrConv.td"
 include "WebAssemblyInstrFloat.td"
 include "WebAssemblyInstrAtomics.td"
 include "WebAssemblyInstrSIMD.td"
 include "WebAssemblyInstrRef.td"
 include "WebAssemblyInstrBulkMemory.td"
+include "WebAssemblyInstrTable.td"

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

+// WebAssemblyInstrTable.td - WebAssembly Table codegen support -*- tablegen -*-
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// WebAssembly Table operand code-gen constructs.
+/// Instructions that handle tables
+//===----------------------------------------------------------------------===//
+
+
+multiclass TABLE<WebAssemblyRegClass rt> {
+  defm TABLE_GET_#rt : I<(outs rt:$res), (ins table32_op:$table),
+                         (outs), (ins table32_op:$table),
+                         [],
+                         "table.get\t$res, $table",
+                         "table.get\t$table",
+                         0x25>;
+
+  defm TABLE_SET_#rt : I<(outs), (ins table32_op:$table, rt:$val, I32:$i),
+                         (outs), (ins table32_op:$table),
+                         [],
+                         "table.set\t$table, $val, $i",
+                         "table.set\t$table",
+                         0x26>;
+
+  defm TABLE_GROW_#rt : I<(outs I32:$sz), (ins table32_op:$table, I32:$n, rt:$val),
+                          (outs), (ins table32_op:$table),
+                          [],
+                          "table.grow\t$sz, $table, $n, $val",
+                          "table.grow\t$table",
+                          0xfc0f>;
+
+  defm TABLE_FILL_#rt : I<(outs), (ins table32_op:$table, I32:$n, rt:$val, I32:$i),
+                          (outs), (ins table32_op:$table),
+                          [],
+                          "table.fill\t$table, $n, $val, $i",
+                          "table.fill\t$table",
+                          0xfc11>;
+
+}
+
+defm "" : TABLE<FUNCREF>, Requires<[HasReferenceTypes]>;
+defm "" : TABLE<EXTERNREF>, Requires<[HasReferenceTypes]>;
+
+defm TABLE_SIZE : I<(outs I32:$sz), (ins table32_op:$table),
+                    (outs), (ins table32_op:$table),
+                    [],
+                    "table.size\t$sz, $table",
+                    "table.size\t$table",
+                    0xfc10>,
+                    Requires<[HasReferenceTypes]>;
+
+
+defm TABLE_COPY : I<(outs), (ins table32_op:$table1, table32_op:$table2, I32:$n, I32:$s, I32:$d),
+                    (outs), (ins table32_op:$table1, table32_op:$table2),
+                    [],
+                    "table.copy\t$table1, $table2, $n, $s, $d",
+                    "table.copy\t$table1, $table2",
+                    0xfc0e>,
+                    Requires<[HasReferenceTypes]>;

llvm/lib/Target/WebAssembly/WebAssemblyRegisterInfo.td

 def I32_0 : WebAssemblyReg<"%i32.0">;
 def I64_0 : WebAssemblyReg<"%i64.0">;
 def F32_0 : WebAssemblyReg<"%f32.0">;
 def F64_0 : WebAssemblyReg<"%f64.0">;
 
 def V128_0: WebAssemblyReg<"%v128">;
 
 def EXNREF_0 : WebAssemblyReg<"%exnref.0">;
+def FUNCREF_0 : WebAssemblyReg<"%funcref.0">;
+def EXTERNREF_0 : WebAssemblyReg<"%externref.0">;
 
 // The value stack "register". This is an opaque entity which serves to order
 // uses and defs that must remain in LIFO order.
 def VALUE_STACK : WebAssemblyReg<"STACK">;
 
 // The incoming arguments "register". This is an opaque entity which serves to
 // order the ARGUMENT instructions that are emulating live-in registers and
 // must not be scheduled below other instructions.
 def ARGUMENTS : WebAssemblyReg<"ARGUMENTS">;
 
 //===----------------------------------------------------------------------===//
 //  Register classes
 //===----------------------------------------------------------------------===//
 
 def I32 : WebAssemblyRegClass<[i32], 32, (add FP32, SP32, I32_0)>;
 def I64 : WebAssemblyRegClass<[i64], 64, (add FP64, SP64, I64_0)>;
 def F32 : WebAssemblyRegClass<[f32], 32, (add F32_0)>;
 def F64 : WebAssemblyRegClass<[f64], 64, (add F64_0)>;
 def V128 : WebAssemblyRegClass<[v4f32, v2f64, v2i64, v4i32, v16i8, v8i16], 128,
                                (add V128_0)>;
 def EXNREF : WebAssemblyRegClass<[exnref], 0, (add EXNREF_0)>;
+def FUNCREF : WebAssemblyRegClass<[funcref], 0, (add FUNCREF_0)>;
+def EXTERNREF : WebAssemblyRegClass<[externref], 0, (add EXTERNREF_0)>;

llvm/test/MC/WebAssembly/tables.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
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+reference-types < %s | FileCheck %s
+# RUN: llvm-mc -show-encoding -triple=wasm32-unknown-unknown -mattr=+reference-types < %s | FileCheck -check-prefix=ENC %s
+# RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+reference-types -filetype=obj < %s | obj2yaml | FileCheck -check-prefix=BIN %s
 
-# Test creating several empty tables
+# Creating several empty tables
 
-.tabletype foo, externref        
+# CHECK:         .tabletype foo, externref
+# CHECK: foo:
+    .tabletype foo, externref
 foo:
 
-bar:
-.tabletype bar, funcref
-
-# CHECK: .tabletype foo, externref
-# CHECK: foo:
 
 #      CHECK: bar:
-# CHECK-NEXT: .tabletype bar, funcref
+# CHECK-NEXT:         .tabletype bar, funcref
+bar:
+    .tabletype bar, funcref
+
+table1:
+    .tabletype table1, funcref
+table2:
+    .tabletype table2, funcref
+
+# Table instructions
+
+#      CHECK: copy_tables:
+# CHECK-NEXT:         .functype copy_tables (i32, i32) -> ()
+# CHECK-NEXT: local.get 0
+# CHECK-NEXT: local.get 1
+#      CHECK: table.size  table1
+#      CHECK: table.copy  table1, table2
+# CHECK-NEXT: end_function
+# CHECK-NEXT:.Ltmp0:
+# CHECK-NEXT: .size copy_tables, .Ltmp0-copy_tables
+copy_tables:
+    .functype copy_tables (i32, i32) -> ()
+    local.get 0
+    local.get 1
+
+    # ENC: table.size table1                  # encoding: [0xfc,0x10,0x80'A',0x80'A',0x80'A',0x80'A',A]
+    table.size table1
+
+    # ENC: table.copy table1, table2          # encoding: [0xfc,0x0e,0x80'A',0x80'A',0x80'A',0x80'A',A,0x80'B',0x80'B',0x80'B',0x80'B',B]
+    table.copy table1, table2
+    end_function
+
+#      CHECK: table_get:
+# CHECK-NEXT: .functype table_get (i32) -> (externref)
+# CHECK-NEXT: local.get 0
+#      CHECK: table.get foo
+# CHECK-NEXT: end_function
+# CHECK-NEXT: .Ltmp1:
+# CHECK-NEXT: .size table_get, .Ltmp1-table_get
+table_get:
+    .functype table_get (i32) -> (externref)
+    local.get 0
+
+    # ENC: table.get  foo                     # encoding: [0x25,0x80'A',0x80'A',0x80'A',0x80'A',A]
+    table.get foo
+    end_function
+
+#      CHECK: table_set:
+# CHECK-NEXT: .functype table_set (i32, externref) -> ()
+# CHECK-NEXT: local.get 0
+# CHECK-NEXT: local.get 1
+#      CHECK: table.set foo
+# CHECK-NEXT: end_function
+# CHECK-NEXT: .Ltmp2:
+# CHECK-NEXT: .size table_set, .Ltmp2-table_set
+table_set:
+    .functype table_set (i32, externref) -> ()
+    local.get 0
+    local.get 1
+
+    # ENC: table.set  foo                     # encoding: [0x26,0x80'A',0x80'A',0x80'A',0x80'A',A]
+    table.set foo
+    end_function
+
+#      CHECK: table_grow:
+# CHECK-NEXT: .functype table_grow (i32) -> (i32)
+# CHECK-NEXT: i32.const 0
+# CHECK-NEXT: table.get foo
+# CHECK-NEXT: local.get 0
+#      CHECK: table.grow  foo
+# CHECK-NEXT: local.get 0
+# CHECK-NEXT: i32.add
+# CHECK-NEXT: end_function
+# CHECK-NEXT: .Ltmp3:
+# CHECK-NEXT: .size table_grow, .Ltmp3-table_grow
+table_grow:
+    .functype table_grow (i32) -> (i32)
+    i32.const 0
+    table.get foo
+    local.get 0
+
+    # ENC: table.grow foo                     # encoding: [0xfc,0x0f,0x80'A',0x80'A',0x80'A',0x80'A',A]
+    table.grow foo
+    local.get 0
+    i32.add
+    end_function
+
+#      CHECK: table_fill:
+# CHECK-NEXT: .functype table_fill (i32, i32) -> ()
+# CHECK-NEXT: local.get 0
+# CHECK-NEXT: i32.const 0
+# CHECK-NEXT: table.get table1
+# CHECK-NEXT: local.get 1
+#      CHECK: table.fill  table1
+# CHECK-NEXT: end_function
+# CHECK-NEXT: .Ltmp4:
+# CHECK-NEXT: .size table_fill, .Ltmp4-table_fill
+table_fill:
+    .functype table_fill (i32, i32) -> ()
+    local.get 0
+    i32.const 0
+    table.get table1
+    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:        ElemType:        EXTERNREF
 # BIN-NEXT:        Limits:
 # BIN-NEXT:          Initial:         0x00000000
 # BIN-NEXT:      - Index:           2
 # 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:        Offset:          0x00000010
+# BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
+# BIN-NEXT:        Index:           3
+# BIN-NEXT:        Offset:          0x00000015
+# BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
+# BIN-NEXT:        Index:           0
+# BIN-NEXT:        Offset:          0x00000020
+# BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
+# BIN-NEXT:        Index:           0
+# BIN-NEXT:        Offset:          0x0000002D
+# BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
+# BIN-NEXT:        Index:           0
+# BIN-NEXT:        Offset:          0x00000038
+# BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
+# BIN-NEXT:        Index:           0
+# BIN-NEXT:        Offset:          0x00000041
+# BIN-NEXT:      - Type:            R_WASM_TABLE_NUMBER_LEB
+# 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:      - Index:           1
+# BIN-NEXT:        Locals:          []
+# BIN-NEXT:        Body:            20002581808080000B
+# BIN-NEXT:      - Index:           2
+# BIN-NEXT:        Locals:          []
+# BIN-NEXT:        Body:            200020012681808080000B
+# BIN-NEXT:      - Index:           3
+# BIN-NEXT:        Locals:          []
+# BIN-NEXT:        Body:            41002581808080002000FC0F818080800020006A0B
+# BIN-NEXT:      - Index:           4
+# BIN-NEXT:        Locals:          []
+# BIN-NEXT:        Body:            200041002583808080002001FC1183808080000B
+
 #      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:      - Index:           1
 # BIN-NEXT:        Kind:            TABLE
 # BIN-NEXT:        Name:            bar
 # BIN-NEXT:        Flags:           [ BINDING_LOCAL ]
 # BIN-NEXT:        Table:           2

llvm/utils/TableGen/CodeGenTarget.cpp

StringRef llvm::getEnumName(MVT::SimpleValueType T) {
   case MVT::nxv2f16:  return "MVT::nxv2f16";
   case MVT::nxv4f16:  return "MVT::nxv4f16";
   case MVT::nxv8f16:  return "MVT::nxv8f16";
   case MVT::nxv16f16: return "MVT::nxv16f16";
   case MVT::nxv32f16: return "MVT::nxv32f16";
   case MVT::nxv2bf16:  return "MVT::nxv2bf16";
   case MVT::nxv4bf16:  return "MVT::nxv4bf16";
   case MVT::nxv8bf16:  return "MVT::nxv8bf16";
-  case MVT::nxv1f32:  return "MVT::nxv1f32";
-  case MVT::nxv2f32:  return "MVT::nxv2f32";
-  case MVT::nxv4f32:  return "MVT::nxv4f32";
-  case MVT::nxv8f32:  return "MVT::nxv8f32";
-  case MVT::nxv16f32: return "MVT::nxv16f32";
-  case MVT::nxv1f64:  return "MVT::nxv1f64";
-  case MVT::nxv2f64:  return "MVT::nxv2f64";
-  case MVT::nxv4f64:  return "MVT::nxv4f64";
-  case MVT::nxv8f64:  return "MVT::nxv8f64";
-  case MVT::token:    return "MVT::token";
-  case MVT::Metadata: return "MVT::Metadata";
-  case MVT::iPTR:     return "MVT::iPTR";
-  case MVT::iPTRAny:  return "MVT::iPTRAny";
-  case MVT::Untyped:  return "MVT::Untyped";
-  case MVT::exnref:   return "MVT::exnref";
+  case MVT::nxv1f32:   return "MVT::nxv1f32";
+  case MVT::nxv2f32:   return "MVT::nxv2f32";
+  case MVT::nxv4f32:   return "MVT::nxv4f32";
+  case MVT::nxv8f32:   return "MVT::nxv8f32";
+  case MVT::nxv16f32:  return "MVT::nxv16f32";
+  case MVT::nxv1f64:   return "MVT::nxv1f64";
+  case MVT::nxv2f64:   return "MVT::nxv2f64";
+  case MVT::nxv4f64:   return "MVT::nxv4f64";
+  case MVT::nxv8f64:   return "MVT::nxv8f64";
+  case MVT::token:     return "MVT::token";
+  case MVT::Metadata:  return "MVT::Metadata";
+  case MVT::iPTR:      return "MVT::iPTR";
+  case MVT::iPTRAny:   return "MVT::iPTRAny";
+  case MVT::Untyped:   return "MVT::Untyped";
+  case MVT::exnref:    return "MVT::exnref";
+  case MVT::funcref:   return "MVT::funcref";
+  case MVT::externref: return "MVT::externref";
   default: llvm_unreachable("ILLEGAL VALUE TYPE!");
   }
 }
 
 /// getQualifiedName - Return the name of the specified record, with a
 /// namespace qualifier if the record contains one.
 ///
 std::string llvm::getQualifiedName(const Record *R) {