[llvm] r315195 - [X86][SSE] Don't call combineTo inside combineX86ShufflesRecursively. NFCI.
Simon Pilgrim via llvm-commits
llvm-commits at lists.llvm.org
Sun Oct 8 13:58:14 PDT 2017
Author: rksimon
Date: Sun Oct 8 13:58:14 2017
New Revision: 315195
URL: http://llvm.org/viewvc/llvm-project?rev=315195&view=rev
Log:
[X86][SSE] Don't call combineTo inside combineX86ShufflesRecursively. NFCI.
Return the combined shuffle from combineX86ShufflesRecursively and perform the combineTo in the caller.
Makes it easier for future patches to use this in functions that aren't actually shuffles themselves.
Modified:
llvm/trunk/lib/Target/X86/X86ISelLowering.cpp
Modified: llvm/trunk/lib/Target/X86/X86ISelLowering.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86ISelLowering.cpp?rev=315195&r1=315194&r2=315195&view=diff
==============================================================================
--- llvm/trunk/lib/Target/X86/X86ISelLowering.cpp (original)
+++ llvm/trunk/lib/Target/X86/X86ISelLowering.cpp Sun Oct 8 13:58:14 2017
@@ -28349,7 +28349,7 @@ static SDValue combineX86ShufflesConstan
/// would simplify under the threshold for PSHUFB formation because of
/// combine-ordering. To fix this, we should do the redundant instruction
/// combining in this recursive walk.
-static bool combineX86ShufflesRecursively(
+static SDValue combineX86ShufflesRecursively(
ArrayRef<SDValue> SrcOps, int SrcOpIndex, SDValue Root,
ArrayRef<int> RootMask, ArrayRef<const SDNode *> SrcNodes, int Depth,
bool HasVariableMask, SelectionDAG &DAG,
@@ -28357,7 +28357,7 @@ static bool combineX86ShufflesRecursivel
// Bound the depth of our recursive combine because this is ultimately
// quadratic in nature.
if (Depth > 8)
- return false;
+ return SDValue();
// Directly rip through bitcasts to find the underlying operand.
SDValue Op = SrcOps[SrcOpIndex];
@@ -28365,7 +28365,7 @@ static bool combineX86ShufflesRecursivel
MVT VT = Op.getSimpleValueType();
if (!VT.isVector())
- return false; // Bail if we hit a non-vector.
+ return SDValue(); // Bail if we hit a non-vector.
assert(Root.getSimpleValueType().isVector() &&
"Shuffles operate on vector types!");
@@ -28376,7 +28376,7 @@ static bool combineX86ShufflesRecursivel
SmallVector<int, 64> OpMask;
SmallVector<SDValue, 2> OpInputs;
if (!resolveTargetShuffleInputs(Op, OpInputs, OpMask, DAG))
- return false;
+ return SDValue();
assert(OpInputs.size() <= 2 && "Too many shuffle inputs");
SDValue Input0 = (OpInputs.size() > 0 ? OpInputs[0] : SDValue());
@@ -28485,18 +28485,15 @@ static bool combineX86ShufflesRecursivel
}
// Handle the all undef/zero cases early.
- if (all_of(Mask, [](int Idx) { return Idx == SM_SentinelUndef; })) {
- DCI.CombineTo(Root.getNode(), DAG.getUNDEF(Root.getValueType()));
- return true;
- }
- if (all_of(Mask, [](int Idx) { return Idx < 0; })) {
- // TODO - should we handle the mixed zero/undef case as well? Just returning
- // a zero mask will lose information on undef elements possibly reducing
- // future combine possibilities.
- DCI.CombineTo(Root.getNode(), getZeroVector(Root.getSimpleValueType(),
- Subtarget, DAG, SDLoc(Root)));
- return true;
- }
+ if (all_of(Mask, [](int Idx) { return Idx == SM_SentinelUndef; }))
+ return DAG.getUNDEF(Root.getValueType());
+
+ // TODO - should we handle the mixed zero/undef case as well? Just returning
+ // a zero mask will lose information on undef elements possibly reducing
+ // future combine possibilities.
+ if (all_of(Mask, [](int Idx) { return Idx < 0; }))
+ return getZeroVector(Root.getSimpleValueType(), Subtarget, DAG,
+ SDLoc(Root));
// Remove unused shuffle source ops.
resolveTargetShuffleInputsAndMask(Ops, Mask);
@@ -28515,21 +28512,19 @@ static bool combineX86ShufflesRecursivel
for (int i = 0, e = Ops.size(); i < e; ++i)
if (Ops[i].getNode()->hasOneUse() ||
SDNode::areOnlyUsersOf(CombinedNodes, Ops[i].getNode()))
- if (combineX86ShufflesRecursively(Ops, i, Root, Mask, CombinedNodes,
- Depth + 1, HasVariableMask, DAG, DCI,
- Subtarget))
- return true;
+ if (SDValue Res = combineX86ShufflesRecursively(
+ Ops, i, Root, Mask, CombinedNodes, Depth + 1, HasVariableMask,
+ DAG, DCI, Subtarget))
+ return Res;
// Attempt to constant fold all of the constant source ops.
if (SDValue Cst = combineX86ShufflesConstants(
- Ops, Mask, Root, HasVariableMask, DAG, DCI, Subtarget)) {
- DCI.CombineTo(Root.getNode(), Cst);
- return true;
- }
+ Ops, Mask, Root, HasVariableMask, DAG, DCI, Subtarget))
+ return Cst;
// We can only combine unary and binary shuffle mask cases.
if (Ops.size() > 2)
- return false;
+ return SDValue();
// Minor canonicalization of the accumulated shuffle mask to make it easier
// to match below. All this does is detect masks with sequential pairs of
@@ -28549,12 +28544,8 @@ static bool combineX86ShufflesRecursivel
}
// Finally, try to combine into a single shuffle instruction.
- if (SDValue Res = combineX86ShuffleChain(
- Ops, Root, Mask, Depth, HasVariableMask, DAG, DCI, Subtarget)) {
- DCI.CombineTo(Root.getNode(), Res, /*AddTo*/ true);
- return true;
- }
- return false;
+ return combineX86ShuffleChain(Ops, Root, Mask, Depth, HasVariableMask, DAG,
+ DCI, Subtarget);
}
/// \brief Get the PSHUF-style mask from PSHUF node.
@@ -29381,10 +29372,12 @@ static SDValue combineShuffle(SDNode *N,
// specific PSHUF instruction sequences into their minimal form so that we
// can evaluate how many specialized shuffle instructions are involved in
// a particular chain.
- if (combineX86ShufflesRecursively({Op}, 0, Op, {0}, {}, /*Depth*/ 1,
- /*HasVarMask*/ false, DAG, DCI,
- Subtarget))
- return SDValue(); // This routine will use CombineTo to replace N.
+ if (SDValue Res = combineX86ShufflesRecursively(
+ {Op}, 0, Op, {0}, {}, /*Depth*/ 1,
+ /*HasVarMask*/ false, DAG, DCI, Subtarget)) {
+ DCI.CombineTo(N, Res);
+ return SDValue();
+ }
}
return SDValue();
@@ -32060,8 +32053,13 @@ static SDValue combineVectorPack(SDNode
// Attempt to combine as shuffle.
SDValue Op(N, 0);
- combineX86ShufflesRecursively({Op}, 0, Op, {0}, {}, /*Depth*/ 1,
- /*HasVarMask*/ false, DAG, DCI, Subtarget);
+ if (SDValue Res = combineX86ShufflesRecursively(
+ {Op}, 0, Op, {0}, {}, /*Depth*/ 1,
+ /*HasVarMask*/ false, DAG, DCI, Subtarget)) {
+ DCI.CombineTo(N, Res);
+ return SDValue();
+ }
+
return SDValue();
}
@@ -32117,10 +32115,12 @@ static SDValue combineVectorShiftImm(SDN
// We can decode 'whole byte' logical bit shifts as shuffles.
if (LogicalShift && (ShiftVal.getZExtValue() % 8) == 0) {
SDValue Op(N, 0);
- if (combineX86ShufflesRecursively({Op}, 0, Op, {0}, {}, /*Depth*/ 1,
- /*HasVarMask*/ false, DAG, DCI,
- Subtarget))
- return SDValue(); // This routine will use CombineTo to replace N.
+ if (SDValue Res = combineX86ShufflesRecursively(
+ {Op}, 0, Op, {0}, {}, /*Depth*/ 1,
+ /*HasVarMask*/ false, DAG, DCI, Subtarget)) {
+ DCI.CombineTo(N, Res);
+ return SDValue();
+ }
}
// Constant Folding.
@@ -32156,8 +32156,13 @@ static SDValue combineVectorInsert(SDNod
// Attempt to combine PINSRB/PINSRW patterns to a shuffle.
SDValue Op(N, 0);
- combineX86ShufflesRecursively({Op}, 0, Op, {0}, {}, /*Depth*/ 1,
- /*HasVarMask*/ false, DAG, DCI, Subtarget);
+ if (SDValue Res = combineX86ShufflesRecursively(
+ {Op}, 0, Op, {0}, {}, /*Depth*/ 1,
+ /*HasVarMask*/ false, DAG, DCI, Subtarget)) {
+ DCI.CombineTo(N, Res);
+ return SDValue();
+ }
+
return SDValue();
}
@@ -32457,10 +32462,12 @@ static SDValue combineAnd(SDNode *N, Sel
// Attempt to recursively combine a bitmask AND with shuffles.
if (VT.isVector() && (VT.getScalarSizeInBits() % 8) == 0) {
SDValue Op(N, 0);
- if (combineX86ShufflesRecursively({Op}, 0, Op, {0}, {}, /*Depth*/ 1,
- /*HasVarMask*/ false, DAG, DCI,
- Subtarget))
- return SDValue(); // This routine will use CombineTo to replace N.
+ if (SDValue Res = combineX86ShufflesRecursively(
+ {Op}, 0, Op, {0}, {}, /*Depth*/ 1,
+ /*HasVarMask*/ false, DAG, DCI, Subtarget)) {
+ DCI.CombineTo(N, Res);
+ return SDValue();
+ }
}
return SDValue();
@@ -34624,10 +34631,12 @@ static SDValue combineAndnp(SDNode *N, S
// Attempt to recursively combine a bitmask ANDNP with shuffles.
if (VT.isVector() && (VT.getScalarSizeInBits() % 8) == 0) {
SDValue Op(N, 0);
- if (combineX86ShufflesRecursively({Op}, 0, Op, {0}, {}, /*Depth*/ 1,
- /*HasVarMask*/ false, DAG, DCI,
- Subtarget))
- return SDValue(); // This routine will use CombineTo to replace N.
+ if (SDValue Res = combineX86ShufflesRecursively(
+ {Op}, 0, Op, {0}, {}, /*Depth*/ 1,
+ /*HasVarMask*/ false, DAG, DCI, Subtarget)) {
+ DCI.CombineTo(N, Res);
+ return SDValue();
+ }
}
return SDValue();
More information about the llvm-commits
mailing list