[WebAssembly] Implement table instruction intrinsics and ref.null

[pmatos]

Summary

This change implements intrinsics for ref.null, table.grow,
table.fill, table.size and table.copy.

[pmatos]

After D111227 was refactored to just contain the polymorphic type implementation, I refactored this revision to contain all the implementation of the table intrinsics and ref.null

[tlively]

llvm/lib/CodeGen/ValueTypes.cpp

203–206

I think we should probably simplify things by making externref be an i8 pointer as well. That's simpler than the other arbitrary type (pointer (to pointer?) to opaque struct) that we are using now, and ultimately the type doesn't really matter. Maybe these comments should say "arbitrary pointer" rather than "opaque pointer" (which I don't think is quite correct, since it's the struct that's opaque rather than the pointer) or "void pointer" (which is not really a concept that exists in LLVM).

llvm/lib/IR/Function.cpp

927 ↗

(On Diff #386842)

The changes in this file look like they should be in the previous revision rather than this one. Is that right?

llvm/lib/Target/WebAssembly/WebAssemblyInstrRef.td

14 ↗

(On Diff #386842)

Since the rc, vt, and ht all correspond 1:1 with each other, you can package them together into records that let you just have a single parameter here. For an example of this pattern, see class Vec and all its instantiations in WebAssemblyInstrSIMD.td.

llvm/test/CodeGen/WebAssembly/funcref-call.ll

7–9

I'm not sure it should be necessary to modify these tests to use i8 as the pointee type. Ultimately the pointee type shouldn't really matter at all (except at the point when a funcref is called) and we should be relying entirely on the address space to figure out what Wasm type it should be. In fact, it would be useful to test that multiple pointee types work correctly. That will give us confidence that nothing will break when opaque pointers are enabled.

llvm/test/CodeGen/WebAssembly/table-copy.ll

21

Can you skip the previous getelementptr and cast the original table pointer directly to i8 addrspace(1)*, at least when the offset is 0? It would also be good to test with various nontrivial offsets and when copying from a table to itself. Same for the other intrinsics.

llvm/utils/TableGen/IntrinsicEmitter.cpp

197 ↗

(On Diff #386842)

These changes also looks like they should be in the previous revision rather than this one.

[pmatos]

After closing D111227, I moved the implementation of all intrinsics to this revision without the need for the polymorphic llvm_anyref_ty type.

There's a single niggle here that I haven't been able to fix and would like further comments on.

Test for reference-types.s is failing due to the parsing of ref.null $heaptype, be it func or extern.
The reason for this is failing is that I have removed the need to specify the input argument heaptype for the ref.null instruction. This allows me to define an intrinsic that doesn't receive an argument. If I specify a heaptype as an input argument, then TableGen really wants the argument to show up in the instruction pattern, but I would really like it to be ignored. Adding extern or func as an argument to the intrinsic just seems overcomplicated. On the other hand, I have been stuck with this for a while and would appreciate some fresh ideas.

[pmatos]

llvm/lib/Target/WebAssembly/WebAssemblyInstrRef.td

18 ↗

(On Diff #389494)

The problem I alluded to in https://reviews.llvm.org/D113420#3151549 happens here. Because I don't mention heaptype as inputs, the parser fails. But if I do add as inputs heaptype, and not in the instruction pattern (where the intrinsic is), then tablegen does not accept it. It makes, however, no sense to have heaptype as an argument since it can be suffix to the intrinsic name.

[pmatos]

Post discussion with @tlively I have changed the textual representation of ref.null to include the heaptype as suffix.
As a consequence the current patch includes all the intrinsics implementations but also the changes to the tests that now use ref.null_extern and ref.null_func, and the removal of the references to HeapType which is now not required anymore.

[pmatos]

To make the changes easier to understand, I am splitting this into two. One for ref.null + HeapType changes and another for the table intrinsics.

[pmatos]

Remove changes related to ref.null.

ref.null intrinsic implementation and heaptype removal work is currently in D114979 and this change builds upon that.

[pmatos]

llvm/lib/CodeGen/ValueTypes.cpp

203–206

I agree that the comments should be changed, but don't you think that externref should still be a pointer to an opaque struct? This seems to match better with what externref truly represents: a host value that you cannot introspect - therefore opaque. I am not sure it matters much as you say, but semantically it seems to be closer to what externref is.

llvm/test/CodeGen/WebAssembly/table-copy.ll

21

Good point! I will take a look at these.

[pmatos]

llvm/test/CodeGen/WebAssembly/funcref-call.ll

7–9

The reason I changed this for all tests is for consistency with intrinsics tests. Intrinsics tests need to define the funcref as i8 pointers to addspace(20), because the intrinsics validator post parse checks that the type defined in LLVM IR matches the type of the intrinsic. Even though it might not be necessary to change it in this specific testcase, I find that for consistency we should always define the funcref type as a type i8 addspace(20).

[pmatos]

Fix a couple of comments - add a new test to table.copy for copies within the same table.

llvm/test/CodeGen/WebAssembly/table-copy.ll

29

@tlively is this the kind of test you were referring to?

[tlively]

LGTM with the extra suggested test, if possible.

llvm/test/CodeGen/WebAssembly/funcref-call.ll

7–9

I agree that it makes sense to be consistent in the majority of the tests, but perhaps we could have an additional test that only checks that the pointee type doesn't matter? That will help us be confident that we will be ready for the removal of pointee types once the wider project makes that switch.

llvm/test/CodeGen/WebAssembly/table-copy.ll

29

Looks good! I was probably thinking of having different offsets in the getelementptr, but not supporting that for now and taking the offsets as arguments to the copy intrinsic seems much simpler.

[pmatos]

llvm/test/CodeGen/WebAssembly/table-copy.ll

29

Humm, I see what you mean but isn't it always the case that since we are dereferencing a global, the GEP will always have zero offsets? I cannot imagine a case, where we use non-zero offsets to dereference a global representing a table, like we do for example in the llvm/test/CodeGen/WebAssembly/funcref-tableget.ll test.

[ljmf00]

In D113420#3151549, @pmatos wrote:

After closing D111420, I moved the implementation of all intrinsics to this revision without the need for the polymorphic llvm_anyref_ty type.

@pmatos You likely referenced the wrong diff. I would suggest amending this to avoid confusion in the future :)

[pmatos]

In D113420#3239319, @ljmf00 wrote:

In D113420#3151549, @pmatos wrote:

After closing D111420, I moved the implementation of all intrinsics to this revision without the need for the polymorphic llvm_anyref_ty type.

@pmatos You likely referenced the wrong diff. I would suggest amending this to avoid confusion in the future :)

Done - thanks for letting me know.

llvm/include/llvm/IR/IntrinsicsWebAssembly.td

 //===- IntrinsicsWebAssembly.td - Defines wasm intrinsics --*- 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
 /// This file defines all of the WebAssembly-specific intrinsics.
 ///
 //===----------------------------------------------------------------------===//
 
+// Type definition for a table in an intrinsic
+def llvm_table_ty : LLVMQualPointerType<llvm_i8_ty, 1>;
+
 let TargetPrefix = "wasm" in {  // All intrinsics start with "llvm.wasm.".
 
 // Query the current memory size, and increase the current memory size.
 // Note that memory.size is not IntrNoMem because it must be sequenced with
 // respect to memory.grow calls.
 def int_wasm_memory_size : Intrinsic<[llvm_anyint_ty],
                                      [llvm_i32_ty],
                                      [IntrReadMem]>;
 def int_wasm_memory_grow : Intrinsic<[llvm_anyint_ty],
                                      [llvm_i32_ty, LLVMMatchType<0>],
                                      []>;
 
 //===----------------------------------------------------------------------===//
 // ref.null intrinsics
 //===----------------------------------------------------------------------===//
 def int_wasm_ref_null_extern : Intrinsic<[llvm_externref_ty], [], [IntrNoMem]>;
 def int_wasm_ref_null_func : Intrinsic<[llvm_funcref_ty], [], [IntrNoMem]>;
 
 //===----------------------------------------------------------------------===//
+// Table intrinsics
+//===----------------------------------------------------------------------===//
+// Query the current table size, and increase the current table size.
+def int_wasm_table_size : Intrinsic<[llvm_i32_ty],
+                                    [llvm_table_ty],
+                                    [IntrReadMem]>;
+def int_wasm_table_copy : Intrinsic<[],
+                                    [llvm_table_ty, llvm_table_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty],
+                                    []>;
+def int_wasm_table_grow_externref : Intrinsic<[llvm_i32_ty],
+                                              [llvm_table_ty, llvm_externref_ty, llvm_i32_ty],
+                                              []>;
+def int_wasm_table_grow_funcref : Intrinsic<[llvm_i32_ty],
+                                            [llvm_table_ty, llvm_funcref_ty, llvm_i32_ty],
+                                            []>;
+def int_wasm_table_fill_externref : Intrinsic<[],
+                                              [llvm_table_ty, llvm_i32_ty, llvm_externref_ty, llvm_i32_ty],
+                                              []>;
+def int_wasm_table_fill_funcref : Intrinsic<[],
+                                            [llvm_table_ty, llvm_i32_ty, llvm_funcref_ty, llvm_i32_ty],
+                                            []>;
+
+//===----------------------------------------------------------------------===//
 // Trapping float-to-int conversions
 //===----------------------------------------------------------------------===//
 
 def int_wasm_trunc_signed : Intrinsic<[llvm_anyint_ty],
                                       [llvm_anyfloat_ty],
                                       [IntrNoMem]>;
 def int_wasm_trunc_unsigned : Intrinsic<[llvm_anyint_ty],
                                         [llvm_anyfloat_ty],

llvm/lib/CodeGen/ValueTypes.cpp

Type *EVT::getTypeForEVT(LLVMContext &Context) const {
   case MVT::f32:     return Type::getFloatTy(Context);
   case MVT::f64:     return Type::getDoubleTy(Context);
   case MVT::f80:     return Type::getX86_FP80Ty(Context);
   case MVT::f128:    return Type::getFP128Ty(Context);
   case MVT::ppcf128: return Type::getPPC_FP128Ty(Context);
   case MVT::x86mmx:  return Type::getX86_MMXTy(Context);
   case MVT::x86amx:  return Type::getX86_AMXTy(Context);
   case MVT::i64x8:   return IntegerType::get(Context, 512);
   case MVT::externref:
+    // pointer to opaque struct in addrspace(10)
     return PointerType::get(StructType::create(Context), 10);
   case MVT::funcref:
-    return PointerType::get(StructType::create(Context), 20);
+    // pointer to i8 addrspace(20)
+    return PointerType::get(Type::getInt8Ty(Context), 20);
   case MVT::v1i1:
     return FixedVectorType::get(Type::getInt1Ty(Context), 1);
   case MVT::v2i1:
     return FixedVectorType::get(Type::getInt1Ty(Context), 2);
   case MVT::v4i1:
     return FixedVectorType::get(Type::getInt1Ty(Context), 4);
   case MVT::v8i1:
     return FixedVectorType::get(Type::getInt1Ty(Context), 8);

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

 def WebAssemblyTableSet : SDNode<"WebAssemblyISD::TABLE_SET", WebAssemblyTableSet_t,
                                  [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
 
 def WebAssemblyTableGet_t : SDTypeProfile<1, 2, [SDTCisPtrTy<1>]>;
 def WebAssemblyTableGet : SDNode<"WebAssemblyISD::TABLE_GET", WebAssemblyTableGet_t,
                                  [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
 
 
-multiclass TABLE<WebAssemblyRegClass rc> {
+multiclass TABLE<WebAssemblyRegClass rc, string suffix> {
   let mayLoad = 1 in
   defm TABLE_GET_#rc : I<(outs rc:$res), (ins table32_op:$table, I32:$i),
                          (outs), (ins table32_op:$table),
                          [],
                          "table.get\t$res, $table, $i",
                          "table.get\t$table",
                          0x25>;
 
   let mayStore = 1 in
   defm TABLE_SET_#rc : I<(outs), (ins table32_op:$table, I32:$i, rc:$val),
                          (outs), (ins table32_op:$table),
                          [],
                          "table.set\t$table, $i, $val",
                          "table.set\t$table",
                          0x26>;
 
   defm TABLE_GROW_#rc : I<(outs I32:$sz), (ins table32_op:$table, rc:$val, I32:$n),
                           (outs), (ins table32_op:$table),
-                          [],
+                          [(set I32:$sz, (!cast<Intrinsic>("int_wasm_table_grow_" # suffix) (WebAssemblyWrapper tglobaladdr:$table), rc:$val, I32:$n))],
                           "table.grow\t$sz, $table, $val, $n",
                           "table.grow\t$table",
                           0xfc0f>;
 
   defm TABLE_FILL_#rc : I<(outs), (ins table32_op:$table, I32:$i, rc:$val, I32:$n),
                           (outs), (ins table32_op:$table),
-                          [],
+                          [(!cast<Intrinsic>("int_wasm_table_fill_" # suffix) (WebAssemblyWrapper tglobaladdr:$table), I32:$i, rc:$val, I32:$n)],
                           "table.fill\t$table, $i, $val, $n",
                           "table.fill\t$table",
                           0xfc11>;
 
   foreach vt = rc.RegTypes in {
     def : Pat<(vt (WebAssemblyTableGet (WebAssemblyWrapper tglobaladdr:$table), i32:$idx)),
               (!cast<NI>("TABLE_GET_" # rc) tglobaladdr:$table, i32:$idx)>;
     def : Pat<(WebAssemblyTableSet
                (WebAssemblyWrapper tglobaladdr:$table),
                i32:$idx,
                vt:$src),
               (!cast<NI>("TABLE_SET_" # rc) tglobaladdr:$table, i32:$idx, vt:$src)>;
   }
 }
 
-defm "" : TABLE<FUNCREF>, Requires<[HasReferenceTypes]>;
-defm "" : TABLE<EXTERNREF>, Requires<[HasReferenceTypes]>;
+defm "" : TABLE<FUNCREF, "funcref">, Requires<[HasReferenceTypes]>;
+defm "" : TABLE<EXTERNREF, "externref">, Requires<[HasReferenceTypes]>;
 
 def : Pat<(WebAssemblyTableSet mcsym:$table, i32:$idx, funcref:$r),
           (TABLE_SET_FUNCREF mcsym:$table, i32:$idx, funcref:$r)>,
           Requires<[HasReferenceTypes]>;
 
 defm TABLE_SIZE : I<(outs I32:$sz), (ins table32_op:$table),
                     (outs), (ins table32_op:$table),
-                    [],
+                    [(set I32:$sz, (int_wasm_table_size (WebAssemblyWrapper tglobaladdr:$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:$d, I32:$s, I32:$n),
                     (outs), (ins table32_op:$table1, table32_op:$table2),
-                    [],
+                    [(int_wasm_table_copy (WebAssemblyWrapper tglobaladdr:$table1),
+                                          (WebAssemblyWrapper tglobaladdr:$table2),
+                                          I32:$d, I32:$s, I32:$n)],
                     "table.copy\t$table1, $table2, $d, $s, $n",
                     "table.copy\t$table1, $table2",
                     0xfc0e>,
                     Requires<[HasReferenceTypes]>;

llvm/test/CodeGen/WebAssembly/funcref-call.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%func = type void ()
-%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+%funcptr = type void () addrspace(20)*
+%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
 
 define void @call_funcref(%funcref %ref) {
-  call addrspace(20) void %ref() 
+  %f = bitcast %funcref %ref to %funcptr
+  call addrspace(20) void %f() 
   ret void
 }
 
 ; CHECK: .tabletype __funcref_call_table, funcref, 1
 
 ; CHECK-LABEL: call_funcref:
 ; CHECK-NEXT: functype       call_funcref (funcref) -> ()
 ; CHECK-NEXT: i32.const 0
 ; CHECK-NEXT: local.get 0
 ; CHECK-NEXT: table.set __funcref_call_table
 ; CHECK-NEXT: i32.const 0
 ; CHECK-NEXT: call_indirect __funcref_call_table, () -> ()
 ; CHECK-NEXT: i32.const 0
 ; CHECK-NEXT: ref.null_func
 ; CHECK-NEXT: table.set __funcref_call_table
 ; CHECK-NEXT: end_function
 

llvm/test/CodeGen/WebAssembly/funcref-globalget.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%func = type opaque
-%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
 
 @funcref_global = local_unnamed_addr addrspace(1) global %funcref undef
 
 define %funcref @return_funcref_global() {
   ;; this generates a global.get of @funcref_global
   %ref = load %funcref, %funcref addrspace(1)* @funcref_global
   ret %funcref %ref
 }
 
 ; CHECK-LABEL: return_funcref_global:
 ; CHECK-NEXT: .functype       return_funcref_global () -> (funcref)
 ; CHECK-NEXT: global.get funcref_global
 ; CHECK-NEXT: end_function
 
 ; CHECK: .globl funcref_global

llvm/test/CodeGen/WebAssembly/funcref-globalset.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%func = type opaque
-%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
 
 @funcref_global = local_unnamed_addr addrspace(1) global %funcref undef
 
 define void @set_funcref_global(%funcref %g) {
   ;; this generates a global.set of @funcref_global
   store %funcref %g, %funcref addrspace(1)* @funcref_global
   ret void
 }
 
 ; CHECK-LABEL: set_funcref_global:
 ; CHECK-NEXT: functype       set_funcref_global (funcref) -> ()
 ; CHECK-NEXT: local.get      0
 ; CHECK-NEXT: global.set     funcref_global
 ; CHECK-NEXT: end_function
 
 ; CHECK: .globl funcref_global

llvm/test/CodeGen/WebAssembly/funcref-table_call.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%func = type void ()
-%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+%funcptr = type void () addrspace(20)*
+%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
 
 @funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
 
 define void @call_funcref_from_table(i32 %i) {
   %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %i
   %ref = load %funcref, %funcref addrspace(1)* %p
-  call addrspace(20) void %ref()
+  %fn = bitcast %funcref %ref to %funcptr
+  call addrspace(20) void %fn()
   ret void
 }
 
 ; CHECK: .tabletype __funcref_call_table, funcref, 1
 
 ; CHECK-LABEL: call_funcref_from_table:
 ; CHECK-NEXT: .functype       call_funcref_from_table (i32) -> ()
 ; CHECK-NEXT: i32.const       0

llvm/test/CodeGen/WebAssembly/funcref-tableget.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%func = type void ()
-%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
 
 @funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
 
 define %funcref @get_funcref_from_table(i32 %i) {
 ; CHECK-LABEL: get_funcref_from_table:
 ; CHECK-NEXT: .functype       get_funcref_from_table (i32) -> (funcref)
 ; CHECK-NEXT: local.get 0
 ; CHECK-NEXT: table.get funcref_table

llvm/test/CodeGen/WebAssembly/funcref-tableset.ll

 ; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
 
-%func = type void ()
-%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
 
 @funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
 
 define void @set_funcref_table(%funcref %g, i32 %i) {
 ; CHECK-LABEL: set_funcref_table:
 ; CHECK-NEXT: .functype       set_funcref_table (funcref, i32) -> ()
 ; CHECK-NEXT: local.get      1
 ; CHECK-NEXT: local.get      0

llvm/test/CodeGen/WebAssembly/table-copy.ll

+; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
+
+%extern = type opaque
+%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
+
+@externref_table1 = local_unnamed_addr addrspace(1) global [0 x %externref] undef
+@externref_table2 = local_unnamed_addr addrspace(1) global [0 x %externref] undef
+
+declare void @llvm.wasm.table.copy(i8 addrspace(1)*, i8 addrspace(1)*, i32, i32, i32) nounwind readonly
+
+define void @table_copy(i32 %dst, i32 %src, i32 %len) {
+; CHECK-LABEL: table_copy:
+; CHECK-NEXT:  .functype  table_copy (i32, i32, i32) -> ()
+; CHECK-NEXT:  local.get    0
+; CHECK-NEXT:  local.get    1
+; CHECK-NEXT:  local.get    2
+; CHECK-NEXT:  table.copy externref_table1, externref_table2
+; CHECK-NEXT:  end_function
+  %tableptr1 = getelementptr [0 x %externref], [0 x %externref] addrspace(1)* @externref_table1, i32 0, i32 0
+  %tb1 = bitcast %externref addrspace(1)* %tableptr1 to i8 addrspace(1)*
+  %tableptr2 = getelementptr [0 x %externref], [0 x %externref] addrspace(1)* @externref_table2, i32 0, i32 0
+  %tb2 = bitcast %externref addrspace(1)* %tableptr2 to i8 addrspace(1)*
+  call void @llvm.wasm.table.copy(i8 addrspace(1)* %tb1, i8 addrspace(1)* %tb2, i32 %dst, i32 %src, i32 %len)
+  ret void
+}
+
+; Testing copying from a table to itself at different offsets
+; Copies len items from table1 at src to table1 at src+off
+define void @self_table_copy(i32 %src, i32 %off, i32 %len) {
+; CHECK-LABEL: self_table_copy:
+; CHECK-NEXT:  .functype  self_table_copy (i32, i32, i32) -> ()
+; CHECK-NEXT:  local.get    0
+; CHECK-NEXT:  local.get    1
+; CHECK-NEXT:  i32.add
+; CHECK-NEXT:  local.get    0
+; CHECK-NEXT:  local.get    2
+; CHECK-NEXT:  table.copy externref_table1, externref_table1
+; CHECK-NEXT:  end_function
+  %dst = add nsw i32 %src, %off
+  %tableptr1 = getelementptr [0 x %externref], [0 x %externref] addrspace(1)* @externref_table1, i32 0, i32 0
+  %tb1 = bitcast %externref addrspace(1)* %tableptr1 to i8 addrspace(1)*
+  call void @llvm.wasm.table.copy(i8 addrspace(1)* %tb1, i8 addrspace(1)* %tb1, i32 %dst, i32 %src, i32 %len)
+  ret void
+}

llvm/test/CodeGen/WebAssembly/table-fill.ll

+; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
+
+%extern = type opaque
+%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
+
+@externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
+
+declare void @llvm.wasm.table.fill.externref(i8 addrspace(1)*, i32, %externref, i32) nounwind readonly
+
+define void @table_fill(i32 %start, i32 %len, %externref %val) {
+; CHECK-LABEL: table_fill:
+; CHECK-NEXT:  .functype  table_fill (i32, i32, externref) -> ()
+; CHECK-NEXT:  local.get    0
+; CHECK-NEXT:  local.get    2
+; CHECK-NEXT:  local.get    1
+; CHECK-NEXT:  table.fill externref_table
+; CHECK-NEXT:  end_function
+  %tableptr = getelementptr [0 x %externref], [0 x %externref] addrspace(1)* @externref_table, i32 0, i32 0
+  %tb = bitcast %externref addrspace(1)* %tableptr to i8 addrspace(1)*
+  call void @llvm.wasm.table.fill.externref(i8 addrspace(1)* %tb, i32 %start, %externref %val, i32 %len)
+  ret void
+}

llvm/test/CodeGen/WebAssembly/table-grow.ll

+; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
+
+%extern = type opaque
+%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
+
+@externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
+
+declare i32 @llvm.wasm.table.grow.externref(i8 addrspace(1)*, %externref, i32) nounwind readonly
+declare %externref @llvm.wasm.ref.null.extern() nounwind readonly
+
+define i32 @table_grow(i32 %sz) {
+; CHECK-LABEL: table_grow:
+; CHECK-NEXT:  .functype  table_grow (i32) -> (i32)
+; CHECK-NEXT:  ref.null_extern
+; CHECK-NEXT:  local.get  0
+; CHECK-NEXT:  table.grow externref_table
+; CHECK-NEXT:  end_function
+  %null = call %externref @llvm.wasm.ref.null.extern()
+  %tableptr = getelementptr [0 x %externref], [0 x %externref] addrspace(1)* @externref_table, i32 0, i32 0
+  %tb = bitcast %externref addrspace(1)* %tableptr to i8 addrspace(1)*
+  %newsz = call i32 @llvm.wasm.table.grow.externref(i8 addrspace(1)* %tb, %externref %null, i32 %sz)
+  ret i32 %newsz
+}

llvm/test/CodeGen/WebAssembly/table-size.ll

+; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
+
+%extern = type opaque
+%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
+
+@externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
+
+declare i32 @llvm.wasm.table.size(i8 addrspace(1)*) nounwind readonly
+
+define i32 @table_size() {
+; CHECK-LABEL: table_size:
+; CHECK-NEXT:  .functype       table_size () -> (i32)
+; CHECK-NEXT:  table.size      externref_table
+; CHECK-NEXT:  end_function
+  %tableptr = getelementptr [0 x %externref], [0 x %externref] addrspace(1)* @externref_table, i32 0, i32 0
+  %tb = bitcast %externref addrspace(1)* %tableptr to i8 addrspace(1)*
+  %sz = call i32 @llvm.wasm.table.size(i8 addrspace(1)* %tb)
+  ret i32 %sz
+}