[llvm] DAG: Use poison instead of undef in some vector combines (PR #177612)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Jan 23 08:48:52 PST 2026
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-selectiondag
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
Use poison for the unused or out of bounds vector components.
---
Full diff: https://github.com/llvm/llvm-project/pull/177612.diff
1 Files Affected:
- (modified) llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp (+43-43)
``````````diff
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 76b7643c902ab..772e51190e71a 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -23780,7 +23780,7 @@ SDValue DAGCombiner::combineInsertEltToShuffle(SDNode *N, unsigned InsIndex) {
// Step 2: Create a wide vector from the inserted source vector by appending
// undefined elements. This is the same size as our destination vector.
SDLoc DL(N);
- SmallVector<SDValue, 8> ConcatOps(ExtendRatio, DAG.getUNDEF(SubVecVT));
+ SmallVector<SDValue, 8> ConcatOps(ExtendRatio, DAG.getPOISON(SubVecVT));
ConcatOps[0] = SubVec;
SDValue PaddedSubV = DAG.getNode(ISD::CONCAT_VECTORS, DL, ShufVT, ConcatOps);
@@ -23898,7 +23898,7 @@ SDValue DAGCombiner::visitINSERT_VECTOR_ELT(SDNode *N) {
// Insert into out-of-bounds element is undefined.
if (IndexC && VT.isFixedLengthVector() &&
IndexC->getZExtValue() >= VT.getVectorNumElements())
- return DAG.getUNDEF(VT);
+ return DAG.getPOISON(VT);
// Remove redundant insertions:
// (insert_vector_elt x (extract_vector_elt x idx) idx) -> x
@@ -24457,7 +24457,7 @@ SDValue DAGCombiner::visitEXTRACT_VECTOR_ELT(SDNode *N) {
if (VecOp.getOpcode() == ISD::SCALAR_TO_VECTOR) {
// Only 0'th element of SCALAR_TO_VECTOR is defined.
if (DAG.isKnownNeverZero(Index))
- return DAG.getUNDEF(ScalarVT);
+ return DAG.getPOISON(ScalarVT);
// Check if the result type doesn't match the inserted element type.
// The inserted element and extracted element may have mismatched bitwidth.
@@ -24867,8 +24867,8 @@ SDValue DAGCombiner::reduceBuildVecExtToExtBuildVec(SDNode *N) {
bool isLE = DAG.getDataLayout().isLittleEndian();
unsigned ElemRatio = OutScalarTy.getSizeInBits()/SourceType.getSizeInBits();
assert(ElemRatio > 1 && "Invalid element size ratio");
- SDValue Filler = AllAnyExt ? DAG.getUNDEF(SourceType):
- DAG.getConstant(0, DL, SourceType);
+ SDValue Filler = AllAnyExt ? DAG.getPOISON(SourceType)
+ : DAG.getConstant(0, DL, SourceType);
unsigned NewBVElems = ElemRatio * VT.getVectorNumElements();
SmallVector<SDValue, 8> Ops(NewBVElems, Filler);
@@ -25023,9 +25023,9 @@ SDValue DAGCombiner::createBuildVecShuffle(const SDLoc &DL, SDNode *N,
// we can concatenate them and pad the rest with undefs.
unsigned NumConcats = VTSize / InVT1Size;
assert(NumConcats >= 2 && "Concat needs at least two inputs!");
- SmallVector<SDValue, 2> ConcatOps(NumConcats, DAG.getUNDEF(InVT1));
+ SmallVector<SDValue, 2> ConcatOps(NumConcats, DAG.getPOISON(InVT1));
ConcatOps[0] = VecIn1;
- ConcatOps[1] = VecIn2 ? VecIn2 : DAG.getUNDEF(InVT1);
+ ConcatOps[1] = VecIn2 ? VecIn2 : DAG.getPOISON(InVT1);
VecIn1 = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, ConcatOps);
VecIn2 = SDValue();
} else if (InVT1Size == VTSize * 2) {
@@ -25059,12 +25059,12 @@ SDValue DAGCombiner::createBuildVecShuffle(const SDLoc &DL, SDNode *N,
if (InVT1 != InVT2) {
if (!TLI.isTypeLegal(InVT2))
return SDValue();
- VecIn2 = DAG.getInsertSubvector(DL, DAG.getUNDEF(InVT1), VecIn2, 0);
+ VecIn2 = DAG.getInsertSubvector(DL, DAG.getPOISON(InVT1), VecIn2, 0);
}
ShuffleNumElems = NumElems * 2;
}
} else if (InVT2Size * 2 == VTSize && InVT1Size == VTSize) {
- SmallVector<SDValue, 2> ConcatOps(2, DAG.getUNDEF(InVT2));
+ SmallVector<SDValue, 2> ConcatOps(2, DAG.getPOISON(InVT2));
ConcatOps[0] = VecIn2;
VecIn2 = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, ConcatOps);
} else if (InVT1Size / VTSize > 1 && InVT1Size % VTSize == 0) {
@@ -25086,7 +25086,7 @@ SDValue DAGCombiner::createBuildVecShuffle(const SDLoc &DL, SDNode *N,
return SDValue();
if (InVT1 != InVT2) {
- VecIn2 = DAG.getInsertSubvector(DL, DAG.getUNDEF(InVT1), VecIn2, 0);
+ VecIn2 = DAG.getInsertSubvector(DL, DAG.getPOISON(InVT1), VecIn2, 0);
}
ShuffleNumElems = InVT1Size / VTSize * NumElems;
} else {
@@ -25121,7 +25121,7 @@ SDValue DAGCombiner::createBuildVecShuffle(const SDLoc &DL, SDNode *N,
// If we already have a VecIn2, it should have the same type as VecIn1.
// If we don't, get an undef/zero vector of the appropriate type.
- VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(InVT1);
+ VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getPOISON(InVT1);
assert(InVT1 == VecIn2.getValueType() && "Unexpected second input type.");
SDValue Shuffle = DAG.getVectorShuffle(InVT1, DL, VecIn1, VecIn2, Mask);
@@ -25452,11 +25452,11 @@ SDValue DAGCombiner::reduceBuildVecToShuffle(SDNode *N) {
// Make sure the initial size of the shuffle list is even.
if (Shuffles.size() % 2)
- Shuffles.push_back(DAG.getUNDEF(VT));
+ Shuffles.push_back(DAG.getPOISON(VT));
for (unsigned CurSize = Shuffles.size(); CurSize > 1; CurSize /= 2) {
if (CurSize % 2) {
- Shuffles[CurSize] = DAG.getUNDEF(VT);
+ Shuffles[CurSize] = DAG.getPOISON(VT);
CurSize++;
}
for (unsigned In = 0, Len = CurSize / 2; In < Len; ++In) {
@@ -25850,7 +25850,7 @@ static SDValue combineConcatVectorOfConcatVectors(SDNode *N,
SmallVector<SDValue> ConcatOps;
for (const SDValue &Op : N->ops()) {
if (Op.isUndef()) {
- ConcatOps.append(FirstConcat->getNumOperands(), DAG.getUNDEF(SubVT));
+ ConcatOps.append(FirstConcat->getNumOperands(), DAG.getPOISON(SubVT));
continue;
}
ConcatOps.append(Op->op_begin(), Op->op_end());
@@ -25873,7 +25873,7 @@ static SDValue combineConcatVectorOfExtracts(SDNode *N, SelectionDAG &DAG) {
int NumElts = VT.getVectorNumElements();
int NumOpElts = OpVT.getVectorNumElements();
- SDValue SV0 = DAG.getUNDEF(VT), SV1 = DAG.getUNDEF(VT);
+ SDValue SV0 = DAG.getPOISON(VT), SV1 = DAG.getPOISON(VT);
SmallVector<int, 8> Mask;
for (SDValue Op : N->ops()) {
@@ -26081,17 +26081,17 @@ static SDValue combineConcatVectorOfShuffleAndItsOperands(
if (!TLI.isShuffleMaskLegal(Mask, VT))
return SDValue();
- // Pad the shuffle operands with UNDEF.
+ // Pad the shuffle operands with poison.
SDLoc dl(N);
std::array<SDValue, 2> ShufOps;
for (auto I : zip(SVN->ops(), ShufOps)) {
SDValue ShufOp = std::get<0>(I);
SDValue &NewShufOp = std::get<1>(I);
if (ShufOp.isUndef())
- NewShufOp = DAG.getUNDEF(VT);
+ NewShufOp = DAG.getPOISON(VT);
else {
SmallVector<SDValue, 2> ShufOpParts(N->getNumOperands(),
- DAG.getUNDEF(OpVT));
+ DAG.getPOISON(OpVT));
ShufOpParts[0] = ShufOp;
NewShufOp = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, ShufOpParts);
}
@@ -26149,7 +26149,7 @@ SDValue DAGCombiner::visitCONCAT_VECTORS(SDNode *N) {
!(LegalDAG && In.getValueType().isScalableVector())) {
unsigned NumOps = N->getNumOperands() * In.getNumOperands();
SmallVector<SDValue, 4> Ops(In->ops());
- Ops.resize(NumOps, DAG.getUNDEF(Ops[0].getValueType()));
+ Ops.resize(NumOps, DAG.getPOISON(Ops[0].getValueType()));
return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Ops);
}
@@ -26226,7 +26226,7 @@ SDValue DAGCombiner::visitCONCAT_VECTORS(SDNode *N) {
unsigned NumElts = OpVT.getVectorNumElements();
if (Op.isUndef())
- Opnds.append(NumElts, DAG.getUNDEF(MinVT));
+ Opnds.append(NumElts, DAG.getPOISON(MinVT));
if (ISD::BUILD_VECTOR == Op.getOpcode()) {
if (SVT.isFloatingPoint()) {
@@ -26674,7 +26674,7 @@ static SDValue foldExtractSubvectorFromShuffleVector(EVT NarrowVT, SDValue Src,
// Did we discover that the shuffle does not actually depend on operands?
if (DemandedSubvectors.empty())
- return DAG.getUNDEF(NarrowVT);
+ return DAG.getPOISON(NarrowVT);
// Profitability check: only deal with extractions from the first subvector
// unless the mask becomes an identity mask.
@@ -26706,7 +26706,7 @@ static SDValue foldExtractSubvectorFromShuffleVector(EVT NarrowVT, SDValue Src,
// If we ended up with only one operand, pad with an undef.
if (NewOps.size() == 1)
- NewOps.emplace_back(DAG.getUNDEF(NarrowVT));
+ NewOps.emplace_back(DAG.getPOISON(NarrowVT));
return DAG.getVectorShuffle(NarrowVT, DL, NewOps[0], NewOps[1], NewMask);
}
@@ -27018,7 +27018,7 @@ static SDValue partitionShuffleOfConcats(SDNode *N, SelectionDAG &DAG) {
N0 = DAG.getVectorShuffle(ConcatVT, SDLoc(N), N0.getOperand(0),
N0.getOperand(1),
Mask.slice(0, NumElemsPerConcat));
- N1 = DAG.getUNDEF(ConcatVT);
+ N1 = DAG.getPOISON(ConcatVT);
return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, N0, N1);
}
@@ -27109,7 +27109,7 @@ static SDValue combineShuffleOfScalars(ShuffleVectorSDNode *SVN,
SmallVector<SDValue, 8> Ops;
SmallSet<SDValue, 16> DuplicateOps;
for (int M : SVN->getMask()) {
- SDValue Op = DAG.getUNDEF(VT.getScalarType());
+ SDValue Op = DAG.getPOISON(VT.getScalarType());
if (M >= 0) {
int Idx = M < (int)NumElts ? M : M - NumElts;
SDValue &S = (M < (int)NumElts ? N0 : N1);
@@ -27117,7 +27117,7 @@ static SDValue combineShuffleOfScalars(ShuffleVectorSDNode *SVN,
Op = S.getOperand(Idx);
} else if (S.getOpcode() == ISD::SCALAR_TO_VECTOR) {
SDValue Op0 = S.getOperand(0);
- Op = Idx == 0 ? Op0 : DAG.getUNDEF(Op0.getValueType());
+ Op = Idx == 0 ? Op0 : DAG.getPOISON(Op0.getValueType());
} else {
// Operand can't be combined - bail out.
return SDValue();
@@ -27745,9 +27745,9 @@ SDValue DAGCombiner::visitVECTOR_SHUFFLE(SDNode *N) {
ShuffleVectorSDNode *SVN = cast<ShuffleVectorSDNode>(N);
- // Canonicalize shuffle v, v -> v, undef
+ // Canonicalize shuffle v, v -> v, poison
if (N0 == N1)
- return DAG.getVectorShuffle(VT, SDLoc(N), N0, DAG.getUNDEF(VT),
+ return DAG.getVectorShuffle(VT, SDLoc(N), N0, DAG.getPOISON(VT),
createUnaryMask(SVN->getMask(), NumElts));
// Canonicalize shuffle undef, v -> v, undef. Commute the shuffle mask.
@@ -27798,7 +27798,7 @@ SDValue DAGCombiner::visitVECTOR_SHUFFLE(SDNode *N) {
DAG.getNode(N0.getOpcode(), DL, EltVT, ExtL, ExtR, N0->getFlags());
SDValue Insert = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT, NewBO);
SmallVector<int, 16> ZeroMask(VT.getVectorNumElements(), 0);
- return DAG.getVectorShuffle(VT, DL, Insert, DAG.getUNDEF(VT), ZeroMask);
+ return DAG.getVectorShuffle(VT, DL, Insert, DAG.getPOISON(VT), ZeroMask);
}
// splat(scalar_to_vector(x), 0) -> build_vector(x,...,x)
@@ -27874,7 +27874,7 @@ SDValue DAGCombiner::visitVECTOR_SHUFFLE(SDNode *N) {
for (unsigned i = 0; i != NumElts; ++i) {
if (SVN->getMaskElt(i) < 0)
- Ops[i] = DAG.getUNDEF(EltVT);
+ Ops[i] = DAG.getPOISON(EltVT);
}
SDValue NewBV = DAG.getBuildVector(V->getValueType(0), SDLoc(N), Ops);
@@ -27931,7 +27931,7 @@ SDValue DAGCombiner::visitVECTOR_SHUFFLE(SDNode *N) {
NewMask.push_back(Idx);
}
if (TLI.isShuffleMaskLegal(NewMask, VT)) {
- SDValue UndefVec = DAG.getUNDEF(N0.getOperand(0).getValueType());
+ SDValue UndefVec = DAG.getPOISON(N0.getOperand(0).getValueType());
SDValue NewCat = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
N0.getOperand(0), UndefVec);
return DAG.getVectorShuffle(VT, SDLoc(N), NewCat, N1, NewMask);
@@ -28035,7 +28035,7 @@ SDValue DAGCombiner::visitVECTOR_SHUFFLE(SDNode *N) {
if (IntSVT.getSizeInBits() >= IntVT.getScalarSizeInBits()) {
SDValue ZeroElt = DAG.getConstant(0, DL, IntSVT);
SDValue AllOnesElt = DAG.getAllOnesConstant(DL, IntSVT);
- SmallVector<SDValue, 16> AndMask(NumElts, DAG.getUNDEF(IntSVT));
+ SmallVector<SDValue, 16> AndMask(NumElts, DAG.getPOISON(IntSVT));
for (int I = 0; I != (int)NumElts; ++I)
if (0 <= Mask[I])
AndMask[I] = Mask[I] == I ? AllOnesElt : ZeroElt;
@@ -28288,13 +28288,13 @@ SDValue DAGCombiner::visitVECTOR_SHUFFLE(SDNode *N) {
SmallVector<int, 4> Mask;
if (MergeInnerShuffle(i != 0, SVN, OtherSV, N->getOperand(1 - i), TLI,
SV0, SV1, Mask)) {
- // Check if all indices in Mask are Undef. In case, propagate Undef.
+ // Check if all indices in Mask are poison. In case, propagate poison.
if (llvm::all_of(Mask, [](int M) { return M < 0; }))
- return DAG.getUNDEF(VT);
+ return DAG.getPOISON(VT);
return DAG.getVectorShuffle(VT, SDLoc(N),
- SV0 ? SV0 : DAG.getUNDEF(VT),
- SV1 ? SV1 : DAG.getUNDEF(VT), Mask);
+ SV0 ? SV0 : DAG.getPOISON(VT),
+ SV1 ? SV1 : DAG.getPOISON(VT), Mask);
}
}
}
@@ -28366,11 +28366,11 @@ SDValue DAGCombiner::visitVECTOR_SHUFFLE(SDNode *N) {
if (MergedLeft || MergedRight) {
SDLoc DL(N);
SDValue LHS = DAG.getVectorShuffle(
- VT, DL, LeftSV0 ? LeftSV0 : DAG.getUNDEF(VT),
- LeftSV1 ? LeftSV1 : DAG.getUNDEF(VT), LeftMask);
+ VT, DL, LeftSV0 ? LeftSV0 : DAG.getPOISON(VT),
+ LeftSV1 ? LeftSV1 : DAG.getPOISON(VT), LeftMask);
SDValue RHS = DAG.getVectorShuffle(
- VT, DL, RightSV0 ? RightSV0 : DAG.getUNDEF(VT),
- RightSV1 ? RightSV1 : DAG.getUNDEF(VT), RightMask);
+ VT, DL, RightSV0 ? RightSV0 : DAG.getPOISON(VT),
+ RightSV1 ? RightSV1 : DAG.getPOISON(VT), RightMask);
return DAG.getNode(SrcOpcode, DL, VT, LHS, RHS);
}
}
@@ -28430,7 +28430,7 @@ SDValue DAGCombiner::visitSCALAR_TO_VECTOR(SDNode *N) {
SDValue V[] = {EE.getOperand(0),
DAG.getConstant(C->getAPIntValue(), DL, VT)};
SDValue VecBO = DAG.getNode(Opcode, DL, VT, V[i], V[1 - i]);
- return DAG.getVectorShuffle(VT, DL, VecBO, DAG.getUNDEF(VT),
+ return DAG.getVectorShuffle(VT, DL, VecBO, DAG.getPOISON(VT),
ShufMask);
}
}
@@ -28463,7 +28463,7 @@ SDValue DAGCombiner::visitSCALAR_TO_VECTOR(SDNode *N) {
SmallVector<int, 8> Mask(SrcNumElts, -1);
Mask[0] = ExtIndexC->getZExtValue();
SDValue LegalShuffle = TLI.buildLegalVectorShuffle(
- SrcVT, SDLoc(N), SrcVec, DAG.getUNDEF(SrcVT), Mask, DAG);
+ SrcVT, SDLoc(N), SrcVec, DAG.getPOISON(SrcVT), Mask, DAG);
if (!LegalShuffle)
return SDValue();
@@ -29175,7 +29175,7 @@ SDValue DAGCombiner::SimplifyVBinOp(SDNode *N, const SDLoc &DL) {
// binop (splat X), (splat C) --> splat (binop X, C)
SDValue X = Shuf0->getOperand(0);
SDValue NewBinOp = DAG.getNode(Opcode, DL, VT, X, RHS, Flags);
- return DAG.getVectorShuffle(VT, DL, NewBinOp, DAG.getUNDEF(VT),
+ return DAG.getVectorShuffle(VT, DL, NewBinOp, DAG.getPOISON(VT),
Shuf0->getMask());
}
if (isConstOrConstSplat(LHS) && Shuf1 && all_equal(Shuf1->getMask()) &&
@@ -29184,7 +29184,7 @@ SDValue DAGCombiner::SimplifyVBinOp(SDNode *N, const SDLoc &DL) {
// binop (splat C), (splat X) --> splat (binop C, X)
SDValue X = Shuf1->getOperand(0);
SDValue NewBinOp = DAG.getNode(Opcode, DL, VT, LHS, X, Flags);
- return DAG.getVectorShuffle(VT, DL, NewBinOp, DAG.getUNDEF(VT),
+ return DAG.getVectorShuffle(VT, DL, NewBinOp, DAG.getPOISON(VT),
Shuf1->getMask());
}
}
``````````
</details>
https://github.com/llvm/llvm-project/pull/177612
More information about the llvm-commits
mailing list