| //===------------ VECustomDAG.h - VE Custom DAG Nodes -----------*- C++ -*-===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This file defines the helper functions that VE uses to lower LLVM code into a | |
| // selection DAG. For example, hiding SDLoc, and easy to use SDNodeFlags. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #ifndef LLVM_LIB_TARGET_VE_VECUSTOMDAG_H | |
| #define LLVM_LIB_TARGET_VE_VECUSTOMDAG_H | |
| #include "VE.h" | |
| #include "VEISelLowering.h" | |
| #include "llvm/CodeGen/SelectionDAG.h" | |
| #include "llvm/CodeGen/TargetLowering.h" | |
| namespace llvm { | |
| std::optional<unsigned> getVVPOpcode(unsigned Opcode); | |
| bool isVVPUnaryOp(unsigned Opcode); | |
| bool isVVPBinaryOp(unsigned Opcode); | |
| bool isVVPReductionOp(unsigned Opcode); | |
| MVT splitVectorType(MVT VT); | |
| bool isPackedVectorType(EVT SomeVT); | |
| bool isMaskType(EVT SomeVT); | |
| bool isMaskArithmetic(SDValue Op); | |
| bool isVVPOrVEC(unsigned); | |
| bool supportsPackedMode(unsigned Opcode, EVT IdiomVT); | |
| bool isPackingSupportOpcode(unsigned Opc); | |
| bool maySafelyIgnoreMask(SDValue Op); | |
| /// The VE backend uses a two-staged process to lower and legalize vector | |
| /// instructions: | |
| // | |
| /// 1. VP and standard vector SDNodes are lowered to SDNodes of the VVP_* layer. | |
| // | |
| // All VVP nodes have a mask and an Active Vector Length (AVL) parameter. | |
| // The AVL parameters refers to the element position in the vector the VVP | |
| // node operates on. | |
| // | |
| // | |
| // 2. The VVP SDNodes are legalized. The AVL in a legal VVP node refers to | |
| // chunks of 64bit. We track this by wrapping the AVL in a LEGALAVL node. | |
| // | |
| // The AVL mechanism in the VE architecture always refers to chunks of | |
| // 64bit, regardless of the actual element type vector instructions are | |
| // operating on. For vector types v256.32 or v256.64 nothing needs to be | |
| // legalized since each element occupies a 64bit chunk - there is no | |
| // difference between counting 64bit chunks or element positions. However, | |
| // all vector types with > 256 elements store more than one logical element | |
| // per 64bit chunk and need to be transformed. | |
| // However legalization is performed, the resulting legal VVP SDNodes will | |
| // have a LEGALAVL node as their AVL operand. The LEGALAVL nodes wraps | |
| // around an AVL that refers to 64 bit chunks just as the architecture | |
| // demands - that is, the wrapped AVL is the correct setting for the VL | |
| // register for this VVP operation to get the desired behavior. | |
| // | |
| /// AVL Functions { | |
| // The AVL operand position of this node. | |
| std::optional<int> getAVLPos(unsigned); | |
| // Whether this is a LEGALAVL node. | |
| bool isLegalAVL(SDValue AVL); | |
| // The AVL operand of this node. | |
| SDValue getNodeAVL(SDValue); | |
| // Mask position of this node. | |
| std::optional<int> getMaskPos(unsigned); | |
| SDValue getNodeMask(SDValue); | |
| // Return the AVL operand of this node. If it is a LEGALAVL node, unwrap it. | |
| // Return with the boolean whether unwrapping happened. | |
| std::pair<SDValue, bool> getAnnotatedNodeAVL(SDValue); | |
| /// } AVL Functions | |
| /// Node Properties { | |
| std::optional<EVT> getIdiomaticVectorType(SDNode *Op); | |
| SDValue getLoadStoreStride(SDValue Op, VECustomDAG &CDAG); | |
| SDValue getMemoryPtr(SDValue Op); | |
| SDValue getNodeChain(SDValue Op); | |
| SDValue getStoredValue(SDValue Op); | |
| SDValue getNodePassthru(SDValue Op); | |
| SDValue getGatherScatterIndex(SDValue Op); | |
| SDValue getGatherScatterScale(SDValue Op); | |
| unsigned getScalarReductionOpcode(unsigned VVPOC, bool IsMask); | |
| // Whether this VP_REDUCE_*/ VECREDUCE_*/VVP_REDUCE_* SDNode has a start | |
| // parameter. | |
| bool hasReductionStartParam(unsigned VVPOC); | |
| /// } Node Properties | |
| enum class Packing { | |
| Normal = 0, // 256 element standard mode. | |
| Dense = 1 // 512 element packed mode. | |
| }; | |
| // Get the vector or mask register type for this packing and element type. | |
| MVT getLegalVectorType(Packing P, MVT ElemVT); | |
| // Whether this type belongs to a packed mask or vector register. | |
| Packing getTypePacking(EVT); | |
| enum class PackElem : int8_t { | |
| Lo = 0, // Integer (63, 32] | |
| Hi = 1 // Float (32, 0] | |
| }; | |
| struct VETargetMasks { | |
| SDValue Mask; | |
| SDValue AVL; | |
| VETargetMasks(SDValue Mask = SDValue(), SDValue AVL = SDValue()) | |
| : Mask(Mask), AVL(AVL) {} | |
| }; | |
| class VECustomDAG { | |
| SelectionDAG &DAG; | |
| SDLoc DL; | |
| public: | |
| SelectionDAG *getDAG() const { return &DAG; } | |
| VECustomDAG(SelectionDAG &DAG, SDLoc DL) : DAG(DAG), DL(DL) {} | |
| VECustomDAG(SelectionDAG &DAG, SDValue WhereOp) : DAG(DAG), DL(WhereOp) {} | |
| VECustomDAG(SelectionDAG &DAG, const SDNode *WhereN) : DAG(DAG), DL(WhereN) {} | |
| /// getNode { | |
| SDValue getNode(unsigned OC, SDVTList VTL, ArrayRef<SDValue> OpV, | |
| std::optional<SDNodeFlags> Flags = std::nullopt) const { | |
| auto N = DAG.getNode(OC, DL, VTL, OpV); | |
| if (Flags) | |
| N->setFlags(*Flags); | |
| return N; | |
| } | |
| SDValue getNode(unsigned OC, ArrayRef<EVT> ResVT, ArrayRef<SDValue> OpV, | |
| std::optional<SDNodeFlags> Flags = std::nullopt) const { | |
| auto N = DAG.getNode(OC, DL, ResVT, OpV); | |
| if (Flags) | |
| N->setFlags(*Flags); | |
| return N; | |
| } | |
| SDValue getNode(unsigned OC, EVT ResVT, ArrayRef<SDValue> OpV, | |
| std::optional<SDNodeFlags> Flags = std::nullopt) const { | |
| auto N = DAG.getNode(OC, DL, ResVT, OpV); | |
| if (Flags) | |
| N->setFlags(*Flags); | |
| return N; | |
| } | |
| SDValue getUNDEF(EVT VT) const { return DAG.getUNDEF(VT); } | |
| /// } getNode | |
| /// Legalizing getNode { | |
| SDValue getLegalReductionOpVVP(unsigned VVPOpcode, EVT ResVT, SDValue StartV, | |
| SDValue VectorV, SDValue Mask, SDValue AVL, | |
| SDNodeFlags Flags) const; | |
| /// } Legalizing getNode | |
| /// Packing { | |
| SDValue getUnpack(EVT DestVT, SDValue Vec, PackElem Part, SDValue AVL) const; | |
| SDValue getPack(EVT DestVT, SDValue LoVec, SDValue HiVec, SDValue AVL) const; | |
| /// } Packing | |
| SDValue getMergeValues(ArrayRef<SDValue> Values) const { | |
| return DAG.getMergeValues(Values, DL); | |
| } | |
| SDValue getConstant(uint64_t Val, EVT VT, bool IsTarget = false, | |
| bool IsOpaque = false) const; | |
| SDValue getConstantMask(Packing Packing, bool AllTrue) const; | |
| SDValue getMaskBroadcast(EVT ResultVT, SDValue Scalar, SDValue AVL) const; | |
| SDValue getBroadcast(EVT ResultVT, SDValue Scalar, SDValue AVL) const; | |
| // Wrap AVL in a LEGALAVL node (unless it is one already). | |
| SDValue annotateLegalAVL(SDValue AVL) const; | |
| VETargetMasks getTargetSplitMask(SDValue RawMask, SDValue RawAVL, | |
| PackElem Part) const; | |
| // Splitting support | |
| SDValue getSplitPtrOffset(SDValue Ptr, SDValue ByteStride, | |
| PackElem Part) const; | |
| SDValue getSplitPtrStride(SDValue PackStride) const; | |
| SDValue getGatherScatterAddress(SDValue BasePtr, SDValue Scale, SDValue Index, | |
| SDValue Mask, SDValue AVL) const; | |
| EVT getVectorVT(EVT ElemVT, unsigned NumElems) const { | |
| return EVT::getVectorVT(*DAG.getContext(), ElemVT, NumElems); | |
| } | |
| }; | |
| } // namespace llvm | |
| #endif // LLVM_LIB_TARGET_VE_VECUSTOMDAG_H |