Lines Matching defs:N1
291 SDValue SimplifySelect(SDLoc DL, SDValue N0, SDValue N1, SDValue N2);
292 SDValue SimplifySelectCC(SDLoc DL, SDValue N0, SDValue N1, SDValue N2,
295 SDValue SimplifySetCC(EVT VT, SDValue N0, SDValue N1, ISD::CondCode Cond,
308 SDValue MatchBSwapHWordLow(SDNode *N, SDValue N0, SDValue N1,
310 SDValue MatchBSwapHWord(SDNode *N, SDValue N0, SDValue N1);
619 SDValue N0, N1, N2;
620 if (isSetCCEquivalent(N, N0, N1, N2) && N.getNode()->hasOneUse())
673 SDValue N0, SDValue N1) {
677 if (SDNode *R = isConstantBuildVectorOrConstantInt(N1)) {
687 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N0.getOperand(0), N1);
696 if (N1.getOpcode() == Opc) {
697 if (SDNode *R = isConstantBuildVectorOrConstantInt(N1.getOperand(1))) {
703 return DAG.getNode(Opc, DL, VT, N1.getOperand(0), OpNode);
705 if (N1.hasOneUse()) {
708 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N1.getOperand(0), N0);
712 return DAG.getNode(Opc, DL, VT, OpNode, N1.getOperand(1));
927 SDValue N1 = Op.getOperand(1);
929 if (N0 == N1)
932 NN1 = PromoteOperand(N1, PVT, Replace1);
944 ReplaceLoadWithPromotedLoad(N1.getNode(), NN1.getNode());
1328 SDValue N1 = N->getOperand(1);
1331 if (isa<ConstantSDNode>(N0) || !isa<ConstantSDNode>(N1)) {
1332 SDValue Ops[] = {N1, N0};
1460 SDValue combineShlAddConstant(SDLoc DL, SDValue N0, SDValue N1,
1475 return DAG.getNode(ISD::ADD, DL, VT, N0, N1);
1483 SDValue N1 = N->getOperand(1);
1485 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
1494 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1497 return N1;
1503 if (N1.getOpcode() == ISD::UNDEF)
1504 return N1;
1510 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N1, N0);
1529 SDValue RADD = ReassociateOps(ISD::ADD, SDLoc(N), N0, N1);
1535 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1, N0.getOperand(1));
1537 if (N1.getOpcode() == ISD::SUB && isa<ConstantSDNode>(N1.getOperand(0)) &&
1538 cast<ConstantSDNode>(N1.getOperand(0))->isNullValue())
1539 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1.getOperand(1));
1541 if (N1.getOpcode() == ISD::SUB && N0 == N1.getOperand(1))
1542 return N1.getOperand(0);
1544 if (N0.getOpcode() == ISD::SUB && N1 == N0.getOperand(1))
1547 if (N1.getOpcode() == ISD::SUB && N1.getOperand(1).getOpcode() == ISD::ADD &&
1548 N0 == N1.getOperand(1).getOperand(0))
1549 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1550 N1.getOperand(1).getOperand(1));
1552 if (N1.getOpcode() == ISD::SUB && N1.getOperand(1).getOpcode() == ISD::ADD &&
1553 N0 == N1.getOperand(1).getOperand(1))
1554 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1555 N1.getOperand(1).getOperand(0));
1557 if ((N1.getOpcode() == ISD::SUB || N1.getOpcode() == ISD::ADD) &&
1558 N1.getOperand(0).getOpcode() == ISD::SUB &&
1559 N0 == N1.getOperand(0).getOperand(1))
1560 return DAG.getNode(N1.getOpcode(), SDLoc(N), VT,
1561 N1.getOperand(0).getOperand(0), N1.getOperand(1));
1564 if (N0.getOpcode() == ISD::SUB && N1.getOpcode() == ISD::SUB) {
1567 SDValue N10 = N1.getOperand(0);
1568 SDValue N11 = N1.getOperand(1);
1573 DAG.getNode(ISD::ADD, SDLoc(N1), VT, N01, N11));
1586 DAG.computeKnownBits(N1, RHSZero, RHSOne);
1592 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1);
1599 SDValue Result = combineShlAddConstant(SDLoc(N), N0, N1, DAG);
1602 if (N1.getOpcode() == ISD::SHL && N1.getNode()->hasOneUse()) {
1603 SDValue Result = combineShlAddConstant(SDLoc(N), N1, N0, DAG);
1608 if (N1.getOpcode() == ISD::SHL &&
1609 N1.getOperand(0).getOpcode() == ISD::SUB)
1611 dyn_cast<ConstantSDNode>(N1.getOperand(0).getOperand(0)))
1615 N1.getOperand(0).getOperand(1),
1616 N1.getOperand(1)));
1622 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1,
1627 if (N1.getOpcode() == ISD::AND) {
1628 SDValue AndOp0 = N1.getOperand(0);
1629 ConstantSDNode *AndOp1 = dyn_cast<ConstantSDNode>(N1->getOperand(1));
1647 return DAG.getNode(ISD::SUB, DL, VT, N1, ZExt);
1655 SDValue N1 = N->getOperand(1);
1657 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
1662 return CombineTo(N, DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N1),
1668 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N1, N0);
1681 DAG.computeKnownBits(N1, RHSZero, RHSOne);
1686 return CombineTo(N, DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1),
1696 SDValue N1 = N->getOperand(1);
1699 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
1704 N1, N0, CarryIn);
1708 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N0, N1);
1727 SDValue N1 = N->getOperand(1);
1729 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
1730 ConstantSDNode *N1C1 = N1.getOpcode() != ISD::ADD ? nullptr :
1731 dyn_cast<ConstantSDNode>(N1.getOperand(1).getNode());
1740 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1746 if (N0 == N1)
1757 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
1759 if (N1.getOpcode() == ISD::SUB && N0 == N1.getOperand(0))
1760 return N1.getOperand(1);
1762 if (N0.getOpcode() == ISD::ADD && N0.getOperand(0) == N1)
1765 if (N0.getOpcode() == ISD::ADD && N0.getOperand(1) == N1)
1768 if (N1.getOpcode() == ISD::ADD && N0C && N1C1) {
1772 N1.getOperand(0));
1778 N0.getOperand(1).getOperand(0) == N1)
1784 N0.getOperand(1).getOperand(1) == N1)
1790 N0.getOperand(1).getOperand(1) == N1)
1797 if (N1.getOpcode() == ISD::UNDEF)
1798 return N1;
1809 if (GlobalAddressSDNode *GB = dyn_cast<GlobalAddressSDNode>(N1))
1820 SDValue N1 = N->getOperand(1);
1822 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
1827 return CombineTo(N, DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1),
1832 if (N0 == N1)
1844 return CombineTo(N, DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0),
1853 SDValue N1 = N->getOperand(1);
1858 return DAG.getNode(ISD::SUBC, SDLoc(N), N->getVTList(), N0, N1);
1865 SDValue N1 = N->getOperand(1);
1869 if (N0.getOpcode() == ISD::UNDEF || N1.getOpcode() == ISD::UNDEF)
1881 N1IsConst = isConstantSplatVector(N1.getNode(), ConstValue1);
1886 N1IsConst = dyn_cast<ConstantSDNode>(N1) != nullptr;
1887 ConstValue1 = N1IsConst ? (dyn_cast<ConstantSDNode>(N1))->getAPIntValue()
1893 return DAG.FoldConstantArithmetic(ISD::MUL, VT, N0.getNode(), N1.getNode());
1897 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N1, N0);
1900 return N1;
1935 N1, N0.getOperand(1));
1950 Sh = N0; Y = N1;
1951 } else if (N1.getOpcode() == ISD::SHL &&
1952 isa<ConstantSDNode>(N1.getOperand(1)) &&
1953 N1.getNode()->hasOneUse()) {
1954 Sh = N1; Y = N0;
1971 N0.getOperand(0), N1),
1972 DAG.getNode(ISD::MUL, SDLoc(N1), VT,
1973 N0.getOperand(1), N1));
1976 SDValue RMUL = ReassociateOps(ISD::MUL, SDLoc(N), N0, N1);
1985 SDValue N1 = N->getOperand(1);
1987 ConstantSDNode *N1C = isConstOrConstSplat(N1);
2009 if (DAG.SignBitIsZero(N1) && DAG.SignBitIsZero(N0))
2010 return DAG.getNode(ISD::UDIV, SDLoc(N), N1.getValueType(),
2011 N0, N1);
2062 if (N1.getOpcode() == ISD::UNDEF)
2063 return N1;
2070 SDValue N1 = N->getOperand(1);
2072 ConstantSDNode *N1C = isConstOrConstSplat(N1);
2090 if (N1.getOpcode() == ISD::SHL) {
2091 if (ConstantSDNode *SHC = dyn_cast<ConstantSDNode>(N1.getOperand(0))) {
2093 EVT ADDVT = N1.getOperand(1).getValueType();
2095 N1.getOperand(1),
2114 if (N1.getOpcode() == ISD::UNDEF)
2115 return N1;
2122 SDValue N1 = N->getOperand(1);
2124 ConstantSDNode *N1C = isConstOrConstSplat(N1);
2133 if (DAG.SignBitIsZero(N1) && DAG.SignBitIsZero(N0))
2134 return DAG.getNode(ISD::UREM, SDLoc(N), VT, N0, N1);
2140 SDValue Div = DAG.getNode(ISD::SDIV, SDLoc(N), VT, N0, N1);
2145 OptimizedDiv, N1);
2156 if (N1.getOpcode() == ISD::UNDEF)
2157 return N1;
2164 SDValue N1 = N->getOperand(1);
2166 ConstantSDNode *N1C = isConstOrConstSplat(N1);
2177 if (N1.getOpcode() == ISD::SHL) {
2178 if (ConstantSDNode *SHC = dyn_cast<ConstantSDNode>(N1.getOperand(0))) {
2181 DAG.getNode(ISD::ADD, SDLoc(N), VT, N1,
2193 SDValue Div = DAG.getNode(ISD::UDIV, SDLoc(N), VT, N0, N1);
2198 OptimizedDiv, N1);
2209 if (N1.getOpcode() == ISD::UNDEF)
2210 return N1;
2217 SDValue N1 = N->getOperand(1);
2218 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
2224 return N1;
2231 if (N0.getOpcode() == ISD::UNDEF || N1.getOpcode() == ISD::UNDEF)
2242 N1 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N1);
2243 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2244 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2245 DAG.getConstant(SimpleSize, getShiftAmountTy(N1.getValueType())));
2246 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2255 SDValue N1 = N->getOperand(1);
2256 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
2262 return N1;
2267 if (N0.getOpcode() == ISD::UNDEF || N1.getOpcode() == ISD::UNDEF)
2278 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N1);
2279 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2280 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2281 DAG.getConstant(SimpleSize, getShiftAmountTy(N1.getValueType())));
2282 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2362 // Compute the high part as N1.
2392 // Compute the high part as N1.
2442 SDValue N0 = N->getOperand(0), N1 = N->getOperand(1);
2444 assert(N0.getOpcode() == N1.getOpcode() && "Bad input!");
2468 Op0VT == N1.getOperand(0).getValueType() &&
2472 N0.getOperand(0), N1.getOperand(0));
2483 N0.getOperand(1) == N1.getOperand(1)) {
2486 N0.getOperand(0), N1.getOperand(0));
2503 SDValue In1 = N1.getOperand(0);
2531 ShuffleVectorSDNode *SVN1 = cast<ShuffleVectorSDNode>(N1);
2533 assert(N0.getOperand(0).getValueType() == N1.getOperand(0).getValueType() &&
2556 if (N0.getOperand(1) == N1.getOperand(1) && ShOp.getNode()) {
2558 N0->getOperand(0), N1->getOperand(0));
2577 if (N0->getOperand(0) == N1->getOperand(0) && ShOp.getNode()) {
2579 N0->getOperand(1), N1->getOperand(1));
2592 SDValue N1 = N->getOperand(1);
2595 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
2596 EVT VT = N1.getValueType();
2607 if (ISD::isBuildVectorAllZeros(N1.getNode()))
2608 return N1;
2612 return N1;
2613 if (ISD::isBuildVectorAllOnes(N1.getNode()))
2618 if (N0.getOpcode() == ISD::UNDEF || N1.getOpcode() == ISD::UNDEF)
2625 return DAG.getNode(ISD::AND, SDLoc(N), VT, N1, N0);
2634 SDValue RAND = ReassociateOps(ISD::AND, SDLoc(N), N0, N1);
2641 return N1;
2677 if (const ConstantSDNode *C = dyn_cast<ConstantSDNode>(N1)) {
2679 } else if (BuildVectorSDNode *Vector = dyn_cast<BuildVectorSDNode>(N1)) {
2761 if (isSetCCEquivalent(N0, LL, LR, CC0) && isSetCCEquivalent(N1, RL, RR, CC1)){
2821 if (N0.getOpcode() == N1.getOpcode()) {
2838 unsigned BitWidth = N1.getValueType().getScalarType().getSizeInBits();
2839 if (DAG.MaskedValueIsZero(N1, APInt::getHighBitsSet(BitWidth,
2858 unsigned BitWidth = N1.getValueType().getScalarType().getSizeInBits();
2859 if (DAG.MaskedValueIsZero(N1, APInt::getHighBitsSet(BitWidth,
2941 if (N0.getOpcode() == ISD::ADD && N1.getOpcode() == ISD::SRL &&
2950 if (ConstantSDNode *SRLI = dyn_cast<ConstantSDNode>(N1.getOperand(1))) {
2981 SDValue DAGCombiner::MatchBSwapHWordLow(SDNode *N, SDValue N0, SDValue N1,
2996 std::swap(N0, N1);
2997 if (N1.getOpcode() == ISD::AND && N1.getOperand(0).getOpcode() == ISD::SHL)
2998 std::swap(N0, N1);
3009 if (N1.getOpcode() == ISD::AND) {
3010 if (!N1.getNode()->hasOneUse())
3012 ConstantSDNode *N11C = dyn_cast<ConstantSDNode>(N1.getOperand(1));
3015 N1 = N1.getOperand(0);
3019 if (N0.getOpcode() == ISD::SRL && N1.getOpcode() == ISD::SHL)
3020 std::swap(N0, N1);
3021 if (N0.getOpcode() != ISD::SHL || N1.getOpcode() != ISD::SRL)
3024 !N1.getNode()->hasOneUse())
3028 ConstantSDNode *N11C = dyn_cast<ConstantSDNode>(N1.getOperand(1));
3046 SDValue N10 = N1->getOperand(0);
3158 SDValue DAGCombiner::MatchBSwapHWord(SDNode *N, SDValue N0, SDValue N1) {
3177 if (N1.getOpcode() == ISD::OR &&
3195 if (!isBSwapHWordElement(N1, Parts))
3230 SDValue N1 = N->getOperand(1);
3233 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
3234 EVT VT = N1.getValueType();
3243 return N1;
3244 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3250 if (ISD::isBuildVectorAllOnes(N1.getNode()))
3251 return N1;
3257 isa<ShuffleVectorSDNode>(N1) &&
3258 N0->getOperand(1) == N1->getOperand(1) &&
3263 const ShuffleVectorSDNode *SV1 = cast<ShuffleVectorSDNode>(N1);
3266 // and N1 as the second operand.
3267 // - Mask2 is a shuffle mask for a shuffle with N1 as the first operand
3300 N1->getOperand(0), &Mask1[0]);
3302 return DAG.getVectorShuffle(VT, SDLoc(N), N1->getOperand(0),
3310 (N0.getOpcode() == ISD::UNDEF || N1.getOpcode() == ISD::UNDEF)) {
3319 return DAG.getNode(ISD::OR, SDLoc(N), VT, N1, N0);
3325 return N1;
3328 return N1;
3331 SDValue BSwap = MatchBSwapHWord(N, N0, N1);
3334 BSwap = MatchBSwapHWordLow(N, N0, N1);
3339 SDValue ROR = ReassociateOps(ISD::OR, SDLoc(N), N0, N1);
3353 N0.getOperand(0), N1), COR);
3357 if (isSetCCEquivalent(N0, LL, LR, CC0) && isSetCCEquivalent(N1, RL, RR, CC1)){
3401 if (N0.getOpcode() == N1.getOpcode()) {
3408 N1.getOpcode() == ISD::AND &&
3410 N1.getOperand(1).getOpcode() == ISD::Constant &&
3412 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
3418 cast<ConstantSDNode>(N1.getOperand(1))->getAPIntValue();
3421 DAG.MaskedValueIsZero(N1.getOperand(0), LHSMask&~RHSMask)) {
3423 N0.getOperand(0), N1.getOperand(0));
3430 if (SDNode *Rot = MatchRotate(N0, N1, SDLoc(N)))
3697 SDValue N1 = N->getOperand(1);
3700 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
3710 return N1;
3711 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3716 if (N0.getOpcode() == ISD::UNDEF && N1.getOpcode() == ISD::UNDEF)
3721 if (N1.getOpcode() == ISD::UNDEF)
3722 return N1;
3728 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
3733 SDValue RXOR = ReassociateOps(ISD::XOR, SDLoc(N), N0, N1);
3774 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
3775 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
3786 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
3787 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
3794 N0->getOperand(1) == N1) {
3798 return DAG.getNode(ISD::AND, SDLoc(N), VT, NotX, N1);
3814 if (N0 == N1)
3818 if (N0.getOpcode() == N1.getOpcode()) {
3946 SDValue N1 = N->getOperand(1);
3948 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
3957 BuildVectorSDNode *N1CV = dyn_cast<BuildVectorSDNode>(N1);
3974 N1C = isConstOrConstSplat(N1);
3999 if (N1.getOpcode() == ISD::TRUNCATE &&
4000 N1.getOperand(0).getOpcode() == ISD::AND) {
4001 SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode());
4017 DAG.getConstant(c1 + c2, N1.getValueType()));
4042 DAG.getConstant(c1 + c2, N1.getValueType()));
4083 DAG.getConstant(c2 - c1, N1.getValueType()));
4087 DAG.getConstant(c1 - c2, N1.getValueType()));
4095 if (N1C && N0.getOpcode() == ISD::SRA && N1 == N0.getOperand(1)) {
4115 SDValue N1 = N->getOperand(1);
4117 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
4126 N1C = isConstOrConstSplat(N1);
4146 if (N1C && N0.getOpcode() == ISD::SHL && N1 == N0.getOperand(1)) {
4165 DAG.getConstant(Sum, N1.getValueType()));
4210 if (N1.getOpcode() == ISD::TRUNCATE &&
4211 N1.getOperand(0).getOpcode() == ISD::AND) {
4212 SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode());
4248 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, N1);
4261 SDValue N1 = N->getOperand(1);
4263 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
4272 N1C = isConstOrConstSplat(N1);
4300 DAG.getConstant(c1 + c2, N1.getValueType()));
4326 if (N1C && N0.getOpcode() == ISD::SHL && N0.getOperand(1) == N1) {
4360 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0), N1);
4399 if (N1.getOpcode() == ISD::TRUNCATE &&
4400 N1.getOperand(0).getOpcode() == ISD::AND) {
4401 SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode());
4506 SDValue N1 = N->getOperand(1);
4509 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1);
4515 if (N1 == N2)
4516 return N1;
4519 return N1;
4563 return DAG.getNode(ISD::OR, SDLoc(N), VT, NOTNode, N1);
4567 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
4570 if (VT == MVT::i1 && (N0 == N1 || (N1C && N1C->getAPIntValue() == 1)))
4575 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
4578 if (SimplifySelectOps(N, N1, N2))
4588 N1, N2, N0.getOperand(2));
4589 return SimplifySelect(SDLoc(N), N0, N1, N2);
4664 SDValue N1 = N->getOperand(1);
4681 N1 == LHS && N2.getOpcode() == ISD::SUB && N1 == N2.getOperand(1))
4684 N2 == LHS && N1.getOpcode() == ISD::SUB && N2 == N1.getOperand(1))
4685 isAbs = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
4727 // Fold (vselect (build_vector all_ones), N1, N2) -> N1
4729 return N1;
4730 // Fold (vselect (build_vector all_zeros), N1, N2) -> N2
4737 if (N1.getOpcode() == ISD::CONCAT_VECTORS &&
4750 SDValue N1 = N->getOperand(1);
4762 N0, N1, CC, SDLoc(N), false);
4785 return SimplifySelectCC(SDLoc(N), N0, N1, N2, N3, CC);
5830 SDValue N1 = N->getOperand(1);
5832 EVT EVT = cast<VTSDNode>(N1)->getVT();
5838 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0, N1);
5848 N0.getOperand(0), N1);
5857 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00, N1);
5928 BSwap, N1);
6465 SDValue N1 = N->getOperand(1);
6467 ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1);
6478 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N1);
6481 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N0);
6488 isNegatibleForFree(N1, LegalOperations, TLI, &DAG.getTarget().Options) == 2)
6490 GetNegatedExpression(N1, DAG, LegalOperations));
6494 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N1,
6503 N0.getOperand(1), N1));
6518 N0.getOpcode() == ISD::FNEG && N0.getOperand(0) == N1)
6523 N1.getOpcode() == ISD::FNEG && N1.getOperand(0) == N0)
6537 if (CFP00 && !CFP01 && N0.getOperand(1) == N1) {
6542 N1, NewCFP);
6546 if (CFP01 && !CFP00 && N0.getOperand(0) == N1) {
6551 N1, NewCFP);
6555 if (CFP00 && !CFP01 && N1.getOpcode() == ISD::FADD &&
6556 N1.getOperand(0) == N1.getOperand(1) &&
6557 N0.getOperand(1) == N1.getOperand(0)) {
6566 if (CFP01 && !CFP00 && N1.getOpcode() == ISD::FADD &&
6567 N1.getOperand(0) == N1.getOperand(1) &&
6568 N0.getOperand(0) == N1.getOperand(0)) {
6577 if (N1.getOpcode() == ISD::FMUL) {
6578 ConstantFPSDNode *CFP10 = dyn_cast<ConstantFPSDNode>(N1.getOperand(0));
6579 ConstantFPSDNode *CFP11 = dyn_cast<ConstantFPSDNode>(N1.getOperand(1));
6582 if (CFP10 && !CFP11 && N1.getOperand(1) == N0) {
6591 if (CFP11 && !CFP10 && N1.getOperand(0) == N0) {
6603 N1.getOperand(1) == N0.getOperand(0)) {
6608 N1.getOperand(1), NewCFP);
6614 N1.getOperand(0) == N0.getOperand(0)) {
6619 N1.getOperand(0), NewCFP);
6627 (N0.getOperand(0) == N1))
6629 N1, DAG.getConstantFP(3.0, VT));
6632 if (N1.getOpcode() == ISD::FADD && AllowNewFpConst) {
6633 ConstantFPSDNode *CFP10 = dyn_cast<ConstantFPSDNode>(N1.getOperand(0));
6635 if (!CFP10 && N1.getOperand(0) == N1.getOperand(1) &&
6636 N1.getOperand(0) == N0)
6643 N0.getOpcode() == ISD::FADD && N1.getOpcode() == ISD::FADD &&
6645 N1.getOperand(0) == N1.getOperand(1) &&
6646 N0.getOperand(0) == N1.getOperand(0))
6661 N0.getOperand(0), N0.getOperand(1), N1);
6665 if (N1.getOpcode() == ISD::FMUL && N1->hasOneUse())
6667 N1.getOperand(0), N1.getOperand(1), N0);
6675 SDValue N1 = N->getOperand(1);
6677 ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1);
6689 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N0, N1);
6697 if (isNegatibleForFree(N1, LegalOperations, TLI, &DAG.getTarget().Options))
6698 return GetNegatedExpression(N1, DAG, LegalOperations);
6700 return DAG.getNode(ISD::FNEG, dl, VT, N1);
6703 if (isNegatibleForFree(N1, LegalOperations, TLI, &DAG.getTarget().Options))
6705 GetNegatedExpression(N1, DAG, LegalOperations));
6712 if (N0 == N1)
6715 if (N1.getOpcode() == ISD::FADD) {
6716 SDValue N10 = N1->getOperand(0);
6717 SDValue N11 = N1->getOperand(1);
6739 DAG.getNode(ISD::FNEG, dl, VT, N1));
6743 if (N1.getOpcode() == ISD::FMUL && N1->hasOneUse())
6746 N1.getOperand(0)),
6747 N1.getOperand(1), N0);
6757 DAG.getNode(ISD::FNEG, dl, VT, N1));
6766 SDValue N1 = N->getOperand(1);
6768 ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1);
6780 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0, N1);
6783 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N1, N0);
6787 return N1;
6790 ISD::isBuildVectorAllZeros(N1.getNode()))
6791 return N1;
6806 if (char RHSNeg = isNegatibleForFree(N1, LegalOperations, TLI,
6813 GetNegatedExpression(N1, DAG, LegalOperations));
6823 N0.getOperand(1), N1));
6830 SDValue N1 = N->getOperand(1);
6833 ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1);
6844 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N2);
6850 return DAG.getNode(ISD::FMA, SDLoc(N), VT, N1, N0, N2);
6858 DAG.getNode(ISD::FADD, dl, VT, N1, N2.getOperand(1)));
6868 DAG.getNode(ISD::FMUL, dl, VT, N1, N0.getOperand(1)),
6890 N1, DAG.getConstantFP(1.0, VT)));
6897 N1, DAG.getConstantFP(-1.0, VT)));
6905 SDValue N1 = N->getOperand(1);
6907 ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1);
6919 return DAG.getNode(ISD::FDIV, SDLoc(N), VT, N0, N1);
6943 if (char RHSNeg = isNegatibleForFree(N1, LegalOperations, TLI,
6950 GetNegatedExpression(N1, DAG, LegalOperations));
6959 SDValue N1 = N->getOperand(1);
6961 ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1);
6966 return DAG.getNode(ISD::FREM, SDLoc(N), VT, N0, N1);
6973 SDValue N1 = N->getOperand(1);
6975 ConstantFPSDNode *N1CFP = dyn_cast<ConstantFPSDNode>(N1);
6979 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0, N1);
7001 N0.getOperand(0), N1);
7004 if (N1.getOpcode() == ISD::FABS)
7008 if (N1.getOpcode() == ISD::FCOPYSIGN)
7010 N0, N1.getOperand(1));
7014 if (N1.getOpcode() == ISD::FP_EXTEND || N1.getOpcode() == ISD::FP_ROUND)
7016 N0, N1.getOperand(0));
7140 SDValue N1 = N->getOperand(1);
7146 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0, N1);
7164 N0.getOperand(0), N1);
7361 SDValue N1 = N->getOperand(1);
7372 if (N1.getOpcode() == ISD::SETCC &&
7374 N1.getOperand(0).getValueType())) {
7376 Chain, N1.getOperand(2),
7377 N1.getOperand(0), N1.getOperand(1), N2);
7380 if ((N1.hasOneUse() && N1.getOpcode() == ISD::SRL) ||
7381 ((N1.getOpcode() == ISD::TRUNCATE && N1.hasOneUse()) &&
7382 (N1.getOperand(0).hasOneUse() &&
7383 N1.getOperand(0).getOpcode() == ISD::SRL))) {
7385 if (N1.getOpcode() == ISD::TRUNCATE) {
7387 Trunc = N1.getNode();
7388 N1 = N1.getOperand(0);
7408 SDValue Op0 = N1.getOperand(0);
7409 SDValue Op1 = N1.getOperand(1);
7438 DAG.ReplaceAllUsesOfValueWith(N1, SetCC);
7439 removeFromWorkList(N1.getNode());
7440 DAG.DeleteNode(N1.getNode());
7447 // Restore N1 if the above transformation doesn't match.
7448 N1 = N->getOperand(1);
7453 if (N1.hasOneUse() && N1.getOpcode() == ISD::XOR) {
7454 SDNode *TheXor = N1.getNode();
7468 DAG.ReplaceAllUsesOfValueWith(N1, Tmp);
7490 EVT SetCCVT = N1.getValueType();
7499 DAG.ReplaceAllUsesOfValueWith(N1, SetCC);
7500 removeFromWorkList(N1.getNode());
7501 DAG.DeleteNode(N1.getNode());
8795 SDValue N1 = Value.getOperand(1);
8796 unsigned BitWidth = N1.getValueSizeInBits();
8797 APInt Imm = cast<ConstantSDNode>(N1)->getAPIntValue();
10384 SDValue N1 = N->getOperand(1);
10389 EVT SclTy1 = N1.getOperand(0)->getValueType(0);
10394 Opnds.push_back(N1.getOperand(i));
10404 N1.getOperand(i)));
10522 SDValue N1 = N->getOperand(1);
10555 Ops.push_back(N1.getOperand(FirstElt - N0.getNumOperands()));
10572 SDValue N1 = N->getOperand(1);
10577 if (N0.getOpcode() == ISD::UNDEF && N1.getOpcode() == ISD::UNDEF)
10583 if (N0 == N1) {
10607 return DAG.getVectorShuffle(VT, SDLoc(N), N1, DAG.getUNDEF(VT),
10612 if (N1.getOpcode() == ISD::UNDEF) {
10624 return DAG.getVectorShuffle(VT, SDLoc(N), N0, N1, &NewMask[0]);
10670 (N1.getOpcode() == ISD::UNDEF ||
10671 (N1.getOpcode() == ISD::CONCAT_VECTORS &&
10672 N0.getOperand(0).getValueType() == N1.getOperand(0).getValueType()))) {
10682 N1.getOpcode() == ISD::UNDEF) {
10758 return DAG.getVectorShuffle(VT, SDLoc(N), N0->getOperand(0), N1,
10762 return DAG.getVectorShuffle(VT, SDLoc(N), N1, N0->getOperand(1),
10963 SDValue N1, SDValue N2){
10966 SDValue SCC = SimplifySelectCC(DL, N0.getOperand(0), N0.getOperand(1), N1, N2,
11105 /// SimplifySelectCC - Simplify an expression of the form (N0 cond N1) ? N2 : N3
11107 SDValue DAGCombiner::SimplifySelectCC(SDLoc DL, SDValue N0, SDValue N1,
11114 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
11120 N0, N1, CC, DL, false);
11132 if (ConstantFPSDNode *CFP = dyn_cast<ConstantFPSDNode>(N1)) {
11188 N0, N1, CC);
11295 N0, N1, CC);
11303 SCC = DAG.getSetCC(SDLoc(N0), MVT::i1, N0, N1, CC);
11329 SDValue Res = DAG.getSetCC(DL, getSetCCResultType(XType), N0, N1, CC);
11399 SDValue N1, ISD::CondCode Cond,
11403 return TLI.SimplifySetCC(VT, N0, N1, Cond, foldBooleans, DagCombineInfo, DL);