[llvm] aaaae99 - [SelectionDAG] Use getInsertSubvector/VectorElt and getExtractSubvector/VectorElt in LegalizeVectorTypes. NFC
Craig Topper via llvm-commits
llvm-commits at lists.llvm.org
Fri May 16 23:37:17 PDT 2025
Author: Craig Topper
Date: 2025-05-16T23:37:03-07:00
New Revision: aaaae99663dbb220c6c27fa9cacf93fcb8f20e7c
URL: https://github.com/llvm/llvm-project/commit/aaaae99663dbb220c6c27fa9cacf93fcb8f20e7c
DIFF: https://github.com/llvm/llvm-project/commit/aaaae99663dbb220c6c27fa9cacf93fcb8f20e7c.diff
LOG: [SelectionDAG] Use getInsertSubvector/VectorElt and getExtractSubvector/VectorElt in LegalizeVectorTypes. NFC
Added:
Modified:
llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
Removed:
################################################################################
diff --git a/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp b/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
index f9fbd303d5e89..4e9a6942d6cd9 100644
--- a/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp
@@ -261,10 +261,8 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_CMP(SDNode *N) {
RHS = GetScalarizedVector(RHS);
} else {
EVT VT = LHS.getValueType().getVectorElementType();
- LHS = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, LHS,
- DAG.getVectorIdxConstant(0, DL));
- RHS = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, RHS,
- DAG.getVectorIdxConstant(0, DL));
+ LHS = DAG.getExtractVectorElt(DL, VT, LHS, 0);
+ RHS = DAG.getExtractVectorElt(DL, VT, RHS, 0);
}
return DAG.getNode(N->getOpcode(), SDLoc(N),
@@ -338,9 +336,8 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_StrictFPOp(SDNode *N) {
if (getTypeAction(OperVT) == TargetLowering::TypeScalarizeVector)
Oper = GetScalarizedVector(Oper);
else
- Oper = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
- OperVT.getVectorElementType(), Oper,
- DAG.getVectorIdxConstant(0, dl));
+ Oper =
+ DAG.getExtractVectorElt(dl, OperVT.getVectorElementType(), Oper, 0);
}
Opers[i] = Oper;
@@ -434,8 +431,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_FP_ROUND(SDNode *N) {
Op = GetScalarizedVector(Op);
} else {
EVT VT = OpVT.getVectorElementType();
- Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Op,
- DAG.getVectorIdxConstant(0, DL));
+ Op = DAG.getExtractVectorElt(DL, VT, Op, 0);
}
return DAG.getNode(ISD::FP_ROUND, DL,
N->getValueType(0).getVectorElementType(), Op,
@@ -492,8 +488,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_UnaryOp(SDNode *N) {
Op = GetScalarizedVector(Op);
} else {
EVT VT = OpVT.getVectorElementType();
- Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Op,
- DAG.getVectorIdxConstant(0, DL));
+ Op = DAG.getExtractVectorElt(DL, VT, Op, 0);
}
return DAG.getNode(N->getOpcode(), SDLoc(N), DestVT, Op, N->getFlags());
}
@@ -517,8 +512,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_VecInregOp(SDNode *N) {
if (getTypeAction(OpVT) == TargetLowering::TypeScalarizeVector) {
Op = GetScalarizedVector(Op);
} else {
- Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, OpEltVT, Op,
- DAG.getVectorIdxConstant(0, DL));
+ Op = DAG.getExtractVectorElt(DL, OpEltVT, Op, 0);
}
switch (N->getOpcode()) {
@@ -549,8 +543,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_ADDRSPACECAST(SDNode *N) {
Op = GetScalarizedVector(Op);
} else {
EVT VT = OpVT.getVectorElementType();
- Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Op,
- DAG.getVectorIdxConstant(0, DL));
+ Op = DAG.getExtractVectorElt(DL, VT, Op, 0);
}
auto *AddrSpaceCastN = cast<AddrSpaceCastSDNode>(N);
unsigned SrcAS = AddrSpaceCastN->getSrcAddressSpace();
@@ -579,8 +572,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_VSELECT(SDNode *N) {
Cond = GetScalarizedVector(Cond);
} else {
EVT VT = OpVT.getVectorElementType();
- Cond = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Cond,
- DAG.getVectorIdxConstant(0, DL));
+ Cond = DAG.getExtractVectorElt(DL, VT, Cond, 0);
}
SDValue LHS = GetScalarizedVector(N->getOperand(1));
@@ -697,10 +689,8 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_SETCC(SDNode *N) {
RHS = GetScalarizedVector(RHS);
} else {
EVT VT = OpVT.getVectorElementType();
- LHS = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, LHS,
- DAG.getVectorIdxConstant(0, DL));
- RHS = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, RHS,
- DAG.getVectorIdxConstant(0, DL));
+ LHS = DAG.getExtractVectorElt(DL, VT, LHS, 0);
+ RHS = DAG.getExtractVectorElt(DL, VT, RHS, 0);
}
// Turn it into a scalar SETCC.
@@ -724,8 +714,7 @@ SDValue DAGTypeLegalizer::ScalarizeVecRes_IS_FPCLASS(SDNode *N) {
Arg = GetScalarizedVector(Arg);
} else {
EVT VT = ArgVT.getVectorElementType();
- Arg = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Arg,
- DAG.getVectorIdxConstant(0, DL));
+ Arg = DAG.getExtractVectorElt(DL, VT, Arg, 0);
}
SDValue Res =
@@ -1913,8 +1902,7 @@ SDValue DAGTypeLegalizer::UnrollVectorOp_StrictFP(SDNode *N, unsigned ResNE) {
EVT OperandVT = Operand.getValueType();
if (OperandVT.isVector()) {
EVT OperandEltVT = OperandVT.getVectorElementType();
- Operands[j] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, OperandEltVT,
- Operand, DAG.getVectorIdxConstant(i, dl));
+ Operands[j] = DAG.getExtractVectorElt(dl, OperandEltVT, Operand, i);
} else {
Operands[j] = Operand;
}
@@ -1999,8 +1987,7 @@ void DAGTypeLegalizer::SplitVecRes_INSERT_VECTOR_ELT(SDNode *N, SDValue &Lo,
Lo.getValueType(), Lo, Elt, Idx);
return;
} else if (!Vec.getValueType().isScalableVector()) {
- Hi = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, Hi.getValueType(), Hi, Elt,
- DAG.getVectorIdxConstant(IdxVal - LoNumElts, dl));
+ Hi = DAG.getInsertVectorElt(dl, Hi, Elt, IdxVal - LoNumElts);
return;
}
}
@@ -3725,8 +3712,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_EXTRACT_SUBVECTOR(SDNode *N) {
return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Lo, Idx);
} else if (SubVT.isScalableVector() ==
N->getOperand(0).getValueType().isScalableVector())
- return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Hi,
- DAG.getVectorIdxConstant(IdxVal - LoEltsMin, dl));
+ return DAG.getExtractSubvector(dl, SubVT, Hi, IdxVal - LoEltsMin);
// After this point the DAG node only permits extracting fixed-width
// subvectors from scalable vectors.
@@ -4216,8 +4202,7 @@ SDValue DAGTypeLegalizer::SplitVecOp_CONCAT_VECTORS(SDNode *N) {
for (const SDValue &Op : N->op_values()) {
for (unsigned i = 0, e = Op.getValueType().getVectorNumElements();
i != e; ++i) {
- Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, Op,
- DAG.getVectorIdxConstant(i, DL)));
+ Elts.push_back(DAG.getExtractVectorElt(DL, EltVT, Op, i));
}
}
@@ -4548,9 +4533,8 @@ void DAGTypeLegalizer::ReplaceOtherWidenResults(SDNode *N, SDNode *WidenNode,
SetWidenedVector(SDValue(N, ResNo), SDValue(WidenNode, ResNo));
} else {
SDLoc DL(N);
- SDValue ResVal = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ResVT,
- SDValue(WidenNode, ResNo),
- DAG.getVectorIdxConstant(0, DL));
+ SDValue ResVal =
+ DAG.getExtractSubvector(DL, ResVT, SDValue(WidenNode, ResNo), 0);
ReplaceValueWith(SDValue(N, ResNo), ResVal);
}
}
@@ -5007,10 +4991,8 @@ static SDValue CollectOpsToWiden(SelectionDAG &DAG, const TargetLowering &TLI,
// Scalar type, create an INSERT_VECTOR_ELEMENT of type NextVT
SDValue VecOp = DAG.getUNDEF(NextVT);
unsigned NumToInsert = ConcatEnd - Idx - 1;
- for (unsigned i = 0, OpIdx = Idx+1; i < NumToInsert; i++, OpIdx++) {
- VecOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NextVT, VecOp,
- ConcatOps[OpIdx], DAG.getVectorIdxConstant(i, dl));
- }
+ for (unsigned i = 0, OpIdx = Idx + 1; i < NumToInsert; i++, OpIdx++)
+ VecOp = DAG.getInsertVectorElt(dl, VecOp, ConcatOps[OpIdx], i);
ConcatOps[Idx+1] = VecOp;
ConcatEnd = Idx + 2;
} else {
@@ -5114,10 +5096,8 @@ SDValue DAGTypeLegalizer::WidenVecRes_BinaryCanTrap(SDNode *N) {
// }
while (CurNumElts != 0) {
while (CurNumElts >= NumElts) {
- SDValue EOp1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, InOp1,
- DAG.getVectorIdxConstant(Idx, dl));
- SDValue EOp2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, InOp2,
- DAG.getVectorIdxConstant(Idx, dl));
+ SDValue EOp1 = DAG.getExtractSubvector(dl, VT, InOp1, Idx);
+ SDValue EOp2 = DAG.getExtractSubvector(dl, VT, InOp2, Idx);
ConcatOps[ConcatEnd++] = DAG.getNode(Opcode, dl, VT, EOp1, EOp2, Flags);
Idx += NumElts;
CurNumElts -= NumElts;
@@ -5129,10 +5109,8 @@ SDValue DAGTypeLegalizer::WidenVecRes_BinaryCanTrap(SDNode *N) {
if (NumElts == 1) {
for (unsigned i = 0; i != CurNumElts; ++i, ++Idx) {
- SDValue EOp1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, WidenEltVT,
- InOp1, DAG.getVectorIdxConstant(Idx, dl));
- SDValue EOp2 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, WidenEltVT,
- InOp2, DAG.getVectorIdxConstant(Idx, dl));
+ SDValue EOp1 = DAG.getExtractVectorElt(dl, WidenEltVT, InOp1, Idx);
+ SDValue EOp2 = DAG.getExtractVectorElt(dl, WidenEltVT, InOp2, Idx);
ConcatOps[ConcatEnd++] = DAG.getNode(Opcode, dl, WidenEltVT,
EOp1, EOp2, Flags);
}
@@ -5227,8 +5205,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_StrictFP(SDNode *N) {
EVT OpExtractVT =
EVT::getVectorVT(*DAG.getContext(), OpVT.getVectorElementType(),
VT.getVectorElementCount());
- Op = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpExtractVT, Op,
- DAG.getVectorIdxConstant(Idx, dl));
+ Op = DAG.getExtractSubvector(dl, OpExtractVT, Op, Idx);
}
EOps.push_back(Op);
@@ -5255,9 +5232,8 @@ SDValue DAGTypeLegalizer::WidenVecRes_StrictFP(SDNode *N) {
EVT OpVT = Op.getValueType();
if (OpVT.isVector())
- Op = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
- OpVT.getVectorElementType(), Op,
- DAG.getVectorIdxConstant(Idx, dl));
+ Op = DAG.getExtractVectorElt(dl, OpVT.getVectorElementType(), Op,
+ Idx);
EOps.push_back(Op);
}
@@ -5408,8 +5384,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_Convert(SDNode *N) {
}
if (InVTEC.isKnownMultipleOf(WidenEC.getKnownMinValue())) {
- SDValue InVal = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, InWidenVT, InOp,
- DAG.getVectorIdxConstant(0, DL));
+ SDValue InVal = DAG.getExtractSubvector(DL, InWidenVT, InOp, 0);
// Extract the input and convert the shorten input vector.
if (N->getNumOperands() == 1)
return DAG.getNode(Opcode, DL, WidenVT, InVal, Flags);
@@ -5424,8 +5399,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_Convert(SDNode *N) {
// necessary.
unsigned MinElts = N->getValueType(0).getVectorNumElements();
for (unsigned i=0; i < MinElts; ++i) {
- SDValue Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, InEltVT, InOp,
- DAG.getVectorIdxConstant(i, DL));
+ SDValue Val = DAG.getExtractVectorElt(DL, InEltVT, InOp, i);
if (N->getNumOperands() == 1)
Ops[i] = DAG.getNode(Opcode, DL, EltVT, Val, Flags);
else
@@ -5509,8 +5483,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_Convert_StrictFP(SDNode *N) {
// necessary.
unsigned MinElts = N->getValueType(0).getVectorNumElements();
for (unsigned i=0; i < MinElts; ++i) {
- NewOps[1] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, InEltVT, InOp,
- DAG.getVectorIdxConstant(i, DL));
+ NewOps[1] = DAG.getExtractVectorElt(DL, InEltVT, InOp, i);
Ops[i] = DAG.getNode(Opcode, DL, EltVTs, NewOps);
OpChains.push_back(Ops[i].getValue(1));
}
@@ -5549,8 +5522,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_EXTEND_VECTOR_INREG(SDNode *N) {
// Unroll, extend the scalars and rebuild the vector.
SmallVector<SDValue, 16> Ops;
for (unsigned i = 0, e = std::min(InVTNumElts, WidenNumElts); i != e; ++i) {
- SDValue Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, InSVT, InOp,
- DAG.getVectorIdxConstant(i, DL));
+ SDValue Val = DAG.getExtractVectorElt(DL, InSVT, InOp, i);
switch (Opcode) {
case ISD::ANY_EXTEND_VECTOR_INREG:
Val = DAG.getNode(ISD::ANY_EXTEND, DL, WidenSVT, Val);
@@ -5888,8 +5860,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_CONCAT_VECTORS(SDNode *N) {
if (InputWidened)
InOp = GetWidenedVector(InOp);
for (unsigned j = 0; j < NumInElts; ++j)
- Ops[Idx++] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
- DAG.getVectorIdxConstant(j, dl));
+ Ops[Idx++] = DAG.getExtractVectorElt(dl, EltVT, InOp, j);
}
SDValue UndefVal = DAG.getUNDEF(EltVT);
for (; Idx < WidenNumElts; ++Idx)
@@ -5956,8 +5927,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_EXTRACT_SUBVECTOR(SDNode *N) {
unsigned I = 0;
for (; I < VTNumElts / GCD; ++I)
Parts.push_back(
- DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, PartVT, InOp,
- DAG.getVectorIdxConstant(IdxVal + I * GCD, dl)));
+ DAG.getExtractSubvector(dl, PartVT, InOp, IdxVal + I * GCD));
for (; I < WidenNumElts / GCD; ++I)
Parts.push_back(DAG.getUNDEF(PartVT));
@@ -5973,8 +5943,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_EXTRACT_SUBVECTOR(SDNode *N) {
SmallVector<SDValue, 16> Ops(WidenNumElts);
unsigned i;
for (i = 0; i < VTNumElts; ++i)
- Ops[i] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
- DAG.getVectorIdxConstant(IdxVal + i, dl));
+ Ops[i] = DAG.getExtractVectorElt(dl, EltVT, InOp, IdxVal + i);
SDValue UndefVal = DAG.getUNDEF(EltVT);
for (; i < WidenNumElts; ++i)
@@ -6335,9 +6304,7 @@ SDValue DAGTypeLegalizer::convertMask(SDValue InMask, EVT MaskVT,
// Adjust Mask to the right number of elements.
unsigned CurrMaskNumEls = Mask->getValueType(0).getVectorNumElements();
if (CurrMaskNumEls > ToMaskVT.getVectorNumElements()) {
- SDValue ZeroIdx = DAG.getVectorIdxConstant(0, SDLoc(Mask));
- Mask = DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(Mask), ToMaskVT, Mask,
- ZeroIdx);
+ Mask = DAG.getExtractSubvector(SDLoc(Mask), ToMaskVT, Mask, 0);
} else if (CurrMaskNumEls < ToMaskVT.getVectorNumElements()) {
unsigned NumSubVecs = (ToMaskVT.getVectorNumElements() / CurrMaskNumEls);
EVT SubVT = Mask->getValueType(0);
@@ -6577,8 +6544,7 @@ SDValue DAGTypeLegalizer::WidenVecRes_VECTOR_REVERSE(SDNode *N) {
unsigned i = 0;
for (; i < VTNumElts / GCD; ++i)
Parts.push_back(
- DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, PartVT, ReverseVal,
- DAG.getVectorIdxConstant(IdxVal + i * GCD, dl)));
+ DAG.getExtractSubvector(dl, PartVT, ReverseVal, IdxVal + i * GCD));
for (; i < WidenNumElts / GCD; ++i)
Parts.push_back(DAG.getUNDEF(PartVT));
@@ -6663,10 +6629,8 @@ SDValue DAGTypeLegalizer::WidenVecRes_STRICT_FSETCC(SDNode *N) {
SmallVector<SDValue, 8> Scalars(WidenNumElts, DAG.getUNDEF(EltVT));
SmallVector<SDValue, 8> Chains(NumElts);
for (unsigned i = 0; i != NumElts; ++i) {
- SDValue LHSElem = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, TmpEltVT, LHS,
- DAG.getVectorIdxConstant(i, dl));
- SDValue RHSElem = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, TmpEltVT, RHS,
- DAG.getVectorIdxConstant(i, dl));
+ SDValue LHSElem = DAG.getExtractVectorElt(dl, TmpEltVT, LHS, i);
+ SDValue RHSElem = DAG.getExtractVectorElt(dl, TmpEltVT, RHS, i);
Scalars[i] = DAG.getNode(N->getOpcode(), dl, {MVT::i1, MVT::Other},
{Chain, LHSElem, RHSElem, CC});
@@ -6868,12 +6832,9 @@ SDValue DAGTypeLegalizer::WidenVecOp_EXTEND(SDNode *N) {
assert(FixedVT.getVectorNumElements() != InVT.getVectorNumElements() &&
"We can't have the same type as we started with!");
if (FixedVT.getVectorNumElements() > InVT.getVectorNumElements())
- InOp = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, FixedVT,
- DAG.getUNDEF(FixedVT), InOp,
- DAG.getVectorIdxConstant(0, DL));
+ InOp = DAG.getInsertSubvector(DL, DAG.getUNDEF(FixedVT), InOp, 0);
else
- InOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, FixedVT, InOp,
- DAG.getVectorIdxConstant(0, DL));
+ InOp = DAG.getExtractSubvector(DL, FixedVT, InOp, 0);
break;
}
}
@@ -6910,10 +6871,8 @@ SDValue DAGTypeLegalizer::WidenVecOp_CMP(SDNode *N) {
// 1. EXTRACT_SUBVECTOR
// 2. SIGN_EXTEND/ZERO_EXTEND
// 3. CMP
- LHS = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpVT, LHS,
- DAG.getVectorIdxConstant(0, dl));
- RHS = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OpVT, RHS,
- DAG.getVectorIdxConstant(0, dl));
+ LHS = DAG.getExtractSubvector(dl, OpVT, LHS, 0);
+ RHS = DAG.getExtractSubvector(dl, OpVT, RHS, 0);
// At this point the result type is guaranteed to be valid, so we can use it
// as the operand type by extending it appropriately
@@ -6951,8 +6910,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_IS_FPCLASS(SDNode *N) {
EVT ResVT =
EVT::getVectorVT(*DAG.getContext(), WideResultVT.getVectorElementType(),
ResultVT.getVectorNumElements());
- SDValue CC = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ResVT, WideNode,
- DAG.getVectorIdxConstant(0, DL));
+ SDValue CC = DAG.getExtractSubvector(DL, ResVT, WideNode, 0);
EVT OpVT = N->getOperand(0).getValueType();
ISD::NodeType ExtendCode =
@@ -6995,8 +6953,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_Convert(SDNode *N) {
else
Res = DAG.getNode(Opcode, dl, WideVT, InOp);
}
- return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, Res,
- DAG.getVectorIdxConstant(0, dl));
+ return DAG.getExtractSubvector(dl, VT, Res, 0);
}
EVT InEltVT = InVT.getVectorElementType();
@@ -7008,8 +6965,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_Convert(SDNode *N) {
SmallVector<SDValue, 4> NewOps(N->ops());
SmallVector<SDValue, 32> OpChains;
for (unsigned i=0; i < NumElts; ++i) {
- NewOps[1] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, InEltVT, InOp,
- DAG.getVectorIdxConstant(i, dl));
+ NewOps[1] = DAG.getExtractVectorElt(dl, InEltVT, InOp, i);
Ops[i] = DAG.getNode(Opcode, dl, { EltVT, MVT::Other }, NewOps);
OpChains.push_back(Ops[i].getValue(1));
}
@@ -7018,8 +6974,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_Convert(SDNode *N) {
} else {
for (unsigned i = 0; i < NumElts; ++i)
Ops[i] = DAG.getNode(Opcode, dl, EltVT,
- DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, InEltVT,
- InOp, DAG.getVectorIdxConstant(i, dl)));
+ DAG.getExtractVectorElt(dl, InEltVT, InOp, i));
}
return DAG.getBuildVector(VT, dl, Ops);
@@ -7063,8 +7018,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_BITCAST(SDNode *N) {
EVT NewVT = EVT::getVectorVT(*DAG.getContext(), VT, NewNumElts);
if (TLI.isTypeLegal(NewVT)) {
SDValue BitOp = DAG.getNode(ISD::BITCAST, dl, NewVT, InOp);
- return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, BitOp,
- DAG.getVectorIdxConstant(0, dl));
+ return DAG.getExtractVectorElt(dl, VT, BitOp, 0);
}
}
@@ -7082,8 +7036,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_BITCAST(SDNode *N) {
EVT NewVT = EVT::getVectorVT(*DAG.getContext(), EltVT, NewNumElts);
if (TLI.isTypeLegal(NewVT)) {
SDValue BitOp = DAG.getNode(ISD::BITCAST, dl, NewVT, InOp);
- return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, BitOp,
- DAG.getVectorIdxConstant(0, dl));
+ return DAG.getExtractSubvector(dl, VT, BitOp, 0);
}
}
}
@@ -7134,8 +7087,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_CONCAT_VECTORS(SDNode *N) {
"Unexpected type action");
InOp = GetWidenedVector(InOp);
for (unsigned j = 0; j < NumInElts; ++j)
- Ops[Idx++] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
- DAG.getVectorIdxConstant(j, dl));
+ Ops[Idx++] = DAG.getExtractVectorElt(dl, EltVT, InOp, j);
}
return DAG.getBuildVector(VT, dl, Ops);
}
@@ -7187,14 +7139,10 @@ SDValue DAGTypeLegalizer::WidenVecOp_INSERT_SUBVECTOR(SDNode *N) {
unsigned Idx = N->getConstantOperandVal(2);
SDValue InsertElt = InVec;
- EVT VectorIdxTy = TLI.getVectorIdxTy(DAG.getDataLayout());
for (unsigned I = 0, E = OrigVT.getVectorNumElements(); I != E; ++I) {
SDValue ExtractElt =
- DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT.getVectorElementType(),
- SubVec, DAG.getConstant(I, DL, VectorIdxTy));
- InsertElt =
- DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT, InsertElt, ExtractElt,
- DAG.getConstant(I + Idx, DL, VectorIdxTy));
+ DAG.getExtractVectorElt(DL, VT.getVectorElementType(), SubVec, I);
+ InsertElt = DAG.getInsertVectorElt(DL, InsertElt, ExtractElt, I + Idx);
}
return InsertElt;
@@ -7497,8 +7445,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_SETCC(SDNode *N) {
EVT ResVT = EVT::getVectorVT(*DAG.getContext(),
SVT.getVectorElementType(),
VT.getVectorElementCount());
- SDValue CC = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResVT, WideSETCC,
- DAG.getVectorIdxConstant(0, dl));
+ SDValue CC = DAG.getExtractSubvector(dl, ResVT, WideSETCC, 0);
EVT OpVT = N->getOperand(0).getValueType();
ISD::NodeType ExtendCode =
@@ -7523,10 +7470,8 @@ SDValue DAGTypeLegalizer::WidenVecOp_STRICT_FSETCC(SDNode *N) {
SmallVector<SDValue, 8> Chains(NumElts);
for (unsigned i = 0; i != NumElts; ++i) {
- SDValue LHSElem = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, TmpEltVT, LHS,
- DAG.getVectorIdxConstant(i, dl));
- SDValue RHSElem = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, TmpEltVT, RHS,
- DAG.getVectorIdxConstant(i, dl));
+ SDValue LHSElem = DAG.getExtractVectorElt(dl, TmpEltVT, LHS, i);
+ SDValue RHSElem = DAG.getExtractVectorElt(dl, TmpEltVT, RHS, i);
Scalars[i] = DAG.getNode(N->getOpcode(), dl, {MVT::i1, MVT::Other},
{Chain, LHSElem, RHSElem, CC});
@@ -7602,14 +7547,12 @@ SDValue DAGTypeLegalizer::WidenVecOp_VECREDUCE(SDNode *N) {
ElementCount::getScalable(GCD));
SDValue SplatNeutral = DAG.getSplatVector(SplatVT, dl, NeutralElem);
for (unsigned Idx = OrigElts; Idx < WideElts; Idx = Idx + GCD)
- Op = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, WideVT, Op, SplatNeutral,
- DAG.getVectorIdxConstant(Idx, dl));
+ Op = DAG.getInsertSubvector(dl, Op, SplatNeutral, Idx);
return DAG.getNode(Opc, dl, VT, Op, Flags);
}
for (unsigned Idx = OrigElts; Idx < WideElts; Idx++)
- Op = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, WideVT, Op, NeutralElem,
- DAG.getVectorIdxConstant(Idx, dl));
+ Op = DAG.getInsertVectorElt(dl, Op, NeutralElem, Idx);
return DAG.getNode(Opc, dl, VT, Op, Flags);
}
@@ -7653,14 +7596,12 @@ SDValue DAGTypeLegalizer::WidenVecOp_VECREDUCE_SEQ(SDNode *N) {
ElementCount::getScalable(GCD));
SDValue SplatNeutral = DAG.getSplatVector(SplatVT, dl, NeutralElem);
for (unsigned Idx = OrigElts; Idx < WideElts; Idx = Idx + GCD)
- Op = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, WideVT, Op, SplatNeutral,
- DAG.getVectorIdxConstant(Idx, dl));
+ Op = DAG.getInsertSubvector(dl, Op, SplatNeutral, Idx);
return DAG.getNode(Opc, dl, VT, AccOp, Op, Flags);
}
for (unsigned Idx = OrigElts; Idx < WideElts; Idx++)
- Op = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, WideVT, Op, NeutralElem,
- DAG.getVectorIdxConstant(Idx, dl));
+ Op = DAG.getInsertVectorElt(dl, Op, NeutralElem, Idx);
return DAG.getNode(Opc, dl, VT, AccOp, Op, Flags);
}
@@ -7692,8 +7633,7 @@ SDValue DAGTypeLegalizer::WidenVecOp_VSELECT(SDNode *N) {
SDValue Select = DAG.getNode(N->getOpcode(), DL, LeftIn.getValueType(), Cond,
LeftIn, RightIn);
- return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Select,
- DAG.getVectorIdxConstant(0, DL));
+ return DAG.getExtractSubvector(DL, VT, Select, 0);
}
SDValue DAGTypeLegalizer::WidenVecOp_VP_CttzElements(SDNode *N) {
@@ -7810,8 +7750,7 @@ static SDValue BuildVectorFromScalar(SelectionDAG& DAG, EVT VecTy,
Idx = Idx * LdTy.getSizeInBits() / NewLdTy.getSizeInBits();
LdTy = NewLdTy;
}
- VecOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, VecOp, LdOps[i],
- DAG.getVectorIdxConstant(Idx++, dl));
+ VecOp = DAG.getInsertVectorElt(dl, VecOp, LdOps[i], Idx++);
}
return DAG.getNode(ISD::BITCAST, dl, VecTy, VecOp);
}
@@ -8104,8 +8043,7 @@ bool DAGTypeLegalizer::GenWidenVectorStores(SmallVectorImpl<SDValue> &StChain,
Align NewAlign = ScaledOffset == 0
? ST->getBaseAlign()
: commonAlignment(ST->getAlign(), ScaledOffset);
- SDValue EOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NewVT, ValOp,
- DAG.getVectorIdxConstant(Idx, dl));
+ SDValue EOp = DAG.getExtractSubvector(dl, NewVT, ValOp, Idx);
SDValue PartStore = DAG.getStore(Chain, dl, EOp, BasePtr, MPI, NewAlign,
MMOFlags, AAInfo);
StChain.push_back(PartStore);
@@ -8122,8 +8060,7 @@ bool DAGTypeLegalizer::GenWidenVectorStores(SmallVectorImpl<SDValue> &StChain,
// Readjust index position based on new vector type.
Idx = Idx * ValEltWidth / NewVTWidth.getFixedValue();
do {
- SDValue EOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, VecOp,
- DAG.getVectorIdxConstant(Idx++, dl));
+ SDValue EOp = DAG.getExtractVectorElt(dl, NewVT, VecOp, Idx++);
SDValue PartStore = DAG.getStore(Chain, dl, EOp, BasePtr, MPI,
ST->getBaseAlign(), MMOFlags, AAInfo);
StChain.push_back(PartStore);
@@ -8171,8 +8108,7 @@ SDValue DAGTypeLegalizer::ModifyToType(SDValue InOp, EVT NVT,
}
if (InEC.hasKnownScalarFactor(WidenEC))
- return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT, InOp,
- DAG.getVectorIdxConstant(0, dl));
+ return DAG.getExtractSubvector(dl, NVT, InOp, 0);
assert(!InVT.isScalableVector() && !NVT.isScalableVector() &&
"Scalable vectors should have been handled already.");
@@ -8186,8 +8122,7 @@ SDValue DAGTypeLegalizer::ModifyToType(SDValue InOp, EVT NVT,
unsigned MinNumElts = std::min(WidenNumElts, InNumElts);
unsigned Idx;
for (Idx = 0; Idx < MinNumElts; ++Idx)
- Ops[Idx] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
- DAG.getVectorIdxConstant(Idx, dl));
+ Ops[Idx] = DAG.getExtractVectorElt(dl, EltVT, InOp, Idx);
SDValue UndefVal = DAG.getUNDEF(EltVT);
for (; Idx < WidenNumElts; ++Idx)
More information about the llvm-commits
mailing list