[WebAssembly][NFC] Update reftype and table tests to use opaque pointers

[asb]

Summary

I'm currently doing some downstream experimentation on support for a broader set of GC types. Some of the options involve changes to the representation of externref and funcref at the IR level, and it seemed cleaner to convert to opaque pointers before further changing these tests. As this is something that needs to be done anyway, I thought I'd share the patch for upstream consideration.

externref-undef.ll is deleted as it's not really testing anything reftype specific.

[sbc100]

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

3

So the old code used type opaque and the new code just uses ptr? But I take that the ptr is also somehow implicitly "opaque".. otherwise the PR description would not make sense? (Sorry i'm not familiar the opaque pointer stuff).

[asb]

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

3

See here for an overview. Basically, pointers can still have an address space, but no longer have type information associated with them. Instead, you make use of a type argument for instructions that need it. As the page mentions, you can look at treatment of integer signedness as analogous - IR doesn't have signed and unsigned types, but has different operations that treat a value as signed or unsigned.

Clang now emits IR using opaque pointers by default, but the majority of .ll tests in llvm/test/ haven't been transitioned.

[sbc100]

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

3

I see.. the new ptr type is also opaque, so that the fact that you are removing the keyword opaque is not actually removing the opaqueness, since its now baked in.

[asb]

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

3

Yep that's right, previously we had a typed pointer to an opaque struct type. Moving to ptr, all pointers are opaque.

[pmatos]

Thanks for the change. LGTM.
I will rebase my further changes on top of this.

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

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

llvm/test/CodeGen/WebAssembly/externref-globalset.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 = type ptr addrspace(10) ;; addrspace 10 is nonintegral
 
 @externref_global = local_unnamed_addr addrspace(1) global %externref undef
 
 define void @set_externref_global(%externref %g) {
   ;; this generates a global.set of @externref.global
-  store %externref %g, %externref addrspace(1)* @externref_global
+  store %externref %g, ptr addrspace(1) @externref_global
   ret void
 }
 
 ; CHECK-LABEL: set_externref_global:
 ; CHECK-NEXT: functype       set_externref_global (externref) -> ()
 ; CHECK-NEXT: local.get      0
 ; CHECK-NEXT: global.set     externref_global
 ; CHECK-NEXT: end_function
 
 ; CHECK: .globl externref_global

llvm/test/CodeGen/WebAssembly/externref-inttoptr.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types 2>&1 | FileCheck %s
 
-%extern = type opaque
-%externref = type %extern addrspace(10)*
+%externref = type ptr addrspace(10)
 
 define %externref @int_to_externref(i32 %i) {
   %ref = inttoptr i32 %i to %externref
   ret %externref %ref
 }
 
 
 ; CHECK-LABEL: int_to_externref:
 ; CHECK-NEXT: .functype       int_to_externref (i32) -> (externref)
 ; CHECK-NEXT: .local externref
 ; CHECK-NEXT: unreachable
 ; CHECK-NEXT: local.get 1
 ; CHECK-NEXT: end_function

llvm/test/CodeGen/WebAssembly/externref-ptrtoint.ll

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types 2>&1 | FileCheck %s
 
-%extern = type opaque
-%externref = type %extern addrspace(10)*
+%externref = type ptr addrspace(10)
 
 define i32 @externref_to_int(%externref %ref) {
   %i = ptrtoint %externref %ref to i32
   ret i32 %i
 }
 
 ; CHECK-LABEL: externref_to_int:
 ; CHECK-NEXT: .functype       externref_to_int (externref) -> (i32)
 ; CHECK-NEXT: .local i32
 ; CHECK-NEXT: unreachable
 ; CHECK-NEXT: local.get 1
 ; CHECK-NEXT: end_function

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

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%extern = type opaque
-%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
+%externref = type ptr addrspace(10) ;; addrspace 10 is nonintegral
 
 @externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
 
 define %externref @get_externref_from_table(i32 %i) {
 ; CHECK-LABEL: get_externref_from_table:
 ; CHECK-NEXT: .functype       get_externref_from_table (i32) -> (externref)
 ; CHECK-NEXT: local.get 0
 ; CHECK-NEXT: table.get externref_table
 ; CHECK-NEXT: end_function
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %i
-  %ref = load %externref, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace(1) @externref_table, i32 0, i32 %i
+  %ref = load %externref, ptr addrspace(1) %p
   ret %externref %ref
 }
 
 define %externref @get_externref_from_table_const() {
 ; CHECK-LABEL: get_externref_from_table_const:
 ; CHECK-NEXT:  .functype      get_externref_from_table_const () -> (externref)
 ; CHECK-NEXT:  i32.const      0
 ; CHECK-NEXT:  table.get      externref_table
 ; CHECK-NEXT:  end_function
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 0
-  %ref = load %externref, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 0
+  %ref = load %externref, ptr addrspace(1) %p
   ret %externref %ref
 }
 
 define %externref @get_externref_from_table_with_offset(i32 %i) {
 ; CHECK-LABEL: get_externref_from_table_with_offset:
 ; CHECK-NEXT:  .functype       get_externref_from_table_with_offset (i32) -> (externref)
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  i32.const       2
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  table.get       externref_table
 ; CHECK-NEXT:  end_function
   %off = add nsw i32 %i, 2
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %off
-  %ref = load %externref, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off
+  %ref = load %externref, ptr addrspace(1) %p
   ret %externref %ref
 }
 
 
 define %externref @get_externref_from_table_with_var_offset(i32 %i, i32 %j) {
 ; CHECK-LABEL: get_externref_from_table_with_var_offset:
 ; CHECK-NEXT:  .functype       get_externref_from_table_with_var_offset (i32, i32) -> (externref)
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  local.get       1
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  table.get       externref_table
 ; CHECK-NEXT:  end_function
   %off = add nsw i32 %i, %j
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %off
-  %ref = load %externref, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off
+  %ref = load %externref, ptr addrspace(1) %p
   ret %externref %ref
 }
 
 declare i32 @get_offset()
 
 define %externref @get_externref_from_table_with_var_offset2(i32 %i) {
 ; CHECK-LABEL: get_externref_from_table_with_var_offset2:
 ; CHECK-NEXT:  .functype       get_externref_from_table_with_var_offset2 (i32) -> (externref)
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  call    get_offset
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  table.get       externref_table
 ; CHECK-NEXT:  end_function
   %j = call i32 @get_offset()
   %off = add nsw i32 %i, %j
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %off
-  %ref = load %externref, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off
+  %ref = load %externref, ptr addrspace(1) %p
   ret %externref %ref
 }
 
 ; CHECK:       .tabletype externref_table, externref
 ; CHECK-LABEL: externref_table:

llvm/test/CodeGen/WebAssembly/externref-tableset.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 = type ptr addrspace(10) ;; addrspace 10 is nonintegral
 
 @externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
 
 define void @set_externref_table(%externref %g, i32 %i) {
 ; CHECK-LABEL: set_externref_table:
 ; CHECK-NEXT: .functype       set_externref_table (externref, i32) -> ()
 ; CHECK-NEXT: local.get      1
 ; CHECK-NEXT: local.get      0
 ; CHECK-NEXT: table.set     externref_table
 ; CHECK-NEXT: end_function
 
 ;; this generates a table.set of @externref_table
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %i
-  store %externref %g, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %i
+  store %externref %g, ptr addrspace(1) %p
   ret void
 }
 
 define void @set_externref_table_const(%externref %g) {
 ; CHECK-LABEL: set_externref_table_const:
 ; CHECK-NEXT:  .functype      set_externref_table_const (externref) -> ()
 ; CHECK-NEXT:  i32.const      0
 ; CHECK-NEXT:  local.get      0
 ; CHECK-NEXT:  table.set      externref_table
 ; CHECK-NEXT:  end_function
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 0
-  store %externref %g, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 0
+  store %externref %g, ptr addrspace(1) %p
   ret void
 }
 
 define void @set_externref_table_with_offset(%externref %g, i32 %i) {
 ; CHECK-LABEL: set_externref_table_with_offset:
 ; CHECK-NEXT:  .functype       set_externref_table_with_offset (externref, i32) -> ()
 ; CHECK-NEXT:  local.get       1
 ; CHECK-NEXT:  i32.const       2
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  table.set       externref_table
 ; CHECK-NEXT:  end_function
   %off = add nsw i32 %i, 2
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %off
-  store %externref %g, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off
+  store %externref %g, ptr addrspace(1) %p
   ret void
 }
 
 define void @set_externref_table_with_var_offset(%externref %g, i32 %i, i32 %j) {
 ; CHECK-LABEL: set_externref_table_with_var_offset:
 ; CHECK-NEXT:  .functype       set_externref_table_with_var_offset (externref, i32, i32) -> ()
 ; CHECK-NEXT:  local.get       1
 ; CHECK-NEXT:  local.get       2
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  table.set       externref_table
 ; CHECK-NEXT:  end_function
   %off = add nsw i32 %i, %j
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %off
-  store %externref %g, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off
+  store %externref %g, ptr addrspace(1) %p
   ret void
 }
 
 declare i32 @set_offset()
 
 define void @set_externref_table_with_var_offset2(%externref %g, i32 %i) {
 ; CHECK-LABEL: set_externref_table_with_var_offset2:
 ; CHECK-NEXT:  .functype       set_externref_table_with_var_offset2 (externref, i32) -> ()
 ; CHECK-NEXT:  local.get       1
 ; CHECK-NEXT:  call    set_offset
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  table.set       externref_table
 ; CHECK-NEXT:  end_function
   %j = call i32 @set_offset()
   %off = add nsw i32 %i, %j
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %off
-  store %externref %g, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off
+  store %externref %g, ptr addrspace(1) %p
   ret void
 }
 
 declare i32 @get_table_slot() local_unnamed_addr
 
 define void @set_externref_table_with_id_from_call(%externref %g) {
 ; CHECK-LABEL: set_externref_table_with_id_from_call:
 ; CHECK-NEXT:  .functype       set_externref_table_with_id_from_call (externref) -> ()
 ; CHECK-NEXT:  call    get_table_slot
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  table.set       externref_table
 ; CHECK-NEXT:  end_function
   %id = call i32 @get_table_slot()
-  %p = getelementptr [0 x %externref], [0 x %externref] addrspace (1)* @externref_table, i32 0, i32 %id
-  store %externref %g, %externref addrspace(1)* %p
+  %p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %id
+  store %externref %g, ptr addrspace(1) %p
   ret void
 }
 
 ;       CHECK: .tabletype externref_table, externref
 ; CHECK-LABEL: externref_table:

llvm/test/CodeGen/WebAssembly/externref-undef.ll

-; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
-
-%extern = type opaque
-%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
-
-@externref_global = local_unnamed_addr addrspace(1) global %externref undef
-
-define %extern @return_extern_undef() {
-  ; Returning a ref.null or an uninitialized externref would make
-  ; more sense if the return type would be %externref. However, in
-  ; this case this is an %extern value, which really is an opaque
-  ; type and should never really happen.
-  ret %extern undef
-}
-
-; CHECK-LABEL: return_extern_undef:
-; CHECK-NEXT: functype       return_extern_undef () -> ()
-; CHECK-NEXT: end_function
-
-; CHECK: .globl externref_global
-

llvm/test/CodeGen/WebAssembly/externref-unsized-load.ll

 ; RUN: not llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
 
-%extern = type opaque
-%externref = type %extern addrspace(10)*
+%externref = type ptr addrspace(10)
 
 define void @load_extern(%externref %ref) {
   %e = load %extern, %externref %ref
   ret void
 }
 
 ; CHECK-ERROR: error: loading unsized types is not allowed

llvm/test/CodeGen/WebAssembly/externref-unsized-store.ll

 ; RUN: not llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s 2>&1 | FileCheck %s --check-prefix=CHECK-ERROR
 
-%extern = type opaque
-%externref = type %extern addrspace(10)*
+%externref = type ptr addrspace(10)
 
 define void @store_extern(%externref %ref) {
   store %extern undef, %externref %ref
   ret void
 }
 
 ; CHECK-ERROR: error: storing unsized types is not allowed

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

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%funcptr = type void () addrspace(20)*
-%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
+%funcref = type ptr addrspace(20) ;; addrspace 20 is nonintegral
 
 ; CHECK: .tabletype __funcref_call_table, funcref, 1
 
 define void @call_funcref(%funcref %ref) {
 ; 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
-  %f = bitcast %funcref %ref to %funcptr
-  call addrspace(20) void %f() 
-  ret void
-}
-
-define void @call_funcptr(%funcptr %ref) {
-; CHECK-LABEL: call_funcptr:
-; CHECK-NEXT: .functype       call_funcptr (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
   call addrspace(20) void %ref()
   ret void
 }
 
 
 

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

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

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

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
+%funcref = type ptr 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
 ; CHECK-NEXT: end_function
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %i
-  %ref = load %funcref, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %i
+  %ref = load %funcref, ptr addrspace(1) %p
   ret %funcref %ref
 }
 
 define %funcref @get_funcref_from_table_const() {
 ; CHECK-LABEL: get_funcref_from_table_const:
 ; CHECK-NEXT:  .functype      get_funcref_from_table_const () -> (funcref)
 ; CHECK-NEXT:  i32.const      0
 ; CHECK-NEXT:  table.get      funcref_table
 ; CHECK-NEXT:  end_function
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 0
-  %ref = load %funcref, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 0
+  %ref = load %funcref, ptr addrspace(1) %p
   ret %funcref %ref
 }
 
 define %funcref @get_funcref_from_table_with_offset(i32 %i) {
 ; CHECK-LABEL: get_funcref_from_table_with_offset:
 ; CHECK-NEXT:  .functype       get_funcref_from_table_with_offset (i32) -> (funcref)
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  i32.const       2
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  table.get       funcref_table
 ; CHECK-NEXT:  end_function
   %off = add nsw i32 %i, 2
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %off
-  %ref = load %funcref, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off
+  %ref = load %funcref, ptr addrspace(1) %p
   ret %funcref %ref
 }
 
 
 define %funcref @get_funcref_from_table_with_var_offset(i32 %i, i32 %j) {
 ; CHECK-LABEL: get_funcref_from_table_with_var_offset:
 ; CHECK-NEXT:  .functype       get_funcref_from_table_with_var_offset (i32, i32) -> (funcref)
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  local.get       1
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  table.get       funcref_table
 ; CHECK-NEXT:  end_function
   %off = add nsw i32 %i, %j
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %off
-  %ref = load %funcref, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off
+  %ref = load %funcref, ptr addrspace(1) %p
   ret %funcref %ref
 }
 
 declare i32 @get_offset()
 
 define %funcref @get_funcref_from_table_with_var_offset2(i32 %i) {
 ; CHECK-LABEL: get_funcref_from_table_with_var_offset2:
 ; CHECK-NEXT:  .functype       get_funcref_from_table_with_var_offset2 (i32) -> (funcref)
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  call    get_offset
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  table.get       funcref_table
 ; CHECK-NEXT:  end_function
   %j = call i32 @get_offset()
   %off = add nsw i32 %i, %j
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %off
-  %ref = load %funcref, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off
+  %ref = load %funcref, ptr addrspace(1) %p
   ret %funcref %ref
 }
 
 ;       CHECK: .tabletype funcref_table, funcref
 ; CHECK-LABEL: funcref_table:

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

 ; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
 
-%funcref = type i8 addrspace(20)* ;; addrspace 20 is nonintegral
+%funcref = type ptr 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
 ; CHECK-NEXT: table.set     funcref_table
 ; CHECK-NEXT: end_function
 
 ;; this generates a table.set of @funcref_table
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %i
-  store %funcref %g, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %i
+  store %funcref %g, ptr addrspace(1) %p
   ret void
 }
 
 define void @set_funcref_table_const(%funcref %g) {
 ; CHECK-LABEL: set_funcref_table_const:
 ; CHECK-NEXT:  .functype      set_funcref_table_const (funcref) -> ()
 ; CHECK-NEXT:  i32.const      0
 ; CHECK-NEXT:  local.get      0
 ; CHECK-NEXT:  table.set      funcref_table
 ; CHECK-NEXT:  end_function
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 0
-  store %funcref %g, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 0
+  store %funcref %g, ptr addrspace(1) %p
   ret void
 }
 
 define void @set_funcref_table_with_offset(%funcref %g, i32 %i) {
 ; CHECK-LABEL: set_funcref_table_with_offset:
 ; CHECK-NEXT:  .functype       set_funcref_table_with_offset (funcref, i32) -> ()
 ; CHECK-NEXT:  local.get       1
 ; CHECK-NEXT:  i32.const       2
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  table.set       funcref_table
 ; CHECK-NEXT:  end_function
   %off = add nsw i32 %i, 2
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %off
-  store %funcref %g, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off
+  store %funcref %g, ptr addrspace(1) %p
   ret void
 }
 
 define void @set_funcref_table_with_var_offset(%funcref %g, i32 %i, i32 %j) {
 ; CHECK-LABEL: set_funcref_table_with_var_offset:
 ; CHECK-NEXT:  .functype       set_funcref_table_with_var_offset (funcref, i32, i32) -> ()
 ; CHECK-NEXT:  local.get       1
 ; CHECK-NEXT:  local.get       2
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  table.set       funcref_table
 ; CHECK-NEXT:  end_function
   %off = add nsw i32 %i, %j
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %off
-  store %funcref %g, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off
+  store %funcref %g, ptr addrspace(1) %p
   ret void
 }
 
 declare i32 @set_offset()
 
 define void @set_funcref_table_with_var_offset2(%funcref %g, i32 %i) {
 ; CHECK-LABEL: set_funcref_table_with_var_offset2:
 ; CHECK-NEXT:  .functype       set_funcref_table_with_var_offset2 (funcref, i32) -> ()
 ; CHECK-NEXT:  local.get       1
 ; CHECK-NEXT:  call    set_offset
 ; CHECK-NEXT:  i32.add
 ; CHECK-NEXT:  local.get       0
 ; CHECK-NEXT:  table.set       funcref_table
 ; CHECK-NEXT:  end_function
   %j = call i32 @set_offset()
   %off = add nsw i32 %i, %j
-  %p = getelementptr [0 x %funcref], [0 x %funcref] addrspace (1)* @funcref_table, i32 0, i32 %off
-  store %funcref %g, %funcref addrspace(1)* %p
+  %p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off
+  store %funcref %g, ptr addrspace(1) %p
   ret void
 }
 
 ;       CHECK: .tabletype funcref_table, funcref
 ; CHECK-LABEL: funcref_table:

llvm/test/CodeGen/WebAssembly/ref-null.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc --mtriple=wasm32-unknown-unknown -mattr=+reference-types < %s | FileCheck %s
 
-%extern = type opaque
-%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
-%funcref = type i8 addrspace(20)*      ;; addrspace 20 is nonintegral
+%externref = type ptr addrspace(10) ;; addrspace 10 is nonintegral
+%funcref = type ptr addrspace(20)   ;; addrspace 20 is nonintegral
 
 declare %externref @llvm.wasm.ref.null.extern() nounwind
 declare %funcref @llvm.wasm.ref.null.func() nounwind
 declare i32 @llvm.wasm.ref.is_null.extern(%externref) nounwind
 declare i32 @llvm.wasm.ref.is_null.func(%funcref) nounwind
 
 define %externref @get_null_extern() {
 ; CHECK-LABEL: get_null_extern:

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 = type ptr 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
+declare void @llvm.wasm.table.copy(ptr addrspace(1), ptr 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)
+  %tableptr1 = getelementptr [0 x %externref], ptr addrspace(1) @externref_table1, i32 0, i32 0
+  %tableptr2 = getelementptr [0 x %externref], ptr addrspace(1) @externref_table2, i32 0, i32 0
+  call void @llvm.wasm.table.copy(ptr addrspace(1) %tableptr1, ptr addrspace(1) %tableptr2, 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)
+  %tableptr1 = getelementptr [0 x %externref], ptr addrspace(1) @externref_table1, i32 0, i32 0
+  call void @llvm.wasm.table.copy(ptr addrspace(1) %tableptr1, ptr addrspace(1) %tableptr1, 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 = type ptr 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
+declare void @llvm.wasm.table.fill.externref(ptr 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)
+  %tableptr = getelementptr [0 x %externref], ptr addrspace(1) @externref_table, i32 0, i32 0
+  call void @llvm.wasm.table.fill.externref(ptr addrspace(1) %tableptr, 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 = type ptr 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 i32 @llvm.wasm.table.grow.externref(ptr 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)
+  %tableptr = getelementptr [0 x %externref], ptr addrspace(1) @externref_table, i32 0, i32 0
+  %newsz = call i32 @llvm.wasm.table.grow.externref(ptr addrspace(1) %tableptr, %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 = type ptr 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
+declare i32 @llvm.wasm.table.size(ptr 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)
+  %tableptr = getelementptr [0 x %externref], ptr addrspace(1) @externref_table, i32 0, i32 0
+  %sz = call i32 @llvm.wasm.table.size(ptr addrspace(1) %tableptr)
   ret i32 %sz
 }

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

 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
 
-%extern = type opaque
-%externref = type %extern addrspace(10)* ;; addrspace 10 is nonintegral
-
-%func = type void ()
-%funcref = type %func addrspace(20)* ;; addrspace 20 is nonintegral
+%externref = type ptr addrspace(10) ;; addrspace 10 is nonintegral
+%funcref = type ptr addrspace(20)   ;; addrspace 20 is nonintegral
 
 ; CHECK: .tabletype eref_table, externref
 ; CHECK-NEXT: .globl eref_table
 ; CHECK-LABEL: eref_table:
 @eref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
 
 ; CHECK-NOT: .globl .Lprivate_eref_table
 ; CHECK: .tabletype .Lprivate_eref_table, externref