Author: Paulo Matos Date: 2021-07-02T09:46:28+02:00 New Revision: 4facbf213c51e4add2e8c19b08d5e58ad71c72de
URL: https://github.com/llvm/llvm-project/commit/4facbf213c51e4add2e8c19b08d5e58ad71c72de DIFF: https://github.com/llvm/llvm-project/commit/4facbf213c51e4add2e8c19b08d5e58ad71c72de.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. 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 b29730c5d706b..ed590fe7e3338 100644 --- a/clang/lib/Basic/Targets/WebAssembly.h +++ b/clang/lib/Basic/Targets/WebAssembly.h @@ -147,7 +147,7 @@ class LLVM_LIBRARY_VISIBILITY WebAssembly32TargetInfo explicit WebAssembly32TargetInfo(const llvm::Triple &T, const TargetOptions &Opts) : WebAssemblyTargetInfo(T, Opts) { - 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: @@ -166,7 +166,7 @@ class LLVM_LIBRARY_VISIBILITY WebAssembly64TargetInfo SizeType = UnsignedLong; PtrDiffType = SignedLong; IntPtrType = SignedLong; - 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 47d6ca43a5ac3..75894d15a9693 100644 --- a/llvm/include/llvm/CodeGen/TargetLowering.h +++ b/llvm/include/llvm/CodeGen/TargetLowering.h @@ -350,7 +350,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 baf674cea5653..9d188ad86fd8c 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 5ea3de9d0db66..f00ec5e13d45e 100644 --- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp @@ -23174,6 +23174,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 9e229450222ff..200df9d4d9ffe 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyISD.def +++ b/llvm/lib/Target/WebAssembly/WebAssemblyISD.def @@ -48,3 +48,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 76427653770f3..2e2cb1b81c6c3 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); @@ -468,6 +479,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; @@ -511,8 +532,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 { @@ -531,6 +555,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; } @@ -1054,6 +1111,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); @@ -1285,6 +1369,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 632c039deac09..b2445b2dec04e 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 8fa80ad40995f..2348bb165daf0 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td +++ b/llvm/lib/Target/WebAssembly/WebAssemblyInstrTable.td @@ -11,15 +11,16 @@ /// Instructions that handle tables //===----------------------------------------------------------------------===// - multiclass TABLE<WebAssemblyRegClass rt> { - defm TABLE_GET_#rt : I<(outs rt:$res), (ins table32_op:$table), + let mayLoad = 1 in + defm TABLE_GET_#rt : I<(outs rt:$res), (ins table32_op:$table, I32:$i), (outs), (ins table32_op:$table), [], - "table.get\t$res, $table", + "table.get\t$res, $table, $i", "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 93e5f2300386e..a266410a98fd0 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp @@ -217,6 +217,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 c305da514ef39..35701e00da3db 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp @@ -121,8 +121,8 @@ WebAssemblyTargetMachine::WebAssemblyTargetMachine( Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT) : LLVMTargetMachine(T, TT.isArch64Bit() - ? "e-m:e-p:64:64-i64:64-n32:64-S128-ni:1" - : "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1", + ? "e-m:e-p:64:64-i64: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 + +@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 + +@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 + +@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..05fd7ad99fa05 --- /dev/null +++ b/llvm/test/CodeGen/WebAssembly/funcref-call.ll @@ -0,0 +1,23 @@ +; 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-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 + +; CHECK: .tabletype __funcref_call_table, funcref 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 + +@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 + +@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 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits