Lines Matching defs:getNode
416 // SDValue.getNode() == 0 - No change was made
417 // SDValue.getNode() == N - N was replaced, is dead and has been handled.
724 if (ISD::isBuildVectorOfConstantSDNodes(StoreVal.getNode()) ||
725 ISD::isBuildVectorOfConstantFPSDNodes(StoreVal.getNode()))
948 AddToWorklist(Op.getNode());
1062 ISD::isBuildVectorOfConstantFPSDNodes(V.getNode());
1108 LoadStore && LoadStore->getBasePtr().getNode() == N) {
1213 return DAG.getNode(Opc, DL, VT, N00, OpNode, NewFlags);
1219 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N00, N1, NewFlags);
1220 return DAG.getNode(Opc, DL, VT, OpNode, N01, NewFlags);
1249 return DAG.getNode(Opc, DL, VT, SDValue(NE, 0), N01);
1259 return DAG.getNode(Opc, DL, VT, SDValue(NE, 0), N00);
1277 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N00, N1, Flags);
1278 return DAG.getNode(Opc, DL, VT, OpNode, N01, Flags);
1281 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N01, N1, Flags);
1282 return DAG.getNode(Opc, DL, VT, OpNode, N00, Flags);
1322 return DAG.getNode(RedOpc, DL, VT,
1323 DAG.getNode(Opc, DL, N0.getOperand(0).getValueType(),
1337 assert((!To[i].getNode() ||
1346 if (To[i].getNode())
1347 AddToWorklistWithUsers(To[i].getNode());
1370 AddToWorklistWithUsers(TLO.New.getNode());
1373 recursivelyDeleteUnusedNodes(TLO.Old.getNode());
1388 AddToWorklist(Op.getNode());
1407 AddToWorklist(Op.getNode());
1416 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, VT, SDValue(ExtLoad, 0));
1424 AddToWorklist(Trunc.getNode());
1431 if (ISD::isUNINDEXEDLoad(Op.getNode())) {
1447 return DAG.getNode(ISD::AssertSext, DL, PVT, Op0, Op.getOperand(1));
1451 return DAG.getNode(ISD::AssertZext, DL, PVT, Op0, Op.getOperand(1));
1456 return DAG.getNode(ExtOpc, DL, PVT, Op);
1462 return DAG.getNode(ISD::ANY_EXTEND, DL, PVT, Op);
1472 if (!NewOp.getNode())
1474 AddToWorklist(NewOp.getNode());
1477 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
1478 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, NewOp.getValueType(), NewOp,
1487 if (!NewOp.getNode())
1489 AddToWorklist(NewOp.getNode());
1492 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
1531 DAG.getNode(ISD::TRUNCATE, DL, VT, DAG.getNode(Opc, DL, PVT, NN0, NN1));
1542 CombineTo(Op.getNode(), RV);
1546 if (Replace0 && Replace1 && N0->isPredecessorOf(N1.getNode())) {
1552 AddToWorklist(NN0.getNode());
1553 ReplaceLoadWithPromotedLoad(N0.getNode(), NN0.getNode());
1556 AddToWorklist(NN1.getNode());
1557 ReplaceLoadWithPromotedLoad(N1.getNode(), NN1.getNode());
1598 if (!N0.getNode())
1604 DAG.getNode(ISD::TRUNCATE, DL, VT, DAG.getNode(Opc, DL, PVT, N0, N1));
1607 ReplaceLoadWithPromotedLoad(Op.getOperand(0).getNode(), N0.getNode());
1639 return DAG.getNode(Op.getOpcode(), SDLoc(Op), VT, Op.getOperand(0));
1648 if (!ISD::isUNINDEXEDLoad(Op.getNode()))
1668 SDNode *N = Op.getNode();
1676 SDValue Result = DAG.getNode(ISD::TRUNCATE, DL, VT, NewLD);
1684 AddToWorklist(Result.getNode());
1711 Nodes.insert(ChildN.getNode());
1779 AddToWorklist(ChildN.getNode(), /*IsCandidateForPruning=*/true,
1784 if (!RV.getNode())
1796 if (RV.getNode() == N)
1806 DAG.ReplaceAllUsesWith(N, RV.getNode());
1819 AddToWorklistWithUsers(RV.getNode());
2007 if (!RV.getNode()) {
2023 if (!RV.getNode()) {
2053 if (!RV.getNode() && TLI.isCommutativeBinOp(N->getOpcode())) {
2089 if (getInputChainForNode(N->getOperand(0).getNode()) == N->getOperand(1))
2091 if (getInputChainForNode(N->getOperand(1).getNode()) == N->getOperand(0))
2143 if (Op.hasOneUse() && !is_contained(TFs, Op.getNode())) {
2145 TFs.push_back(Op.getNode());
2153 if (SeenOps.insert(Op.getNode()).second)
2181 Worklist.push_back(std::make_pair(Op.getNode(), NumLeftToConsider++));
2192 while (OrigOpNumber < Ops.size() && Ops[OrigOpNumber].getNode() != Op)
2231 AddToWorklist(i, Op.getNode(), CurOpNumber);
2237 AddToWorklist(i, CurNode->getOperand(0).getNode(), CurOpNumber);
2241 AddToWorklist(i, MemNode->getChain().getNode(), CurOpNumber);
2260 if (SeenChains.count(Op.getNode()) == 0)
2329 if (LD->isIndexed() || LD->getBasePtr().getNode() != N)
2334 if (ST->isIndexed() || ST->getBasePtr().getNode() != N)
2339 if (LD->isIndexed() || LD->getBasePtr().getNode() != N)
2344 if (ST->isIndexed() || ST->getBasePtr().getNode() != N)
2412 SDValue NewBO = DAG.getNode(Opcode, SDLoc(N), VT, F0, FVal, N->getFlags());
2418 SDValue NewBO = DAG.getNode(Opcode, SDLoc(N), VT, F0, TVal, N->getFlags());
2495 // If CBO is an opaque constant, we can't rely on getNode to constant fold.
2560 return DAG.getNode(IsAdd ? ISD::SUB : ISD::ADD, DL, VT, C1, LowBit);
2573 return DAG.getNode(ISD::AVGCEILU, DL, VT, A, B);
2579 return DAG.getNode(ISD::AVGCEILS, DL, VT, A, B);
2618 SDValue NewShift = DAG.getNode(IsAdd ? ISD::SRA : ISD::SRL, DL, VT,
2620 return DAG.getNode(ISD::ADD, DL, VT, NewShift, NewC);
2654 return DAG.getNode(ISD::ADD, DL, VT, N1, N0);
2665 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
2679 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), Sub);
2683 return DAG.getNode(ISD::SUB, DL, VT, Add, N0.getOperand(1));
2698 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Not);
2709 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), Add);
2736 return DAG.getNode(
2738 DAG.getNode(ISD::ADD, DL, VT, N1, N0.getOperand(0)),
2758 return DAG.getNode(ISD::SUB, DL, VT, N1, A);
2762 return DAG.getNode(ISD::SUB, DL, VT, N0, B);
2775 return DAG.getNode(ISD::SUB, DL, VT, C, B);
2780 return DAG.getNode(ISD::SUB, DL, VT, A, C);
2785 return DAG.getNode(ISD::SUB, DL, VT, B, C);
2791 return DAG.getNode(N1.getOpcode(), DL, VT, B, C);
2797 return DAG.getNode(ISD::SUB, DL, VT,
2798 DAG.getNode(ISD::ADD, SDLoc(N0), VT, A, C),
2799 DAG.getNode(ISD::ADD, SDLoc(N1), VT, B, D));
2809 return DAG.getNode(ISD::USUBSAT, DL, VT, N0.getOperand(0),
2819 return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT),
2835 return DAG.getNode(ISD::SUB, DL, VT, A, Xor.getOperand(0));
2848 return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(1), Not);
2856 return DAG.getNode(ISD::ADD, DL, VT, Not, N0.getOperand(0));
2880 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N1), VT, A,
2882 return DAG.getNode(
2909 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N1), VT, A,
2911 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N1), VT, Mul, B, Flags);
2912 return DAG.getNode(
2938 return DAG.getNode(ISD::AVGFLOORU, DL, VT, A, B);
2944 return DAG.getNode(ISD::AVGFLOORS, DL, VT, A, B);
2974 return DAG.getNode(ISD::OR, DL, VT, N0, N1, Flags);
2991 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), VS);
3011 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), SV);
3036 return DAG.getNode(Opcode, DL, VT, N1, N0);
3044 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
3054 return DAG.getNode(ISD::ADD, DL, VT, N0, N1);
3132 return DAG.getNode(IsAdd ? ISD::SUB : ISD::ADD, DL, VT, N0, N10);
3144 return DAG.getNode(ISD::SUB, DL, VT, N0,
3145 DAG.getNode(ISD::SHL, DL, VT, Y, N));
3160 return DAG.getNode(ISD::SUB, DL, VT, N1, Not);
3168 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), N1);
3169 return DAG.getNode(ISD::SUB, DL, VT, Add, N0.getOperand(1));
3174 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N1, N0.getOperand(1));
3175 return DAG.getNode(ISD::ADD, DL, VT, Sub, N0.getOperand(0));
3183 SDValue NewC = DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(1),
3185 return DAG.getNode(ISD::MUL, DL, VT, N0.getOperand(0), NewC);
3194 SDValue ZExt = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
3195 return DAG.getNode(ISD::SUB, DL, VT, N1, ZExt);
3202 SDValue ZExt = DAG.getNode(ISD::AND, DL, VT, N1.getOperand(0),
3204 return DAG.getNode(ISD::SUB, DL, VT, N0, ZExt);
3211 return DAG.getNode(ISD::UADDO_CARRY, DL, N1->getVTList(),
3217 return DAG.getNode(ISD::UADDO_CARRY, DL,
3232 return CombineTo(N, DAG.getNode(ISD::ADD, DL, VT, N0, N1),
3233 DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
3239 return DAG.getNode(ISD::ADDC, DL, N->getVTList(), N1, N0);
3243 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE,
3248 return CombineTo(N, DAG.getNode(ISD::ADD, DL, VT, N0, N1),
3249 DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
3307 return CombineTo(N, DAG.getNode(ISD::ADD, DL, VT, N0, N1),
3313 return DAG.getNode(N->getOpcode(), DL, N->getVTList(), N1, N0);
3321 return CombineTo(N, DAG.getNode(ISD::ADD, DL, VT, N0, N1),
3327 return DAG.getNode(ISD::SSUBO, DL, N->getVTList(),
3332 SDValue Sub = DAG.getNode(ISD::USUBO, DL, N->getVTList(),
3359 return DAG.getNode(ISD::UADDO_CARRY, SDLoc(N), N->getVTList(), N0, Y,
3366 return DAG.getNode(ISD::UADDO_CARRY, SDLoc(N), N->getVTList(), N0,
3381 return DAG.getNode(ISD::ADDE, SDLoc(N), N->getVTList(),
3386 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N0, N1);
3401 return DAG.getNode(ISD::UADDO_CARRY, DL, N->getVTList(), N1, N0, CarryIn);
3407 return DAG.getNode(ISD::UADDO, DL, N->getVTList(), N0, N1);
3415 AddToWorklist(CarryExt.getNode());
3416 return CombineTo(N, DAG.getNode(ISD::AND, DL, VT, CarryExt,
3494 DAG.getNode(ISD::UADDO_CARRY, DL, Carry0->getVTList(), A, B, Z);
3495 Combiner.AddToWorklist(NewY.getNode());
3496 return DAG.getNode(ISD::UADDO_CARRY, DL, N->getVTList(), X,
3578 if (Carry1.getNode()->isOperandOf(Carry0.getNode()))
3606 DAG.getNode(NewOp, DL, Carry1->getVTList(), Carry0.getOperand(0),
3635 SDValue Sub = DAG.getNode(ISD::USUBO_CARRY, DL, N->getVTList(), N1,
3649 return DAG.getNode(ISD::UADDO_CARRY, SDLoc(N), N->getVTList(),
3673 return DAG.getNode(ISD::SSUBO_CARRY, SDLoc(N), N->getVTList(), N1,
3690 return DAG.getNode(ISD::SADDO_CARRY, DL, N->getVTList(), N1, N0, CarryIn);
3696 return DAG.getNode(ISD::SADDO, DL, N->getVTList(), N0, N1);
3717 return DAG.getNode(ISD::USUBSAT, DL, DstVT, LHS, RHS);
3730 RHS = DAG.getNode(ISD::UMIN, DL, SrcVT, RHS, SatLimit);
3731 RHS = DAG.getNode(ISD::TRUNCATE, DL, DstVT, RHS);
3732 LHS = DAG.getNode(ISD::TRUNCATE, DL, DstVT, LHS);
3733 return DAG.getNode(ISD::USUBSAT, DL, DstVT, LHS, RHS);
3823 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
3832 return DAG.getNode(ISD::ADD, DL, VT, N0,
3845 return DAG.getNode(NewSh, DL, VT, N1.getOperand(0), N1.getOperand(1));
3866 if (SDValue Result = TLI.expandABS(N1.getNode(), DAG, true))
3880 return DAG.getNode(ISD::XOR, DL, VT, N1, N0);
3884 return DAG.getNode(ISD::ADD, DL, VT, N0, N1.getOperand(1));
3902 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(0), NewC);
3909 return DAG.getNode(ISD::SUB, DL, VT, NewC, N1.getOperand(0));
3916 return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), NewC);
3923 return DAG.getNode(ISD::SUB, DL, VT, NewC, N0.getOperand(1));
3930 return DAG.getNode(ISD::ADD, DL, VT, A, C);
3934 return DAG.getNode(ISD::SUB, DL, VT, A, C);
3938 return DAG.getNode(ISD::SUB, DL, VT, A, B);
3942 return DAG.getNode(ISD::ADD, DL, VT, N0,
3943 DAG.getNode(ISD::SUB, DL, VT, C, B));
3948 return DAG.getNode(ISD::AND, DL, VT, N0, DAG.getNOT(DL, B, VT));
3952 return DAG.getNode(ISD::ADD, DL, VT, N0,
3953 DAG.getNode(ISD::MUL, DL, VT, B, C));
3979 return DAG.getNode(ISD::ADD, DL, VT, A, DAG.getNOT(DL, B, VT));
3986 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0, N1.getOperand(0));
3987 return DAG.getNode(ISD::ADD, DL, VT, Add, DAG.getConstant(1, DL, VT));
3995 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), N1);
3996 return DAG.getNode(ISD::ADD, DL, VT, Sub, N0.getOperand(1));
4001 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, N1.getOperand(0));
4002 return DAG.getNode(ISD::SUB, DL, VT, Sub, N1.getOperand(1));
4008 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), N1);
4009 return DAG.getNode(ISD::SUB, DL, VT, Sub, N0.getOperand(1));
4014 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(1), N1);
4015 return DAG.getNode(ISD::SUB, DL, VT, N0.getOperand(0), Add);
4025 SDValue SExt = DAG.getNode(ISD::SIGN_EXTEND, DL, VT, N1.getOperand(0));
4026 return DAG.getNode(ISD::ADD, DL, VT, N0, SExt);
4033 return DAG.getNode(ISD::ABS, DL, VT, A);
4049 SDValue ZExt = DAG.getNode(ISD::AND, DL, VT, N1.getOperand(0),
4051 return DAG.getNode(ISD::ADD, DL, VT, N0, ZExt);
4058 return DAG.getNode(ISD::ADD, DL, VT, N0, DAG.getVScale(DL, VT, -IntVal));
4064 return DAG.getNode(ISD::ADD, DL, VT, N0,
4074 SDValue SRA = DAG.getNode(ISD::SRA, DL, VT, N1.getOperand(0), ShAmt);
4075 return DAG.getNode(ISD::ADD, DL, VT, N0, SRA);
4085 return DAG.getNode(ISD::ADD, DL, VT, N1, N0);
4091 return DAG.getNode(ISD::USUBO_CARRY, DL, N0->getVTList(),
4099 SDValue NegX = DAG.getNode(ISD::SUB, DL, VT, Zero, X);
4100 return DAG.getNode(ISD::UADDO_CARRY, DL,
4113 return DAG.getNode(ISD::XOR, DL, VT, N1, N0);
4121 return DAG.getNode(ISD::ABDS, DL, VT, A, B);
4127 return DAG.getNode(ISD::ABDU, DL, VT, A, B);
4158 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
4168 return DAG.getNode(ISD::SUB, DL, VT, N0, N1);
4181 return CombineTo(N, DAG.getNode(ISD::SUB, DL, VT, N0, N1),
4182 DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
4187 DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
4191 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
4195 return CombineTo(N, DAG.getNode(ISD::XOR, DL, VT, N1, N0),
4196 DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
4212 return CombineTo(N, DAG.getNode(ISD::SUB, DL, VT, N0, N1),
4223 return DAG.getNode(ISD::SADDO, DL, N->getVTList(), N0,
4232 return CombineTo(N, DAG.getNode(ISD::SUB, DL, VT, N0, N1),
4237 return CombineTo(N, DAG.getNode(ISD::XOR, DL, VT, N1, N0),
4250 return DAG.getNode(ISD::SUBC, SDLoc(N), N->getVTList(), N0, N1);
4264 return DAG.getNode(ISD::USUBO, SDLoc(N), N->getVTList(), N0, N1);
4279 return DAG.getNode(ISD::SSUBO, SDLoc(N), N->getVTList(), N0, N1);
4300 return DAG.getNode(N->getOpcode(), SDLoc(N), VT, N1, N0, Scale);
4329 return Matcher.getNode(ISD::MUL, DL, VT, N1, N0);
4342 N1IsConst = ISD::isConstantSplatVector(N1.getNode(), ConstValue1);
4367 return Matcher.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), N0);
4375 return Matcher.getNode(ISD::SHL, DL, VT, N0, Trunc);
4385 return Matcher.getNode(
4387 Matcher.getNode(ISD::SHL, DL, VT, N0,
4445 DAG.getNode(ISD::SHL, DL, VT, N0, DAG.getConstant(ShAmt, DL, VT));
4447 TZeros ? DAG.getNode(MathOp, DL, VT, Shl,
4448 DAG.getNode(ISD::SHL, DL, VT, N0,
4450 : DAG.getNode(MathOp, DL, VT, Shl, N0);
4461 return DAG.getNode(ISD::MUL, DL, VT, N0.getOperand(0), C3);
4478 if (Sh.getNode()) {
4479 SDValue Mul = Matcher.getNode(ISD::MUL, DL, VT, Sh.getOperand(0), Y);
4480 return Matcher.getNode(ISD::SHL, DL, VT, Mul, Sh.getOperand(1));
4489 return Matcher.getNode(
4491 Matcher.getNode(ISD::MUL, SDLoc(N0), VT, N0.getOperand(0), N1),
4492 Matcher.getNode(ISD::MUL, SDLoc(N1), VT, N0.getOperand(1), N1));
4505 ISD::isConstantSplatVector(N1.getNode(), MulVal)) {
4518 return Matcher.getNode(ISD::ABS, DL, VT, X);
4547 return DAG.getNode(ISD::AND, DL, VT, N0, DAG.getBuildVector(VT, DL, Mask));
4642 combined = DAG.getNode(DivRemOpc, SDLoc(Node), VTs, Op0, Op1);
4741 return DAG.getNode(ISD::UDIV, DL, N1.getValueType(), N0, N1);
4748 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT, V, N1);
4749 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, Mul);
4750 AddToWorklist(Mul.getNode());
4751 AddToWorklist(Sub.getNode());
4802 SDValue C1 = DAG.getNode(ISD::CTTZ, DL, VT, N1);
4804 SDValue Inexact = DAG.getNode(ISD::SUB, DL, ShiftAmtTy, Bits, C1);
4809 SDValue Sign = DAG.getNode(ISD::SRA, DL, VT, N0,
4811 AddToWorklist(Sign.getNode());
4814 SDValue Srl = DAG.getNode(ISD::SRL, DL, VT, Sign, Inexact);
4815 AddToWorklist(Srl.getNode());
4816 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N0, Srl);
4817 AddToWorklist(Add.getNode());
4818 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, Add, C1);
4819 AddToWorklist(Sra.getNode());
4827 SDValue IsOneOrAllOnes = DAG.getNode(ISD::OR, DL, CCVT, IsOne, IsAllOnes);
4833 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, Zero, Sra);
4888 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT, V, N1);
4889 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, Mul);
4890 AddToWorklist(Mul.getNode());
4891 AddToWorklist(Sub.getNode());
4915 AddToWorklist(LogBase2.getNode());
4919 AddToWorklist(Trunc.getNode());
4920 return DAG.getNode(ISD::SRL, DL, VT, N0, Trunc);
4929 AddToWorklist(LogBase2.getNode());
4933 AddToWorklist(Trunc.getNode());
4934 SDValue Add = DAG.getNode(ISD::ADD, DL, ADDVT, N1.getOperand(1), Trunc);
4935 AddToWorklist(Add.getNode());
4936 return DAG.getNode(ISD::SRL, DL, VT, N0, Add);
4995 return DAG.getNode(ISD::UREM, DL, VT, N0, N1);
5000 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N1, NegOne);
5001 AddToWorklist(Add.getNode());
5002 return DAG.getNode(ISD::AND, DL, VT, N0, Add);
5011 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, N1, NegOne);
5012 AddToWorklist(Add.getNode());
5013 return DAG.getNode(ISD::AND, DL, VT, N0, Add);
5035 if (OptimizedDiv.getNode() && OptimizedDiv.getNode() != N) {
5041 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT, OptimizedDiv, N1);
5042 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, Mul);
5043 AddToWorklist(OptimizedDiv.getNode());
5044 AddToWorklist(Mul.getNode());
5069 return DAG.getNode(ISD::MULHS, DL, N->getVTList(), N1, N0);
5077 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
5087 return DAG.getNode(
5103 N0 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N0);
5104 N1 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N1);
5105 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
5106 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
5108 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
5128 return DAG.getNode(ISD::MULHU, DL, N->getVTList(), N1, N0);
5136 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
5157 SDValue SRLAmt = DAG.getNode(
5161 return DAG.getNode(ISD::SRL, DL, VT, N0, Trunc);
5173 N0 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N0);
5174 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N1);
5175 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
5176 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
5178 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
5206 return DAG.getNode(Opcode, DL, N->getVTList(), N1, N0);
5225 return DAG.getNode(ISD::SRA, DL, VT, X,
5228 return DAG.getNode(ISD::SRL, DL, VT, X,
5237 SDValue AvgU = DAG.getNode(Opcode, DL, X.getValueType(), X, Y);
5238 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, AvgU);
5244 SDValue AvgS = DAG.getNode(Opcode, DL, X.getValueType(), X, Y);
5245 return DAG.getNode(ISD::SIGN_EXTEND, DL, VT, AvgS);
5254 return DAG.getNode(
5256 DAG.getNode(ISD::ADD, DL, VT, N1, DAG.getAllOnesConstant(DL, VT)));
5258 return DAG.getNode(
5260 DAG.getNode(ISD::ADD, DL, VT, N0, DAG.getAllOnesConstant(DL, VT)));
5280 return DAG.getNode(Opcode, DL, N->getVTList(), N1, N0);
5295 return DAG.getNode(ISD::ABS, DL, VT, X);
5304 return DAG.getNode(ISD::ABDU, DL, VT, N1, N0);
5318 SDValue Res = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0), N->ops());
5326 SDValue Res = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1), N->ops());
5336 SDValue Lo = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0), N->ops());
5337 AddToWorklist(Lo.getNode());
5338 SDValue LoOpt = combine(Lo.getNode());
5339 if (LoOpt.getNode() && LoOpt.getNode() != Lo.getNode() &&
5346 SDValue Hi = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1), N->ops());
5347 AddToWorklist(Hi.getNode());
5348 SDValue HiOpt = combine(Hi.getNode());
5349 if (HiOpt.getNode() && HiOpt != Hi &&
5369 return DAG.getNode(ISD::SMUL_LOHI, DL, N->getVTList(), N0, N1);
5374 return DAG.getNode(ISD::SMUL_LOHI, DL, N->getVTList(), N1, N0);
5383 SDValue Lo = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N0);
5384 SDValue Hi = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N1);
5385 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
5387 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
5389 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
5391 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
5410 return DAG.getNode(ISD::UMUL_LOHI, DL, N->getVTList(), N0, N1);
5415 return DAG.getNode(ISD::UMUL_LOHI, DL, N->getVTList(), N1, N0);
5436 SDValue Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N0);
5437 SDValue Hi = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N1);
5438 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
5440 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
5442 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
5444 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
5479 return DAG.getNode(N->getOpcode(), DL, N->getVTList(), N1, N0);
5490 return DAG.getNode(IsSigned ? ISD::SADDO : ISD::UADDO, DL,
5495 SDValue And = DAG.getNode(ISD::AND, DL, VT, N0, N1);
5503 return CombineTo(N, DAG.getNode(ISD::MUL, DL, VT, N0, N1),
5634 SDValue Sat = DAG.getNode(NewOpc, DL, NewVT, Fp.getOperand(0),
5670 DAG.getNode(ISD::FP_TO_UINT_SAT, SDLoc(N0), NewVT, N0.getOperand(0),
5693 return DAG.getNode(Opcode, DL, VT, N1, N0);
5721 return DAG.getNode(AltOpcode, DL, VT, N0, N1);
5802 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
5804 return DAG.getNode(HandOpcode, DL, VT, Logic, N0.getOperand(1));
5805 return DAG.getNode(HandOpcode, DL, VT, Logic);
5826 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
5827 return DAG.getNode(HandOpcode, DL, VT, Logic);
5838 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
5839 return DAG.getNode(HandOpcode, DL, VT, Logic, N0.getOperand(1));
5847 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
5848 return DAG.getNode(HandOpcode, DL, VT, Logic);
5861 SDValue Logic0 = DAG.getNode(LogicOpcode, DL, VT, X, Y);
5862 SDValue Logic1 = DAG.getNode(LogicOpcode, DL, VT, X1, Y1);
5863 return DAG.getNode(HandOpcode, DL, VT, Logic0, Logic1, S);
5879 SDValue Logic = DAG.getNode(LogicOpcode, DL, XVT, X, Y);
5880 return DAG.getNode(HandOpcode, DL, VT, Logic);
5917 if (N0.getOperand(1) == N1.getOperand(1) && ShOp.getNode()) {
5918 SDValue Logic = DAG.getNode(LogicOpcode, DL, VT,
5930 if (N0.getOperand(0) == N1.getOperand(0) && ShOp.getNode()) {
5931 SDValue Logic = DAG.getNode(LogicOpcode, DL, VT, N0.getOperand(1),
5986 SDValue Or = DAG.getNode(ISD::OR, SDLoc(N0), OpVT, LL, RL);
5987 AddToWorklist(Or.getNode());
6005 SDValue And = DAG.getNode(ISD::AND, SDLoc(N0), OpVT, LL, RL);
6006 AddToWorklist(And.getNode());
6019 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N0), OpVT, LL, One);
6020 AddToWorklist(Add.getNode());
6031 SDValue XorL = DAG.getNode(ISD::XOR, SDLoc(N0), OpVT, LL, LR);
6032 SDValue XorR = DAG.getNode(ISD::XOR, SDLoc(N1), OpVT, RL, RR);
6033 SDValue Or = DAG.getNode(ISD::OR, DL, OpVT, XorL, XorR);
6052 SDValue Max = DAG.getNode(ISD::UMAX, DL, OpVT, LR, RR);
6053 SDValue Min = DAG.getNode(ISD::UMIN, DL, OpVT, LR, RR);
6054 SDValue Offset = DAG.getNode(ISD::SUB, DL, OpVT, LL, Min);
6055 SDValue Diff = DAG.getNode(ISD::SUB, DL, OpVT, Max, Min);
6057 SDValue And = DAG.getNode(ISD::AND, DL, OpVT, Offset, Mask);
6166 LogicOp, LHS.getNode(), RHS.getNode());
6261 DAG.getNode(NewOpcode, DL, OpVT, Operand1, Operand2);
6286 SDValue AbsOp = DAG.getNode(ISD::ABS, DL, OpVT, LHS0);
6287 return DAG.getNode(ISD::SETCC, DL, VT, AbsOp,
6315 SDValue AndOp = DAG.getNode(ISD::AND, DL, OpVT, NotOp,
6317 return DAG.getNode(ISD::SETCC, DL, VT, AndOp,
6321 SDValue AddOp = DAG.getNode(ISD::ADD, DL, OpVT, LHS0,
6323 SDValue AndOp = DAG.getNode(ISD::AND, DL, OpVT, AddOp,
6325 return DAG.getNode(ISD::SETCC, DL, VT, AndOp,
6359 return DAG.getNode(ISD::AND, DL, OpVT, CondMask, T.getOperand(0));
6402 DAG.getNode(ISD::ADD, DL0, VT,
6404 CombineTo(N0.getNode(), NewAdd);
6601 if (!SearchForAndLoads(Op.getNode(), Loads, NodesWithConsts, Mask,
6612 NodeToMask = Op.getNode();
6657 SDValue And = DAG.getNode(ISD::AND, SDLoc(FixupNode),
6662 DAG.UpdateNodeOperands(And.getNode(), SDValue(FixupNode, 0), MaskOp);
6672 DAG.getNode(ISD::AND, SDLoc(Op0), Op0.getValueType(), Op0, MaskOp);
6676 DAG.getNode(ISD::AND, SDLoc(Op1), Op1.getValueType(), Op1, MaskOp);
6687 SDValue And = DAG.getNode(ISD::AND, SDLoc(Load), Load->getValueType(0),
6692 DAG.UpdateNodeOperands(And.getNode(), SDValue(Load, 0), MaskOp), 0);
6693 SDValue NewLoad = reduceLoadWidth(And.getNode());
6698 DAG.ReplaceAllUsesWith(N, N->getOperand(0).getNode());
6751 SDValue T0 = DAG.getNode(InnerShift, DL, VT, X, Y);
6753 SDValue T1 = DAG.getNode(OuterShift, DL, VT, T0, Y);
6827 SDValue NewAnd = DAG.getNode(ISD::AND, DL, SrcVT, X, Mask);
6852 return DAG.getNode(ISD::USUBSAT, DL, VT, X,
6897 SDValue LogicX = DAG.getNode(LogicOpcode, DL, VT, X0, X1);
6898 SDValue NewShift = DAG.getNode(ShiftOpcode, DL, VT, LogicX, Y);
6899 return DAG.getNode(LogicOpcode, DL, VT, NewShift, Z);
6936 return DAG.getNode(LogicOpcode, DL, VT, CombinedShifts, W);
6956 return DAG.getNode(ISD::AND, DL, VT, N1, N0);
6967 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
6973 if (ISD::isConstantSplatVectorAllOnes(N1.getNode()))
7047 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0Op0);
7054 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT,
7055 DAG.getNode(ISD::AND, DL, SrcVT, N0Op0,
7069 DAG.getNode(ISD::AND, DL, VT, N1,
7070 DAG.getNode(ExtOpc, DL, VT, N0Op0.getOperand(1)));
7071 return DAG.getNode(ISD::AND, DL, VT,
7072 DAG.getNode(ExtOpc, DL, VT, N0Op0.getOperand(0)),
7156 CombineTo(N, (N0.getNode() == Load) ? NewLoad : N0);
7199 DAG.getNode(ISD::ZERO_EXTEND, DL, ExtVT, Extendee);
7201 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, ZeroExtExtendee,
7212 isConstantSplatVectorMaskForType(N1.getNode(), ScalarVT) &&
7222 AddToWorklist(ZExtLoad.getNode());
7271 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, SubRHS.getOperand(0));
7282 if (ISD::isUNINDEXEDLoad(N0.getNode()) &&
7283 (ISD::isEXTLoad(N0.getNode()) ||
7284 (ISD::isSEXTLoad(N0.getNode()) && N0.hasOneUse()))) {
7299 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
7306 if (SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
7340 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
7462 SDValue Res = DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N00);
7465 Res = DAG.getNode(ISD::SRL, DL, VT, Res,
7557 Parts[MaskByteOffset] = N0.getOperand(0).getNode();
7571 Parts[0] = Parts[1] = N.getOperand(0).getOperand(0).getNode();
7615 SDValue BSwap = DAG.getNode(ISD::BSWAP, DL, VT, Shift0.getOperand(0));
7617 return DAG.getNode(ISD::ROTR, DL, VT, BSwap, ShAmt);
7672 SDValue BSwap = DAG.getNode(ISD::BSWAP, DL, VT,
7679 return DAG.getNode(ISD::ROTL, DL, VT, BSwap, ShAmt);
7681 return DAG.getNode(ISD::ROTR, DL, VT, BSwap, ShAmt);
7682 return DAG.getNode(ISD::OR, DL, VT,
7683 DAG.getNode(ISD::SHL, DL, VT, BSwap, ShAmt),
7684 DAG.getNode(ISD::SRL, DL, VT, BSwap, ShAmt));
7716 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
7718 return DAG.getNode(ISD::AND, DL, VT, X,
7731 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
7733 return DAG.getNode(ISD::AND, DL, VT, N0.getOperand(0), X);
7767 return DAG.getNode(ISD::OR, DL, VT, DAG.getZExtOrTrunc(N00, DL, VT),
7775 return DAG.getNode(ISD::OR, DL, VT, DAG.getZExtOrTrunc(N01, DL, VT),
7784 return DAG.getNode(ISD::OR, DL, VT, X, N1);
7790 return DAG.getNode(ISD::OR, DL, VT, X, Y);
7825 Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, NotLo);
7826 Hi = DAG.getNode(ISD::ANY_EXTEND, DL, VT, NotHi);
7827 Hi = DAG.getNode(ISD::SHL, DL, VT, Hi,
7829 return DAG.getNOT(DL, DAG.getNode(ISD::OR, DL, VT, Lo, Hi), VT);
7853 return DAG.getNode(ISD::OR, DL, VT, N1, N0);
7861 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
7865 if (ISD::isConstantSplatVectorAllOnes(N1.getNode()))
7874 bool ZeroN00 = ISD::isBuildVectorAllZeros(N0.getOperand(0).getNode());
7875 bool ZeroN01 = ISD::isBuildVectorAllZeros(N0.getOperand(1).getNode());
7876 bool ZeroN10 = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
7877 bool ZeroN11 = ISD::isBuildVectorAllZeros(N1.getOperand(1).getNode());
7975 SDValue IOR = DAG.getNode(ISD::OR, SDLoc(N0), VT, N0.getOperand(0), N1);
7976 AddToWorklist(IOR.getNode());
7977 return DAG.getNode(ISD::AND, DL, VT, COR, IOR);
8085 return DAG.getNode(ISD::SHL, DL, ShiftedVT, OppShiftLHS,
8165 return DAG.getNode(Opcode, DL, ResVT, OppShiftLHS, NewShiftNode);
8316 return DAG.getNode(HasPos ? PosOpcode : NegOpcode, DL, VT, Shifted,
8345 return DAG.getNode(HasPos ? PosOpcode : NegOpcode, DL, VT, N0, N1,
8366 return DAG.getNode(ISD::FSHL, DL, VT, N0, N1.getOperand(0), Pos);
8375 return DAG.getNode(ISD::FSHR, DL, VT, N0.getOperand(0), N1, Neg);
8385 return DAG.getNode(ISD::FSHR, DL, VT, N0.getOperand(0), N1, Neg);
8424 return DAG.getNode(ISD::TRUNCATE, SDLoc(LHS), LHS.getValueType(), Rot);
8493 if (LHSMask.getNode() || RHSMask.getNode()) {
8497 if (LHSMask.getNode()) {
8498 SDValue RHSBits = DAG.getNode(ISD::SRL, DL, VT, AllOnes, RHSShiftAmt);
8499 Mask = DAG.getNode(ISD::AND, DL, VT, Mask,
8500 DAG.getNode(ISD::OR, DL, VT, LHSMask, RHSBits));
8502 if (RHSMask.getNode()) {
8503 SDValue LHSBits = DAG.getNode(ISD::SHL, DL, VT, AllOnes, LHSShiftAmt);
8504 Mask = DAG.getNode(ISD::AND, DL, VT, Mask,
8505 DAG.getNode(ISD::OR, DL, VT, RHSMask, LHSBits));
8508 Res = DAG.getNode(ISD::AND, DL, VT, Res, Mask);
8541 SDValue RotX = DAG.getNode(ISD::ROTL, DL, VT, X, LHSShiftAmt);
8542 SDValue ShlY = DAG.getNode(ISD::SHL, DL, VT, Y, LHSShiftAmt);
8543 Res = DAG.getNode(ISD::OR, DL, VT, RotX, ShlY);
8546 SDValue RotX = DAG.getNode(ISD::ROTL, DL, VT, X, LHSShiftAmt);
8547 SDValue SrlY = DAG.getNode(ISD::SRL, DL, VT, Y, RHSShiftAmt);
8548 Res = DAG.getNode(ISD::OR, DL, VT, RotX, SrlY);
8568 Res = DAG.getNode(UseROTL ? ISD::ROTL : ISD::ROTR, DL, VT, LHSShiftArg,
8572 Res = DAG.getNode(UseFSHL ? ISD::FSHL : ISD::FSHR, DL, VT, LHSShiftArg,
8586 if (LHSMask.getNode() || RHSMask.getNode())
8791 auto L = cast<LoadSDNode>(Op.getNode());
9051 SourceValue = DAG.getNode(ISD::TRUNCATE, DL, WideVT, SourceValue);
9058 SourceValue = DAG.getNode(ISD::BSWAP, DL, WideVT, SourceValue);
9062 SourceValue = DAG.getNode(ISD::ROTR, DL, WideVT, SourceValue, RotAmt);
9070 DAG.ReplaceAllUsesWith(N, NewStore.getNode());
9280 NeedsZext ? DAG.getNode(ISD::SHL, SDLoc(N), VT, NewLoad,
9284 return DAG.getNode(ISD::BSWAP, SDLoc(N), VT, ShiftedLoad);
9345 if (isa<ConstantSDNode>(M.getNode()))
9360 SDValue LHS = DAG.getNode(ISD::AND, DL, VT, NotX, M);
9362 SDValue RHS = DAG.getNode(ISD::OR, DL, VT, M, Y);
9363 return DAG.getNode(ISD::AND, DL, VT, NotLHS, RHS);
9372 SDValue LHS = DAG.getNode(ISD::OR, DL, VT, X, NotM);
9374 SDValue RHS = DAG.getNode(ISD::AND, DL, VT, NotM, NotY);
9376 return DAG.getNode(ISD::AND, DL, VT, LHS, NotRHS);
9379 SDValue LHS = DAG.getNode(ISD::AND, DL, VT, X, M);
9381 SDValue RHS = DAG.getNode(ISD::AND, DL, VT, Y, NotM);
9383 return DAG.getNode(ISD::OR, DL, VT, LHS, RHS);
9409 return DAG.getNode(ISD::XOR, DL, VT, N1, N0);
9417 if (ISD::isConstantSplatVectorAllZeros(N1.getNode()))
9442 return DAG.getNode(ISD::OR, DL, VT, N0, N1, Flags);
9479 recursivelyDeleteUnusedNodes(N0.getNode());
9493 V = DAG.getNode(ISD::XOR, DL0, V.getValueType(), V,
9495 AddToWorklist(V.getNode());
9496 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, V);
9505 N00 = DAG.getNode(ISD::XOR, SDLoc(N00), VT, N00, N1); // N00 = ~N00
9506 N01 = DAG.getNode(ISD::XOR, SDLoc(N01), VT, N01, N1); // N01 = ~N01
9507 AddToWorklist(N00.getNode()); AddToWorklist(N01.getNode());
9508 return DAG.getNode(NewOpcode, DL, VT, N00, N01);
9517 N00 = DAG.getNode(ISD::XOR, SDLoc(N00), VT, N00, N1); // N00 = ~N00
9518 N01 = DAG.getNode(ISD::XOR, SDLoc(N01), VT, N01, N1); // N01 = ~N01
9519 AddToWorklist(N00.getNode()); AddToWorklist(N01.getNode());
9520 return DAG.getNode(NewOpcode, DL, VT, N00, N01);
9529 return DAG.getNode(ISD::ADD, DL, VT, N0.getOperand(1),
9543 AddToWorklist(NotX.getNode());
9544 return DAG.getNode(ISD::AND, DL, VT, NotX, N1);
9557 return DAG.getNode(ISD::ABS, DL, VT, S0);
9585 return DAG.getNode(ISD::ROTL, DL, VT, DAG.getConstant(~1, DL, VT),
9683 SDValue NewShift1 = DAG.getNode(ShiftOpcode, DL, VT, X, ShiftSumC);
9684 SDValue NewShift2 = DAG.getNode(ShiftOpcode, DL, VT, Y, C1);
9685 return DAG.getNode(LogicOpcode, DL, VT, NewShift1, NewShift2,
9750 SDValue NewShift = DAG.getNode(N->getOpcode(), DL, VT, LHS.getOperand(0),
9752 return DAG.getNode(LHS.getOpcode(), DL, VT, NewShift, NewRHS);
9770 SDValue Trunc00 = DAG.getNode(ISD::TRUNCATE, DL, TruncVT, N00);
9771 SDValue Trunc01 = DAG.getNode(ISD::TRUNCATE, DL, TruncVT, N01);
9772 AddToWorklist(Trunc00.getNode());
9773 AddToWorklist(Trunc01.getNode());
9774 return DAG.getNode(ISD::AND, DL, TruncVT, Trunc00, Trunc01);
9810 return DAG.getNode(N->getOpcode(), dl, VT, N0, Amt);
9817 return DAG.getNode(ISD::BSWAP, dl, VT, N0);
9826 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
9827 return DAG.getNode(N->getOpcode(), dl, VT, N0, NewOp1);
9853 return DAG.getNode(N->getOpcode(), dl, VT, N0->getOperand(0),
9895 return DAG.getNode(ISD::AND, DL, VT, N00, C);
9911 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
9912 return DAG.getNode(ISD::SHL, DL, VT, N0, NewOp1);
9935 SDValue Sum = DAG.getNode(ISD::ADD, DL, ShiftVT, N1, N0.getOperand(1));
9936 return DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0), Sum);
9978 SDValue Ext = DAG.getNode(N0.getOpcode(), DL, VT, N0Op0.getOperand(0));
9980 Sum = DAG.getNode(ISD::ADD, DL, ShiftVT, Sum, N1);
9981 return DAG.getNode(ISD::SHL, DL, VT, Ext, Sum);
10004 NewSHL = DAG.getNode(ISD::SHL, DL, N0Op0.getValueType(), N0Op0, NewSHL);
10005 AddToWorklist(NewSHL.getNode());
10006 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N0), VT, NewSHL);
10026 SDValue Diff = DAG.getNode(ISD::SUB, DL, ShiftVT, N1, N01);
10027 return DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0), Diff);
10033 SDValue Diff = DAG.getNode(ISD::SUB, DL, ShiftVT, N01, N1);
10034 return DAG.getNode(N0.getOpcode(), DL, VT, N0.getOperand(0), Diff);
10049 SDValue Diff = DAG.getNode(ISD::SUB, DL, ShiftVT, N01, N1);
10051 Mask = DAG.getNode(ISD::SHL, DL, VT, Mask, N01);
10052 Mask = DAG.getNode(ISD::SRL, DL, VT, Mask, Diff);
10053 SDValue Shift = DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0), Diff);
10054 return DAG.getNode(ISD::AND, DL, VT, Shift, Mask);
10060 SDValue Diff = DAG.getNode(ISD::SUB, DL, ShiftVT, N1, N01);
10062 Mask = DAG.getNode(ISD::SHL, DL, VT, Mask, N1);
10063 SDValue Shift = DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0), Diff);
10064 return DAG.getNode(ISD::AND, DL, VT, Shift, Mask);
10073 SDValue HiBitsMask = DAG.getNode(ISD::SHL, DL, VT, AllBits, N1);
10074 return DAG.getNode(ISD::AND, DL, VT, N0.getOperand(0), HiBitsMask);
10086 SDValue Shl0 = DAG.getNode(ISD::SHL, SDLoc(N0), VT, N0.getOperand(0), N1);
10087 AddToWorklist(Shl0.getNode());
10092 return DAG.getNode(N0.getOpcode(), DL, VT, Shl0, Shl1, Flags);
10110 SDValue ExtX = DAG.getNode(N0.getOpcode(), DL, VT, Add.getOperand(0));
10111 SDValue ShlX = DAG.getNode(ISD::SHL, DL, VT, ExtX, N1);
10112 return DAG.getNode(ISD::ADD, DL, VT, ShlX, ShlC);
10122 return DAG.getNode(ISD::MUL, DL, VT, N0.getOperand(0), Shl);
10141 DAG.getZExtOrTrunc(DAG.getNode(ISD::AND, DL, ShiftVT, Y, NegY), DL, VT);
10142 return DAG.getNode(ISD::MUL, DL, VT, And, N0);
10158 ISD::isConstantSplatVector(N1.getNode(), ShlVal)) {
10278 DAG.getNode(MulhOpcode, DL, NarrowVT, LeftOp.getOperand(0), MulhRightOp);
10300 return DAG.getNode(N0.getOpcode(), DL, VT, OldLHS.getOperand(0),
10305 SDValue NewBitReorder = DAG.getNode(Opcode, DL, VT, OldRHS);
10306 return DAG.getNode(N0.getOpcode(), DL, VT, OldLHS.getOperand(0),
10311 SDValue NewBitReorder = DAG.getNode(Opcode, DL, VT, OldLHS);
10312 return DAG.getNode(N0.getOpcode(), DL, VT, NewBitReorder,
10377 return DAG.getNode(ISD::SRA, DL, VT, N0.getOperand(0), ShiftValue);
10409 SDValue Shift = DAG.getNode(ISD::SRL, DL, VT,
10411 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, TruncVT,
10413 return DAG.getNode(ISD::SIGN_EXTEND, DL,
10454 Add = DAG.getNode(ISD::ADD, DL, TruncVT, Trunc, ShiftC);
10456 Add = DAG.getNode(ISD::SUB, DL, TruncVT, ShiftC, Trunc);
10466 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
10467 return DAG.getNode(ISD::SRA, DL, VT, N0, NewOp1);
10486 Amt = DAG.getNode(ISD::ADD, DL, LargeShiftVT, Amt,
10489 DAG.getNode(ISD::SRA, DL, LargeVT, N0Op0.getOperand(0), Amt);
10490 return DAG.getNode(ISD::TRUNCATE, DL, VT, SRA);
10501 return DAG.getNode(ISD::SRL, DL, VT, N0, N1);
10568 SDValue Sum = DAG.getNode(ISD::ADD, DL, ShiftVT, N1, N0.getOperand(1));
10569 return DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0), Sum);
10589 SDValue NewShift = DAG.getNode(ISD::SRL, DL, InnerShiftVT,
10591 return DAG.getNode(ISD::TRUNCATE, DL, VT, NewShift);
10598 SDValue NewShift = DAG.getNode(ISD::SRL, DL, InnerShiftVT,
10603 SDValue And = DAG.getNode(ISD::AND, DL, InnerShiftVT, NewShift, Mask);
10604 return DAG.getNode(ISD::TRUNCATE, DL, VT, And);
10625 SDValue Diff = DAG.getNode(ISD::SUB, DL, ShiftVT, N01, N1);
10627 Mask = DAG.getNode(ISD::SRL, DL, VT, Mask, N01);
10628 Mask = DAG.getNode(ISD::SHL, DL, VT, Mask, Diff);
10629 SDValue Shift = DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0), Diff);
10630 return DAG.getNode(ISD::AND, DL, VT, Shift, Mask);
10636 SDValue Diff = DAG.getNode(ISD::SUB, DL, ShiftVT, N1, N01);
10638 Mask = DAG.getNode(ISD::SRL, DL, VT, Mask, N1);
10639 SDValue Shift = DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0), Diff);
10640 return DAG.getNode(ISD::AND, DL, VT, Shift, Mask);
10657 DAG.getNode(ISD::SRL, DL0, SmallVT, N0.getOperand(0),
10659 AddToWorklist(SmallShift.getNode());
10661 return DAG.getNode(ISD::AND, DL, VT,
10662 DAG.getNode(ISD::ANY_EXTEND, DL, VT, SmallShift),
10671 return DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0), N1);
10701 Op = DAG.getNode(ISD::SRL, DL, VT, Op,
10703 AddToWorklist(Op.getNode());
10705 return DAG.getNode(ISD::XOR, DL, VT, Op, DAG.getConstant(1, DL, VT));
10712 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
10713 return DAG.getNode(ISD::SRL, DL, VT, N0, NewOp1);
10800 return DAG.getNode(N->getOpcode(), DL, VT, N0, N1,
10813 return DAG.getNode(
10817 return DAG.getNode(
10846 AddToWorklist(NewPtr.getNode());
10868 return DAG.getNode(ISD::SRL, DL, VT, N1, N2);
10870 return DAG.getNode(ISD::SHL, DL, VT, N0, N2);
10880 return DAG.getNode(RotOpc, DL, VT, N0, N2);
10908 return DAG.getNode(ISD::SHL, DL, VT, N0, N1);
10914 return DAG.getNode(ISD::SHL, DL, VT, N0, N1);
10928 N = N->getOperand(0).getNode();
10953 SDValue ABD = DAG.getNode(ISD::ABDS, DL, VT, Op0, Op1);
10974 SDValue ABD = DAG.getNode(ABDOpcode, DL, MaxVT,
10975 DAG.getNode(ISD::TRUNCATE, DL, MaxVT, Op0),
10976 DAG.getNode(ISD::TRUNCATE, DL, MaxVT, Op1));
10977 ABD = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, ABD);
10984 SDValue ABD = DAG.getNode(ABDOpcode, DL, VT, Op0, Op1);
11016 return DAG.getNode(
11018 DAG.getNode(ISD::ABS, DL, ExtVT,
11019 DAG.getNode(ISD::TRUNCATE, DL, ExtVT, N0.getOperand(0))));
11043 SDValue BSwap = DAG.getNode(ISD::BSWAP, DL, VT, N0.getOperand(0));
11044 return DAG.getNode(ISD::BITREVERSE, DL, VT, BSwap);
11060 Res = DAG.getNode(ISD::SHL, DL, VT, Res,
11063 Res = DAG.getNode(ISD::BSWAP, DL, HalfVT, Res);
11077 SDValue NewSwap = DAG.getNode(ISD::BSWAP, DL, VT, N0.getOperand(0));
11079 return DAG.getNode(InverseShift, DL, VT, NewSwap, N0.getOperand(1));
11107 return DAG.getNode(ISD::SHL, DL, VT, X, Y);
11112 return DAG.getNode(ISD::SRL, DL, VT, X, Y);
11129 return DAG.getNode(ISD::CTLZ_ZERO_UNDEF, DL, VT, N0);
11158 return DAG.getNode(ISD::CTTZ_ZERO_UNDEF, DL, VT, N0);
11196 return DAG.getNode(ISD::CTPOP, DL, VT, N0.getOperand(0));
11211 SDValue PopCnt = DAG.getNode(ISD::CTPOP, DL, HalfVT,
11254 return DAG.getNode(IEEEOpcode, DL, VT, LHS, RHS);
11258 return DAG.getNode(Opcode, DL, VT, LHS, RHS);
11269 return DAG.getNode(IEEEOpcode, DL, VT, LHS, RHS);
11273 return DAG.getNode(Opcode, DL, VT, LHS, RHS);
11314 return DAG.getNode(ISD::FNEG, DL, VT, Combined);
11346 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, X, ShAmtC);
11347 return DAG.getNode(ISD::OR, DL, VT, Sra, C1);
11352 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, X, ShAmtC);
11353 return DAG.getNode(ISD::AND, DL, VT, Sra, C1);
11410 DAG.getNode(ISD::XOR, DL, CondVT, Cond, DAG.getConstant(1, DL, CondVT));
11460 return DAG.getNode(ISD::ADD, DL, VT, Cond, N2);
11466 return DAG.getNode(ISD::ADD, DL, VT, Cond, N2);
11474 return DAG.getNode(ISD::SHL, DL, VT, Cond, ShAmtC);
11480 return DAG.getNode(ISD::OR, DL, VT, Cond, N2);
11487 return DAG.getNode(ISD::OR, DL, VT, NotCond, N1);
11514 return matcher.getNode(ISD::OR, DL, VT, Cond, DAG.getFreeze(F));
11519 return matcher.getNode(ISD::AND, DL, VT, Cond, DAG.getFreeze(T));
11524 matcher.getNode(ISD::XOR, DL, VT, Cond, DAG.getAllOnesConstant(DL, VT));
11525 return matcher.getNode(ISD::OR, DL, VT, NotCond, DAG.getFreeze(T));
11531 matcher.getNode(ISD::XOR, DL, VT, Cond, DAG.getAllOnesConstant(DL, VT));
11532 return matcher.getNode(ISD::AND, DL, VT, NotCond, DAG.getFreeze(F));
11564 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, Cond0, ShiftAmt);
11565 return DAG.getNode(ISD::AND, DL, VT, Sra, DAG.getFreeze(N1));
11572 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, Cond0, ShiftAmt);
11573 return DAG.getNode(ISD::OR, DL, VT, Sra, DAG.getFreeze(N2));
11583 SDValue Sra = DAG.getNode(ISD::SRA, DL, VT, Cond0, ShiftAmt);
11585 return DAG.getNode(ISD::AND, DL, VT, Not, DAG.getFreeze(N2));
11641 DAG.getNode(ISD::SELECT, DL, N1.getValueType(), Cond1, N1, N2, Flags);
11643 return DAG.getNode(ISD::SELECT, DL, N1.getValueType(), Cond0,
11647 recursivelyDeleteUnusedNodes(InnerSelect.getNode());
11653 SDValue InnerSelect = DAG.getNode(ISD::SELECT, DL, N1.getValueType(),
11656 return DAG.getNode(ISD::SELECT, DL, N1.getValueType(), Cond0, N1,
11660 recursivelyDeleteUnusedNodes(InnerSelect.getNode());
11671 SDValue And = DAG.getNode(ISD::AND, DL, N0.getValueType(), N0, N1_0);
11672 return DAG.getNode(ISD::SELECT, DL, N1.getValueType(), And, N1_1,
11677 return DAG.getNode(ISD::SELECT, DL, N1.getValueType(), Combined, N1_1,
11690 SDValue Or = DAG.getNode(ISD::OR, DL, N0.getValueType(), N0, N2_0);
11691 return DAG.getNode(ISD::SELECT, DL, N1.getValueType(), Or, N1,
11696 return DAG.getNode(ISD::SELECT, DL, N1.getValueType(), Combined, N1,
11740 SDValue UAO = DAG.getNode(ISD::UADDO, DL, VTs, Cond0, N2.getOperand(1));
11751 SDValue SelectNode = DAG.getNode(ISD::SELECT_CC, DL, VT, Cond0, Cond1, N1,
11801 else if (Cond->getOperand(i).getNode() != BottomHalf)
11813 else if (Cond->getOperand(i).getNode() != TopHalf)
11820 return DAG.getNode(
11841 BasePtr = DAG.getNode(ISD::ADD, DL, VT, BasePtr, SplatVal);
11851 BasePtr = DAG.getNode(ISD::ADD, DL, VT, BasePtr, SplatVal);
11857 BasePtr = DAG.getNode(ISD::ADD, DL, VT, BasePtr, SplatVal);
11906 if (ISD::isConstantSplatVectorAllZeros(Mask.getNode()))
11936 if (ISD::isConstantSplatVectorAllZeros(Mask.getNode()))
11965 if (ISD::isConstantSplatVectorAllZeros(Mask.getNode()))
11975 ISD::isConstantSplatVectorAllOnes(Mask.getNode())) &&
11987 if (ISD::isConstantSplatVectorAllOnes(Mask.getNode()) && MST->isUnindexed() &&
12063 if (ISD::isConstantSplatVector(Mask.getNode(), SplatVal))
12070 if (ISD::isBuildVectorOfConstantSDNodes(Mask.getNode())) {
12082 SDValue VecI = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ScalarVT, Vec,
12091 ? DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ScalarVT, Passthru,
12142 if (ISD::isConstantSplatVectorAllZeros(Mask.getNode()))
12168 if (ISD::isConstantSplatVectorAllZeros(Mask.getNode()))
12173 if (ISD::isConstantSplatVectorAllOnes(Mask.getNode()) && MLD->isUnindexed() &&
12214 !ISD::isBuildVectorOfConstantSDNodes(N1.getNode()) ||
12215 !ISD::isBuildVectorOfConstantSDNodes(N2.getNode()))
12250 SDValue ExtendedCond = DAG.getNode(ExtendOpcode, DL, VT, Cond);
12251 return DAG.getNode(ISD::ADD, DL, VT, ExtendedCond, N2);
12256 if (ISD::isConstantSplatVector(N1.getNode(), Pow2C) && Pow2C.isPowerOf2() &&
12260 return DAG.getNode(ISD::SHL, DL, VT, ZextCond, ShAmtC);
12311 return DAG.getNode(
12313 DAG.getNode(ISD::AND, DL, N0.getValueType(), N1.getOperand(1), N0));
12325 bool RHSIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
12328 (ISD::isBuildVectorAllOnes(RHS.getNode()) && CC == ISD::SETGT)) &&
12330 isAbs = ISD::isBuildVectorAllZeros(N2.getOperand(0).getNode());
12333 isAbs = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
12337 return DAG.getNode(ISD::ABS, DL, VT, LHS);
12339 SDValue Shift = DAG.getNode(
12342 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, LHS, Shift);
12343 AddToWorklist(Shift.getNode());
12344 AddToWorklist(Add.getNode());
12345 return DAG.getNode(ISD::XOR, DL, VT, Add, Shift);
12387 SDValue WideLHS = DAG.getNode(ExtOpcode, DL, WideVT, LHS);
12388 SDValue WideRHS = DAG.getNode(ExtOpcode, DL, WideVT, RHS);
12412 return DAG.getNode(ABDOpc, DL, VT, LHS, RHS);
12419 return DAG.getNode(ABDOpc, DL, VT, LHS, RHS);
12433 if (ISD::isConstantSplatVectorAllOnes(N1.getNode())) {
12436 } else if (ISD::isConstantSplatVectorAllOnes(N2.getNode())) {
12455 return DAG.getNode(ISD::UADDSAT, DL, VT, OpLHS, OpRHS);
12469 return DAG.getNode(ISD::UADDSAT, DL, VT, OpLHS, OpRHS);
12480 if (ISD::isConstantSplatVectorAllZeros(N1.getNode())) {
12483 } else if (ISD::isConstantSplatVectorAllZeros(N2.getNode())) {
12512 return DAG.getNode(ISD::USUBSAT, DL, VT, OpLHS, OpRHS);
12530 return DAG.getNode(ISD::USUBSAT, DL, VT, OpLHS, OpRHS);
12540 ISD::isConstantSplatVector(OpRHS.getNode(), SplatValue) &&
12541 ISD::isConstantSplatVectorAllZeros(CondRHS.getNode()) &&
12546 return DAG.getNode(ISD::USUBSAT, DL, VT, OpLHS, OpRHS);
12559 if (ISD::isConstantSplatVectorAllOnes(N0.getNode()))
12562 if (ISD::isConstantSplatVectorAllZeros(N0.getNode()))
12570 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())) {
12609 AddToWorklist(SCC.getNode());
12613 if (auto *SCCC = dyn_cast<ConstantSDNode>(SCC.getNode()))
12624 DAG.getNode(ISD::SELECT_CC, DL, N2.getValueType(), SCC.getOperand(0),
12658 if (NewSetCC.getNode() == N)
12748 DAG.getNode(NewShiftOpc, DL, OpVT, ShiftOrRotate.getOperand(0),
12760 DAG.getNode(ISD::AND, DL, OpVT, ShiftOrRotate.getOperand(0),
12782 return DAG.getNode(ISD::SETCC, SDLoc(N), N->getVTList(), LHS, RHS, Cond);
12856 SDValue Ext1 = DAG.getNode(Opcode, DL, VT, Op1);
12857 SDValue Ext2 = DAG.getNode(Opcode, DL, VT, Op2);
12881 return DAG.getNode(Opcode, DL, VT, N0);
12904 DAG.getNode(FoldOpc, DL, VT, Op1),
12905 DAG.getNode(FoldOpc, DL, VT, Op2));
12914 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())))
13022 Ops.push_back(DAG.getNode(ExtType, DL, ExtLoad->getValueType(0), SOp));
13026 CombineTo(SetCC, DAG.getNode(ISD::SETCC, DL, SetCC->getValueType(0), Ops));
13112 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
13113 SDValue NewValue = DAG.getNode(ISD::CONCAT_VECTORS, DL, DstVT, Loads);
13116 AddToWorklist(NewChain.getNode());
13123 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(), NewValue);
13125 CombineTo(N0.getNode(), Trunc, NewChain);
13171 if (!ExtendUsesToFormExtLoad(VT, N1.getNode(), N1.getOperand(0),
13181 SDValue Shift = DAG.getNode(N1.getOpcode(), DL1, VT, ExtLoad,
13186 SDValue And = DAG.getNode(N0.getOpcode(), DL0, VT, Shift,
13194 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(Load),
13200 recursivelyDeleteUnusedNodes(N0.getNode());
13241 CastA = DAG.getNode(CastOpcode, DL, VT, A, Cast->getOperand(1));
13242 CastB = DAG.getNode(CastOpcode, DL, VT, B, Cast->getOperand(1));
13244 CastA = DAG.getNode(CastOpcode, DL, VT, A);
13245 CastB = DAG.getNode(CastOpcode, DL, VT, B);
13247 return DAG.getNode(ISD::VSELECT, DL, VT, SetCC, CastA, CastB);
13256 SDNode *N0Node = N0.getNode();
13290 if (!ISD::isNON_EXTLoad(N0.getNode()) || !ISD::isUNINDEXEDLoad(N0.getNode()))
13339 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(), ExtLoad);
13364 SDValue PassThru = DAG.getNode(ExtOpc, dl, VT, Ld->getPassThru());
13369 DAG.ReplaceAllUsesOfValueWith(SDValue(Ld, 1), SDValue(NewLoad.getNode(), 1));
13398 DAG.getNode(ISD::TRUNCATE, SDLoc(ALoad), OrigVT, SDValue(NewALoad, 0)));
13434 return DAG.getNode(ShiftOpcode, DL, VT, NotX, ShiftAmount);
13499 if (!(ISD::isNON_EXTLoad(V.getNode()) &&
13500 ISD::isUNINDEXEDLoad(V.getNode()) &&
13511 if (UI.getUse().getResNo() != 0 || User == N0.getNode())
13523 SDValue Ext0 = DAG.getNode(ExtOpcode, DL, VT, N00);
13524 SDValue Ext1 = DAG.getNode(ExtOpcode, DL, VT, N01);
13584 return DAG.getNode(ISD::SIGN_EXTEND, DL, VT, N0.getOperand(0));
13590 return DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, SDLoc(N), VT,
13599 SDValue T = DAG.getNode(ISD::TRUNCATE, DL, ExtVT, N00);
13600 return DAG.getNode(ISD::SIGN_EXTEND, DL, VT, T);
13607 if (SDValue NarrowLoad = reduceLoadWidth(N0.getNode())) {
13608 SDNode *oye = N0.getOperand(0).getNode();
13609 if (NarrowLoad.getNode() != N0.getNode()) {
13610 CombineTo(N0.getNode(), NarrowLoad);
13634 return DAG.getNode(ISD::SIGN_EXTEND, DL, VT, Op);
13639 return DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
13646 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N0), VT, Op);
13648 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT, Op);
13649 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, Op,
13691 bool DoXform = ExtendUsesToFormExtLoad(VT, N0.getNode(), N0.getOperand(0),
13699 SDValue And = DAG.getNode(N0.getOpcode(), DL, VT,
13708 DAG.getNode(ISD::TRUNCATE, DL, N0.getValueType(), And);
13709 CombineTo(N0.getNode(), TruncAnd);
13714 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(LN00),
13735 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0, Flags);
13757 return DAG.getNode(ISD::ADD, DL, VT, Zext, DAG.getAllOnesConstant(DL, VT));
13766 if (SDValue NewXor = visitXOR(N0.getNode())) {
13769 if (NewXor.getNode() == N0.getNode()) {
13776 return DAG.getNode(ISD::SIGN_EXTEND, DL, VT, NewXor);
13779 SDValue Zext = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
13780 return DAG.getNode(ISD::ADD, DL, VT, Zext, DAG.getAllOnesConstant(DL, VT));
13809 return DAG.getNode(ISD::CTPOP, DL, VT, NewZext);
13834 DAG.getNode(ISD::SIGN_EXTEND, SDLoc(Abs), LegalVT, Abs.getOperand(0));
13835 SDValue NewAbs = DAG.getNode(ISD::ABS, SDLoc(Abs), LegalVT, SExt);
13861 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0), Flags);
13868 return DAG.getNode(ISD::ZERO_EXTEND_VECTOR_INREG, DL, VT, N0.getOperand(0));
13885 DAG.salvageDebugInfo(*N0.getNode());
13895 if (SDValue NarrowLoad = reduceLoadWidth(N0.getNode())) {
13896 SDNode *oye = N0.getOperand(0).getNode();
13897 if (NarrowLoad.getNode() != N0.getNode()) {
13898 CombineTo(N0.getNode(), NarrowLoad);
13925 return DAG.getNode(ISD::SIGN_EXTEND, DL, VT, Op);
13930 return DAG.getNode(ISD::TRUNCATE, DL, VT, Op);
13941 AddToWorklist(Op.getNode());
13951 AddToWorklist(Op.getNode());
13970 return DAG.getNode(ISD::AND, DL, VT,
14019 DoXform = ExtendUsesToFormExtLoad(VT, N0.getNode(), N0.getOperand(0),
14027 SDValue And = DAG.getNode(N0.getOpcode(), DL, VT,
14036 DAG.getNode(ISD::TRUNCATE, DL, N0.getValueType(), And);
14037 CombineTo(N0.getNode(), TruncAnd);
14042 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(LN00),
14082 SDValue VSetCC = DAG.getNode(ISD::SETCC, DL, VT, N0.getOperand(0),
14092 DAG.getNode(ISD::SETCC, DL, MatchingVectorType, N0.getOperand(0),
14106 return DAG.getNode(ISD::ZERO_EXTEND, DL, VT, SCC);
14137 ShAmt = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShAmt);
14139 return DAG.getNode(N0.getOpcode(), DL, VT,
14140 DAG.getNode(ISD::ZERO_EXTEND, DL, VT, ShVal), ShAmt);
14187 return DAG.getNode(N0.getOpcode(), DL, VT, N0.getOperand(0), Flags);
14196 return DAG.getNode(N0.getOpcode(), DL, VT, N0.getOperand(0));
14201 if (SDValue NarrowLoad = reduceLoadWidth(N0.getNode())) {
14202 SDNode *oye = N0.getOperand(0).getNode();
14203 if (NarrowLoad.getNode() != N0.getNode()) {
14204 CombineTo(N0.getNode(), NarrowLoad);
14223 SDValue Y = DAG.getNode(ISD::ANY_EXTEND, DL, VT, N0.getOperand(1));
14225 return DAG.getNode(ISD::AND, DL, VT, X, Y);
14237 } else if (ISD::isNON_EXTLoad(N0.getNode()) &&
14238 ISD::isUNINDEXEDLoad(N0.getNode()) &&
14259 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(), ExtLoad);
14269 if (N0.getOpcode() == ISD::LOAD && !ISD::isNON_EXTLoad(N0.getNode()) &&
14270 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
14358 SDValue NewAssert = DAG.getNode(Opcode, DL, BigA.getValueType(),
14360 return DAG.getNode(ISD::TRUNCATE, DL, N->getValueType(0), NewAssert);
14373 SDValue NewAssert = DAG.getNode(Opcode, DL, BigA.getValueType(),
14375 return DAG.getNode(ISD::TRUNCATE, DL, N->getValueType(0), NewAssert);
14412 return DAG.getNode(N0.getOpcode(), DL, N0.getValueType(), LHS, RHS);
14624 AddToWorklist(NewPtr.getNode());
14652 Result = DAG.getNode(ISD::SHL, DL, VT, Result,
14662 Result = DAG.getNode(ISD::SHL, DL, VT, Result, ShiftC);
14684 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0, N1);
14693 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0.getOperand(0),
14706 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00);
14724 return DAG.getNode(ISD::SIGN_EXTEND_VECTOR_INREG, SDLoc(N), VT, N00);
14733 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00);
14760 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0.getOperand(0),
14769 if (ISD::isEXTLoad(N0.getNode()) &&
14770 ISD::isUNINDEXEDLoad(N0.getNode()) &&
14781 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
14782 AddToWorklist(ExtLoad.getNode());
14787 if (ISD::isZEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
14798 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
14813 CombineTo(N0.getNode(), ExtMaskedLoad, ExtMaskedLoad.getValue(1));
14831 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
14832 AddToWorklist(ExtLoad.getNode());
14839 if (SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
14841 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, BSwap, N1);
14858 DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), InnerExtVT, Extendee);
14859 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), VT, SignExtExtendee,
14896 return DAG.getNode(Opcode, DL, VT, Src);
14938 return DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(0));
14950 return DAG.getNode(N0.getOpcode(), DL, VT, N0.getOperand(0));
14953 return DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(0));
14967 SDValue TrX = DAG.getNode(ISD::TRUNCATE, DL, VT, X);
14968 return DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, VT, TrX, ExtVal);
15003 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, TrTy,
15015 SDValue TruncOp0 = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(1));
15016 SDValue TruncOp1 = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(2));
15017 return DAG.getNode(ISD::SELECT, DL, VT, Cond, TruncOp0, TruncOp1);
15030 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(0));
15033 AddToWorklist(Amt.getNode());
15035 return DAG.getNode(ISD::SHL, DL, VT, Trunc, Amt);
15039 if (SDValue V = foldSubToUSubSat(VT, N0.getNode(), DL))
15054 SDValue TruncOp = DAG.getNode(ISD::TRUNCATE, DL, SVT, Op);
15066 VT, DL, DAG.getNode(ISD::TRUNCATE, DL, SVT, N0->getOperand(0)));
15107 if (N0.hasOneUse() && ISD::isUNINDEXEDLoad(N0.getNode())) {
15147 assert(V.getNode() && "The single defined operand is empty!");
15154 SDValue NV = DAG.getNode(ISD::TRUNCATE, SDLoc(V), VTs[i], V);
15155 AddToWorklist(NV.getNode());
15158 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Opnds);
15173 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, VecSrc,
15193 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N0->getOperand(0)), VT,
15219 SDValue NarrowL = DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(0));
15220 SDValue NarrowR = DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(1));
15221 return DAG.getNode(N0.getOpcode(), DL, VT, NarrowL, NarrowR);
15235 SDValue X = DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(0));
15236 SDValue Y = DAG.getNode(ISD::TRUNCATE, DL, VT, N0.getOperand(1));
15238 return DAG.getNode(N0.getOpcode(), DL, VTs, X, Y, N0.getOperand(2));
15262 return Elt.getNode();
15263 return Elt.getOperand(Elt.getResNo()).getNode();
15360 SDValue CastOp0 = DAG.getNode(ISD::BITCAST, SDLoc(N), VT, LogicOp0);
15361 SDValue FPOp = DAG.getNode(FPOpcode, SDLoc(N), VT, CastOp0);
15364 return DAG.getNode(ISD::FNEG, SDLoc(N), VT, FPOp);
15390 return ConstantFoldBITCASTofBUILD_VECTOR(N0.getNode(),
15393 // If the input is a constant, let getNode fold it.
15404 if (C.getNode() != N)
15420 (ISD::isBuildVectorOfConstantSDNodes(V.getNode()) &&
15424 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
15431 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
15474 AddToWorklist(NewConv.getNode());
15484 AddToWorklist(FlipBit.getNode());
15488 DAG.getNode(ISD::EXTRACT_ELEMENT, SDLoc(NewConv), MVT::i64, NewConv,
15491 AddToWorklist(Hi.getNode());
15492 FlipBit = DAG.getNode(ISD::AND, SDLoc(N0), MVT::i64, Hi, SignBit);
15493 AddToWorklist(FlipBit.getNode());
15496 DAG.getNode(ISD::BUILD_PAIR, SDLoc(N0), VT, FlipBit, FlipBit);
15497 AddToWorklist(FlipBits.getNode());
15498 return DAG.getNode(ISD::XOR, DL, VT, NewConv, FlipBits);
15502 return DAG.getNode(ISD::XOR, DL, VT,
15505 return DAG.getNode(ISD::AND, DL, VT,
15527 AddToWorklist(X.getNode());
15532 X = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, X);
15533 AddToWorklist(X.getNode());
15538 X = DAG.getNode(ISD::SRL, DL,
15542 AddToWorklist(X.getNode());
15543 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
15544 AddToWorklist(X.getNode());
15550 AddToWorklist(Cst.getNode());
15552 AddToWorklist(X.getNode());
15553 SDValue XorResult = DAG.getNode(ISD::XOR, SDLoc(N0), VT, Cst, X);
15554 AddToWorklist(XorResult.getNode());
15555 SDValue XorResult64 = DAG.getNode(
15559 AddToWorklist(XorResult64.getNode());
15561 DAG.getNode(ISD::AND, SDLoc(XorResult64), MVT::i64, XorResult64,
15563 AddToWorklist(FlipBit.getNode());
15565 DAG.getNode(ISD::BUILD_PAIR, SDLoc(N0), VT, FlipBit, FlipBit);
15566 AddToWorklist(FlipBits.getNode());
15567 return DAG.getNode(ISD::XOR, SDLoc(N), VT, Cst, FlipBits);
15570 X = DAG.getNode(ISD::AND, SDLoc(X), VT,
15572 AddToWorklist(X.getNode());
15575 Cst = DAG.getNode(ISD::AND, SDLoc(Cst), VT,
15577 AddToWorklist(Cst.getNode());
15579 return DAG.getNode(ISD::OR, SDLoc(N), VT, X, Cst);
15585 if (SDValue CombineLD = CombineConsecutiveLoads(N0.getNode(), VT))
15679 if (llvm::ISD::isBuildVectorAllOnes(N0.getNode()))
15681 if (llvm::ISD::isBuildVectorOfConstantSDNodes(N0.getNode())) {
15734 DAG.UpdateNodeOperands(FrozenMaybePoisonOperand.getNode(),
15763 R = DAG.getNode(N0.getOpcode(), SDLoc(N0), N0->getVTList(), Ops);
15790 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(BV), SrcEltVT, Op);
15792 AddToWorklist(Ops.back().getNode());
15806 BV = ConstantFoldBITCASTofBUILD_VECTOR(BV, IntVT).getNode();
15814 SDNode *Tmp = ConstantFoldBITCASTofBUILD_VECTOR(BV, TmpVT).getNode();
15927 return matcher.getNode(PreferredFusedOpcode, SL, VT, N0.getOperand(0),
15934 return matcher.getNode(PreferredFusedOpcode, SL, VT, N1.getOperand(0),
15964 SDValue CDE = matcher.getNode(PreferredFusedOpcode, SL, VT, C, D, E);
15983 return matcher.getNode(
15985 matcher.getNode(ISD::FP_EXTEND, SL, VT, N00.getOperand(0)),
15986 matcher.getNode(ISD::FP_EXTEND, SL, VT, N00.getOperand(1)), N1);
15997 return matcher.getNode(
15999 matcher.getNode(ISD::FP_EXTEND, SL, VT, N10.getOperand(0)),
16000 matcher.getNode(ISD::FP_EXTEND, SL, VT, N10.getOperand(1)), N0);
16010 return matcher.getNode(
16012 matcher.getNode(PreferredFusedOpcode, SL, VT,
16013 matcher.getNode(ISD::FP_EXTEND, SL, VT, U),
16014 matcher.getNode(ISD::FP_EXTEND, SL, VT, V), Z));
16037 return matcher.getNode(
16039 matcher.getNode(ISD::FP_EXTEND, SL, VT, X),
16040 matcher.getNode(ISD::FP_EXTEND, SL, VT, Y),
16041 matcher.getNode(PreferredFusedOpcode, SL, VT,
16042 matcher.getNode(ISD::FP_EXTEND, SL, VT, U),
16043 matcher.getNode(ISD::FP_EXTEND, SL, VT, V), Z));
16151 return matcher.getNode(PreferredFusedOpcode, SL, VT, XY.getOperand(0),
16153 matcher.getNode(ISD::FNEG, SL, VT, Z));
16162 return matcher.getNode(
16164 matcher.getNode(ISD::FNEG, SL, VT, YZ.getOperand(0)),
16194 return matcher.getNode(PreferredFusedOpcode, SL, VT,
16195 matcher.getNode(ISD::FNEG, SL, VT, N00), N01,
16196 matcher.getNode(ISD::FNEG, SL, VT, N1));
16208 return matcher.getNode(
16210 matcher.getNode(ISD::FP_EXTEND, SL, VT, N00.getOperand(0)),
16211 matcher.getNode(ISD::FP_EXTEND, SL, VT, N00.getOperand(1)),
16212 matcher.getNode(ISD::FNEG, SL, VT, N1));
16224 return matcher.getNode(
16226 matcher.getNode(
16228 matcher.getNode(ISD::FP_EXTEND, SL, VT, N10.getOperand(0))),
16229 matcher.getNode(ISD::FP_EXTEND, SL, VT, N10.getOperand(1)), N0);
16246 return matcher.getNode(
16248 matcher.getNode(
16250 matcher.getNode(ISD::FP_EXTEND, SL, VT, N000.getOperand(0)),
16251 matcher.getNode(ISD::FP_EXTEND, SL, VT, N000.getOperand(1)),
16270 return matcher.getNode(
16272 matcher.getNode(
16274 matcher.getNode(ISD::FP_EXTEND, SL, VT, N000.getOperand(0)),
16275 matcher.getNode(ISD::FP_EXTEND, SL, VT, N000.getOperand(1)),
16287 return isContractableFMUL(N) && isReassociable(N.getNode());
16302 return matcher.getNode(
16304 matcher.getNode(PreferredFusedOpcode, SL, VT,
16307 matcher.getNode(ISD::FNEG, SL, VT, N1)));
16317 return matcher.getNode(
16319 matcher.getNode(ISD::FNEG, SL, VT, N1.getOperand(0)),
16321 matcher.getNode(PreferredFusedOpcode, SL, VT,
16322 matcher.getNode(ISD::FNEG, SL, VT, N20), N21, N0));
16334 return matcher.getNode(
16336 matcher.getNode(
16338 matcher.getNode(ISD::FP_EXTEND, SL, VT, N020.getOperand(0)),
16339 matcher.getNode(ISD::FP_EXTEND, SL, VT, N020.getOperand(1)),
16340 matcher.getNode(ISD::FNEG, SL, VT, N1)));
16358 return matcher.getNode(
16360 matcher.getNode(ISD::FP_EXTEND, SL, VT, N00.getOperand(0)),
16361 matcher.getNode(ISD::FP_EXTEND, SL, VT, N00.getOperand(1)),
16362 matcher.getNode(
16364 matcher.getNode(ISD::FP_EXTEND, SL, VT, N002.getOperand(0)),
16365 matcher.getNode(ISD::FP_EXTEND, SL, VT, N002.getOperand(1)),
16366 matcher.getNode(ISD::FNEG, SL, VT, N1)));
16381 return matcher.getNode(
16383 matcher.getNode(ISD::FNEG, SL, VT, N1.getOperand(0)),
16385 matcher.getNode(
16387 matcher.getNode(ISD::FNEG, SL, VT,
16388 matcher.getNode(ISD::FP_EXTEND, SL, VT, N1200)),
16389 matcher.getNode(ISD::FP_EXTEND, SL, VT, N1201), N0));
16409 return matcher.getNode(
16411 matcher.getNode(ISD::FNEG, SL, VT,
16412 matcher.getNode(ISD::FP_EXTEND, SL, VT, N100)),
16413 matcher.getNode(ISD::FP_EXTEND, SL, VT, N101),
16414 matcher.getNode(
16416 matcher.getNode(ISD::FNEG, SL, VT,
16417 matcher.getNode(ISD::FP_EXTEND, SL, VT, N1020)),
16418 matcher.getNode(ISD::FP_EXTEND, SL, VT, N1021), N0));
16470 return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y,
16473 return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y,
16474 DAG.getNode(ISD::FNEG, SL, VT, Y));
16493 return DAG.getNode(PreferredFusedOpcode, SL, VT,
16494 DAG.getNode(ISD::FNEG, SL, VT, X.getOperand(1)), Y,
16497 return DAG.getNode(PreferredFusedOpcode, SL, VT,
16498 DAG.getNode(ISD::FNEG, SL, VT, X.getOperand(1)), Y,
16499 DAG.getNode(ISD::FNEG, SL, VT, Y));
16503 return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y,
16504 DAG.getNode(ISD::FNEG, SL, VT, Y));
16506 return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y,
16527 AddToWorklist(Fused.getNode());
16553 return DAG.getNode(ISD::FADD, DL, VT, N1, N0);
16573 return DAG.getNode(ISD::FSUB, DL, VT, N0, NegN1);
16579 return DAG.getNode(ISD::FSUB, DL, VT, N1, NegN0);
16591 SDValue Add = DAG.getNode(ISD::FADD, DL, VT, B, B);
16592 return DAG.getNode(ISD::FSUB, DL, VT, N1, Add);
16597 SDValue Add = DAG.getNode(ISD::FADD, DL, VT, B, B);
16598 return DAG.getNode(ISD::FSUB, DL, VT, N0, Add);
16625 SDValue NewC = DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1), N1);
16626 return DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(0), NewC);
16641 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1),
16643 return DAG.getNode(ISD::FMUL, DL, VT, N1, NewCFP);
16650 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1),
16652 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0), NewCFP);
16664 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N1.getOperand(1),
16666 return DAG.getNode(ISD::FMUL, DL, VT, N0, NewCFP);
16673 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N1.getOperand(1),
16675 return DAG.getNode(ISD::FMUL, DL, VT, N1.getOperand(0), NewCFP);
16685 return DAG.getNode(ISD::FMUL, DL, VT, N1,
16696 return DAG.getNode(ISD::FMUL, DL, VT, N0,
16706 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0),
16720 AddToWorklist(Fused.getNode());
16739 return DAG.getNode(ISD::STRICT_FSUB, DL, DAG.getVTList(VT, ChainVT),
16747 return DAG.getNode(ISD::STRICT_FSUB, DL, DAG.getVTList(VT, ChainVT),
16807 return DAG.getNode(ISD::FNEG, DL, VT, N1);
16817 return DAG.getNode(ISD::FNEG, DL, VT, N1->getOperand(1));
16820 return DAG.getNode(ISD::FNEG, DL, VT, N1->getOperand(0));
16826 return DAG.getNode(ISD::FADD, DL, VT, N0, NegN1);
16830 AddToWorklist(Fused.getNode());
16935 SDValue Shift = DAG.getNode(ISD::SHL, DL, NewIntVT, Log2, MantissaShiftCnt);
16937 DAG.getNode(N->getOpcode() == ISD::FMUL ? ISD::ADD : ISD::SUB, DL,
16963 return DAG.getNode(ISD::FMUL, DL, VT, N1, N0);
16983 SDValue MulConsts = DAG.getNode(ISD::FMUL, DL, VT, N01, N1);
16984 return DAG.getNode(ISD::FMUL, DL, VT, N00, MulConsts);
16993 SDValue MulConsts = DAG.getNode(ISD::FMUL, DL, VT, Two, N1);
16994 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0), MulConsts);
17005 return DAG.getNode(ISD::FADD, DL, VT, N0, N0);
17010 return DAG.getNode(ISD::FSUB, DL, VT,
17028 return DAG.getNode(ISD::FMUL, DL, VT, NegN0, NegN1);
17067 return DAG.getNode(ISD::FNEG, DL, VT,
17068 DAG.getNode(ISD::FABS, DL, VT, X));
17070 return DAG.getNode(ISD::FABS, DL, VT, X);
17079 AddToWorklist(Fused.getNode());
17108 return matcher.getNode(ISD::FMA, DL, VT, N0, N1, N2);
17124 return matcher.getNode(ISD::FMA, DL, VT, NegN0, NegN1, N2);
17137 return matcher.getNode(ISD::FADD, SDLoc(N), VT, N1, N2);
17139 return matcher.getNode(ISD::FADD, SDLoc(N), VT, N0, N2);
17144 return matcher.getNode(ISD::FMA, SDLoc(N), VT, N1, N0, N2);
17153 return matcher.getNode(
17155 matcher.getNode(ISD::FADD, DL, VT, N1, N2.getOperand(1)));
17162 return matcher.getNode(
17164 matcher.getNode(ISD::FMUL, DL, VT, N1, N0.getOperand(1)), N2);
17172 return matcher.getNode(ISD::FADD, DL, VT, N0, N2);
17176 SDValue RHSNeg = matcher.getNode(ISD::FNEG, DL, VT, N0);
17177 AddToWorklist(RHSNeg.getNode());
17178 return matcher.getNode(ISD::FADD, DL, VT, N2, RHSNeg);
17186 return matcher.getNode(ISD::FMA, DL, VT, N0.getOperand(0),
17187 matcher.getNode(ISD::FNEG, DL, VT, N1), N2);
17195 return matcher.getNode(ISD::FMUL, DL, VT, N0,
17196 matcher.getNode(ISD::FADD, DL, VT, N1,
17202 return matcher.getNode(ISD::FMUL, DL, VT, N0,
17203 matcher.getNode(ISD::FADD, DL, VT, N1,
17213 return matcher.getNode(ISD::FNEG, DL, VT, Neg);
17227 return DAG.getNode(ISD::FMAD, DL, VT, N0, N1, N2);
17294 SDValue Reciprocal = DAG.getNode(ISD::FDIV, DL, VT, FPOne, N1, Flags);
17300 SDValue NewNode = DAG.getNode(ISD::FMUL, SDLoc(U), VT, Dividend,
17303 } else if (U != Reciprocal.getNode()) {
17357 return DAG.getNode(ISD::FMUL, DL, VT, N0,
17366 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV);
17371 RV = DAG.getNode(ISD::FP_EXTEND, SDLoc(N1), VT, RV);
17372 AddToWorklist(RV.getNode());
17373 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV);
17379 RV = DAG.getNode(ISD::FP_ROUND, SDLoc(N1), VT, RV, N1.getOperand(1));
17380 AddToWorklist(RV.getNode());
17381 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV);
17394 if (Sqrt.getNode()) {
17407 SDValue AA = DAG.getNode(ISD::FMUL, DL, VT, A, A);
17409 DAG.getNode(ISD::FMUL, DL, VT, AA, Sqrt.getOperand(0));
17411 return DAG.getNode(ISD::FMUL, DL, VT, N0, Rsqrt);
17414 recursivelyDeleteUnusedNodes(AAZ.getNode());
17421 SDValue Div = DAG.getNode(ISD::FDIV, SDLoc(N1), VT, Rsqrt, Y);
17422 AddToWorklist(Div.getNode());
17423 return DAG.getNode(ISD::FMUL, DL, VT, N0, Div);
17453 return DAG.getNode(ISD::FDIV, SDLoc(N), VT, NegN0, NegN1);
17489 SDValue Div = DAG.getNode(ISD::FDIV, DL, VT, N0, N1);
17490 SDValue Rnd = DAG.getNode(ISD::FTRUNC, DL, VT, Div);
17493 MLA = DAG.getNode(ISD::FMA, DL, VT, DAG.getNode(ISD::FNEG, DL, VT, Rnd),
17496 SDValue Mul = DAG.getNode(ISD::FMUL, DL, VT, Rnd, N1);
17497 MLA = DAG.getNode(ISD::FSUB, DL, VT, N0, Mul);
17499 return NeedsCopySign ? DAG.getNode(ISD::FCOPYSIGN, DL, VT, MLA, N0) : MLA;
17571 return DAG.getNode(ISD::FABS, DL, VT, N0);
17574 return DAG.getNode(ISD::FNEG, DL, VT,
17575 DAG.getNode(ISD::FABS, SDLoc(N0), VT, N0));
17584 return DAG.getNode(ISD::FCOPYSIGN, DL, VT, N0.getOperand(0), N1);
17588 return DAG.getNode(ISD::FABS, DL, VT, N0);
17592 return DAG.getNode(ISD::FCOPYSIGN, DL, VT, N0, N1.getOperand(1));
17597 return DAG.getNode(ISD::FCOPYSIGN, DL, VT, N0, N1.getOperand(0));
17644 return DAG.getNode(ISD::FCBRT, SDLoc(N), VT, N->getOperand(0));
17679 SDValue Sqrt = DAG.getNode(ISD::FSQRT, DL, VT, N->getOperand(0));
17680 SDValue SqrtSqrt = DAG.getNode(ISD::FSQRT, DL, VT, Sqrt);
17684 return DAG.getNode(ISD::FMUL, DL, VT, Sqrt, SqrtSqrt);
17708 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0.getOperand(0));
17712 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0.getOperand(0));
17731 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
17739 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
17783 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
17791 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
17841 return DAG.getNode(ExtOp, SDLoc(N), VT, Src);
17844 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Src);
17860 return DAG.getNode(ISD::FP_TO_SINT, SDLoc(N), VT, N0);
17875 return DAG.getNode(ISD::FP_TO_UINT, SDLoc(N), VT, N0);
17890 return DAG.getNode(N->getOpcode(), SDLoc(N), VT, N0);
17935 return DAG.getNode(
17949 SDValue Tmp = DAG.getNode(ISD::FP_ROUND, SDLoc(N0), VT,
17951 AddToWorklist(Tmp.getNode());
17952 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
17977 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, N0);
17982 return DAG.getNode(ISD::FP16_TO_FP, SDLoc(N), VT, N0.getOperand(0));
17991 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT,
17993 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, In);
17997 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
18006 N0.getNode(),
18007 DAG.getNode(ISD::FP_ROUND, SDLoc(N0), N0.getValueType(), ExtLoad,
18025 return DAG.getNode(ISD::FCEIL, SDLoc(N), VT, N0);
18036 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0);
18060 return DAG.getNode(ISD::FFREXP, SDLoc(N), N->getVTList(), N0);
18070 return DAG.getNode(ISD::FFLOOR, SDLoc(N), VT, N0);
18082 return DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0);
18095 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N0.getOperand(1),
18122 return DAG.getNode(N->getOpcode(), SDLoc(N), VT, N1, N0);
18169 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
18178 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0.getOperand(0));
18194 return DAG.getNode(ISD::BRCOND, SDLoc(N), MVT::Other, Chain,
18242 return DAG.getNode(
18258 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
18268 return DAG.getNode(ISD::BRCOND, SDLoc(N), MVT::Other,
18331 SDValue Tmp = visitXOR(N.getNode());
18333 if (!Tmp.getNode())
18337 if (Tmp.getNode() == N.getNode())
18388 if (Simp.getNode()) AddToWorklist(Simp.getNode());
18391 if (Simp.getNode() && Simp.getOpcode() == ISD::SETCC)
18392 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
18508 if (Val == Ptr || Ptr->isPredecessorOf(Val.getNode()))
18529 if (Use.getUser() == Ptr.getNode() || Use != BasePtr)
18571 if (!canFoldInAddressingMode(Ptr.getNode(), Use, DAG, TLI))
18614 if (OtherUses[i]->getOperand(OffsetIdx).getNode() == BasePtr.getNode())
18616 assert(OtherUses[i]->getOperand(!OffsetIdx).getNode() ==
18617 BasePtr.getNode() && "Expected BasePtr operand");
18651 SDValue NewUse = DAG.getNode(Opcode,
18660 deleteAndRecombine(Ptr.getNode());
18661 AddToWorklist(Result.getNode());
18687 if (Use == Ptr.getNode())
18742 Visited.insert(Ptr.getNode());
18825 return DAG.getNode(Opc, SDLoc(LD), BP.getSimpleValueType(), BP, Inc);
18841 Val = DAG.getNode(ISD::FTRUNC, SDLoc(ST), STMemType, Val);
18846 Val = DAG.getNode(ISD::TRUNCATE, SDLoc(ST), STMemType, Val);
18869 Val = DAG.getNode(ISD::ANY_EXTEND, SDLoc(LD), LDType, Val);
18872 Val = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(LD), LDType, Val);
18875 Val = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(LD), LDType, Val);
18895 StoreSDNode *Store = dyn_cast<StoreSDNode>(Op.getNode());
18905 (Aliases.size() == 1 && Aliases.front().getNode() == Store))
18910 StoreSDNode *Store = dyn_cast<StoreSDNode>(Chain.getNode());
19007 auto Val = DAG.getNode(ISD::AND, SDLoc(LD), LDType, ST->getValue(), Mask);
19019 Val = DAG.getNode(ISD::SRL, SDLoc(LD), STType, Val,
19039 Val = DAG.getNode(ISD::TRUNCATE, SDLoc(LD), LDMemType, Val);
19050 deleteAndRecombine(Val.getNode());
19078 AddUsersToWorklist(Chain.getNode());
19133 assert(NewLoad.getNode() == N);
19159 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
19416 BaseAddr = DAG->getNode(ISD::ADD, DL, ArithType, BaseAddr,
19433 DAG->getNode(ISD::ZERO_EXTEND, SDLoc(LastInst), FinalType, LastInst);
19721 SDValue Chain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other,
19724 AddToWorklist(Chain.getNode());
19738 !ISD::isNormalLoad(V->getOperand(0).getNode()))
19783 if (LD == Chain.getNode())
19788 if (!LD->isOperandOf(Chain.getNode()))
19844 IVal = DAG.getNode(
19869 IVal = DAG.getNode(ISD::TRUNCATE, SDLoc(IVal), VT, IVal);
19928 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
19929 Chain == SDValue(N0.getNode(), 1)) {
19990 SDValue NewVal = DAG.getNode(Opc, SDLoc(Value), NewVT, NewLD,
19997 AddToWorklist(NewPtr.getNode());
19998 AddToWorklist(NewLD.getNode());
19999 AddToWorklist(NewVal.getNode());
20016 if (ISD::isNormalStore(ST) && ISD::isNormalLoad(Value.getNode()) &&
20056 AddToWorklist(NewLD.getNode());
20057 AddToWorklist(NewST.getNode());
20097 SDNode *MulVar = AddNode.getOperand(0).getNode();
20101 OtherOp = Use->getOperand(1).getNode();
20103 OtherOp = Use->getOperand(0).getNode();
20133 OtherOp->getOperand(0).getNode() == MulVar)
20154 if (Visited.insert(StoreNodes[i].MemNode->getChain().getNode()).second)
20258 StoredVal = DAG.getNode(MemVT.isVector() ? ISD::CONCAT_VECTORS
20281 Val = DAG.getNode(ISD::BUILD_VECTOR, DL, MemVT, Val);
20287 Val = DAG.getNode(OpC, SDLoc(Val), MemVT, Vec, Idx);
20294 StoredVal = DAG.getNode(MemVT.isVector() ? ISD::CONCAT_VECTORS
20327 } else if (ISD::isBuildVectorOfConstantSDNodes(Val.getNode()) ||
20328 ISD::isBuildVectorOfConstantFPSDNodes(Val.getNode())) {
20378 AddToWorklist(NewChain.getNode());
20389 if (!BasePtr.getBase().getNode() || BasePtr.getBase().isUndef())
20497 SDNode *RootNode = St->getChain().getNode();
20528 RootNode = Ldn->getChain().getNode();
20577 Worklist.push_back(Op.getNode());
20603 Worklist.push_back(Op.getNode());
20691 else if (ISD::isBuildVectorAllZeros(StoredVal.getNode()))
20888 if (LdBasePtr.getBase().getNode()) {
21078 AddToWorklist(NewStoreChain.getNode());
21107 StoreOp = DAG.getNode(ISD::ROTL, LoadDL, JointMemOpVT, NewLoad, RotAmt);
21133 SDValue(NewLoad.getNode(), 1));
21142 recursivelyDeleteUnusedNodes(Val.getNode());
21260 SDValue Token = DAG.getNode(ISD::TokenFactor, SL,
21264 AddToWorklist(Token.getNode());
21340 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
21463 assert(NewStore.getNode() == N);
21509 AddToWorklist(Value.getNode());
21682 if (!mayAlias(Chain.getNode(), N))
21803 Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Lo.getOperand(0));
21804 Hi = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Hi.getOperand(0));
21967 SDValue PaddedSubV = DAG.getNode(ISD::CONCAT_VECTORS, DL, ShufVT, ConcatOps);
21972 AddToWorklist(PaddedSubV.getNode());
21973 AddToWorklist(DestVecBC.getNode());
21974 AddToWorklist(Shuf.getNode());
22058 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), VecLoad->getBasePtr(),
22068 return Extend ? DAG.getNode(Extend, DL, VT, Load) : Load;
22128 SDValue NewOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, DL, VT,
22130 AddToWorklist(NewOp.getNode());
22131 return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(InVec.getNode()),
22250 return DAG.getNode(ISD::AND, DL, VT, CurVec,
22346 Load = DAG.getNode(ISD::TRUNCATE, DL, ResultVT, Load);
22377 ISD::isConstantSplatVector(Op0.getNode(), SplatVal) ||
22379 ISD::isConstantSplatVector(Op1.getNode(), SplatVal)) {
22383 SDValue Ext0 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Op0, Index);
22384 SDValue Ext1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, Op1, Index);
22385 return DAG.getNode(Vec.getOpcode(), DL, VT, Ext0, Ext1);
22483 User->getOperand(0).getNode() == E.Producer && ShAmtC) {
22545 SDValue V = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, NewScalarVT, NewVecOp,
22585 return DAG.getNode(ISD::TRUNCATE, DL, ScalarVT, InOp);
22586 return DAG.getNode(ISD::ANY_EXTEND, DL, ScalarVT, InOp);
22722 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ScalarVT, SVInVec,
22785 ISD::isNormalLoad(VecOp.getNode()) &&
22786 !Index->hasPredecessor(VecOp.getNode())) {
22802 if (ISD::isNormalLoad(VecOp.getNode())) {
22806 ISD::isNormalLoad(VecOp.getOperand(0).getNode())) {
22838 if (ISD::isNormalLoad(VecOp.getNode())) {
22862 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL,
22865 return DAG.getNode(ISD::BITCAST, DL, ScalarVT, Elt);
22994 AddToWorklist(BV.getNode());
23091 EVT InVT2 = VecIn2.getNode() ? VecIn2.getValueType() : InVT1;
23118 VecIn1 = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, ConcatOps);
23124 if (!VecIn2.getNode()) {
23127 VecIn2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, VecIn1,
23129 VecIn1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, VecIn1, ZeroIdx);
23151 VecIn2 = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, InVT1,
23159 VecIn2 = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, ConcatOps);
23166 if (VT.getVectorNumElements() <= 2 || !VecIn2.getNode())
23179 VecIn2 = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, InVT1,
23215 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(InVT1);
23220 Shuffle = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, VT, Shuffle, ZeroIdx);
23420 SDValue VecIn2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, Vec,
23422 SDValue VecIn1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, SplitVT, Vec,
23537 LMask = cast<ShuffleVectorSDNode>(L.getNode())->getMask();
23546 RMask = cast<ShuffleVectorSDNode>(R.getNode())->getMask();
23616 In = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, InVT, In,
23618 return DAG.getNode(FoundZeroExtend ? ISD::ZERO_EXTEND : ISD::ANY_EXTEND, DL,
23733 Op = DAG.getNode(ISD::TRUNCATE, DL, NewScalarIntVT, Op);
23772 DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), NewVT, Ops);
23804 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), N->getValueType(0),
23828 return DAG.getNode(ISD::SPLAT_VECTOR, SDLoc(N), VT, V);
23855 Ops.push_back(DAG.getNode(ISD::UNDEF, DL, SVT));
23880 Op = DAG.getNode(ISD::UNDEF, DL, SVT);
23927 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, ConcatOps);
24067 SDValue NewConcat = DAG.getNode(ISD::CONCAT_VECTORS, DL, ConcatSrcVT, SrcOps);
24068 return DAG.getNode(CastOpcode, DL, VT, NewConcat);
24104 (Op.getNode() == CurSVN || is_contained(CurSVN->ops(), Op));
24136 if (Op.getNode() == SVN) {
24167 NewShufOp = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, ShufOpParts);
24202 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Ops);
24243 SDValue Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), NVT, Scalar);
24287 DAG.getNode(ISD::TRUNCATE, SDLoc(N), MinVT, Op.getOperand(i)));
24340 if (SingleSource.getNode()) {
24359 if (SingleSource.getNode())
24413 return DAG.getNode(BinOpcode, SDLoc(Extract), SubVT, Sub0, Sub1,
24493 SDValue X = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowBVT,
24495 SDValue Y = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowBVT,
24498 DAG.getNode(BOpcode, DL, NarrowBVT, X, Y, BinOp->getFlags());
24534 : DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowBVT,
24538 : DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowBVT,
24541 SDValue NarrowBinOp = DAG.getNode(BOpcode, DL, NarrowBVT, X, Y);
24750 NewOps.emplace_back(DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NarrowVT,
24783 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NVT, V.getOperand(0),
24807 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NVT, InsSub,
24827 SDValue NewExtract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NewExtVT,
24845 DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NewExtVT,
24853 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, ScalarVT,
24892 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, NVT,
24924 Src = DAG.getNode(ISD::TRUNCATE, DL, EltVT, Src);
24956 return DAG.getNode(
25018 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Shuf0, Shuf1);
25049 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, N0, N1);
25083 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Ops);
25121 if (N0AnyConst && !N1AnyConst && !ISD::isBuildVectorAllZeros(N0.getNode()))
25123 if (!N0AnyConst && N1AnyConst && !ISD::isBuildVectorAllZeros(N1.getNode()))
25255 return DAG.getBitcast(VT, DAG.getNode(Opcode, SDLoc(SVN), *OutVT, N0));
25376 return DAG.getBitcast(VT, DAG.getNode(Opcode, SDLoc(SVN), *OutVT,
25717 return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(Shuf), Op0.getValueType(),
25811 SDValue ExtL = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, L, Index);
25812 SDValue ExtR = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, R, Index);
25814 DAG.getNode(N0.getOpcode(), DL, EltVT, ExtL, ExtR, N0->getFlags());
25815 SDValue Insert = DAG.getNode(ISD::SCALAR_TO_VECTOR, DL, VT, NewBO);
25853 SDNode *V = N0.getNode();
25858 V = ConvInput.getNode();
25873 if (!Base.getNode())
25943 SDValue NewCat = DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
25994 return DAG.getNode(ISD::INSERT_SUBVECTOR, SDLoc(N), VT, LHS,
26061 VT, DAG.getNode(ISD::AND, DL, IntVT, DAG.getBitcast(IntVT, N0),
26187 if (!SV0.getNode() || SV0 == CurrentVec) {
26194 if (!SV1.getNode() || SV1 == CurrentVec) {
26289 N->isOnlyUserOf(N->getOperand(i).getNode())) {
26316 if (TLI.isBinOp(SrcOpcode) && N->isOnlyUserOf(N0.getNode()) &&
26318 (SrcOpcode == N1.getOpcode() && N->isOnlyUserOf(N1.getNode())))) {
26383 return DAG.getNode(SrcOpcode, DL, VT, LHS, RHS);
26420 Scalar->isOnlyUserOf(Scalar.getOperand(0).getNode()) &&
26421 Scalar->isOnlyUserOf(Scalar.getOperand(1).getNode()) &&
26441 SDValue VecBO = DAG.getNode(Opcode, DL, VT, V[i], V[1 - i]);
26458 SDValue Val = DAG.getNode(ISD::TRUNCATE, SDLoc(Scalar), VecEltVT, Scalar);
26459 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), VT, Val);
26488 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), SubVT, LegalShuffle,
26520 return DAG.getNode(ISD::INSERT_SUBVECTOR, SDLoc(N),
26524 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N),
26540 return DAG.getNode(ISD::SPLAT_VECTOR, SDLoc(N), VT, N1.getOperand(0));
26568 SDValue NewINSERT = DAG.getNode(ISD::INSERT_SUBVECTOR, SDLoc(N),
26580 return DAG.getNode(ISD::INSERT_SUBVECTOR, SDLoc(N), VT, N0.getOperand(0),
26589 return DAG.getNode(ISD::INSERT_SUBVECTOR, SDLoc(N), VT, N0,
26623 Res = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, NewVT, Res, N1Src, NewIdx);
26638 SDValue NewOp = DAG.getNode(ISD::INSERT_SUBVECTOR, SDLoc(N), VT,
26640 AddToWorklist(NewOp.getNode());
26641 return DAG.getNode(ISD::INSERT_SUBVECTOR, SDLoc(N0.getNode()),
26655 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Ops);
26686 return DAG.getNode(Op, SDLoc(N), N->getValueType(0), N0.getOperand(0));
26722 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT.getVectorElementType(), N0,
26725 Res = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Res);
26737 return DAG.getNode(NewOpcode, SDLoc(N), N->getValueType(0), N0);
26750 return DAG.getNode(Opcode, SDLoc(N), N->getValueType(0), Subvec);
26761 AddToWorklist(Fused.getNode());
26793 ISD::isConstantSplatVectorAllZeros(N->getOperand(*MaskIdx).getNode());
27042 SDValue X = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, Src0, IndexC);
27043 SDValue Y = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT, Src1, IndexC);
27044 SDValue ScalarBO = DAG.getNode(Opcode, DL, EltVT, X, Y, N->getFlags());
27084 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, SrcEltVT, Src0, IndexC);
27085 SDValue ScalarBO = DAG.getNode(Opcode, DL, EltVT, Elt, N->getFlags());
27118 SDValue NewBinOp = DAG.getNode(Opcode, DL, VT, LHS.getOperand(0),
27135 SDValue NewBinOp = DAG.getNode(Opcode, DL, VT, X, RHS, Flags);
27144 SDValue NewBinOp = DAG.getNode(Opcode, DL, VT, LHS, X, Flags);
27167 DAG.getNode(Opcode, DL, VT, DAG.getUNDEF(VT), DAG.getUNDEF(VT));
27168 SDValue NarrowBO = DAG.getNode(Opcode, DL, NarrowVT, X, Y);
27169 return DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT, VecC, NarrowBO, Z);
27178 ISD::isBuildVectorOfConstantSDNodes(Op.getNode());
27196 ConcatOps.push_back(DAG.getNode(Opcode, DL, NarrowVT, LHS.getOperand(i),
27200 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, ConcatOps);
27221 if (SCC.getNode()) {
27226 SDValue SETCC = DAG.getNode(ISD::SETCC, SDLoc(N0),
27230 AddToWorklist(SETCC.getNode());
27358 SDNode *CondNode = TheSelect->getOperand(0).getNode();
27378 SDNode *CondLHS = TheSelect->getOperand(0).getNode();
27379 SDNode *CondRHS = TheSelect->getOperand(1).getNode();
27389 Addr = DAG.getNode(ISD::SELECT_CC, SDLoc(TheSelect),
27426 CombineTo(LHS.getNode(), Load.getValue(0), Load.getValue(1));
27427 CombineTo(RHS.getNode(), Load.getValue(0), Load.getValue(1));
27467 auto *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
27472 SDValue Shift = DAG.getNode(ISD::SRL, DL, XType, N0, ShiftAmt);
27473 AddToWorklist(Shift.getNode());
27476 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
27477 AddToWorklist(Shift.getNode());
27483 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
27492 SDValue Shift = DAG.getNode(ISD::SRA, DL, XType, N0, ShiftAmt);
27493 AddToWorklist(Shift.getNode());
27496 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
27497 AddToWorklist(Shift.getNode());
27503 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
27535 SDValue NewBinOp = DAG.getNode(BinOpc, DL, OpVTs, NewSel, N1.getOperand(1));
27538 return SDValue(NewBinOp.getNode(), N1.getResNo());
27550 DAG.getNode(BinOpc, DL, OpVTs, N1.getOperand(0), NewSel);
27553 return SDValue(NewBinOp.getNode(), N1.getResNo());
27595 Int = DAG.getNode(IsFabs ? ISD::AND : ISD::XOR, DL, IntVT, Int,
27597 AddToWorklist(Int.getNode());
27648 AddToWorklist(Cond.getNode());
27650 AddToWorklist(CstOffset.getNode());
27651 CPIdx = DAG.getNode(ISD::ADD, DL, CPIdx.getValueType(), CPIdx, CstOffset);
27652 AddToWorklist(CPIdx.getNode());
27669 auto *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
27670 auto *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
27671 auto *N3C = dyn_cast<ConstantSDNode>(N3.getNode());
27675 AddToWorklist(SCC.getNode());
27707 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N0), VT, AndLHS, ShlAmt);
27712 SDValue Shr = DAG.getNode(ISD::SRA, SDLoc(N0), VT, Shl, ShrAmt);
27714 return DAG.getNode(ISD::AND, DL, VT, Shr, N3);
27745 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2), VT, SCC);
27748 AddToWorklist(SCC.getNode());
27749 AddToWorklist(Temp.getNode());
27759 return DAG.getNode(
27787 return DAG.getNode(ISD::CTTZ, DL, VT, N0);
27794 return DAG.getNode(ISD::CTLZ, DL, VT, N0);
27806 SDValue ASR = DAG.getNode(
27809 return DAG.getNode(ISD::XOR, DL, VT, DAG.getSExtOrTrunc(ASR, DL, VT),
27996 return DAG.getNode(ISD::ADD, DL, VT, LogX,
28022 return DAG.getNode(Op.getOpcode(), DL, VT, LogX, LogY);
28039 SDValue Ctlz = DAG.getNode(ISD::CTLZ, DL, VT, V);
28041 SDValue LogBase2 = DAG.getNode(ISD::SUB, DL, VT, Base, Ctlz);
28074 AddToWorklist(Est.getNode());
28086 MulEst = DAG.getNode(ISD::FMUL, DL, VT, N, Est, Flags);
28087 AddToWorklist(MulEst.getNode());
28090 SDValue NewEst = DAG.getNode(ISD::FMUL, DL, VT, Op, MulEst, Flags);
28091 AddToWorklist(NewEst.getNode());
28093 NewEst = DAG.getNode(ISD::FSUB, DL, VT,
28095 AddToWorklist(NewEst.getNode());
28097 NewEst = DAG.getNode(ISD::FMUL, DL, VT, Est, NewEst, Flags);
28098 AddToWorklist(NewEst.getNode());
28100 Est = DAG.getNode(ISD::FADD, DL, VT, MulEst, NewEst, Flags);
28101 AddToWorklist(Est.getNode());
28105 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, N, Flags);
28106 AddToWorklist(Est.getNode());
28130 SDValue HalfArg = DAG.getNode(ISD::FMUL, DL, VT, ThreeHalves, Arg, Flags);
28131 HalfArg = DAG.getNode(ISD::FSUB, DL, VT, HalfArg, Arg, Flags);
28135 SDValue NewEst = DAG.getNode(ISD::FMUL, DL, VT, Est, Est, Flags);
28136 NewEst = DAG.getNode(ISD::FMUL, DL, VT, HalfArg, NewEst, Flags);
28137 NewEst = DAG.getNode(ISD::FSUB, DL, VT, ThreeHalves, NewEst, Flags);
28138 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, NewEst, Flags);
28143 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, Arg, Flags);
28168 SDValue AE = DAG.getNode(ISD::FMUL, DL, VT, Arg, Est, Flags);
28169 SDValue AEE = DAG.getNode(ISD::FMUL, DL, VT, AE, Est, Flags);
28170 SDValue RHS = DAG.getNode(ISD::FADD, DL, VT, AEE, MinusThree, Flags);
28178 LHS = DAG.getNode(ISD::FMUL, DL, VT, Est, MinusHalf, Flags);
28181 LHS = DAG.getNode(ISD::FMUL, DL, VT, AE, MinusHalf, Flags);
28184 Est = DAG.getNode(ISD::FMUL, DL, VT, LHS, RHS, Flags);
28218 AddToWorklist(Est.getNode());
28232 Est = DAG.getNode(
28296 if (MUC0.BasePtr.getNode() && MUC0.BasePtr == MUC1.BasePtr &&
28433 bool IsOpLoad = isa<LoadSDNode>(C.getNode()) &&
28434 cast<LSBaseSDNode>(C.getNode())->isSimple();
28435 if ((IsLoad && IsOpLoad) || !mayAlias(N, C.getNode())) {
28453 if (!mayAlias(N, C.getNode())) {
28472 if (!Visited.insert(Chain.getNode()).second)
28491 // likelihood that getNode will find a matching token factor (CSE.)
28504 if (Chain.getNode())
28568 if (!BasePtr.getBase().getNode())
28666 AddToWorklist(TF.getNode());
28668 AddToWorklist(Op.getNode());
28680 if (!BasePtr.getBase().getNode())