Skip to content

[VE][nfci] Internalize CustomDAG helper functions #26

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 1 commit into from
Mar 21, 2021
Merged

[VE][nfci] Internalize CustomDAG helper functions #26

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
93 changes: 83 additions & 10 deletions llvm/lib/Target/VE/CustomDAG.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -25,15 +25,98 @@

namespace llvm {


/// Packing {

bool isPackedMaskType(EVT SomeVT) {
return isPackedType(SomeVT) && isMaskType(SomeVT);
}
template <> Packing getPackingForMaskBits(const LaneBits MB) {
return Packing::Normal;
}
template <> Packing getPackingForMaskBits(const PackedLaneBits MB) {
return Packing::Dense;
}

PackElem getPartForLane(unsigned ElemIdx) {
return (ElemIdx % 2 == 0) ? PackElem::Hi : PackElem::Lo;
}

PackElem getOtherPart(PackElem Part) {
return Part == PackElem::Lo ? PackElem::Hi : PackElem::Lo;
}

unsigned getOverPackedSubRegIdx(PackElem Part) {
return Part == PackElem::Lo ? VE::sub_pack_lo : VE::sub_pack_hi;
}

unsigned getPackedMaskSubRegIdx(PackElem Part) {
return Part == PackElem::Lo ? VE::sub_vm_lo : VE::sub_vm_hi;
}

MVT getMaskVT(Packing P) {
return P == Packing::Normal ? MVT::v256i1 : MVT::v512i1;
}

PackElem getPackElemForVT(EVT VT) {
if (VT.isFloatingPoint())
return PackElem::Hi;
if (VT.isVector())
return getPackElemForVT(VT.getVectorElementType());
return PackElem::Lo;
}

// The subregister VT an unpack of part \p Elem from \p VT would source its
// result from.
MVT getUnpackSourceType(EVT VT, PackElem Elem) {
if (!VT.isVector())
return Elem == PackElem::Hi ? MVT::f32 : MVT::i32;

EVT ElemVT = VT.getVectorElementType();
if (isMaskType(VT))
return MVT::v256i1;
if (isOverPackedType(VT))
return ElemVT.isFloatingPoint() ? MVT::v256f64 : MVT::v256i64;
return ElemVT.isFloatingPoint() ? MVT::v256f32 : MVT::v256i32;
}

Packing getPackingForVT(EVT VT) {
assert(VT.isVector());
return isPackedType(VT) ? Packing::Dense : Packing::Normal;
}

// True, iff this is a VEC_UNPACK_LO/HI, VEC_SWAP or VEC_PACK.
bool isPackingSupportOpcode(unsigned Opcode) {
switch (Opcode) {
case VEISD::VEC_UNPACK_LO:
case VEISD::VEC_UNPACK_HI:
case VEISD::VEC_PACK:
case VEISD::VEC_SWAP:
return true;
}
return false;
}

bool isUnpackOp(unsigned OPC) {
return (OPC == VEISD::VEC_UNPACK_LO) || (OPC == VEISD::VEC_UNPACK_HI);
}

PackElem getPartForUnpackOpcode(unsigned OPC) {
if (OPC == VEISD::VEC_UNPACK_LO)
return PackElem::Lo;
if (OPC == VEISD::VEC_UNPACK_HI)
return PackElem::Hi;
llvm_unreachable("Not an unpack opcode!");
}

unsigned getUnpackOpcodeForPart(PackElem Part) {
return (Part == PackElem::Lo) ? VEISD::VEC_UNPACK_LO : VEISD::VEC_UNPACK_HI;
}

SDValue getUnpackPackOperand(SDValue N) { return N->getOperand(0); }

SDValue getUnpackAVL(SDValue N) { return N->getOperand(1); }

/// } Packing

/// Node Properties {
Expand Down Expand Up @@ -264,16 +347,6 @@ Optional<int> getAVLPos(unsigned Opc) {
return None;
}

static SDValue getLoadStoreMask(SDValue Op) {
if (auto *MaskedN = dyn_cast<MaskedLoadStoreSDNode>(Op.getNode())) {
return MaskedN->getMask();
}
if (auto *VPLoadN = dyn_cast<VPLoadStoreSDNode>(Op.getNode())) {
return VPLoadN->getMask();
}
return SDValue();
}

// Return the mask operand position for this VVP or VEC op.
Optional<int> getMaskPos(unsigned Opc) {
// VP opcode.
Expand Down
80 changes: 15 additions & 65 deletions llvm/lib/Target/VE/CustomDAG.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -91,9 +91,7 @@ EVT splitType(EVT);
// (requiring a packed VL param..)
bool isPackedType(EVT SomeVT);
bool isMaskType(EVT VT);
static inline bool isPackedMaskType(EVT SomeVT) {
return isPackedType(SomeVT) && isMaskType(SomeVT);
}
bool isPackedMaskType(EVT SomeVT);
bool isOverPackedType(EVT VT);

// whether this VVP operation has no mask argument
Expand Down Expand Up @@ -159,86 +157,38 @@ enum class PackElem : int8_t {
Hi = 1 // float (32, 0]
};

static PackElem getPartForLane(unsigned ElemIdx) {
return (ElemIdx % 2 == 0) ? PackElem::Hi : PackElem::Lo;
}
PackElem getPartForLane(unsigned ElemIdx);

static PackElem getOtherPart(PackElem Part) {
return Part == PackElem::Lo ? PackElem::Hi : PackElem::Lo;
}
PackElem getOtherPart(PackElem Part);

static unsigned getOverPackedSubRegIdx(PackElem Part) {
return Part == PackElem::Lo ? VE::sub_pack_lo : VE::sub_pack_hi;
}
unsigned getOverPackedSubRegIdx(PackElem Part);

static unsigned getPackedMaskSubRegIdx(PackElem Part) {
return Part == PackElem::Lo ? VE::sub_vm_lo : VE::sub_vm_hi;
}
unsigned getPackedMaskSubRegIdx(PackElem Part);

static inline MVT getMaskVT(Packing P) {
return P == Packing::Normal ? MVT::v256i1 : MVT::v512i1;
}
MVT getMaskVT(Packing P);

static PackElem getPackElemForVT(EVT VT) {
if (VT.isFloatingPoint())
return PackElem::Hi;
if (VT.isVector())
return getPackElemForVT(VT.getVectorElementType());
return PackElem::Lo;
}
PackElem getPackElemForVT(EVT VT);

// The subregister VT an unpack of part \p Elem from \p VT would source its
// result from.
static MVT getUnpackSourceType(EVT VT, PackElem Elem) {
if (!VT.isVector())
return Elem == PackElem::Hi ? MVT::f32 : MVT::i32;

EVT ElemVT = VT.getVectorElementType();
if (isMaskType(VT))
return MVT::v256i1;
if (isOverPackedType(VT))
return ElemVT.isFloatingPoint() ? MVT::v256f64 : MVT::v256i64;
return ElemVT.isFloatingPoint() ? MVT::v256f32 : MVT::v256i32;
}
MVT getUnpackSourceType(EVT VT, PackElem Elem);

static inline Packing getPackingForVT(EVT VT) {
assert(VT.isVector());
return isPackedType(VT) ? Packing::Dense : Packing::Normal;
}
Packing getPackingForVT(EVT VT);

template <typename MaskBits> Packing getPackingForMaskBits(const MaskBits MB);

// True, iff this is a VEC_UNPACK_LO/HI, VEC_SWAP or VEC_PACK.
static inline bool isPackingSupportOpcode(unsigned Opcode) {
switch (Opcode) {
case VEISD::VEC_UNPACK_LO:
case VEISD::VEC_UNPACK_HI:
case VEISD::VEC_PACK:
case VEISD::VEC_SWAP:
return true;
}
return false;
}
bool isPackingSupportOpcode(unsigned Opcode);

static bool isUnpackOp(unsigned OPC) {
return (OPC == VEISD::VEC_UNPACK_LO) || (OPC == VEISD::VEC_UNPACK_HI);
}
bool isUnpackOp(unsigned OPC);

static PackElem getPartForUnpackOpcode(unsigned OPC) {
if (OPC == VEISD::VEC_UNPACK_LO)
return PackElem::Lo;
if (OPC == VEISD::VEC_UNPACK_HI)
return PackElem::Hi;
llvm_unreachable("Not an unpack opcode!");
}
PackElem getPartForUnpackOpcode(unsigned OPC);

static unsigned getUnpackOpcodeForPart(PackElem Part) {
return (Part == PackElem::Lo) ? VEISD::VEC_UNPACK_LO : VEISD::VEC_UNPACK_HI;
}
unsigned getUnpackOpcodeForPart(PackElem Part);

static SDValue getUnpackPackOperand(SDValue N) { return N->getOperand(0); }
SDValue getUnpackPackOperand(SDValue N);

static SDValue getUnpackAVL(SDValue N) { return N->getOperand(1); }
SDValue getUnpackAVL(SDValue N);

/// } Packing

Expand Down