forked from OSchip/llvm-project
[DAGCombiner] avoid unnecessary indirection from SDNode/SDValue; NFCI
This commit is contained in:
Sanjay Patel
parent
5b875bf59b
commit
21dadd774f
|
|
@ -862,7 +862,7 @@ bool DAGCombiner::isSetCCEquivalent(SDValue N, SDValue &LHS, SDValue &RHS,
|
|||
/// it is profitable to do so.
|
||||
bool DAGCombiner::isOneUseSetCC(SDValue N) const {
|
||||
SDValue N0, N1, N2;
|
||||
if (isSetCCEquivalent(N, N0, N1, N2) && N.getNode()->hasOneUse())
|
||||
if (isSetCCEquivalent(N, N0, N1, N2) && N.hasOneUse())
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
|
@ -1235,8 +1235,8 @@ SDValue DAGCombiner::PromoteIntBinOp(SDValue Op) {
|
|||
|
||||
// We are always replacing N0/N1's use in N and only need
|
||||
// additional replacements if there are additional uses.
|
||||
Replace0 &= !N0->hasOneUse();
|
||||
Replace1 &= (N0 != N1) && !N1->hasOneUse();
|
||||
Replace0 &= !N0.hasOneUse();
|
||||
Replace1 &= (N0 != N1) && !N1.hasOneUse();
|
||||
|
||||
// Combine Op here so it is preserved past replacements.
|
||||
CombineTo(Op.getNode(), RV);
|
||||
|
|
@ -3587,12 +3587,10 @@ SDValue DAGCombiner::visitMUL(SDNode *N) {
|
|||
|
||||
// Check for both (mul (shl X, C), Y) and (mul Y, (shl X, C)).
|
||||
if (N0.getOpcode() == ISD::SHL &&
|
||||
isConstantOrConstantVector(N0.getOperand(1)) &&
|
||||
N0.getNode()->hasOneUse()) {
|
||||
isConstantOrConstantVector(N0.getOperand(1)) && N0.hasOneUse()) {
|
||||
Sh = N0; Y = N1;
|
||||
} else if (N1.getOpcode() == ISD::SHL &&
|
||||
isConstantOrConstantVector(N1.getOperand(1)) &&
|
||||
N1.getNode()->hasOneUse()) {
|
||||
isConstantOrConstantVector(N1.getOperand(1)) && N1.hasOneUse()) {
|
||||
Sh = N1; Y = N0;
|
||||
}
|
||||
|
||||
|
|
@ -5484,7 +5482,7 @@ SDValue DAGCombiner::MatchBSwapHWordLow(SDNode *N, SDValue N0, SDValue N1,
|
|||
if (N1.getOpcode() == ISD::AND && N1.getOperand(0).getOpcode() == ISD::SHL)
|
||||
std::swap(N0, N1);
|
||||
if (N0.getOpcode() == ISD::AND) {
|
||||
if (!N0.getNode()->hasOneUse())
|
||||
if (!N0.hasOneUse())
|
||||
return SDValue();
|
||||
ConstantSDNode *N01C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
|
||||
// Also handle 0xffff since the LHS is guaranteed to have zeros there.
|
||||
|
|
@ -5497,7 +5495,7 @@ SDValue DAGCombiner::MatchBSwapHWordLow(SDNode *N, SDValue N0, SDValue N1,
|
|||
}
|
||||
|
||||
if (N1.getOpcode() == ISD::AND) {
|
||||
if (!N1.getNode()->hasOneUse())
|
||||
if (!N1.hasOneUse())
|
||||
return SDValue();
|
||||
ConstantSDNode *N11C = dyn_cast<ConstantSDNode>(N1.getOperand(1));
|
||||
if (!N11C || N11C->getZExtValue() != 0xFF)
|
||||
|
|
@ -5510,7 +5508,7 @@ SDValue DAGCombiner::MatchBSwapHWordLow(SDNode *N, SDValue N0, SDValue N1,
|
|||
std::swap(N0, N1);
|
||||
if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
|
||||
return SDValue();
|
||||
if (!N0.getNode()->hasOneUse() || !N1.getNode()->hasOneUse())
|
||||
if (!N0.hasOneUse() || !N1.hasOneUse())
|
||||
return SDValue();
|
||||
|
||||
ConstantSDNode *N01C = dyn_cast<ConstantSDNode>(N0.getOperand(1));
|
||||
|
|
@ -5523,7 +5521,7 @@ SDValue DAGCombiner::MatchBSwapHWordLow(SDNode *N, SDValue N0, SDValue N1,
|
|||
// Look for (shl (and a, 0xff), 8), (srl (and a, 0xff00), 8)
|
||||
SDValue N00 = N0->getOperand(0);
|
||||
if (!LookPassAnd0 && N00.getOpcode() == ISD::AND) {
|
||||
if (!N00.getNode()->hasOneUse())
|
||||
if (!N00.hasOneUse())
|
||||
return SDValue();
|
||||
ConstantSDNode *N001C = dyn_cast<ConstantSDNode>(N00.getOperand(1));
|
||||
if (!N001C || N001C->getZExtValue() != 0xFF)
|
||||
|
|
@ -5534,7 +5532,7 @@ SDValue DAGCombiner::MatchBSwapHWordLow(SDNode *N, SDValue N0, SDValue N1,
|
|||
|
||||
SDValue N10 = N1->getOperand(0);
|
||||
if (!LookPassAnd1 && N10.getOpcode() == ISD::AND) {
|
||||
if (!N10.getNode()->hasOneUse())
|
||||
if (!N10.hasOneUse())
|
||||
return SDValue();
|
||||
ConstantSDNode *N101C = dyn_cast<ConstantSDNode>(N10.getOperand(1));
|
||||
// Also allow 0xFFFF since the bits will be shifted out. This is needed
|
||||
|
|
@ -5584,7 +5582,7 @@ SDValue DAGCombiner::MatchBSwapHWordLow(SDNode *N, SDValue N0, SDValue N1,
|
|||
/// ((x & 0x00ff0000) << 8) |
|
||||
/// ((x & 0xff000000) >> 8)
|
||||
static bool isBSwapHWordElement(SDValue N, MutableArrayRef<SDNode *> Parts) {
|
||||
if (!N.getNode()->hasOneUse())
|
||||
if (!N.hasOneUse())
|
||||
return false;
|
||||
|
||||
unsigned Opc = N.getOpcode();
|
||||
|
|
@ -5698,7 +5696,7 @@ static SDValue matchBSwapHWordOrAndAnd(const TargetLowering &TLI,
|
|||
if (N0.getOpcode() != ISD::AND || N1.getOpcode() != ISD::AND)
|
||||
return SDValue();
|
||||
// TODO: this is too restrictive; lifting this restriction requires more tests
|
||||
if (!N0->hasOneUse() || !N1->hasOneUse())
|
||||
if (!N0.hasOneUse() || !N1.hasOneUse())
|
||||
return SDValue();
|
||||
ConstantSDNode *Mask0 = isConstOrConstSplat(N0.getOperand(1));
|
||||
ConstantSDNode *Mask1 = isConstOrConstSplat(N1.getOperand(1));
|
||||
|
|
@ -5810,7 +5808,7 @@ SDValue DAGCombiner::visitORLike(SDValue N0, SDValue N1, SDNode *N) {
|
|||
// (or (and X, C1), (and Y, C2)) -> (and (or X, Y), C3) if possible.
|
||||
if (N0.getOpcode() == ISD::AND && N1.getOpcode() == ISD::AND &&
|
||||
// Don't increase # computations.
|
||||
(N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
|
||||
(N0.hasOneUse() || N1.hasOneUse())) {
|
||||
// We can only do this xform if we know that bits from X that are set in C2
|
||||
// but not in C1 are already zero. Likewise for Y.
|
||||
if (const ConstantSDNode *N0O1C =
|
||||
|
|
@ -5838,7 +5836,7 @@ SDValue DAGCombiner::visitORLike(SDValue N0, SDValue N1, SDNode *N) {
|
|||
N1.getOpcode() == ISD::AND &&
|
||||
N0.getOperand(0) == N1.getOperand(0) &&
|
||||
// Don't increase # computations.
|
||||
(N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
|
||||
(N0.hasOneUse() || N1.hasOneUse())) {
|
||||
SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
|
||||
N0.getOperand(1), N1.getOperand(1));
|
||||
return DAG.getNode(ISD::AND, DL, VT, N0.getOperand(0), X);
|
||||
|
|
@ -6002,7 +6000,7 @@ SDValue DAGCombiner::visitOR(SDNode *N) {
|
|||
auto MatchIntersect = [](ConstantSDNode *C1, ConstantSDNode *C2) {
|
||||
return !C1 || !C2 || C1->getAPIntValue().intersects(C2->getAPIntValue());
|
||||
};
|
||||
if (N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
|
||||
if (N0.getOpcode() == ISD::AND && N0.hasOneUse() &&
|
||||
ISD::matchBinaryPredicate(N0.getOperand(1), N1, MatchIntersect, true)) {
|
||||
if (SDValue COR = DAG.FoldConstantArithmetic(ISD::OR, SDLoc(N1), VT,
|
||||
{N1, N0.getOperand(1)})) {
|
||||
|
|
@ -7874,8 +7872,7 @@ SDValue DAGCombiner::visitSHL(SDNode *N) {
|
|||
// Variant of version done on multiply, except mul by a power of 2 is turned
|
||||
// into a shift.
|
||||
if ((N0.getOpcode() == ISD::ADD || N0.getOpcode() == ISD::OR) &&
|
||||
N0.getNode()->hasOneUse() &&
|
||||
isConstantOrConstantVector(N1, /* No Opaques */ true) &&
|
||||
N0.hasOneUse() && isConstantOrConstantVector(N1, /* No Opaques */ true) &&
|
||||
isConstantOrConstantVector(N0.getOperand(1), /* No Opaques */ true) &&
|
||||
TLI.isDesirableToCommuteWithShift(N, Level)) {
|
||||
SDValue Shl0 = DAG.getNode(ISD::SHL, SDLoc(N0), VT, N0.getOperand(0), N1);
|
||||
|
|
@ -7886,7 +7883,7 @@ SDValue DAGCombiner::visitSHL(SDNode *N) {
|
|||
}
|
||||
|
||||
// fold (shl (mul x, c1), c2) -> (mul x, c1 << c2)
|
||||
if (N0.getOpcode() == ISD::MUL && N0.getNode()->hasOneUse() &&
|
||||
if (N0.getOpcode() == ISD::MUL && N0.hasOneUse() &&
|
||||
isConstantOrConstantVector(N1, /* No Opaques */ true) &&
|
||||
isConstantOrConstantVector(N0.getOperand(1), /* No Opaques */ true)) {
|
||||
SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N1), VT, N0.getOperand(1), N1);
|
||||
|
|
@ -8805,7 +8802,7 @@ SDValue DAGCombiner::visitSELECT(SDNode *N) {
|
|||
TLI.shouldNormalizeToSelectSequence(*DAG.getContext(), VT);
|
||||
// select (and Cond0, Cond1), X, Y
|
||||
// -> select Cond0, (select Cond1, X, Y), Y
|
||||
if (N0->getOpcode() == ISD::AND && N0->hasOneUse()) {
|
||||
if (N0.getOpcode() == ISD::AND && N0.hasOneUse()) {
|
||||
SDValue Cond0 = N0->getOperand(0);
|
||||
SDValue Cond1 = N0->getOperand(1);
|
||||
SDValue InnerSelect =
|
||||
|
|
@ -8818,7 +8815,7 @@ SDValue DAGCombiner::visitSELECT(SDNode *N) {
|
|||
recursivelyDeleteUnusedNodes(InnerSelect.getNode());
|
||||
}
|
||||
// select (or Cond0, Cond1), X, Y -> select Cond0, X, (select Cond1, X, Y)
|
||||
if (N0->getOpcode() == ISD::OR && N0->hasOneUse()) {
|
||||
if (N0.getOpcode() == ISD::OR && N0.hasOneUse()) {
|
||||
SDValue Cond0 = N0->getOperand(0);
|
||||
SDValue Cond1 = N0->getOperand(1);
|
||||
SDValue InnerSelect = DAG.getNode(ISD::SELECT, DL, N1.getValueType(),
|
||||
|
|
@ -8832,7 +8829,7 @@ SDValue DAGCombiner::visitSELECT(SDNode *N) {
|
|||
}
|
||||
|
||||
// select Cond0, (select Cond1, X, Y), Y -> select (and Cond0, Cond1), X, Y
|
||||
if (N1->getOpcode() == ISD::SELECT && N1->hasOneUse()) {
|
||||
if (N1.getOpcode() == ISD::SELECT && N1.hasOneUse()) {
|
||||
SDValue N1_0 = N1->getOperand(0);
|
||||
SDValue N1_1 = N1->getOperand(1);
|
||||
SDValue N1_2 = N1->getOperand(2);
|
||||
|
|
@ -8851,7 +8848,7 @@ SDValue DAGCombiner::visitSELECT(SDNode *N) {
|
|||
}
|
||||
}
|
||||
// select Cond0, X, (select Cond1, X, Y) -> select (or Cond0, Cond1), X, Y
|
||||
if (N2->getOpcode() == ISD::SELECT && N2->hasOneUse()) {
|
||||
if (N2.getOpcode() == ISD::SELECT && N2.hasOneUse()) {
|
||||
SDValue N2_0 = N2->getOperand(0);
|
||||
SDValue N2_1 = N2->getOperand(1);
|
||||
SDValue N2_2 = N2->getOperand(2);
|
||||
|
|
@ -11018,7 +11015,7 @@ SDValue DAGCombiner::visitTRUNCATE(SDNode *N) {
|
|||
// creates this pattern) and before operation legalization after which
|
||||
// we need to be more careful about the vector instructions that we generate.
|
||||
if (N0.getOpcode() == ISD::EXTRACT_VECTOR_ELT &&
|
||||
LegalTypes && !LegalOperations && N0->hasOneUse() && VT != MVT::i1) {
|
||||
LegalTypes && !LegalOperations && N0.hasOneUse() && VT != MVT::i1) {
|
||||
EVT VecTy = N0.getOperand(0).getValueType();
|
||||
EVT ExTy = N0.getValueType();
|
||||
EVT TrTy = N->getValueType(0);
|
||||
|
|
@ -11397,7 +11394,7 @@ SDValue DAGCombiner::visitBITCAST(SDNode *N) {
|
|||
(!LegalTypes ||
|
||||
(!LegalOperations && VT.isInteger() && N0.getValueType().isInteger() &&
|
||||
TLI.isTypeLegal(VT.getVectorElementType()))) &&
|
||||
N0.getOpcode() == ISD::BUILD_VECTOR && N0.getNode()->hasOneUse() &&
|
||||
N0.getOpcode() == ISD::BUILD_VECTOR && N0.hasOneUse() &&
|
||||
cast<BuildVectorSDNode>(N0)->isConstant())
|
||||
return ConstantFoldBITCASTofBUILD_VECTOR(N0.getNode(),
|
||||
VT.getVectorElementType());
|
||||
|
|
@ -11465,7 +11462,7 @@ SDValue DAGCombiner::visitBITCAST(SDNode *N) {
|
|||
// This often reduces constant pool loads.
|
||||
if (((N0.getOpcode() == ISD::FNEG && !TLI.isFNegFree(N0.getValueType())) ||
|
||||
(N0.getOpcode() == ISD::FABS && !TLI.isFAbsFree(N0.getValueType()))) &&
|
||||
N0.getNode()->hasOneUse() && VT.isInteger() &&
|
||||
N0.hasOneUse() && VT.isInteger() &&
|
||||
!VT.isVector() && !N0.getValueType().isVector()) {
|
||||
SDValue NewConv = DAG.getBitcast(VT, N0.getOperand(0));
|
||||
AddToWorklist(NewConv.getNode());
|
||||
|
|
@ -11514,7 +11511,7 @@ SDValue DAGCombiner::visitBITCAST(SDNode *N) {
|
|||
// (xor (bitcast cst), (bitcast x)), 0),
|
||||
// signbit)
|
||||
// (xor (bitcast cst) (build_pair flipbit, flipbit))
|
||||
if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse() &&
|
||||
if (N0.getOpcode() == ISD::FCOPYSIGN && N0.hasOneUse() &&
|
||||
isa<ConstantFPSDNode>(N0.getOperand(0)) &&
|
||||
VT.isInteger() && !VT.isVector()) {
|
||||
unsigned OrigXWidth = N0.getOperand(1).getValueSizeInBits();
|
||||
|
|
@ -11818,14 +11815,14 @@ SDValue DAGCombiner::visitFADDForFMACombine(SDNode *N) {
|
|||
}
|
||||
|
||||
// fold (fadd (fmul x, y), z) -> (fma x, y, z)
|
||||
if (isContractableFMUL(N0) && (Aggressive || N0->hasOneUse())) {
|
||||
if (isContractableFMUL(N0) && (Aggressive || N0.hasOneUse())) {
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
N0.getOperand(0), N0.getOperand(1), N1, Flags);
|
||||
}
|
||||
|
||||
// fold (fadd x, (fmul y, z)) -> (fma y, z, x)
|
||||
// Note: Commutes FADD operands.
|
||||
if (isContractableFMUL(N1) && (Aggressive || N1->hasOneUse())) {
|
||||
if (isContractableFMUL(N1) && (Aggressive || N1.hasOneUse())) {
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
N1.getOperand(0), N1.getOperand(1), N0, Flags);
|
||||
}
|
||||
|
|
@ -11867,7 +11864,7 @@ SDValue DAGCombiner::visitFADDForFMACombine(SDNode *N) {
|
|||
if (CanFuse &&
|
||||
N0.getOpcode() == PreferredFusedOpcode &&
|
||||
N0.getOperand(2).getOpcode() == ISD::FMUL &&
|
||||
N0->hasOneUse() && N0.getOperand(2)->hasOneUse()) {
|
||||
N0.hasOneUse() && N0.getOperand(2).hasOneUse()) {
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
N0.getOperand(0), N0.getOperand(1),
|
||||
DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
|
|
@ -11880,7 +11877,7 @@ SDValue DAGCombiner::visitFADDForFMACombine(SDNode *N) {
|
|||
if (CanFuse &&
|
||||
N1->getOpcode() == PreferredFusedOpcode &&
|
||||
N1.getOperand(2).getOpcode() == ISD::FMUL &&
|
||||
N1->hasOneUse() && N1.getOperand(2)->hasOneUse()) {
|
||||
N1.hasOneUse() && N1.getOperand(2).hasOneUse()) {
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
N1.getOperand(0), N1.getOperand(1),
|
||||
DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
|
|
@ -12031,7 +12028,7 @@ SDValue DAGCombiner::visitFSUBForFMACombine(SDNode *N) {
|
|||
|
||||
// fold (fsub (fmul x, y), z) -> (fma x, y, (fneg z))
|
||||
auto tryToFoldXYSubZ = [&](SDValue XY, SDValue Z) {
|
||||
if (isContractableFMUL(XY) && (Aggressive || XY->hasOneUse())) {
|
||||
if (isContractableFMUL(XY) && (Aggressive || XY.hasOneUse())) {
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT, XY.getOperand(0),
|
||||
XY.getOperand(1), DAG.getNode(ISD::FNEG, SL, VT, Z),
|
||||
Flags);
|
||||
|
|
@ -12042,7 +12039,7 @@ SDValue DAGCombiner::visitFSUBForFMACombine(SDNode *N) {
|
|||
// fold (fsub x, (fmul y, z)) -> (fma (fneg y), z, x)
|
||||
// Note: Commutes FSUB operands.
|
||||
auto tryToFoldXSubYZ = [&](SDValue X, SDValue YZ) {
|
||||
if (isContractableFMUL(YZ) && (Aggressive || YZ->hasOneUse())) {
|
||||
if (isContractableFMUL(YZ) && (Aggressive || YZ.hasOneUse())) {
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
DAG.getNode(ISD::FNEG, SL, VT, YZ.getOperand(0)),
|
||||
YZ.getOperand(1), X, Flags);
|
||||
|
|
@ -12071,7 +12068,7 @@ SDValue DAGCombiner::visitFSUBForFMACombine(SDNode *N) {
|
|||
|
||||
// fold (fsub (fneg (fmul, x, y)), z) -> (fma (fneg x), y, (fneg z))
|
||||
if (N0.getOpcode() == ISD::FNEG && isContractableFMUL(N0.getOperand(0)) &&
|
||||
(Aggressive || (N0->hasOneUse() && N0.getOperand(0).hasOneUse()))) {
|
||||
(Aggressive || (N0.hasOneUse() && N0.getOperand(0).hasOneUse()))) {
|
||||
SDValue N00 = N0.getOperand(0).getOperand(0);
|
||||
SDValue N01 = N0.getOperand(0).getOperand(1);
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
|
|
@ -12168,8 +12165,8 @@ SDValue DAGCombiner::visitFSUBForFMACombine(SDNode *N) {
|
|||
// fold (fsub (fma x, y, (fmul u, v)), z)
|
||||
// -> (fma x, y (fma u, v, (fneg z)))
|
||||
if (CanFuse && N0.getOpcode() == PreferredFusedOpcode &&
|
||||
isContractableFMUL(N0.getOperand(2)) && N0->hasOneUse() &&
|
||||
N0.getOperand(2)->hasOneUse()) {
|
||||
isContractableFMUL(N0.getOperand(2)) && N0.hasOneUse() &&
|
||||
N0.getOperand(2).hasOneUse()) {
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
N0.getOperand(0), N0.getOperand(1),
|
||||
DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
|
|
@ -12183,7 +12180,7 @@ SDValue DAGCombiner::visitFSUBForFMACombine(SDNode *N) {
|
|||
// -> (fma (fneg y), z, (fma (fneg u), v, x))
|
||||
if (CanFuse && N1.getOpcode() == PreferredFusedOpcode &&
|
||||
isContractableFMUL(N1.getOperand(2)) &&
|
||||
N1->hasOneUse() && NoSignedZero) {
|
||||
N1.hasOneUse() && NoSignedZero) {
|
||||
SDValue N20 = N1.getOperand(2).getOperand(0);
|
||||
SDValue N21 = N1.getOperand(2).getOperand(1);
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
|
|
@ -12199,7 +12196,7 @@ SDValue DAGCombiner::visitFSUBForFMACombine(SDNode *N) {
|
|||
// fold (fsub (fma x, y, (fpext (fmul u, v))), z)
|
||||
// -> (fma x, y (fma (fpext u), (fpext v), (fneg z)))
|
||||
if (N0.getOpcode() == PreferredFusedOpcode &&
|
||||
N0->hasOneUse()) {
|
||||
N0.hasOneUse()) {
|
||||
SDValue N02 = N0.getOperand(2);
|
||||
if (N02.getOpcode() == ISD::FP_EXTEND) {
|
||||
SDValue N020 = N02.getOperand(0);
|
||||
|
|
@ -12252,7 +12249,7 @@ SDValue DAGCombiner::visitFSUBForFMACombine(SDNode *N) {
|
|||
// -> (fma (fneg y), z, (fma (fneg (fpext u)), (fpext v), x))
|
||||
if (N1.getOpcode() == PreferredFusedOpcode &&
|
||||
N1.getOperand(2).getOpcode() == ISD::FP_EXTEND &&
|
||||
N1->hasOneUse()) {
|
||||
N1.hasOneUse()) {
|
||||
SDValue N120 = N1.getOperand(2).getOperand(0);
|
||||
if (isContractableFMUL(N120) &&
|
||||
TLI.isFPExtFoldable(DAG, PreferredFusedOpcode, VT,
|
||||
|
|
@ -12349,7 +12346,7 @@ SDValue DAGCombiner::visitFMULForFMADistributiveCombine(SDNode *N) {
|
|||
// fold (fmul (fadd x0, +1.0), y) -> (fma x0, y, y)
|
||||
// fold (fmul (fadd x0, -1.0), y) -> (fma x0, y, (fneg y))
|
||||
auto FuseFADD = [&](SDValue X, SDValue Y, const SDNodeFlags Flags) {
|
||||
if (X.getOpcode() == ISD::FADD && (Aggressive || X->hasOneUse())) {
|
||||
if (X.getOpcode() == ISD::FADD && (Aggressive || X.hasOneUse())) {
|
||||
if (auto *C = isConstOrConstSplatFP(X.getOperand(1), true)) {
|
||||
if (C->isExactlyValue(+1.0))
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y,
|
||||
|
|
@ -12372,7 +12369,7 @@ SDValue DAGCombiner::visitFMULForFMADistributiveCombine(SDNode *N) {
|
|||
// fold (fmul (fsub x0, +1.0), y) -> (fma x0, y, (fneg y))
|
||||
// fold (fmul (fsub x0, -1.0), y) -> (fma x0, y, y)
|
||||
auto FuseFSUB = [&](SDValue X, SDValue Y, const SDNodeFlags Flags) {
|
||||
if (X.getOpcode() == ISD::FSUB && (Aggressive || X->hasOneUse())) {
|
||||
if (X.getOpcode() == ISD::FSUB && (Aggressive || X.hasOneUse())) {
|
||||
if (auto *C0 = isConstOrConstSplatFP(X.getOperand(0), true)) {
|
||||
if (C0->isExactlyValue(+1.0))
|
||||
return DAG.getNode(PreferredFusedOpcode, SL, VT,
|
||||
|
|
@ -13538,7 +13535,7 @@ SDValue DAGCombiner::visitFP_ROUND(SDNode *N) {
|
|||
}
|
||||
|
||||
// fold (fp_round (copysign X, Y)) -> (copysign (fp_round X), Y)
|
||||
if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse()) {
|
||||
if (N0.getOpcode() == ISD::FCOPYSIGN && N0.hasOneUse()) {
|
||||
SDValue Tmp = DAG.getNode(ISD::FP_ROUND, SDLoc(N0), VT,
|
||||
N0.getOperand(0), N1);
|
||||
AddToWorklist(Tmp.getNode());
|
||||
|
|
@ -13677,9 +13674,7 @@ SDValue DAGCombiner::visitFNEG(SDNode *N) {
|
|||
|
||||
// Transform fneg(bitconvert(x)) -> bitconvert(x ^ sign) to avoid loading
|
||||
// constant pool values.
|
||||
if (!TLI.isFNegFree(VT) &&
|
||||
N0.getOpcode() == ISD::BITCAST &&
|
||||
N0.getNode()->hasOneUse()) {
|
||||
if (!TLI.isFNegFree(VT) && N0.getOpcode() == ISD::BITCAST && N0.hasOneUse()) {
|
||||
SDValue Int = N0.getOperand(0);
|
||||
EVT IntVT = Int.getValueType();
|
||||
if (IntVT.isInteger() && !IntVT.isVector()) {
|
||||
|
|
@ -13702,8 +13697,7 @@ SDValue DAGCombiner::visitFNEG(SDNode *N) {
|
|||
}
|
||||
|
||||
// (fneg (fmul c, x)) -> (fmul -c, x)
|
||||
if (N0.getOpcode() == ISD::FMUL &&
|
||||
(N0.getNode()->hasOneUse() || !TLI.isFNegFree(VT))) {
|
||||
if (N0.getOpcode() == ISD::FMUL && (N0.hasOneUse() || !TLI.isFNegFree(VT))) {
|
||||
ConstantFPSDNode *CFP1 = dyn_cast<ConstantFPSDNode>(N0.getOperand(1));
|
||||
if (CFP1) {
|
||||
APFloat CVal = CFP1->getValueAPF();
|
||||
|
|
@ -15598,7 +15592,7 @@ bool DAGCombiner::isMulAddWithConstProfitable(SDNode *MulNode,
|
|||
APInt Val;
|
||||
|
||||
// If the add only has one use, this would be OK to do.
|
||||
if (AddNode.getNode()->hasOneUse())
|
||||
if (AddNode.hasOneUse())
|
||||
return true;
|
||||
|
||||
// Walk all the users of the constant with which we're multiplying.
|
||||
|
|
@ -16846,7 +16840,7 @@ SDValue DAGCombiner::visitSTORE(SDNode *N) {
|
|||
// If this is an FP_ROUND or TRUNC followed by a store, fold this into a
|
||||
// truncating store. We can do this even if this is already a truncstore.
|
||||
if ((Value.getOpcode() == ISD::FP_ROUND || Value.getOpcode() == ISD::TRUNCATE)
|
||||
&& Value.getNode()->hasOneUse() && ST->isUnindexed() &&
|
||||
&& Value.hasOneUse() && ST->isUnindexed() &&
|
||||
TLI.isTruncStoreLegal(Value.getOperand(0).getValueType(),
|
||||
ST->getMemoryVT())) {
|
||||
return DAG.getTruncStore(Chain, SDLoc(N), Value.getOperand(0),
|
||||
|
|
@ -18919,7 +18913,7 @@ static SDValue narrowExtractedVectorBinOp(SDNode *Extract, SelectionDAG &DAG) {
|
|||
unsigned ConcatOpNum = ExtractIndex / VT.getVectorNumElements();
|
||||
unsigned ExtBOIdx = ConcatOpNum * NarrowBVT.getVectorNumElements();
|
||||
if (TLI.isExtractSubvectorCheap(NarrowBVT, WideBVT, ExtBOIdx) &&
|
||||
BinOp.hasOneUse() && Extract->getOperand(0)->hasOneUse()) {
|
||||
BinOp.hasOneUse() && Extract->getOperand(0).hasOneUse()) {
|
||||
// extract (binop B0, B1), N --> binop (extract B0, N), (extract B1, N)
|
||||
SDLoc DL(Extract);
|
||||
SDValue NewExtIndex = DAG.getVectorIdxConstant(ExtBOIdx, DL);
|
||||
|
|
@ -19345,13 +19339,13 @@ static SDValue combineShuffleOfScalars(ShuffleVectorSDNode *SVN,
|
|||
SDValue N0 = SVN->getOperand(0);
|
||||
SDValue N1 = SVN->getOperand(1);
|
||||
|
||||
if (!N0->hasOneUse())
|
||||
if (!N0.hasOneUse())
|
||||
return SDValue();
|
||||
|
||||
// If only one of N1,N2 is constant, bail out if it is not ALL_ZEROS as
|
||||
// discussed above.
|
||||
if (!N1.isUndef()) {
|
||||
if (!N1->hasOneUse())
|
||||
if (!N1.hasOneUse())
|
||||
return SDValue();
|
||||
|
||||
bool N0AnyConst = isAnyConstantBuildVector(N0);
|
||||
|
|
|
|||
Loading…
Reference in New Issue