[clang] 46667a1 - [WebAssembly] Implementation of global.get/set for reftypes in LLVM IR
Paulo Matos via cfe-commits
cfe-commits at lists.llvm.org
Thu Jul 22 13:07:44 PDT 2021
Author: Paulo Matos
Date: 2021-07-22T22:07:24+02:00
New Revision: 46667a10039b664b953eb70534c27627b35a267d
URL: https://github.com/llvm/llvm-project/commit/46667a10039b664b953eb70534c27627b35a267d
DIFF: https://github.com/llvm/llvm-project/commit/46667a10039b664b953eb70534c27627b35a267d.diff
LOG: [WebAssembly] Implementation of global.get/set for reftypes in LLVM IR
Reland of 31859f896.
This change implements new DAG notes GLOBAL_GET/GLOBAL_SET, and
lowering methods for load and stores of reference types from IR
globals. Once the lowering creates the new nodes, tablegen pattern
matches those and converts them to Wasm global.get/set.
Reviewed By: tlively
Differential Revision: https://reviews.llvm.org/D104797
Added:
llvm/test/CodeGen/WebAssembly/externref-globalget.ll
llvm/test/CodeGen/WebAssembly/externref-globalset.ll
llvm/test/CodeGen/WebAssembly/externref-inttoptr.ll
llvm/test/CodeGen/WebAssembly/externref-ptrtoint.ll
llvm/test/CodeGen/WebAssembly/externref-undef.ll
llvm/test/CodeGen/WebAssembly/externref-unsized-load.ll
llvm/test/CodeGen/WebAssembly/externref-unsized-store.ll
llvm/test/CodeGen/WebAssembly/funcref-call.ll
llvm/test/CodeGen/WebAssembly/funcref-globalget.ll
llvm/test/CodeGen/WebAssembly/funcref-globalset.ll
Modified:
clang/lib/Basic/Targets/WebAssembly.h
clang/test/CodeGen/target-data.c
llvm/include/llvm/CodeGen/TargetLowering.h
llvm/include/llvm/CodeGen/ValueTypes.h
llvm/lib/CodeGen/CodeGenPrepare.cpp
llvm/lib/CodeGen/MachineOperand.cpp
llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
llvm/lib/CodeGen/TargetLoweringBase.cpp
llvm/lib/CodeGen/ValueTypes.cpp
llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.cpp
llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.h
llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
llvm/lib/Target/WebAssembly/WebAssemblyISD.def
llvm/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp
llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.h
llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td
llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
Removed:
################################################################################
diff --git a/clang/lib/Basic/Targets/WebAssembly.h b/clang/lib/Basic/Targets/WebAssembly.h
index a43e770eb1e8c..4a5ba25c75e7e 100644
--- a/clang/lib/Basic/Targets/WebAssembly.h
+++ b/clang/lib/Basic/Targets/WebAssembly.h
@@ -150,9 +150,9 @@ class LLVM_LIBRARY_VISIBILITY WebAssembly32TargetInfo
const TargetOptions &Opts)
: WebAssemblyTargetInfo(T, Opts) {
if (T.isOSEmscripten())
- resetDataLayout("e-m:e-p:32:32-i64:64-f128:64-n32:64-S128-ni:1");
+ resetDataLayout("e-m:e-p:32:32-i64:64-f128:64-n32:64-S128-ni:1:10:20");
else
- resetDataLayout("e-m:e-p:32:32-i64:64-n32:64-S128-ni:1");
+ resetDataLayout("e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20");
}
protected:
@@ -172,9 +172,9 @@ class LLVM_LIBRARY_VISIBILITY WebAssembly64TargetInfo
PtrDiffType = SignedLong;
IntPtrType = SignedLong;
if (T.isOSEmscripten())
- resetDataLayout("e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1");
+ resetDataLayout("e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1:10:20");
else
- resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128-ni:1");
+ resetDataLayout("e-m:e-p:64:64-i64:64-n32:64-S128-ni:1:10:20");
}
protected:
diff --git a/clang/test/CodeGen/target-data.c b/clang/test/CodeGen/target-data.c
index 1d88984530e5b..1be01efd16515 100644
--- a/clang/test/CodeGen/target-data.c
+++ b/clang/test/CodeGen/target-data.c
@@ -108,11 +108,11 @@
// RUN: %clang_cc1 -triple wasm32-unknown-unknown -o - -emit-llvm %s | \
// RUN: FileCheck %s -check-prefix=WEBASSEMBLY32
-// WEBASSEMBLY32: target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1"
+// WEBASSEMBLY32: target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"
// RUN: %clang_cc1 -triple wasm64-unknown-unknown -o - -emit-llvm %s | \
// RUN: FileCheck %s -check-prefix=WEBASSEMBLY64
-// WEBASSEMBLY64: target datalayout = "e-m:e-p:64:64-i64:64-n32:64-S128-ni:1"
+// WEBASSEMBLY64: target datalayout = "e-m:e-p:64:64-i64:64-n32:64-S128-ni:1:10:20"
// RUN: %clang_cc1 -triple lanai-unknown-unknown -o - -emit-llvm %s | \
// RUN: FileCheck %s -check-prefix=LANAI
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index 1cf6ac0e5f949..9b42cc9dfb3a0 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -349,7 +349,7 @@ class TargetLoweringBase {
/// Return the in-memory pointer type for the given address space, defaults to
/// the pointer type from the data layout. FIXME: The default needs to be
/// removed once all the code is updated.
- MVT getPointerMemTy(const DataLayout &DL, uint32_t AS = 0) const {
+ virtual MVT getPointerMemTy(const DataLayout &DL, uint32_t AS = 0) const {
return MVT::getIntegerVT(DL.getPointerSizeInBits(AS));
}
diff --git a/llvm/include/llvm/CodeGen/ValueTypes.h b/llvm/include/llvm/CodeGen/ValueTypes.h
index e7346f7a75abc..7b17b98d5c555 100644
--- a/llvm/include/llvm/CodeGen/ValueTypes.h
+++ b/llvm/include/llvm/CodeGen/ValueTypes.h
@@ -120,6 +120,12 @@ namespace llvm {
return changeExtendedTypeToInteger();
}
+ /// Test if the given EVT has zero size, this will fail if called on a
+ /// scalable type
+ bool isZeroSized() const {
+ return !isScalableVector() && getSizeInBits() == 0;
+ }
+
/// Test if the given EVT is simple (as opposed to being extended).
bool isSimple() const {
return V.SimpleTy != MVT::INVALID_SIMPLE_VALUE_TYPE;
@@ -207,7 +213,9 @@ namespace llvm {
}
/// Return true if the bit size is a multiple of 8.
- bool isByteSized() const { return getSizeInBits().isKnownMultipleOf(8); }
+ bool isByteSized() const {
+ return !isZeroSized() && getSizeInBits().isKnownMultipleOf(8);
+ }
/// Return true if the size is a power-of-two number of bytes.
bool isRound() const {
diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp
index 163236c7c8472..1c0932ee40e53 100644
--- a/llvm/lib/CodeGen/CodeGenPrepare.cpp
+++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp
@@ -6465,6 +6465,10 @@ bool CodeGenPrepare::optimizeLoadExt(LoadInst *Load) {
EVT LoadResultVT = TLI->getValueType(*DL, Load->getType());
unsigned BitWidth = LoadResultVT.getSizeInBits();
+ // If the BitWidth is 0, do not try to optimize the type
+ if (BitWidth == 0)
+ return false;
+
APInt DemandBits(BitWidth, 0);
APInt WidestAndBits(BitWidth, 0);
diff --git a/llvm/lib/CodeGen/MachineOperand.cpp b/llvm/lib/CodeGen/MachineOperand.cpp
index db973bda5e555..b8ba0453d24c7 100644
--- a/llvm/lib/CodeGen/MachineOperand.cpp
+++ b/llvm/lib/CodeGen/MachineOperand.cpp
@@ -1180,7 +1180,7 @@ void MachineMemOperand::print(raw_ostream &OS, ModuleSlotTracker &MST,
<< "unknown-address";
}
MachineOperand::printOperandOffset(OS, getOffset());
- if (getAlign() != getSize())
+ if (getSize() > 0 && getAlign() != getSize())
OS << ", align " << getAlign().value();
if (getAlign() != getBaseAlign())
OS << ", basealign " << getBaseAlign().value();
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 57da56e3e0643..4df41ee7d8a6e 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -23243,6 +23243,10 @@ bool DAGCombiner::parallelizeChainedStores(StoreSDNode *St) {
if (BasePtr.getBase().isUndef())
return false;
+ // Do not handle stores to opaque types
+ if (St->getMemoryVT().isZeroSized())
+ return false;
+
// BaseIndexOffset assumes that offsets are fixed-size, which
// is not valid for scalable vectors where the offsets are
// scaled by `vscale`, so bail out early.
diff --git a/llvm/lib/CodeGen/TargetLoweringBase.cpp b/llvm/lib/CodeGen/TargetLoweringBase.cpp
index ebac779984ec5..3c5dd29036db0 100644
--- a/llvm/lib/CodeGen/TargetLoweringBase.cpp
+++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp
@@ -1710,7 +1710,7 @@ bool TargetLoweringBase::allowsMemoryAccessForAlignment(
// For example, the ABI alignment may change based on software platform while
// this function should only be affected by hardware implementation.
Type *Ty = VT.getTypeForEVT(Context);
- if (Alignment >= DL.getABITypeAlign(Ty)) {
+ if (VT.isZeroSized() || Alignment >= DL.getABITypeAlign(Ty)) {
// Assume that an access that meets the ABI-specified alignment is fast.
if (Fast != nullptr)
*Fast = true;
diff --git a/llvm/lib/CodeGen/ValueTypes.cpp b/llvm/lib/CodeGen/ValueTypes.cpp
index ae0b945bdba8e..9daebfd9e63d6 100644
--- a/llvm/lib/CodeGen/ValueTypes.cpp
+++ b/llvm/lib/CodeGen/ValueTypes.cpp
@@ -198,6 +198,10 @@ Type *EVT::getTypeForEVT(LLVMContext &Context) const {
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::externref:
+ return PointerType::get(StructType::create(Context), 10);
+ case MVT::funcref:
+ return PointerType::get(StructType::create(Context), 20);
case MVT::v1i1:
return FixedVectorType::get(Type::getInt1Ty(Context), 1);
case MVT::v2i1:
diff --git a/llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.cpp b/llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.cpp
index 824d336651360..3da80f4fc8752 100644
--- a/llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.cpp
+++ b/llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.cpp
@@ -116,6 +116,31 @@ MCSymbolWasm *WebAssembly::getOrCreateFunctionTableSymbol(
return Sym;
}
+MCSymbolWasm *WebAssembly::getOrCreateFuncrefCallTableSymbol(
+ MCContext &Ctx, const WebAssemblySubtarget *Subtarget) {
+ StringRef Name = "__funcref_call_table";
+ MCSymbolWasm *Sym = cast_or_null<MCSymbolWasm>(Ctx.lookupSymbol(Name));
+ if (Sym) {
+ if (!Sym->isFunctionTable())
+ Ctx.reportError(SMLoc(), "symbol is not a wasm funcref table");
+ } else {
+ Sym = cast<MCSymbolWasm>(Ctx.getOrCreateSymbol(Name));
+
+ // Setting Weak ensure only one table is left after linking when multiple
+ // modules define the table.
+ Sym->setWeak(true);
+
+ wasm::WasmLimits Limits = {0, 1, 1};
+ wasm::WasmTableType TableType = {wasm::WASM_TYPE_FUNCREF, Limits};
+ Sym->setType(wasm::WASM_SYMBOL_TYPE_TABLE);
+ Sym->setTableType(TableType);
+ }
+ // MVP object files can't have symtab entries for tables.
+ if (!(Subtarget && Subtarget->hasReferenceTypes()))
+ Sym->setOmitFromLinkingSection();
+ return Sym;
+}
+
// Find a catch instruction from an EH pad.
MachineInstr *WebAssembly::findCatch(MachineBasicBlock *EHPad) {
assert(EHPad->isEHPad());
diff --git a/llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.h b/llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.h
index 1ec1df5d0c3d1..673dc9521ced7 100644
--- a/llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.h
+++ b/llvm/lib/Target/WebAssembly/Utils/WebAssemblyUtilities.h
@@ -68,6 +68,12 @@ MCSymbolWasm *
getOrCreateFunctionTableSymbol(MCContext &Ctx,
const WebAssemblySubtarget *Subtarget);
+/// Returns the __funcref_call_table, for use in funcref calls when lowered to
+/// table.set + call_indirect.
+MCSymbolWasm *
+getOrCreateFuncrefCallTableSymbol(MCContext &Ctx,
+ const WebAssemblySubtarget *Subtarget);
+
/// Find a catch instruction from an EH pad. Returns null if no catch
/// instruction found or the catch is in an invalid location.
MachineInstr *findCatch(MachineBasicBlock *EHPad);
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
index cb0cdf1d8f985..171d59ae4c6b8 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
@@ -130,9 +130,12 @@ class WebAssemblyFastISel final : public FastISel {
case MVT::i64:
case MVT::f32:
case MVT::f64:
+ return VT;
case MVT::funcref:
case MVT::externref:
- return VT;
+ if (Subtarget->hasReferenceTypes())
+ return VT;
+ break;
case MVT::f16:
return MVT::f32;
case MVT::v16i8:
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyISD.def b/llvm/lib/Target/WebAssembly/WebAssemblyISD.def
index 382034f170491..21519d6135b79 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyISD.def
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyISD.def
@@ -50,3 +50,4 @@ HANDLE_NODETYPE(MEMORY_FILL)
HANDLE_MEM_NODETYPE(LOAD_SPLAT)
HANDLE_MEM_NODETYPE(GLOBAL_GET)
HANDLE_MEM_NODETYPE(GLOBAL_SET)
+HANDLE_MEM_NODETYPE(TABLE_SET)
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp
index c3230cb9ca029..f4bae59132e68 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyISelDAGToDAG.cpp
@@ -13,6 +13,7 @@
#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
#include "WebAssembly.h"
+#include "WebAssemblyISelLowering.h"
#include "WebAssemblyTargetMachine.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
#include "llvm/CodeGen/SelectionDAGISel.h"
@@ -47,11 +48,32 @@ class WebAssemblyDAGToDAGISel final : public SelectionDAGISel {
return "WebAssembly Instruction Selection";
}
+ void checkForInvalidNodes(const Function &F) {
+ // This function will check for uses of ptrtoint on reference types and
+ // report a fatal error if these are found.
+ for (const BasicBlock &BB : F) {
+ for (const Instruction &I : BB) {
+ if (const PtrToIntInst *PTI = dyn_cast<const PtrToIntInst>(&I)) {
+ const Value *V = PTI->getPointerOperand();
+ if (WebAssemblyTargetLowering::isFuncrefType(V->getType()) ||
+ WebAssemblyTargetLowering::isExternrefType(V->getType()))
+ report_fatal_error("ptrtoint not allowed on reference types");
+ } else if (const IntToPtrInst *ITP = dyn_cast<const IntToPtrInst>(&I)) {
+ if (WebAssemblyTargetLowering::isFuncrefType(ITP->getDestTy()) ||
+ WebAssemblyTargetLowering::isExternrefType(ITP->getDestTy()))
+ report_fatal_error("inttoptr not allowed on reference types");
+ }
+ }
+ }
+ }
+
bool runOnMachineFunction(MachineFunction &MF) override {
LLVM_DEBUG(dbgs() << "********** ISelDAGToDAG **********\n"
"********** Function: "
<< MF.getName() << '\n');
+ checkForInvalidNodes(MF.getFunction());
+
Subtarget = &MF.getSubtarget<WebAssemblySubtarget>();
return SelectionDAGISel::runOnMachineFunction(MF);
@@ -63,6 +85,7 @@ class WebAssemblyDAGToDAGISel final : public SelectionDAGISel {
bool SelectInlineAsmMemoryOperand(const SDValue &Op, unsigned ConstraintID,
std::vector<SDValue> &OutOps) override;
+ bool SelectExternRefAddr(const SDValue &Addr, const SDValue &Base);
// Include the pieces autogenerated from the target description.
#include "WebAssemblyGenDAGISel.inc"
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
index 1cff336cb3e4e..62c53c0051ae0 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
@@ -13,6 +13,7 @@
#include "WebAssemblyISelLowering.h"
#include "MCTargetDesc/WebAssemblyMCTargetDesc.h"
+#include "Utils/WebAssemblyTypeUtilities.h"
#include "Utils/WebAssemblyUtilities.h"
#include "WebAssemblyMachineFunctionInfo.h"
#include "WebAssemblySubtarget.h"
@@ -66,6 +67,10 @@ WebAssemblyTargetLowering::WebAssemblyTargetLowering(
addRegisterClass(MVT::v2i64, &WebAssembly::V128RegClass);
addRegisterClass(MVT::v2f64, &WebAssembly::V128RegClass);
}
+ if (Subtarget->hasReferenceTypes()) {
+ addRegisterClass(MVT::externref, &WebAssembly::EXTERNREFRegClass);
+ addRegisterClass(MVT::funcref, &WebAssembly::FUNCREFRegClass);
+ }
// Compute derived properties from the register classes.
computeRegisterProperties(Subtarget->getRegisterInfo());
@@ -82,6 +87,12 @@ WebAssemblyTargetLowering::WebAssemblyTargetLowering(
setOperationAction(ISD::STORE, T, Custom);
}
}
+ if (Subtarget->hasReferenceTypes()) {
+ for (auto T : {MVT::externref, MVT::funcref}) {
+ setOperationAction(ISD::LOAD, T, Custom);
+ setOperationAction(ISD::STORE, T, Custom);
+ }
+ }
setOperationAction(ISD::GlobalAddress, MVTPtr, Custom);
setOperationAction(ISD::GlobalTLSAddress, MVTPtr, Custom);
@@ -497,6 +508,16 @@ LowerCallResults(MachineInstr &CallResults, DebugLoc DL, MachineBasicBlock *BB,
bool IsIndirect = CallParams.getOperand(0).isReg();
bool IsRetCall = CallResults.getOpcode() == WebAssembly::RET_CALL_RESULTS;
+ bool IsFuncrefCall = false;
+ if (IsIndirect) {
+ Register Reg = CallParams.getOperand(0).getReg();
+ const MachineFunction *MF = BB->getParent();
+ const MachineRegisterInfo &MRI = MF->getRegInfo();
+ const TargetRegisterClass *TRC = MRI.getRegClass(Reg);
+ IsFuncrefCall = (TRC == &WebAssembly::FUNCREFRegClass);
+ assert(!IsFuncrefCall || Subtarget->hasReferenceTypes());
+ }
+
unsigned CallOp;
if (IsIndirect && IsRetCall) {
CallOp = WebAssembly::RET_CALL_INDIRECT;
@@ -540,8 +561,11 @@ LowerCallResults(MachineInstr &CallResults, DebugLoc DL, MachineBasicBlock *BB,
// Placeholder for the type index.
MIB.addImm(0);
// The table into which this call_indirect indexes.
- MCSymbolWasm *Table =
- WebAssembly::getOrCreateFunctionTableSymbol(MF.getContext(), Subtarget);
+ MCSymbolWasm *Table = IsFuncrefCall
+ ? WebAssembly::getOrCreateFuncrefCallTableSymbol(
+ MF.getContext(), Subtarget)
+ : WebAssembly::getOrCreateFunctionTableSymbol(
+ MF.getContext(), Subtarget);
if (Subtarget->hasReferenceTypes()) {
MIB.addSym(Table);
} else {
@@ -560,6 +584,39 @@ LowerCallResults(MachineInstr &CallResults, DebugLoc DL, MachineBasicBlock *BB,
CallParams.eraseFromParent();
CallResults.eraseFromParent();
+ // If this is a funcref call, to avoid hidden GC roots, we need to clear the
+ // table slot with ref.null upon call_indirect return.
+ //
+ // This generates the following code, which comes right after a call_indirect
+ // of a funcref:
+ //
+ // i32.const 0
+ // ref.null func
+ // table.set __funcref_call_table
+ if (IsIndirect && IsFuncrefCall) {
+ MCSymbolWasm *Table = WebAssembly::getOrCreateFuncrefCallTableSymbol(
+ MF.getContext(), Subtarget);
+ Register RegZero =
+ MF.getRegInfo().createVirtualRegister(&WebAssembly::I32RegClass);
+ MachineInstr *Const0 =
+ BuildMI(MF, DL, TII.get(WebAssembly::CONST_I32), RegZero).addImm(0);
+ BB->insertAfter(MIB.getInstr()->getIterator(), Const0);
+
+ Register RegFuncref =
+ MF.getRegInfo().createVirtualRegister(&WebAssembly::FUNCREFRegClass);
+ MachineInstr *RefNull =
+ BuildMI(MF, DL, TII.get(WebAssembly::REF_NULL_FUNCREF), RegFuncref)
+ .addImm(static_cast<int32_t>(WebAssembly::HeapType::Funcref));
+ BB->insertAfter(Const0->getIterator(), RefNull);
+
+ MachineInstr *TableSet =
+ BuildMI(MF, DL, TII.get(WebAssembly::TABLE_SET_FUNCREF))
+ .addSym(Table)
+ .addReg(RegZero)
+ .addReg(RegFuncref);
+ BB->insertAfter(RefNull->getIterator(), TableSet);
+ }
+
return BB;
}
@@ -1029,6 +1086,33 @@ WebAssemblyTargetLowering::LowerCall(CallLoweringInfo &CLI,
InTys.push_back(In.VT);
}
+ // Lastly, if this is a call to a funcref we need to add an instruction
+ // table.set to the chain and transform the call.
+ if (CLI.CB && isFuncrefType(CLI.CB->getCalledOperand()->getType())) {
+ // In the absence of function references proposal where a funcref call is
+ // lowered to call_ref, using reference types we generate a table.set to set
+ // the funcref to a special table used solely for this purpose, followed by
+ // a call_indirect. Here we just generate the table set, and return the
+ // SDValue of the table.set so that LowerCall can finalize the lowering by
+ // generating the call_indirect.
+ SDValue Chain = Ops[0];
+
+ MCSymbolWasm *Table = WebAssembly::getOrCreateFuncrefCallTableSymbol(
+ MF.getContext(), Subtarget);
+ SDValue Sym = DAG.getMCSymbol(Table, PtrVT);
+ SDValue TableSlot = DAG.getConstant(0, DL, MVT::i32);
+ SDValue TableSetOps[] = {Chain, Sym, TableSlot, Callee};
+ SDValue TableSet = DAG.getMemIntrinsicNode(
+ WebAssemblyISD::TABLE_SET, DL, DAG.getVTList(MVT::Other), TableSetOps,
+ MVT::funcref,
+ // Machine Mem Operand args
+ MachinePointerInfo(WasmAddressSpace::FUNCREF),
+ CLI.CB->getCalledOperand()->getPointerAlignment(DAG.getDataLayout()),
+ MachineMemOperand::MOStore);
+
+ Ops[0] = TableSet; // The new chain is the TableSet itself
+ }
+
if (CLI.IsTailCall) {
// ret_calls do not return values to the current frame
SDVTList NodeTys = DAG.getVTList(MVT::Other, MVT::Glue);
@@ -1260,6 +1344,16 @@ static Optional<unsigned> IsWebAssemblyLocal(SDValue Op, SelectionDAG &DAG) {
return WebAssemblyFrameLowering::getLocalForStackObject(MF, FI->getIndex());
}
+bool WebAssemblyTargetLowering::isFuncrefType(const Type *Ty) {
+ return isa<PointerType>(Ty) &&
+ Ty->getPointerAddressSpace() == WasmAddressSpace::FUNCREF;
+}
+
+bool WebAssemblyTargetLowering::isExternrefType(const Type *Ty) {
+ return isa<PointerType>(Ty) &&
+ Ty->getPointerAddressSpace() == WasmAddressSpace::EXTERNREF;
+}
+
SDValue WebAssemblyTargetLowering::LowerStore(SDValue Op,
SelectionDAG &DAG) const {
SDLoc DL(Op);
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.h b/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.h
index df9a4ad0280cc..5d813fefb96be 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.h
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyISelLowering.h
@@ -45,6 +45,36 @@ class WebAssemblyTargetLowering final : public TargetLowering {
WebAssemblyTargetLowering(const TargetMachine &TM,
const WebAssemblySubtarget &STI);
+ enum WasmAddressSpace : unsigned {
+ // WebAssembly uses the following address spaces:
+ // AS 0 : is the default address space for values in linear memory
+ DEFAULT = 0,
+ // AS 1 : is a non-integral address space for global variables
+ GLOBAL = 1,
+ // AS 10 : is a non-integral address space for externref values
+ EXTERNREF = 10,
+ // AS 20 : is a non-integral address space for funcref values
+ FUNCREF = 20,
+ };
+
+ MVT getPointerTy(const DataLayout &DL, uint32_t AS = 0) const override {
+ if (AS == WasmAddressSpace::EXTERNREF)
+ return MVT::externref;
+ if (AS == WasmAddressSpace::FUNCREF)
+ return MVT::funcref;
+ return TargetLowering::getPointerTy(DL, AS);
+ }
+ MVT getPointerMemTy(const DataLayout &DL, uint32_t AS = 0) const override {
+ if (AS == WasmAddressSpace::EXTERNREF)
+ return MVT::externref;
+ if (AS == WasmAddressSpace::FUNCREF)
+ return MVT::funcref;
+ return TargetLowering::getPointerMemTy(DL, AS);
+ }
+
+ static bool isFuncrefType(const Type *Ty);
+ static bool isExternrefType(const Type *Ty);
+
private:
/// Keep a pointer to the WebAssemblySubtarget around so that we can make the
/// right decision when generating code for
diff erent targets.
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td b/llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td
index 8d5f80be5543a..2348bb165daf0 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td
@@ -11,8 +11,8 @@
/// Instructions that handle tables
//===----------------------------------------------------------------------===//
-
multiclass TABLE<WebAssemblyRegClass rt> {
+ let mayLoad = 1 in
defm TABLE_GET_#rt : I<(outs rt:$res), (ins table32_op:$table, I32:$i),
(outs), (ins table32_op:$table),
[],
@@ -20,6 +20,7 @@ multiclass TABLE<WebAssemblyRegClass rt> {
"table.get\t$table",
0x25>;
+ let mayStore = 1 in
defm TABLE_SET_#rt : I<(outs), (ins table32_op:$table, I32:$i, rt:$val),
(outs), (ins table32_op:$table),
[],
@@ -46,6 +47,17 @@ multiclass TABLE<WebAssemblyRegClass rt> {
defm "" : TABLE<FUNCREF>, Requires<[HasReferenceTypes]>;
defm "" : TABLE<EXTERNREF>, Requires<[HasReferenceTypes]>;
+def wasm_table_set_t : SDTypeProfile<0, 3, []>;
+def wasm_table_set : SDNode<"WebAssemblyISD::TABLE_SET", wasm_table_set_t,
+ [SDNPHasChain, SDNPMayStore, SDNPMemOperand]>;
+
+def : Pat<(wasm_table_set i32:$table, i32:$idx, funcref:$r),
+ (TABLE_SET_FUNCREF i32:$table, i32:$idx, funcref:$r)>,
+ Requires<[HasReferenceTypes]>;
+def : Pat<(wasm_table_set i32:$table, i32:$idx, externref:$r),
+ (TABLE_SET_EXTERNREF i32:$table, i32:$idx, externref:$r)>,
+ Requires<[HasReferenceTypes]>;
+
defm TABLE_SIZE : I<(outs I32:$sz), (ins table32_op:$table),
(outs), (ins table32_op:$table),
[],
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
index b412a8f5fd03b..ec2380a501ab7 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
@@ -167,6 +167,10 @@ static wasm::ValType getType(const TargetRegisterClass *RC) {
return wasm::ValType::F64;
if (RC == &WebAssembly::V128RegClass)
return wasm::ValType::V128;
+ if (RC == &WebAssembly::EXTERNREFRegClass)
+ return wasm::ValType::EXTERNREF;
+ if (RC == &WebAssembly::FUNCREFRegClass)
+ return wasm::ValType::FUNCREF;
llvm_unreachable("Unexpected register class");
}
diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
index 6a37903da4f5f..746a7599c58ce 100644
--- a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
+++ b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
@@ -124,11 +124,11 @@ WebAssemblyTargetMachine::WebAssemblyTargetMachine(
T,
TT.isArch64Bit()
? (TT.isOSEmscripten()
- ? "e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1"
- : "e-m:e-p:64:64-i64:64-n32:64-S128-ni:1")
+ ? "e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1:10:20"
+ : "e-m:e-p:64:64-i64:64-n32:64-S128-ni:1:10:20")
: (TT.isOSEmscripten()
- ? "e-m:e-p:32:32-i64:64-f128:64-n32:64-S128-ni:1"
- : "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1"),
+ ? "e-m:e-p:32:32-i64:64-f128:64-n32:64-S128-ni:1:10:20"
+ : "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20"),
TT, CPU, FS, Options, getEffectiveRelocModel(RM, TT),
getEffectiveCodeModel(CM, CodeModel::Large), OL),
TLOF(new WebAssemblyTargetObjectFile()) {
diff --git a/llvm/test/CodeGen/WebAssembly/externref-globalget.ll b/llvm/test/CodeGen/WebAssembly/externref-globalget.ll
new file mode 100644
index 0000000000000..b8303704227c1
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/externref-globalget.ll
@@ -0,0 +1,19 @@
+; 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
+
+ at 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
+ 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
diff --git a/llvm/test/CodeGen/WebAssembly/externref-globalset.ll b/llvm/test/CodeGen/WebAssembly/externref-globalset.ll
new file mode 100644
index 0000000000000..749c7daaf4abd
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/externref-globalset.ll
@@ -0,0 +1,20 @@
+; 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
+
+ at 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
+ 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
diff --git a/llvm/test/CodeGen/WebAssembly/externref-inttoptr.ll b/llvm/test/CodeGen/WebAssembly/externref-inttoptr.ll
new file mode 100644
index 0000000000000..cc106b5dee32e
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/externref-inttoptr.ll
@@ -0,0 +1,11 @@
+; RUN: not --crash 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)*
+
+define %externref @int_to_externref(i32 %i) {
+ %ref = inttoptr i32 %i to %externref
+ ret %externref %ref
+}
+
+; CHECK-ERROR: LLVM ERROR: inttoptr not allowed on reference types
diff --git a/llvm/test/CodeGen/WebAssembly/externref-ptrtoint.ll b/llvm/test/CodeGen/WebAssembly/externref-ptrtoint.ll
new file mode 100644
index 0000000000000..8aea1506a903e
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/externref-ptrtoint.ll
@@ -0,0 +1,11 @@
+; RUN: not --crash 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)*
+
+define i32 @externref_to_int(%externref %ref) {
+ %i = ptrtoint %externref %ref to i32
+ ret i32 %i
+}
+
+; CHECK-ERROR: LLVM ERROR: ptrtoint not allowed on reference types
diff --git a/llvm/test/CodeGen/WebAssembly/externref-undef.ll b/llvm/test/CodeGen/WebAssembly/externref-undef.ll
new file mode 100644
index 0000000000000..e5453420e825d
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/externref-undef.ll
@@ -0,0 +1,21 @@
+; 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
+
+ at 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
+
diff --git a/llvm/test/CodeGen/WebAssembly/externref-unsized-load.ll b/llvm/test/CodeGen/WebAssembly/externref-unsized-load.ll
new file mode 100644
index 0000000000000..69aa53a9732c7
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/externref-unsized-load.ll
@@ -0,0 +1,11 @@
+; 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)*
+
+define void @load_extern(%externref %ref) {
+ %e = load %extern, %externref %ref
+ ret void
+}
+
+; CHECK-ERROR: error: loading unsized types is not allowed
diff --git a/llvm/test/CodeGen/WebAssembly/externref-unsized-store.ll b/llvm/test/CodeGen/WebAssembly/externref-unsized-store.ll
new file mode 100644
index 0000000000000..9608873a78b95
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/externref-unsized-store.ll
@@ -0,0 +1,11 @@
+; 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)*
+
+define void @store_extern(%externref %ref) {
+ store %extern undef, %externref %ref
+ ret void
+}
+
+; CHECK-ERROR: error: storing unsized types is not allowed
diff --git a/llvm/test/CodeGen/WebAssembly/funcref-call.ll b/llvm/test/CodeGen/WebAssembly/funcref-call.ll
new file mode 100644
index 0000000000000..bd8d6c3eacef2
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/funcref-call.ll
@@ -0,0 +1,24 @@
+; 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
+
+define void @call_funcref(%funcref %ref) {
+ call addrspace(20) void %ref()
+ 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: local.get 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
+
diff --git a/llvm/test/CodeGen/WebAssembly/funcref-globalget.ll b/llvm/test/CodeGen/WebAssembly/funcref-globalget.ll
new file mode 100644
index 0000000000000..901404aafd717
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/funcref-globalget.ll
@@ -0,0 +1,19 @@
+; 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
+
+ at 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
diff --git a/llvm/test/CodeGen/WebAssembly/funcref-globalset.ll b/llvm/test/CodeGen/WebAssembly/funcref-globalset.ll
new file mode 100644
index 0000000000000..18b0e02cf7390
--- /dev/null
+++ b/llvm/test/CodeGen/WebAssembly/funcref-globalset.ll
@@ -0,0 +1,20 @@
+; 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
+
+ at 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
More information about the cfe-commits
mailing list