This is an archive of the discontinued LLVM Phabricator instance.

Differential D134436

[WebAssembly] Use intrinsics for table.get/set instructions
ClosedPublic

Authored by pmatos on Sep 22 2022, 6:32 AM.

Details

Reviewers
asb
tlively
Commits
rG1bd1a4407058: [WebAssembly] Use intrinsics for table.get/set instructions
Summary

Initial table.get/set implementation would match and lower combinations
of GEP+load/store to table.get/set instructions. However, this is error
prone due to potential combinations of GEP+load/store we don't implement,
and load/store optimizations. By changing the code to using intrinsics, we
avoid both issues and simplify the code.

New builtins implemented:

  • @llvm.wasm.table.get.externref
  • @llvm.wasm.table.get.funcref
  • @llvm.wasm.table.set.externref
  • @llvm.wasm.table.set.funcref

Diff Detail

Event Timeline

pmatos created this revision.Sep 22 2022, 6:32 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 22 2022, 6:32 AM
Herald added subscribers: StephenFan, wingo, ecnelises and 5 others. · View Herald Transcript
pmatos requested review of this revision.Sep 22 2022, 6:32 AM
Harbormaster completed remote builds in B188166: Diff 462164.Sep 22 2022, 6:32 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 22 2022, 6:32 AM
Herald added subscribers: llvm-commits, aheejin. · View Herald Transcript
asb accepted this revision.Sep 26 2022, 1:57 AM

This change LGTM, thanks!

Needing one intrinsic per GC type is non-ideal, but the longer term plan to move to a 'wasmref' type (with associated type metadata) once we've fleshed out that prototype and go through necessary RFCs should remove that issue.

I wondered a bit about the properties for the intrinsic, and now I've reminded myself that intrinsics are not speculatable by default I think they're fine as defined.

llvm/include/llvm/IR/IntrinsicsWebAssembly.td
55

Nit: this line seems to have unwanted whitespace (a bunch of spaces)

This revision is now accepted and ready to land.Sep 26 2022, 1:57 AM
tlively accepted this revision.Sep 26 2022, 11:39 AM

LGTM!

pmatos marked an inline comment as done.Sep 27 2022, 12:16 AM
Closed by commit rG1bd1a4407058: [WebAssembly] Use intrinsics for table.get/set instructions (authored by pmatos). · Explain WhySep 27 2022, 12:17 AM
This revision was automatically updated to reflect the committed changes.
pmatos added a commit: rG1bd1a4407058: [WebAssembly] Use intrinsics for table.get/set instructions.

Revision Contents

PathSize
llvm/
include/
llvm/
IR/
14 lines
lib/
Target/
WebAssembly/
113 lines
4 lines
test/
CodeGen/
WebAssembly/
17 lines
20 lines
5 lines
17 lines
17 lines

Diff 463115

llvm/include/llvm/IR/IntrinsicsWebAssembly.td

Show All 33 Lines
def int_wasm_ref_is_null_extern : Intrinsic<[llvm_i32_ty], [llvm_externref_ty], def int_wasm_ref_is_null_extern : Intrinsic<[llvm_i32_ty], [llvm_externref_ty],
[IntrNoMem], "llvm.wasm.ref.is_null.extern">; [IntrNoMem], "llvm.wasm.ref.is_null.extern">;
def int_wasm_ref_is_null_func : Intrinsic<[llvm_i32_ty], [llvm_funcref_ty], def int_wasm_ref_is_null_func : Intrinsic<[llvm_i32_ty], [llvm_funcref_ty],
[IntrNoMem], "llvm.wasm.ref.is_null.func">; [IntrNoMem], "llvm.wasm.ref.is_null.func">;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Table intrinsics // Table intrinsics
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
def int_wasm_table_set_externref : Intrinsic<[],
[llvm_table_ty, llvm_i32_ty, llvm_externref_ty],
[IntrWriteMem]>;
def int_wasm_table_set_funcref : Intrinsic<[],
[llvm_table_ty, llvm_i32_ty, llvm_funcref_ty],
[IntrWriteMem]>;
def int_wasm_table_get_externref : Intrinsic<[llvm_externref_ty],
[llvm_table_ty, llvm_i32_ty],
[IntrReadMem]>;
def int_wasm_table_get_funcref : Intrinsic<[llvm_funcref_ty],
[llvm_table_ty, llvm_i32_ty],
[IntrReadMem]>;
asbUnsubmitted
Done
ReplyInline Actions

Nit: this line seems to have unwanted whitespace (a bunch of spaces)

asb: Nit: this line seems to have unwanted whitespace (a bunch of spaces)
// Query the current table size, and increase the current table size. // Query the current table size, and increase the current table size.
def int_wasm_table_size : Intrinsic<[llvm_i32_ty], def int_wasm_table_size : Intrinsic<[llvm_i32_ty],
[llvm_table_ty], [llvm_table_ty],
[IntrReadMem]>; [IntrReadMem]>;
def int_wasm_table_copy : Intrinsic<[], def int_wasm_table_copy : Intrinsic<[],
[llvm_table_ty, llvm_table_ty, llvm_i32_ty, llvm_i32_ty, llvm_i32_ty], [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], def int_wasm_table_grow_externref : Intrinsic<[llvm_i32_ty],
▲ Show 20 Lines • Show All 264 Lines • Show Last 20 Lines

llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp

Show First 20 Lines • Show All 1,452 Lines • ▼ Show 20 Linesstatic Optional<unsigned> IsWebAssemblyLocal(SDValue Op, SelectionDAG &DAG) {
const FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Op); const FrameIndexSDNode *FI = dyn_cast<FrameIndexSDNode>(Op);
if (!FI) if (!FI)
return None; return None;
auto &MF = DAG.getMachineFunction(); auto &MF = DAG.getMachineFunction();
return WebAssemblyFrameLowering::getLocalForStackObject(MF, FI->getIndex()); return WebAssemblyFrameLowering::getLocalForStackObject(MF, FI->getIndex());
} }
static bool IsWebAssemblyTable(SDValue Op) {
const GlobalAddressSDNode *GA = dyn_cast<GlobalAddressSDNode>(Op);
if (GA && WebAssembly::isWasmVarAddressSpace(GA->getAddressSpace())) {
const GlobalValue *Value = GA->getGlobal();
const Type *Ty = Value->getValueType();
if (Ty->isArrayTy() && WebAssembly::isRefType(Ty->getArrayElementType()))
return true;
}
return false;
}
// This function will accept as Op any access to a table, so Op can
// be the actual table or an offset into the table.
static bool IsWebAssemblyTableWithOffset(SDValue Op) {
if (Op->getOpcode() == ISD::ADD && Op->getNumOperands() == 2)
return (Op->getOperand(1).getSimpleValueType() == MVT::i32 &&
IsWebAssemblyTableWithOffset(Op->getOperand(0))) ||
(Op->getOperand(0).getSimpleValueType() == MVT::i32 &&
IsWebAssemblyTableWithOffset(Op->getOperand(1)));
return IsWebAssemblyTable(Op);
}
// Helper for table pattern matching used in LowerStore and LowerLoad
bool WebAssemblyTargetLowering::MatchTableForLowering(SelectionDAG &DAG,
const SDLoc &DL,
const SDValue &Base,
GlobalAddressSDNode *&GA,
SDValue &Idx) const {
// We expect the following graph for a load of the form:
// table[<var> + <constant offset>]
//
// Case 1:
// externref = load t1
// t1: i32 = add t2, i32:<constant offset>
// t2: i32 = add tX, table
//
// This is in some cases simplified to just:
// Case 2:
// externref = load t1
// t1: i32 = add t2, i32:tX
//
// So, unfortunately we need to check for both cases and if we are in the
// first case extract the table GlobalAddressNode and build a new node tY
// that's tY: i32 = add i32:<constant offset>, i32:tX
//
if (IsWebAssemblyTable(Base)) {
GA = cast<GlobalAddressSDNode>(Base);
Idx = DAG.getConstant(0, DL, MVT::i32);
} else {
GA = dyn_cast<GlobalAddressSDNode>(Base->getOperand(0));
if (GA) {
// We are in Case 2 above.
Idx = Base->getOperand(1);
assert(GA->getNumValues() == 1);
} else {
// This might be Case 1 above (or an error)
SDValue V = Base->getOperand(0);
GA = dyn_cast<GlobalAddressSDNode>(V->getOperand(1));
if (V->getOpcode() != ISD::ADD || V->getNumOperands() != 2 || !GA)
return false;
SDValue IdxV = DAG.getNode(ISD::ADD, DL, MVT::i32, Base->getOperand(1),
V->getOperand(0));
Idx = IdxV;
}
}
return true;
}
SDValue WebAssemblyTargetLowering::LowerStore(SDValue Op, SDValue WebAssemblyTargetLowering::LowerStore(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
SDLoc DL(Op); SDLoc DL(Op);
StoreSDNode *SN = cast<StoreSDNode>(Op.getNode()); StoreSDNode *SN = cast<StoreSDNode>(Op.getNode());
const SDValue &Value = SN->getValue(); const SDValue &Value = SN->getValue();
const SDValue &Base = SN->getBasePtr(); const SDValue &Base = SN->getBasePtr();
const SDValue &Offset = SN->getOffset(); const SDValue &Offset = SN->getOffset();
if (IsWebAssemblyTableWithOffset(Base)) {
if (!Offset->isUndef())
report_fatal_error(
"unexpected offset when loading from webassembly table", false);
SDValue Idx;
GlobalAddressSDNode *GA;
if (!MatchTableForLowering(DAG, DL, Base, GA, Idx))
report_fatal_error("failed pattern matching for lowering table store",
false);
SDVTList Tys = DAG.getVTList(MVT::Other);
SDValue TableSetOps[] = {SN->getChain(), SDValue(GA, 0), Idx, Value};
SDValue TableSet =
DAG.getMemIntrinsicNode(WebAssemblyISD::TABLE_SET, DL, Tys, TableSetOps,
SN->getMemoryVT(), SN->getMemOperand());
return TableSet;
}
if (IsWebAssemblyGlobal(Base)) { if (IsWebAssemblyGlobal(Base)) {
if (!Offset->isUndef()) if (!Offset->isUndef())
report_fatal_error("unexpected offset when storing to webassembly global", report_fatal_error("unexpected offset when storing to webassembly global",
false); false);
SDVTList Tys = DAG.getVTList(MVT::Other); SDVTList Tys = DAG.getVTList(MVT::Other);
SDValue Ops[] = {SN->getChain(), Value, Base}; SDValue Ops[] = {SN->getChain(), Value, Base};
return DAG.getMemIntrinsicNode(WebAssemblyISD::GLOBAL_SET, DL, Tys, Ops, return DAG.getMemIntrinsicNode(WebAssemblyISD::GLOBAL_SET, DL, Tys, Ops,
Show All 21 Lines
SDValue WebAssemblyTargetLowering::LowerLoad(SDValue Op, SDValue WebAssemblyTargetLowering::LowerLoad(SDValue Op,
SelectionDAG &DAG) const { SelectionDAG &DAG) const {
SDLoc DL(Op); SDLoc DL(Op);
LoadSDNode *LN = cast<LoadSDNode>(Op.getNode()); LoadSDNode *LN = cast<LoadSDNode>(Op.getNode());
const SDValue &Base = LN->getBasePtr(); const SDValue &Base = LN->getBasePtr();
const SDValue &Offset = LN->getOffset(); const SDValue &Offset = LN->getOffset();
if (IsWebAssemblyTableWithOffset(Base)) {
if (!Offset->isUndef())
report_fatal_error(
"unexpected offset when loading from webassembly table", false);
GlobalAddressSDNode *GA;
SDValue Idx;
if (!MatchTableForLowering(DAG, DL, Base, GA, Idx))
report_fatal_error("failed pattern matching for lowering table load",
false);
SDVTList Tys = DAG.getVTList(LN->getValueType(0), MVT::Other);
SDValue TableGetOps[] = {LN->getChain(), SDValue(GA, 0), Idx};
SDValue TableGet =
DAG.getMemIntrinsicNode(WebAssemblyISD::TABLE_GET, DL, Tys, TableGetOps,
LN->getMemoryVT(), LN->getMemOperand());
return TableGet;
}
if (IsWebAssemblyGlobal(Base)) { if (IsWebAssemblyGlobal(Base)) {
if (!Offset->isUndef()) if (!Offset->isUndef())
report_fatal_error( report_fatal_error(
"unexpected offset when loading from webassembly global", false); "unexpected offset when loading from webassembly global", false);
SDVTList Tys = DAG.getVTList(LN->getValueType(0), MVT::Other); SDVTList Tys = DAG.getVTList(LN->getValueType(0), MVT::Other);
SDValue Ops[] = {LN->getChain(), Base}; SDValue Ops[] = {LN->getChain(), Base};
return DAG.getMemIntrinsicNode(WebAssemblyISD::GLOBAL_GET, DL, Tys, Ops, return DAG.getMemIntrinsicNode(WebAssemblyISD::GLOBAL_GET, DL, Tys, Ops,
▲ Show 20 Lines • Show All 1,138 Lines • Show Last 20 Lines

llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td

Show All 18 Lines
def WebAssemblyTableGet : SDNode<"WebAssemblyISD::TABLE_GET", WebAssemblyTableGet_t, def WebAssemblyTableGet : SDNode<"WebAssemblyISD::TABLE_GET", WebAssemblyTableGet_t,
[SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>; [SDNPHasChain, SDNPMayLoad, SDNPMemOperand]>;
multiclass TABLE<WebAssemblyRegClass rc, string suffix> { multiclass TABLE<WebAssemblyRegClass rc, string suffix> {
let mayLoad = 1 in let mayLoad = 1 in
defm TABLE_GET_#rc : I<(outs rc:$res), (ins table32_op:$table, I32:$i), defm TABLE_GET_#rc : I<(outs rc:$res), (ins table32_op:$table, I32:$i),
(outs), (ins table32_op:$table), (outs), (ins table32_op:$table),
[], [(set rc:$res, (!cast<Intrinsic>("int_wasm_table_get_" # suffix) (WebAssemblyWrapper tglobaladdr:$table), I32:$i))],
"table.get\t$res, $table, $i", "table.get\t$res, $table, $i",
"table.get\t$table", "table.get\t$table",
0x25>; 0x25>;
let mayStore = 1 in let mayStore = 1 in
defm TABLE_SET_#rc : I<(outs), (ins table32_op:$table, I32:$i, rc:$val), defm TABLE_SET_#rc : I<(outs), (ins table32_op:$table, I32:$i, rc:$val),
(outs), (ins table32_op:$table), (outs), (ins table32_op:$table),
[], [(!cast<Intrinsic>("int_wasm_table_set_" # suffix) (WebAssemblyWrapper tglobaladdr:$table), I32:$i, rc:$val)],
"table.set\t$table, $i, $val", "table.set\t$table, $i, $val",
"table.set\t$table", "table.set\t$table",
0x26>; 0x26>;
defm TABLE_GROW_#rc : I<(outs I32:$sz), (ins table32_op:$table, rc:$val, I32:$n), defm TABLE_GROW_#rc : I<(outs I32:$sz), (ins table32_op:$table, rc:$val, I32:$n),
(outs), (ins table32_op:$table), (outs), (ins table32_op:$table),
[(set I32:$sz, (!cast<Intrinsic>("int_wasm_table_grow_" # suffix) (WebAssemblyWrapper tglobaladdr:$table), rc:$val, I32:$n))], [(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$sz, $table, $val, $n",
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
%externref = type ptr 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 @externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
declare %externref @llvm.wasm.table.get.externref(ptr addrspace(1), i32) nounwind
define %externref @get_externref_from_table(i32 %i) { define %externref @get_externref_from_table(i32 %i) {
; CHECK-LABEL: get_externref_from_table: ; CHECK-LABEL: get_externref_from_table:
; CHECK-NEXT: .functype get_externref_from_table (i32) -> (externref) ; CHECK-NEXT: .functype get_externref_from_table (i32) -> (externref)
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.get externref_table ; CHECK-NEXT: table.get externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%p = getelementptr [0 x %externref], ptr addrspace(1) @externref_table, i32 0, i32 %i %ref = call %externref @llvm.wasm.table.get.externref(ptr addrspace(1) @externref_table, i32 %i)
%ref = load %externref, ptr addrspace(1) %p
ret %externref %ref ret %externref %ref
} }
define %externref @get_externref_from_table_const() { define %externref @get_externref_from_table_const() {
; CHECK-LABEL: get_externref_from_table_const: ; CHECK-LABEL: get_externref_from_table_const:
; CHECK-NEXT: .functype get_externref_from_table_const () -> (externref) ; CHECK-NEXT: .functype get_externref_from_table_const () -> (externref)
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: table.get externref_table ; CHECK-NEXT: table.get externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 0 %ref = call %externref @llvm.wasm.table.get.externref(ptr addrspace(1) @externref_table, i32 0)
%ref = load %externref, ptr addrspace(1) %p
ret %externref %ref ret %externref %ref
} }
define %externref @get_externref_from_table_with_offset(i32 %i) { define %externref @get_externref_from_table_with_offset(i32 %i) {
; CHECK-LABEL: get_externref_from_table_with_offset: ; CHECK-LABEL: get_externref_from_table_with_offset:
; CHECK-NEXT: .functype get_externref_from_table_with_offset (i32) -> (externref) ; CHECK-NEXT: .functype get_externref_from_table_with_offset (i32) -> (externref)
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 2 ; CHECK-NEXT: i32.const 2
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: table.get externref_table ; CHECK-NEXT: table.get externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%off = add nsw i32 %i, 2 %off = add nsw i32 %i, 2
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off %ref = call %externref @llvm.wasm.table.get.externref(ptr addrspace(1) @externref_table, i32 %off)
%ref = load %externref, ptr addrspace(1) %p
ret %externref %ref ret %externref %ref
} }
define %externref @get_externref_from_table_with_var_offset(i32 %i, i32 %j) { define %externref @get_externref_from_table_with_var_offset(i32 %i, i32 %j) {
; CHECK-LABEL: get_externref_from_table_with_var_offset: ; CHECK-LABEL: get_externref_from_table_with_var_offset:
; CHECK-NEXT: .functype get_externref_from_table_with_var_offset (i32, i32) -> (externref) ; CHECK-NEXT: .functype get_externref_from_table_with_var_offset (i32, i32) -> (externref)
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: table.get externref_table ; CHECK-NEXT: table.get externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%off = add nsw i32 %i, %j %off = add nsw i32 %i, %j
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off %ref = call %externref @llvm.wasm.table.get.externref(ptr addrspace(1) @externref_table, i32 %off)
%ref = load %externref, ptr addrspace(1) %p
ret %externref %ref ret %externref %ref
} }
declare i32 @get_offset() declare i32 @get_offset()
define %externref @get_externref_from_table_with_var_offset2(i32 %i) { define %externref @get_externref_from_table_with_var_offset2(i32 %i) {
; CHECK-LABEL: get_externref_from_table_with_var_offset2: ; CHECK-LABEL: get_externref_from_table_with_var_offset2:
; CHECK-NEXT: .functype get_externref_from_table_with_var_offset2 (i32) -> (externref) ; CHECK-NEXT: .functype get_externref_from_table_with_var_offset2 (i32) -> (externref)
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: call get_offset ; CHECK-NEXT: call get_offset
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: table.get externref_table ; CHECK-NEXT: table.get externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%j = call i32 @get_offset() %j = call i32 @get_offset()
%off = add nsw i32 %i, %j %off = add nsw i32 %i, %j
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off %ref = call %externref @llvm.wasm.table.get.externref(ptr addrspace(1) @externref_table, i32 %off)
%ref = load %externref, ptr addrspace(1) %p
ret %externref %ref ret %externref %ref
} }
; CHECK: .tabletype externref_table, externref ; CHECK: .tabletype externref_table, externref
; CHECK-LABEL: externref_table: ; 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 ; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
%externref = type ptr 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 @externref_table = local_unnamed_addr addrspace(1) global [0 x %externref] undef
declare void @llvm.wasm.table.set.externref(ptr addrspace(1), i32, %externref) nounwind
define void @set_externref_table(%externref %g, i32 %i) { define void @set_externref_table(%externref %g, i32 %i) {
; CHECK-LABEL: set_externref_table: ; CHECK-LABEL: set_externref_table:
; CHECK-NEXT: .functype set_externref_table (externref, i32) -> () ; CHECK-NEXT: .functype set_externref_table (externref, i32) -> ()
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set externref_table ; CHECK-NEXT: table.set externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
;; this generates a table.set of @externref_table ;; this generates a table.set of @externref_table
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %i call void @llvm.wasm.table.set.externref(ptr addrspace(1) @externref_table, i32 %i, %externref %g)
store %externref %g, ptr addrspace(1) %p
ret void ret void
} }
define void @set_externref_table_const(%externref %g) { define void @set_externref_table_const(%externref %g) {
; CHECK-LABEL: set_externref_table_const: ; CHECK-LABEL: set_externref_table_const:
; CHECK-NEXT: .functype set_externref_table_const (externref) -> () ; CHECK-NEXT: .functype set_externref_table_const (externref) -> ()
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set externref_table ; CHECK-NEXT: table.set externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 0 call void @llvm.wasm.table.set.externref(ptr addrspace(1) @externref_table, i32 0, %externref %g)
store %externref %g, ptr addrspace(1) %p
ret void ret void
} }
define void @set_externref_table_with_offset(%externref %g, i32 %i) { define void @set_externref_table_with_offset(%externref %g, i32 %i) {
; CHECK-LABEL: set_externref_table_with_offset: ; CHECK-LABEL: set_externref_table_with_offset:
; CHECK-NEXT: .functype set_externref_table_with_offset (externref, i32) -> () ; CHECK-NEXT: .functype set_externref_table_with_offset (externref, i32) -> ()
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 2 ; CHECK-NEXT: i32.const 2
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set externref_table ; CHECK-NEXT: table.set externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%off = add nsw i32 %i, 2 %off = add nsw i32 %i, 2
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off call void @llvm.wasm.table.set.externref(ptr addrspace(1) @externref_table, i32 %off, %externref %g)
store %externref %g, ptr addrspace(1) %p
ret void ret void
} }
define void @set_externref_table_with_var_offset(%externref %g, i32 %i, i32 %j) { define void @set_externref_table_with_var_offset(%externref %g, i32 %i, i32 %j) {
; CHECK-LABEL: set_externref_table_with_var_offset: ; CHECK-LABEL: set_externref_table_with_var_offset:
; CHECK-NEXT: .functype set_externref_table_with_var_offset (externref, i32, i32) -> () ; CHECK-NEXT: .functype set_externref_table_with_var_offset (externref, i32, i32) -> ()
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 2 ; CHECK-NEXT: local.get 2
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set externref_table ; CHECK-NEXT: table.set externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%off = add nsw i32 %i, %j %off = add nsw i32 %i, %j
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off call void @llvm.wasm.table.set.externref(ptr addrspace(1) @externref_table, i32 %off, %externref %g)
store %externref %g, ptr addrspace(1) %p
ret void ret void
} }
declare i32 @set_offset() declare i32 @set_offset()
define void @set_externref_table_with_var_offset2(%externref %g, i32 %i) { define void @set_externref_table_with_var_offset2(%externref %g, i32 %i) {
; CHECK-LABEL: set_externref_table_with_var_offset2: ; CHECK-LABEL: set_externref_table_with_var_offset2:
; CHECK-NEXT: .functype set_externref_table_with_var_offset2 (externref, i32) -> () ; CHECK-NEXT: .functype set_externref_table_with_var_offset2 (externref, i32) -> ()
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: call set_offset ; CHECK-NEXT: call set_offset
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set externref_table ; CHECK-NEXT: table.set externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%j = call i32 @set_offset() %j = call i32 @set_offset()
%off = add nsw i32 %i, %j %off = add nsw i32 %i, %j
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %off call void @llvm.wasm.table.set.externref(ptr addrspace(1) @externref_table, i32 %off, %externref %g)
store %externref %g, ptr addrspace(1) %p
ret void ret void
} }
declare i32 @get_table_slot() local_unnamed_addr declare i32 @get_table_slot() local_unnamed_addr
define void @set_externref_table_with_id_from_call(%externref %g) { define void @set_externref_table_with_id_from_call(%externref %g) {
; CHECK-LABEL: set_externref_table_with_id_from_call: ; CHECK-LABEL: set_externref_table_with_id_from_call:
; CHECK-NEXT: .functype set_externref_table_with_id_from_call (externref) -> () ; CHECK-NEXT: .functype set_externref_table_with_id_from_call (externref) -> ()
; CHECK-NEXT: call get_table_slot ; CHECK-NEXT: call get_table_slot
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set externref_table ; CHECK-NEXT: table.set externref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%id = call i32 @get_table_slot() %id = call i32 @get_table_slot()
%p = getelementptr [0 x %externref], ptr addrspace (1) @externref_table, i32 0, i32 %id call void @llvm.wasm.table.set.externref(ptr addrspace(1) @externref_table, i32 %id, %externref %g)
store %externref %g, ptr addrspace(1) %p
ret void ret void
} }
; CHECK: .tabletype externref_table, externref ; CHECK: .tabletype externref_table, externref
; CHECK-LABEL: externref_table: ; CHECK-LABEL: externref_table:

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

; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
%funcref = type ptr 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 @funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
; CHECK: .tabletype __funcref_call_table, funcref, 1 ; CHECK: .tabletype __funcref_call_table, funcref, 1
declare %funcref @llvm.wasm.table.get.funcref(ptr addrspace(1), i32) nounwind
define void @call_funcref_from_table(i32 %i) { define void @call_funcref_from_table(i32 %i) {
; CHECK-LABEL: call_funcref_from_table: ; CHECK-LABEL: call_funcref_from_table:
; CHECK-NEXT: .functype call_funcref_from_table (i32) -> () ; CHECK-NEXT: .functype call_funcref_from_table (i32) -> ()
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.get funcref_table ; CHECK-NEXT: table.get funcref_table
; CHECK-NEXT: table.set __funcref_call_table ; CHECK-NEXT: table.set __funcref_call_table
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: call_indirect __funcref_call_table, () -> () ; CHECK-NEXT: call_indirect __funcref_call_table, () -> ()
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: ref.null_func ; CHECK-NEXT: ref.null_func
; CHECK-NEXT: table.set __funcref_call_table ; CHECK-NEXT: table.set __funcref_call_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %i %ref = call %funcref @llvm.wasm.table.get.funcref(ptr addrspace(1) @funcref_table, i32 %i)
%ref = load %funcref, ptr addrspace(1) %p
call addrspace(20) void %ref() call addrspace(20) void %ref()
ret void ret void
} }
; CHECK: .tabletype funcref_table, funcref ; CHECK: .tabletype funcref_table, funcref
; CHECK-LABEL: funcref_table: ; 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 ; RUN: llc < %s --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types | FileCheck %s
%funcref = type ptr 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 @funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
declare %funcref @llvm.wasm.table.get.funcref(ptr addrspace(1), i32) nounwind
define %funcref @get_funcref_from_table(i32 %i) { define %funcref @get_funcref_from_table(i32 %i) {
; CHECK-LABEL: get_funcref_from_table: ; CHECK-LABEL: get_funcref_from_table:
; CHECK-NEXT: .functype get_funcref_from_table (i32) -> (funcref) ; CHECK-NEXT: .functype get_funcref_from_table (i32) -> (funcref)
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.get funcref_table ; CHECK-NEXT: table.get funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %i %ref = call %funcref @llvm.wasm.table.get.funcref(ptr addrspace(1) @funcref_table, i32 %i)
%ref = load %funcref, ptr addrspace(1) %p
ret %funcref %ref ret %funcref %ref
} }
define %funcref @get_funcref_from_table_const() { define %funcref @get_funcref_from_table_const() {
; CHECK-LABEL: get_funcref_from_table_const: ; CHECK-LABEL: get_funcref_from_table_const:
; CHECK-NEXT: .functype get_funcref_from_table_const () -> (funcref) ; CHECK-NEXT: .functype get_funcref_from_table_const () -> (funcref)
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: table.get funcref_table ; CHECK-NEXT: table.get funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 0 %ref = call %funcref @llvm.wasm.table.get.funcref(ptr addrspace(1) @funcref_table, i32 0)
%ref = load %funcref, ptr addrspace(1) %p
ret %funcref %ref ret %funcref %ref
} }
define %funcref @get_funcref_from_table_with_offset(i32 %i) { define %funcref @get_funcref_from_table_with_offset(i32 %i) {
; CHECK-LABEL: get_funcref_from_table_with_offset: ; CHECK-LABEL: get_funcref_from_table_with_offset:
; CHECK-NEXT: .functype get_funcref_from_table_with_offset (i32) -> (funcref) ; CHECK-NEXT: .functype get_funcref_from_table_with_offset (i32) -> (funcref)
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: i32.const 2 ; CHECK-NEXT: i32.const 2
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: table.get funcref_table ; CHECK-NEXT: table.get funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%off = add nsw i32 %i, 2 %off = add nsw i32 %i, 2
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off %ref = call %funcref @llvm.wasm.table.get.funcref(ptr addrspace(1) @funcref_table, i32 %off)
%ref = load %funcref, ptr addrspace(1) %p
ret %funcref %ref ret %funcref %ref
} }
define %funcref @get_funcref_from_table_with_var_offset(i32 %i, i32 %j) { define %funcref @get_funcref_from_table_with_var_offset(i32 %i, i32 %j) {
; CHECK-LABEL: get_funcref_from_table_with_var_offset: ; CHECK-LABEL: get_funcref_from_table_with_var_offset:
; CHECK-NEXT: .functype get_funcref_from_table_with_var_offset (i32, i32) -> (funcref) ; CHECK-NEXT: .functype get_funcref_from_table_with_var_offset (i32, i32) -> (funcref)
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: table.get funcref_table ; CHECK-NEXT: table.get funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%off = add nsw i32 %i, %j %off = add nsw i32 %i, %j
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off %ref = call %funcref @llvm.wasm.table.get.funcref(ptr addrspace(1) @funcref_table, i32 %off)
%ref = load %funcref, ptr addrspace(1) %p
ret %funcref %ref ret %funcref %ref
} }
declare i32 @get_offset() declare i32 @get_offset()
define %funcref @get_funcref_from_table_with_var_offset2(i32 %i) { define %funcref @get_funcref_from_table_with_var_offset2(i32 %i) {
; CHECK-LABEL: get_funcref_from_table_with_var_offset2: ; CHECK-LABEL: get_funcref_from_table_with_var_offset2:
; CHECK-NEXT: .functype get_funcref_from_table_with_var_offset2 (i32) -> (funcref) ; CHECK-NEXT: .functype get_funcref_from_table_with_var_offset2 (i32) -> (funcref)
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: call get_offset ; CHECK-NEXT: call get_offset
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: table.get funcref_table ; CHECK-NEXT: table.get funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%j = call i32 @get_offset() %j = call i32 @get_offset()
%off = add nsw i32 %i, %j %off = add nsw i32 %i, %j
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off %ref = call %funcref @llvm.wasm.table.get.funcref(ptr addrspace(1) @funcref_table, i32 %off)
%ref = load %funcref, ptr addrspace(1) %p
ret %funcref %ref ret %funcref %ref
} }
; CHECK: .tabletype funcref_table, funcref ; CHECK: .tabletype funcref_table, funcref
; CHECK-LABEL: funcref_table: ; 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 ; RUN: llc --mtriple=wasm32-unknown-unknown -asm-verbose=false -mattr=+reference-types < %s | FileCheck %s
%funcref = type ptr 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 @funcref_table = local_unnamed_addr addrspace(1) global [0 x %funcref] undef
declare void @llvm.wasm.table.set.funcref(ptr addrspace(1), i32, %funcref) nounwind
define void @set_funcref_table(%funcref %g, i32 %i) { define void @set_funcref_table(%funcref %g, i32 %i) {
; CHECK-LABEL: set_funcref_table: ; CHECK-LABEL: set_funcref_table:
; CHECK-NEXT: .functype set_funcref_table (funcref, i32) -> () ; CHECK-NEXT: .functype set_funcref_table (funcref, i32) -> ()
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set funcref_table ; CHECK-NEXT: table.set funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
;; this generates a table.set of @funcref_table ;; this generates a table.set of @funcref_table
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %i call void @llvm.wasm.table.set.funcref(ptr addrspace(1) @funcref_table, i32 %i, %funcref %g)
store %funcref %g, ptr addrspace(1) %p
ret void ret void
} }
define void @set_funcref_table_const(%funcref %g) { define void @set_funcref_table_const(%funcref %g) {
; CHECK-LABEL: set_funcref_table_const: ; CHECK-LABEL: set_funcref_table_const:
; CHECK-NEXT: .functype set_funcref_table_const (funcref) -> () ; CHECK-NEXT: .functype set_funcref_table_const (funcref) -> ()
; CHECK-NEXT: i32.const 0 ; CHECK-NEXT: i32.const 0
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set funcref_table ; CHECK-NEXT: table.set funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 0 call void @llvm.wasm.table.set.funcref(ptr addrspace(1) @funcref_table, i32 0, %funcref %g)
store %funcref %g, ptr addrspace(1) %p
ret void ret void
} }
define void @set_funcref_table_with_offset(%funcref %g, i32 %i) { define void @set_funcref_table_with_offset(%funcref %g, i32 %i) {
; CHECK-LABEL: set_funcref_table_with_offset: ; CHECK-LABEL: set_funcref_table_with_offset:
; CHECK-NEXT: .functype set_funcref_table_with_offset (funcref, i32) -> () ; CHECK-NEXT: .functype set_funcref_table_with_offset (funcref, i32) -> ()
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: i32.const 2 ; CHECK-NEXT: i32.const 2
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set funcref_table ; CHECK-NEXT: table.set funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%off = add nsw i32 %i, 2 %off = add nsw i32 %i, 2
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off call void @llvm.wasm.table.set.funcref(ptr addrspace(1) @funcref_table, i32 %off, %funcref %g)
store %funcref %g, ptr addrspace(1) %p
ret void ret void
} }
define void @set_funcref_table_with_var_offset(%funcref %g, i32 %i, i32 %j) { define void @set_funcref_table_with_var_offset(%funcref %g, i32 %i, i32 %j) {
; CHECK-LABEL: set_funcref_table_with_var_offset: ; CHECK-LABEL: set_funcref_table_with_var_offset:
; CHECK-NEXT: .functype set_funcref_table_with_var_offset (funcref, i32, i32) -> () ; CHECK-NEXT: .functype set_funcref_table_with_var_offset (funcref, i32, i32) -> ()
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: local.get 2 ; CHECK-NEXT: local.get 2
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set funcref_table ; CHECK-NEXT: table.set funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%off = add nsw i32 %i, %j %off = add nsw i32 %i, %j
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off call void @llvm.wasm.table.set.funcref(ptr addrspace(1) @funcref_table, i32 %off, %funcref %g)
store %funcref %g, ptr addrspace(1) %p
ret void ret void
} }
declare i32 @set_offset() declare i32 @set_offset()
define void @set_funcref_table_with_var_offset2(%funcref %g, i32 %i) { define void @set_funcref_table_with_var_offset2(%funcref %g, i32 %i) {
; CHECK-LABEL: set_funcref_table_with_var_offset2: ; CHECK-LABEL: set_funcref_table_with_var_offset2:
; CHECK-NEXT: .functype set_funcref_table_with_var_offset2 (funcref, i32) -> () ; CHECK-NEXT: .functype set_funcref_table_with_var_offset2 (funcref, i32) -> ()
; CHECK-NEXT: local.get 1 ; CHECK-NEXT: local.get 1
; CHECK-NEXT: call set_offset ; CHECK-NEXT: call set_offset
; CHECK-NEXT: i32.add ; CHECK-NEXT: i32.add
; CHECK-NEXT: local.get 0 ; CHECK-NEXT: local.get 0
; CHECK-NEXT: table.set funcref_table ; CHECK-NEXT: table.set funcref_table
; CHECK-NEXT: end_function ; CHECK-NEXT: end_function
%j = call i32 @set_offset() %j = call i32 @set_offset()
%off = add nsw i32 %i, %j %off = add nsw i32 %i, %j
%p = getelementptr [0 x %funcref], ptr addrspace (1) @funcref_table, i32 0, i32 %off call void @llvm.wasm.table.set.funcref(ptr addrspace(1) @funcref_table, i32 %off, %funcref %g)
store %funcref %g, ptr addrspace(1) %p
ret void ret void
} }
; CHECK: .tabletype funcref_table, funcref ; CHECK: .tabletype funcref_table, funcref
; CHECK-LABEL: funcref_table: ; CHECK-LABEL: funcref_table: