Lines Matching refs:getNode
226 // SDValue.getNode() == 0 - No change was made
227 // SDValue.getNode() == N - N was replaced, is dead and has been handled.
560 AddToWorklist(Op.getNode());
642 const SDNodeFlags *Flags = Op.getNode()->getFlags();
658 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
663 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
677 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
687 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
693 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
700 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
704 return DAG.getNode(ISD::FP_ROUND, SDLoc(Op), Op.getValueType(),
726 !TLI.isConstTrueVal(N.getOperand(2).getNode()) ||
727 !TLI.isConstFalseVal(N.getOperand(3).getNode()))
745 if (isSetCCEquivalent(N, N0, N1, N2) && N.getNode()->hasOneUse())
770 return N.getNode();
771 if (ISD::isBuildVectorOfConstantSDNodes(N.getNode()))
772 return N.getNode();
780 return N.getNode();
781 if (ISD::isBuildVectorOfConstantFPSDNodes(N.getNode()))
782 return N.getNode();
832 return DAG.getNode(Opc, DL, VT, N0.getOperand(0), OpNode);
838 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N0.getOperand(0), N1);
839 if (!OpNode.getNode())
841 AddToWorklist(OpNode.getNode());
842 return DAG.getNode(Opc, DL, VT, OpNode, N0.getOperand(1));
852 return DAG.getNode(Opc, DL, VT, N1.getOperand(0), OpNode);
858 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N1.getOperand(0), N0);
859 if (!OpNode.getNode())
861 AddToWorklist(OpNode.getNode());
862 return DAG.getNode(Opc, DL, VT, OpNode, N1.getOperand(1));
877 To[0].getNode()->dump(&DAG);
880 assert((!To[i].getNode() ||
889 if (To[i].getNode()) {
890 AddToWorklist(To[i].getNode());
891 AddUsersToWorklist(To[i].getNode());
912 AddToWorklist(TLO.New.getNode());
913 AddUsersToWorklist(TLO.New.getNode());
918 if (TLO.Old.getNode()->use_empty())
919 deleteAndRecombine(TLO.Old.getNode());
931 AddToWorklist(Op.getNode());
936 TLO.Old.getNode()->dump(&DAG);
938 TLO.New.getNode()->dump(&DAG);
948 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, VT, SDValue(ExtLoad, 0));
953 Trunc.getNode()->dump(&DAG);
959 AddToWorklist(Trunc.getNode());
981 return DAG.getNode(ISD::AssertSext, dl, PVT,
985 return DAG.getNode(ISD::AssertZext, dl, PVT,
991 return DAG.getNode(ExtOpc, dl, PVT, Op);
997 return DAG.getNode(ISD::ANY_EXTEND, dl, PVT, Op);
1007 if (!NewOp.getNode())
1009 AddToWorklist(NewOp.getNode());
1012 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
1013 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NewOp.getValueType(), NewOp,
1022 if (!NewOp.getNode())
1024 AddToWorklist(NewOp.getNode());
1027 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
1057 if (!NN0.getNode())
1067 if (!NN1.getNode())
1071 AddToWorklist(NN0.getNode());
1072 if (NN1.getNode())
1073 AddToWorklist(NN1.getNode());
1076 ReplaceLoadWithPromotedLoad(N0.getNode(), NN0.getNode());
1078 ReplaceLoadWithPromotedLoad(N1.getNode(), NN1.getNode());
1081 Op.getNode()->dump(&DAG));
1083 return DAG.getNode(ISD::TRUNCATE, dl, VT,
1084 DAG.getNode(Opc, dl, PVT, NN0, NN1));
1120 if (!N0.getNode())
1123 AddToWorklist(N0.getNode());
1125 ReplaceLoadWithPromotedLoad(Op.getOperand(0).getNode(), N0.getNode());
1128 Op.getNode()->dump(&DAG));
1130 return DAG.getNode(ISD::TRUNCATE, dl, VT,
1131 DAG.getNode(Opc, dl, PVT, N0, Op.getOperand(1)));
1159 Op.getNode()->dump(&DAG));
1160 return DAG.getNode(Op.getOpcode(), SDLoc(Op), VT, Op.getOperand(0));
1186 SDNode *N = Op.getNode();
1196 SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, VT, NewLD);
1201 Result.getNode()->dump(&DAG);
1207 AddToWorklist(Result.getNode());
1232 Nodes.insert(ChildN.getNode());
1305 if (!CombinedNodes.count(ChildN.getNode()))
1306 AddToWorklist(ChildN.getNode());
1310 if (!RV.getNode
1319 if (RV.getNode() == N)
1323 RV.getNode()->getOpcode() != ISD::DELETED_NODE &&
1327 RV.getNode()->dump(&DAG));
1331 if (N->getNumValues() == RV.getNode()->getNumValues())
1332 DAG.ReplaceAllUsesWith(N, RV.getNode());
1341 AddToWorklist(RV.getNode());
1342 AddUsersToWorklist(RV.getNode());
1457 if (!RV.getNode()) {
1473 if (!RV.getNode()) {
1503 if (!RV.getNode() && SelectionDAG::isCommutativeBinOp(N->getOpcode()) &&
1540 if (getInputChainForNode(N->getOperand(0).getNode()) == N->getOperand(1))
1542 if (getInputChainForNode(N->getOperand(1).getNode()) == N->getOperand(0))
1571 std::find(TFs.begin(), TFs.end(), Op.getNode()) == TFs.end()) {
1573 TFs.push_back(Op.getNode());
1575 AddToWorklist(Op.getNode());
1583 if (SeenOps.insert(Op.getNode()).second)
1601 Result = DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other, Ops);
1649 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1651 if (ISD::isBuildVectorAllZeros(N0.getNode()))
1668 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N1, N0);
1683 return DAG.getNode(ISD::SUB, DL, VT,
1693 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1, N0.getOperand(1));
1696 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1.getOperand(1));
1706 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1711 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1717 return DAG.getNode(N1.getOpcode(), SDLoc(N), VT,
1728 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1729 DAG.getNode
1730 DAG.getNode(ISD::ADD, SDLoc(N1), VT, N01, N11));
1739 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1);
1744 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0,
1745 DAG.getNode(ISD::SHL, SDLoc(N), VT,
1750 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1,
1751 DAG.getNode(ISD::SHL, SDLoc(N), VT,
1764 return DAG.getNode(ISD::SUB, DL, VT, N->getOperand(0), AndOp0);
1773 SDValue ZExt = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
1774 return DAG.getNode(ISD::SUB, DL, VT, N1, ZExt);
1782 SDValue ZExt = DAG.getNode(ISD::AND, DL, VT, N1.getOperand(0),
1784 return DAG.getNode(ISD::SUB, DL, VT, N0, ZExt);
1798 return CombineTo(N, DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N1),
1799 DAG.getNode(ISD::CARRY_FALSE,
1806 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N1, N0);
1810 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE,
1824 return CombineTo(N, DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1),
1825 DAG.getNode(ISD::CARRY_FALSE,
1841 return DAG.getNode(ISD::ADDE, SDLoc(N), N->getVTList(),
1846 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N0, N1);
1874 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1890 return DAG.getNode(ISD::ADD, DL, VT, N0,
1895 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
1907 dyn_cast<ConstantSDNode>(N1.getOperand(1).getNode());
1912 return DAG.getNode(ISD::SUB, DL, VT, NewC,
1920 return DAG.getNode(N0.getOperand(1).getOpcode(), SDLoc(N), VT,
1926 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
1932 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1961 SDValue ZExt = DAG.getNode(ISD::AND, DL, VT, N1.getOperand(0),
1963 return DAG.getNode(ISD::ADD, DL, VT, N0, ZExt);
1978 return CombineTo(N, DAG.getNode(ISD::SUB, DL, VT, N0, N1),
1979 DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
1984 DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
1988 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
1992 return CombineTo(N, DAG.getNode(ISD::XOR, DL, VT, N1, N0),
1993 DAG.getNode(ISD::CARRY_FALSE, DL, MVT::Glue));
2005 return DAG.getNode(ISD::SUBC, SDLoc(N), N->getVTList(), N0, N1);
2029 N0IsConst = isConstantSplatVector(N0.getNode(), ConstValue0);
2030 N1IsConst = isConstantSplatVector(N1.getNode(), ConstValue1);
2047 N0.getNode(), N1.getNode());
2052 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N1, N0);
2066 return DAG.getNode(ISD::SUB, DL, VT,
2073 return DAG.getNode(ISD::SHL, DL, VT, N0,
2084 return DAG.getNode(ISD::SUB, DL, VT,
2086 DAG.getNode(ISD::SHL, DL, VT, N0,
2094 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
2096 SDValue C3 = DAG.getNode(ISD::SHL, SDLoc(N), VT,
2098 AddToWorklist(C3.getNode());
2099 return DAG.getNode(ISD::MUL, SDLoc(N), VT,
2109 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
2111 N0.getNode()->hasOneUse()) {
2115 N1.getNode()->hasOneUse()) {
2119 if (Sh.getNode()) {
2120 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
2122 return DAG.getNode(ISD::SHL, SDLoc(N), VT,
2132 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
2133 DAG.getNode(ISD::MUL, SDLoc(N0), VT,
2135 DAG.getNode(ISD::MUL, SDLoc(N1), VT,
2195 for (SDNode::use_iterator UI = Op0.getNode()->use_begin(),
2196 UE = Op0.getNode()->use_end(); UI != UE; ++UI) {
2210 combined = DAG.getNode(DivRemOpc, SDLoc(Node), VTs, Op0, Op1);
2249 return DAG.getNode(ISD::SUB, DL, VT,
2256 return DAG.getNode(ISD::UDIV, DL, N1.getValueType(), N0, N1);
2275 DAG.getNode(ISD::SRA, DL, VT, N0,
2278 AddToWorklist(SGN.getNode());
2282 DAG.getNode(ISD::SRL, DL, VT, SGN,
2285 SDValue ADD = DAG.getNode(ISD::ADD, DL, VT, N0, SRL);
2286 AddToWorklist(SRL.getNode());
2287 AddToWorklist(ADD.getNode()); // Divide by pow2
2288 SDValue SRA = DAG.getNode(ISD::SRA, DL, VT, ADD,
2297 AddToWorklist(SRA.getNode());
2298 return DAG.getNode(ISD::SUB, DL, VT, DAG.getConstant(0, DL, VT), SRA);
2347 return DAG.getNode(ISD::SRL, DL, VT, N0,
2356 SDValue Add = DAG.getNode(ISD::ADD, DL, ADDVT,
2361 AddToWorklist(Add.getNode());
2362 return DAG.getNode(ISD::SRL, DL, VT, N0, Add);
2411 return DAG.getNode(ISD::UREM, DL, VT, N0, N1);
2417 return DAG.getNode(ISD::AND, DL, VT, N0,
2425 DAG.getNode(ISD::ADD, DL, VT, N1,
2428 AddToWorklist(Add.getNode());
2429 return DAG.getNode(ISD::AND, DL, VT, N0, Add);
2447 SDValue Div = DAG.getNode(DivOpcode, DL, VT, N0, N1);
2448 AddToWorklist(Div.getNode());
2449 SDValue OptimizedDiv = combine(Div.getNode());
2450 if (OptimizedDiv.getNode() && OptimizedDiv.getNode() != Div.getNode()) {
2453 SDValue Mul = DAG.getNode(ISD::MUL, DL, VT, OptimizedDiv, N1);
2454 SDValue Sub = DAG.getNode(ISD::SUB, DL, VT, N0, Mul);
2455 AddToWorklist(Mul.getNode());
2486 return DAG.getNode(ISD::SRA, DL, N0.getValueType(), N0,
2502 N0 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N0);
2503 N1 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N1);
2504 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2505 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2508 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2538 N0 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N0);
2539 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N1);
2540 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2541 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2544 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2561 SDValue Res = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0), N->ops());
2570 SDValue Res = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1), N->ops());
2580 SDValue Lo = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0), N->ops());
2581 AddToWorklist(Lo.getNode());
2582 SDValue LoOpt = combine(Lo.getNode());
2583 if (LoOpt.getNode() && LoOpt.getNode() != Lo.getNode() &&
2590 SDValue Hi = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1), N->ops());
2591 AddToWorklist(Hi.getNode());
2592 SDValue HiOpt = combine(Hi.getNode());
2593 if (HiOpt.getNode() && HiOpt != Hi &&
2616 SDValue Lo = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(0));
2617 SDValue Hi = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(1));
2618 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
2620 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
2623 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
2625 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
2647 SDValue Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(0));
2648 SDValue Hi = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(1));
2649 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
2651 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
2654 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
2656 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
2668 return DAG.getNode(ISD::SADDO, SDLoc(N), N->getVTList(),
2678 return DAG.getNode(ISD::UADDO, SDLoc(N), N->getVTList(),
2703 return DAG.getNode(N->getOpcode(), SDLoc(N), VT, N1, N0);
2716 if (N0.getNode()->getNumOperands() == 0) return SDValue();
2741 SDValue ORNode = DAG.getNode(N->getOpcode(), SDLoc(N0),
2744 AddToWorklist(ORNode.getNode());
2745 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, ORNode);
2755 SDValue ORNode = DAG.getNode(N->getOpcode(), SDLoc(N0),
2758 AddToWorklist(ORNode.getNode());
2759 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
2781 SDValue Op = DAG.getNode(N->getOpcode(), DL, In0Ty, In0, In1);
2782 SDValue BC = DAG.getNode(N0.getOpcode(), DL, VT, Op);
2783 AddToWorklist(Op.getNode());
2827 if (N0.getOperand(1) == N1.getOperand(1) && ShOp.getNode()) {
2828 SDValue NewNode = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
2830 AddToWorklist(NewNode.getNode());
2848 if (N0->getOperand(0) == N1->getOperand(0) && ShOp.getNode()) {
2849 SDValue NewNode = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
2851 AddToWorklist(NewNode.getNode());
2882 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(N0),
2884 AddToWorklist(ORNode.getNode());
2890 SDValue ANDNode = DAG.getNode(ISD::AND, SDLoc(N0),
2892 AddToWorklist(ANDNode.getNode());
2897 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(N0),
2899 AddToWorklist(ORNode.getNode());
2910 SDValue ADDNode = DAG.getNode(ISD::ADD, DL, LL.getValueType(),
2913 AddToWorklist(ADDNode.getNode());
2956 DAG.getNode(ISD::ADD, DL, VT,
2958 CombineTo(N0.getNode(), NewAdd);
3022 if (ISD::isBuildVectorAllZeros(N0.getNode()))
3028 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3036 if (ISD::isBuildVectorAllOnes(N0.getNode()))
3038 if (ISD::isBuildVectorAllOnes(N1.getNode()))
3050 return DAG.getNode(ISD::AND, SDLoc(N), VT, N1, N0);
3073 SDValue Zext = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N),
3082 CombineTo(N0.getNode(), Zext);
3186 CombineTo(N, (N0.getNode() == Load) ? NewLoad : N0);
3231 NewPtr = DAG.getNode(ISD::ADD, DL, PtrType,
3236 AddToWorklist(NewPtr.getNode());
3267 if (ISD::isEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode())) {
3281 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
3286 if (ISD::isSEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
3301 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
3307 SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
3309 if (BSwap.getNode())
3336 if (!N0.getNode()->hasOneUse())
3346 if (!N1.getNode()->hasOneUse())
3359 if (!N0.getNode()->hasOneUse() ||
3360 !N1.getNode()->hasOneUse())
3373 if (!N00.getNode()->hasOneUse())
3384 if (!N10.getNode()->hasOneUse())
3414 SDValue Res = DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N00);
3417 Res = DAG.getNode(ISD::SRL, DL, VT, Res,
3431 if (!N.getNode()->hasOneUse())
3493 Parts[Num] = N0.getOperand(0).getNode();
3559 SDValue BSwap = DAG.getNode(ISD::BSWAP, DL, VT,
3566 return DAG.getNode(ISD::ROTL, DL, VT, BSwap, ShAmt);
3568 return DAG.getNode(ISD::ROTR, DL, VT, BSwap, ShAmt);
3569 return DAG.getNode(ISD::OR, DL, VT,
3570 DAG.getNode(ISD::SHL, DL, VT, BSwap, ShAmt),
3571 DAG.getNode(ISD::SRL, DL, VT, BSwap, ShAmt));
3595 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(LR),
3597 AddToWorklist(ORNode.getNode());
3603 SDValue ANDNode = DAG.getNode(ISD::AND, SDLoc(LR),
3605 AddToWorklist(ANDNode.getNode());
3633 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
3647 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
3650 return DAG.getNode(ISD::AND, DL, VT, X,
3662 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
3663 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
3665 return DAG.getNode(ISD::AND, SDLoc(LocReference), VT, N0.getOperand(0), X);
3682 if (ISD::isBuildVectorAllZeros(N0.getNode()))
3684 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3688 if (ISD::isBuildVectorAllOnes(N0.getNode()))
3694 if (ISD::isBuildVectorAllOnes(N1.getNode()))
3709 ISD::isBuildVectorAllZeros(N0.getOperand(1).getNode())) {
3766 return DAG.getNode(ISD::OR, SDLoc(N), VT, N1, N0);
3791 if (N1C && N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
3797 return DAG.getNode(
3799 DAG.getNode(ISD::OR, SDLoc(N0), VT, N0.getOperand(0), N1), COR);
3961 return DAG.getNode(HasPos ? PosOpcode : NegOpcode, DL, VT, Shifted,
3962 HasPos ? Pos : Neg).getNode();
4019 SDValue Rot = DAG.getNode(HasROTL ? ISD::ROTL : ISD::ROTR, DL, VT,
4023 if (LHSMask.getNode() || RHSMask.getNode()) {
4027 if (LHSMask.getNode()) {
4029 Mask = DAG.getNode(ISD::AND, DL, VT, Mask,
4030 DAG.getNode(ISD::OR, DL, VT, LHSMask,
4033 if (RHSMask.getNode()) {
4035 Mask = DAG.getNode(ISD::AND, DL, VT, Mask,
4036 DAG.getNode(ISD::OR, DL, VT, RHSMask,
4040 Rot = DAG.getNode(ISD::AND, DL, VT, Rot, Mask);
4043 return Rot.getNode();
4048 if (LHSMask.getNode() || RHSMask.getNode())
4090 if (ISD::isBuildVectorAllZeros(N0.getNode()))
4092 if (ISD::isBuildVectorAllZeros(N1.getNode()))
4112 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
4122 if (TLI.isConstTrueVal(N1.getNode()) && isSetCCEquivalent(N0, LHS, RHS, CC)) {
4143 N0.getNode()->hasOneUse() &&
4147 V = DAG.getNode(ISD::XOR, DL, V.getValueType(), V,
4149 AddToWorklist(V.getNode());
4150 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, V);
4159 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
4160 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
4161 AddToWorklist(LHS.getNode()); AddToWorklist(RHS.getNode());
4162 return DAG.getNode(NewOpcode, SDLoc(N), VT, LHS, RHS);
4171 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
4172 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
4173 AddToWorklist(LHS.getNode()); AddToWorklist(RHS.getNode());
4174 return DAG.getNode(NewOpcode, SDLoc(N), VT, LHS, RHS);
4178 if (N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
4182 AddToWorklist(NotX.getNode());
4183 return DAG.getNode(ISD::AND, SDLoc(N), VT, NotX, N1);
4189 return DAG.getNode(ISD::XOR, DL, VT, N0.getOperand(1),
4195 return DAG.getNode(ISD::XOR, DL, VT, N0.getOperand(0),
4225 return DAG.getNode(ISD::ROTL, DL, VT, DAG.getConstant(~1, DL, VT),
4245 SDNode *LHS = N->getOperand(0).getNode();
4279 SDNode *BinOpLHSVal = LHS->getOperand(0).getNode();
4302 SDValue NewRHS = DAG.getNode(N->getOpcode(), SDLoc(LHS->getOperand(1)),
4308 SDValue NewShift = DAG.getNode(N->getOpcode(),
4313 return DAG.getNode(LHS->getOpcode(), SDLoc(N), VT, NewShift, NewRHS);
4332 return DAG.getNode(ISD::AND, DL, TruncVT,
4333 DAG.getNode(ISD::TRUNCATE, DL, TruncVT, N00),
4346 SDValue NewOp1 = distributeTruncateThroughAnd(N->getOperand(1).getNode());
4347 if (NewOp1.getNode())
4348 return DAG.getNode(N->getOpcode(), SDLoc(N), N->getValueType(0),
4380 return DAG.getNode(ISD::AND, SDLoc(N), VT, N00, C);
4411 SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode());
4412 if (NewOp1.getNode())
4413 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0, NewOp1);
4427 return DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0),
4451 return DAG.getNode(ISD::SHL, DL, VT,
4452 DAG.getNode(N0.getOpcode(), DL, VT,
4473 SDValue NewSHL = DAG.getNode(ISD::SHL, DL, NewOp0.getValueType(),
4476 AddToWorklist(NewSHL.getNode());
4477 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N0), VT, NewSHL);
4492 return DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0),
4494 return DAG.getNode(N0.getOpcode(), DL, VT, N0.getOperand(0),
4513 Shift = DAG.getNode(ISD::SHL, DL, VT, N0.getOperand(0),
4518 Shift = DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0),
4522 return DAG.getNode(ISD::AND, DL, VT, Shift,
4535 return DAG.getNode(ISD::AND, DL, VT, N0.getOperand(0),
4543 if (N1C && N0.getOpcode() == ISD::ADD && N0.getNode()->hasOneUse() &&
4545 isConstantSplatVector(N0.getOperand(1).getNode(), Val))) {
4546 SDValue Shl0 = DAG.getNode(ISD::SHL, SDLoc(N0), VT, N0.getOperand(0), N1);
4547 SDValue Shl1 = DAG.getNode(ISD::SHL, SDLoc(N1), VT, N0.getOperand(1), N1);
4548 return DAG.getNode(ISD::ADD, SDLoc(N), VT, Shl0, Shl1);
4552 if (N1C && N0.getOpcode() == ISD::MUL && N0.getNode()->hasOneUse()) {
4556 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N0.getOperand(0), Folded);
4608 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
4619 return DAG.getNode(ISD::SRA, DL, VT, N0.getOperand(0),
4655 SDValue Shift = DAG.getNode(ISD::SRL, DL, VT,
4657 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, DL, TruncVT,
4659 return DAG.getNode(ISD::SIGN_EXTEND, DL,
4668 SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode());
4669 if (NewOp1.getNode())
4670 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0, NewOp1);
4691 SDValue SRA = DAG.getNode(ISD::SRA, DL, LargeVT,
4693 return DAG.getNode(ISD::TRUNCATE, DL, VT, SRA);
4705 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, N1);
4755 return DAG.getNode(ISD::SRL, DL, VT, N0.getOperand(0),
4775 return DAG.getNode(ISD::TRUNCATE, DL, VT,
4776 DAG.getNode(ISD::SRL, DL, InnerShiftVT,
4789 return DAG.getNode(ISD::AND, DL, VT, N0.getOperand(0),
4805 SDValue SmallShift = DAG.getNode(ISD::SRL, DL0, SmallVT,
4809 AddToWorklist(SmallShift.getNode());
4812 return DAG.getNode(ISD::AND, DL, VT,
4813 DAG.getNode(ISD::ANY_EXTEND, DL, VT, SmallShift),
4822 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0), N1);
4851 Op = DAG.getNode(ISD::SRL, DL, VT, Op,
4854 AddToWorklist(Op.getNode());
4858 return DAG.getNode(ISD::XOR, DL, VT,
4866 if (SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode()))
4867 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, NewOp1);
4921 return DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N0);
4934 return DAG.getNode(ISD::CTLZ, SDLoc(N), VT, N0);
4944 return DAG.getNode(ISD::CTLZ_ZERO_UNDEF, SDLoc(N), VT, N0);
4954 return DAG.getNode(ISD::CTTZ, SDLoc(N), VT, N0);
4964 return DAG.getNode(ISD::CTTZ_ZERO_UNDEF, SDLoc(N), VT, N0);
4974 return DAG.getNode(ISD::CTPOP, SDLoc(N), VT, N0);
4996 return DAG.getNode(Opcode, DL, VT, LHS, RHS);
5007 return DAG.getNode(Opcode, DL, VT, LHS, RHS);
5032 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N2);
5052 return DAG.getNode(ISD::XOR, DL, VT0,
5056 XORNode = DAG.getNode(ISD::XOR, DL0, VT0,
5058 AddToWorklist(XORNode.getNode());
5060 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, XORNode);
5061 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, XORNode);
5066 AddToWorklist(NOTNode.getNode());
5067 return DAG.getNode(ISD::AND, SDLoc(N), VT, NOTNode, N2);
5072 AddToWorklist(NOTNode.getNode());
5073 return DAG.getNode(ISD::OR, SDLoc(N), VT, NOTNode, N1);
5077 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
5081 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N2);
5085 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
5107 SDValue InnerSelect = DAG.getNode(ISD::SELECT, SDLoc(N),
5110 return DAG.getNode(ISD::SELECT, SDLoc(N), N1.getValueType(), Cond0,
5117 SDValue InnerSelect = DAG.getNode(ISD::SELECT, SDLoc(N),
5120 return DAG.getNode(ISD::SELECT, SDLoc(N), N1.getValueType(), Cond0, N1,
5132 SDValue And = DAG.getNode(ISD::AND, SDLoc(N), N0.getValueType(),
5134 return DAG.getNode(ISD::SELECT, SDLoc(N), N1.getValueType(), And,
5139 return DAG.getNode(ISD::SELECT, SDLoc(N), N1.getValueType(), Combined,
5151 SDValue Or = DAG.getNode(ISD::OR, SDLoc(N), N0.getValueType(),
5153 return DAG.getNode(ISD::SELECT, SDLoc(N), N1.getValueType(), Or,
5158 return DAG.getNode(ISD::SELECT, SDLoc(N), N1.getValueType(), Combined,
5190 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT,
5210 Lo = DAG.getNode(N->getOpcode(), DL, LoVT, LL, RL, N->getOperand(2));
5211 Hi = DAG.getNode(N->getOpcode(), DL, HiVT, LH, RH, N->getOperand(2));
5246 else if (Cond->getOperand(i).getNode() != BottomHalf)
5258 else if (Cond->getOperand(i).getNode() != TopHalf)
5265 return DAG.getNode(
5293 std::tie(MaskLo, MaskHi) = SplitVSETCC(Mask.getNode(), DAG);
5326 AddToWorklist(Lo.getNode());
5327 AddToWorklist(Hi.getNode());
5329 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
5354 std::tie(MaskLo, MaskHi) = SplitVSETCC(Mask.getNode(), DAG);
5386 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
5398 AddToWorklist(Lo.getNode());
5399 AddToWorklist(Hi.getNode());
5401 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
5431 std::tie(MaskLo, MaskHi) = SplitVSETCC(Mask.getNode(), DAG);
5465 AddToWorklist(Lo.getNode());
5466 AddToWorklist(Hi.getNode());
5470 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo.getValue(1),
5477 SDValue GatherRes = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
5506 std::tie(MaskLo, MaskHi) = SplitVSETCC(Mask.getNode(), DAG);
5538 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
5549 AddToWorklist(Lo.getNode());
5550 AddToWorklist(Hi.getNode());
5554 Chain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo.getValue(1),
5561 SDValue LoadRes = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
5584 bool RHSIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
5587 (ISD::isBuildVectorAllOnes(RHS.getNode()) && CC == ISD::SETGT)) &&
5589 isAbs = ISD::isBuildVectorAllZeros(N2.getOperand(0).getNode());
5592 isAbs = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
5596 SDValue Shift = DAG.getNode(
5599 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, LHS, Shift);
5600 AddToWorklist(Shift.getNode());
5601 AddToWorklist(Add.getNode());
5602 return DAG.getNode(ISD::XOR, DL, VT, Add, Shift);
5622 std::tie(CCLo, CCHi) = SplitVSETCC(N0.getNode(), DAG);
5626 Lo = DAG.getNode(N->getOpcode(), DL, LL.getValueType(), CCLo, LL, RL);
5627 Hi = DAG.getNode(N->getOpcode(), DL, LH.getValueType(), CCHi, LH, RH);
5631 AddToWorklist(Lo.getNode());
5632 AddToWorklist(Hi.getNode());
5634 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
5638 if (ISD::isBuildVectorAllOnes(N0.getNode()))
5641 if (ISD::isBuildVectorAllZeros(N0.getNode()))
5649 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())) {
5672 if (SCC.getNode()) {
5673 AddToWorklist(SCC.getNode());
5675 if (ConstantSDNode *SCCC = dyn_cast<ConstantSDNode>(SCC.getNode())) {
5686 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), N2.getValueType(),
5714 return DAG.getNode(ISD::SETCC, SDLoc(N), N->getVTList(), LHS, RHS, Cond);
5740 return DAG.getNode(Opcode, SDLoc(N), VT, N0).getNode();
5748 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())))
5775 return DAG.getNode(ISD::BUILD_VECTOR, DL, VT, Elts).getNode();
5788 for (SDNode::use_iterator UI = N0.getNode()->use_begin(),
5789 UE = N0.getNode()->use_end();
5855 Ops.push_back(DAG.getNode(ExtType, DL, ExtLoad->getValueType(0), SOp));
5859 CombineTo(SetCC, DAG.getNode(ISD::SETCC, DL, SetCC->getValueType(0), Ops));
5937 BasePtr = DAG.getNode(ISD::ADD, DL, BasePtr.getValueType(), BasePtr,
5944 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
5945 SDValue NewValue = DAG.getNode
5952 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(), NewValue);
5953 CombineTo(N0.getNode(), Trunc, NewChain);
5970 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT,
5976 if (SDValue NarrowLoad = ReduceLoadWidth(N0.getNode())) {
5977 SDNode* oye = N0.getNode()->getOperand(0).getNode();
5978 if (NarrowLoad.getNode() != N0.getNode()) {
5979 CombineTo(N0.getNode(), NarrowLoad);
6003 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, Op);
6008 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
6015 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N0), VT, Op);
6017 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT, Op);
6018 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, Op,
6026 if (ISD::isNON_EXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
6043 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
6045 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
6059 if ((ISD::isSEXTLoad(N0.getNode()) || ISD::isEXTLoad(N0.getNode())) &&
6060 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
6070 CombineTo(N0.getNode(),
6071 DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
6101 SDValue And = DAG.getNode(N0.getOpcode(), DL, VT,
6103 SDValue Trunc = DAG.getNode(ISD::TRUNCATE,
6107 CombineTo(N0.getOperand(0).getNode(), Trunc, ExtLoad.getValue(1));
6158 if (SCC.getNode()) return SCC;
6177 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, N0);
6229 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT,
6248 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, Op);
6250 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
6259 if (SDValue NarrowLoad = ReduceLoadWidth(N0.getNode())) {
6260 SDNode* oye = N0.getNode()->getOperand(0).getNode();
6261 if (NarrowLoad.getNode() != N0.getNode()) {
6262 CombineTo(N0.getNode(), NarrowLoad);
6274 if (SDValue NarrowLoad = ReduceLoadWidth(N0.getNode())) {
6275 SDNode *oye = N0.getNode()->getOperand(0).getNode();
6276 if (NarrowLoad.getNode() != N0.getNode()) {
6277 CombineTo(N0.getNode(), NarrowLoad);
6294 AddToWorklist(Op.getNode());
6302 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, Op);
6303 AddToWorklist(Op.getNode());
6305 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
6306 AddToWorklist(Op.getNode());
6322 X = DAG.getNode(ISD::ANY_EXTEND, SDLoc(X), VT, X);
6324 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
6329 return DAG.getNode(ISD::AND, DL, VT,
6336 if (ISD::isNON_EXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
6353 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
6355 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
6404 SDValue And = DAG.getNode(N0.getOpcode(), DL, VT,
6406 SDValue Trunc = DAG.getNode(ISD::TRUNCATE,
6410 CombineTo(N0.getOperand(0).getNode(), Trunc, ExtLoad.getValue(1));
6420 if ((ISD::isZEXTLoad(N0.getNode()) || ISD::isEXTLoad(N0.getNode())) &&
6421 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
6431 CombineTo(N0.getNode(),
6432 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(),
6458 return DAG.getNode(ISD::AND, DL, VT,
6462 DAG.getNode(ISD::BUILD_VECTOR, DL, VT,
6478 return DAG.getNode(ISD::AND, DL, VT,
6480 DAG.getNode(ISD::BUILD_VECTOR, DL, VT, OneOps));
6489 if (SCC.getNode()) return SCC;
6513 ShAmt = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShAmt);
6515 return DAG.getNode(N0.getOpcode(), DL, VT,
6516 DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0)),
6537 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, N0.getOperand(0));
6542 if (SDValue NarrowLoad = ReduceLoadWidth(N0.getNode())) {
6543 SDNode* oye = N0.getNode()->getOperand(0).getNode();
6544 if (NarrowLoad.getNode() != N0.getNode()) {
6545 CombineTo(N0.getNode(), NarrowLoad);
6559 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, TruncOp);
6560 return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, TruncOp);
6572 X = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, X);
6574 X = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, X);
6579 return DAG.getNode(ISD::AND, DL, VT,
6587 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
6588 ISD::isUNINDEXEDLoad(N0.getNode()) &&
6601 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
6603 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
6614 !ISD::isNON_EXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
6624 CombineTo(N0.getNode(),
6625 DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
6668 if (SCC.getNode())
6682 const ConstantSDNode *CV = cast<ConstantSDNode>(V.getNode());
6700 if (!V.getNode()->hasOneUse())
6710 return DAG.getNode(ISD::SRL, SDLoc(V), V.getValueType(),
6847 SDValue NewPtr = DAG.getNode(ISD::ADD, DL,
6850 AddToWorklist(NewPtr.getNode());
6882 Result = DAG.getNode(ISD::SHL, DL, VT,
6903 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0, N1);
6912 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
6922 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00, N1);
6949 return DAG.getNode(ISD::SRA, SDLoc(N), VT,
6955 if (ISD::isEXTLoad(N0.getNode()) &&
6956 ISD::isUNINDEXEDLoad(N0.getNode()) &&
6966 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
6967 AddToWorklist(ExtLoad.getNode());
6971 if (ISD::isZEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
6982 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
6988 SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
6990 if (BSwap.getNode())
6991 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
7022 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0);
7025 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
7032 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
7036 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
7071 SDValue V = DAG.getNode(ISD::BITCAST, SDLoc(N),
7075 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT,
7088 SDValue TruncOp0 = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(1));
7089 SDValue TruncOp1 = DAG.getNode(ISD::TRUNCATE, SL, VT, N0.getOperand(2));
7090 return DAG.getNode(ISD::SELECT, SDLoc(N), VT, Cond, TruncOp0, TruncOp1);
7121 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, Opnds);
7134 if (Shorter.getNode())
7135 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Shorter);
7145 if (N0.hasOneUse() && ISD::isUNINDEXEDLoad(N0.getNode())) {
7185 assert(V.getNode() && "The single defined operand is empty!");
7192 SDValue NV = DAG.getNode(ISD::TRUNCATE, SDLoc(V), VTs[i], V);
7193 AddToWorklist(NV.getNode());
7196 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Opnds);
7211 return Elt.getNode();
7212 return Elt.getOperand(Elt.getResNo()).getNode();
7263 N0.getOpcode() == ISD::BUILD_VECTOR && N0.getNode()->hasOneUse() &&
7271 return ConstantFoldBITCASTofBUILD_VECTOR(N0.getNode(), DestEltVT);
7274 // If the input is a constant, let getNode fold it.
7284 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, N0);
7289 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT,
7294 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
7331 N0.getNode()->hasOneUse() && VT.isInteger() &&
7333 SDValue NewConv = DAG.getNode(ISD::BITCAST, SDLoc(N0), VT,
7335 AddToWorklist(NewConv.getNode());
7345 AddToWorklist(FlipBit.getNode());
7349 DAG.getNode(ISD::EXTRACT_ELEMENT, SDLoc(NewConv), MVT::i64, NewConv,
7352 AddToWorklist(Hi.getNode());
7353 FlipBit = DAG.getNode(ISD::AND, SDLoc(N0), MVT::i64, Hi, SignBit);
7354 AddToWorklist(FlipBit.getNode());
7357 DAG.getNode(ISD::BUILD_PAIR, SDLoc(N0), VT, FlipBit, FlipBit);
7358 AddToWorklist(FlipBits.getNode());
7359 return DAG.getNode(ISD::XOR, DL, VT, NewConv, FlipBits);
7363 return DAG.getNode(ISD::XOR, DL, VT,
7366 return DAG.getNode(ISD::AND, DL, VT,
7381 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse() &&
7387 SDValue X = DAG.getNode(ISD::BITCAST, SDLoc(N0),
7389 AddToWorklist(X.getNode());
7394 X = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, X);
7395 AddToWorklist(X.getNode());
7400 X = DAG.getNode(ISD::SRL, DL,
7404 AddToWorklist(X.getNode());
7405 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
7406 AddToWorklist(X.getNode());
7411 SDValue Cst = DAG.getNode(ISD::BITCAST, SDLoc(N0.getOperand(0)), VT,
7413 AddToWorklist(Cst.getNode());
7414 SDValue X = DAG.getNode(ISD::BITCAST, SDLoc(N0.getOperand(1)), VT,
7416 AddToWorklist(X.getNode());
7417 SDValue XorResult = DAG.getNode(ISD::XOR, SDLoc(N0), VT, Cst, X);
7418 AddToWorklist(XorResult.getNode());
7419 SDValue XorResult64 = DAG.getNode(
7423 AddToWorklist(XorResult64.getNode());
7425 DAG.getNode(ISD::AND, SDLoc(XorResult64), MVT::i64, XorResult64,
7427 AddToWorklist(FlipBit.getNode());
7429 DAG.getNode(ISD::BUILD_PAIR, SDLoc(N0), VT, FlipBit, FlipBit);
7430 AddToWorklist(FlipBits.getNode());
7431 return DAG.getNode(ISD::XOR, SDLoc(N), VT, Cst, FlipBits);
7434 X = DAG.getNode(ISD::AND, SDLoc(X), VT,
7436 AddToWorklist(X.getNode());
7438 SDValue Cst = DAG.getNode(ISD::BITCAST, SDLoc(N0),
7440 Cst = DAG.getNode(ISD::AND, SDLoc(Cst), VT,
7442 AddToWorklist(Cst.getNode());
7444 return DAG.getNode(ISD::OR, SDLoc(N), VT, X, Cst);
7450 if (SDValue CombineLD = CombineConsecutiveLoads(N0.getNode(), VT))
7469 if (ISD::isBuildVectorOfConstantSDNodes(Op.getNode()) ||
7470 ISD::isBuildVectorOfConstantFPSDNodes(Op.getNode()))
7471 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Op);
7527 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(BV), VT,
7528 DAG.getNode(ISD::BITCAST, SDLoc(BV),
7536 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(BV), SrcEltVT, Op);
7537 Ops.push_back(DAG.getNode(ISD::BITCAST, SDLoc(BV),
7539 AddToWorklist(Ops.back().getNode());
7541 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT, Ops);
7551 BV = ConstantFoldBITCASTofBUILD_VECTOR(BV, IntVT).getNode();
7559 SDNode *Tmp = ConstantFoldBITCASTofBUILD_VECTOR(BV, TmpVT).getNode();
7597 return DAG.getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
7627 return DAG.getNode(ISD::BUILD_VECTOR, DL, VT, Ops);
7662 if (N0.getNode()->use_size() > N1.getNode()->use_size())
7669 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7677 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7687 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7688 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7690 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7699 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7700 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7702 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7712 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7714 DAG.getNode(PreferredFusedOpcode, SL, VT,
7723 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7725 DAG.getNode(PreferredFusedOpcode, SL, VT,
7736 return DAG.getNode(PreferredFusedOpcode, SL, VT, X, Y,
7737 DAG.getNode(PreferredFusedOpcode, SL, VT,
7738 DAG.getNode(ISD::FP_EXTEND, SL, VT, U),
7739 DAG.getNode(ISD::FP_EXTEND, SL, VT, V),
7760 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7761 DAG.getNode(ISD::FP_EXTEND, SL, VT, X),
7762 DAG.getNode(ISD::FP_EXTEND, SL, VT, Y),
7763 DAG.getNode(PreferredFusedOpcode, SL, VT,
7764 DAG.getNode(ISD::FP_EXTEND, SL, VT, U),
7765 DAG.getNode(ISD::FP_EXTEND, SL, VT, V),
7844 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7846 DAG.getNode(ISD::FNEG, SL, VT, N1));
7853 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7854 DAG.getNode(ISD::FNEG, SL, VT,
7864 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7865 DAG.getNode(ISD::FNEG, SL, VT, N00), N01,
7866 DAG.getNode(ISD::FNEG, SL, VT, N1));
7876 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7877 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7879 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7881 DAG.getNode(ISD::FNEG, SL, VT, N1));
7890 getNode(PreferredFusedOpcode, SL, VT,
7891 DAG.getNode(ISD::FNEG, SL, VT,
7892 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7894 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7910 return DAG.getNode(ISD::FNEG, SL, VT,
7911 DAG.getNode(PreferredFusedOpcode, SL, VT,
7912 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7914 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7932 return DAG.getNode(ISD::FNEG, SL, VT,
7933 DAG.getNode(PreferredFusedOpcode, SL, VT,
7934 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7936 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7951 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7953 DAG.getNode(PreferredFusedOpcode, SL, VT,
7956 DAG.getNode(ISD::FNEG, SL, VT,
7966 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7967 DAG.getNode(ISD::FNEG, SL, VT,
7970 DAG.getNode(PreferredFusedOpcode, SL, VT,
7971 DAG.getNode(ISD::FNEG, SL, VT, N20),
7984 return DAG.getNode(PreferredFusedOpcode, SL, VT,
7986 DAG.getNode(PreferredFusedOpcode, SL, VT,
7987 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7989 DAG.getNode(ISD::FP_EXTEND, SL, VT,
7991 DAG.getNode(ISD::FNEG, SL, VT,
8007 return DAG.getNode(PreferredFusedOpcode, SL, VT,
8008 DAG.getNode(ISD::FP_EXTEND, SL, VT,
8010 DAG.getNode(ISD::FP_EXTEND, SL, VT,
8012 DAG.getNode(PreferredFusedOpcode, SL, VT,
8013 DAG.getNode(ISD::FP_EXTEND, SL, VT,
8015 DAG.getNode(ISD::FP_EXTEND, SL, VT,
8017 DAG.getNode(ISD::FNEG, SL, VT,
8030 return DAG.getNode(PreferredFusedOpcode, SL, VT,
8031 DAG.getNode(ISD::FNEG, SL, VT, N1.getOperand(0)),
8033 DAG.getNode(PreferredFusedOpcode, SL, VT,
8034 DAG.getNode(ISD::FNEG, SL, VT,
8035 DAG.getNode(ISD::FP_EXTEND, SL,
8037 DAG.getNode(ISD::FP_EXTEND, SL, VT,
8057 return DAG.getNode(PreferredFusedOpcode, SL, VT,
8058 DAG.getNode(ISD::FNEG, SL, VT,
8059 DAG.getNode(ISD::FP_EXTEND, SL, VT,
8061 DAG.getNode(ISD::FP_EXTEND, SL, VT, N101),
8062 DAG.getNode(PreferredFusedOpcode, SL, VT,
8063 DAG.getNode(ISD::FNEG, SL, VT,
8064 DAG.getNode(ISD::FP_EXTEND, SL,
8066 DAG.getNode(ISD::FP_EXTEND, SL, VT,
8112 return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y, Y);
8114 return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y,
8115 DAG.getNode(ISD::FNEG, SL, VT, Y));
8133 return DAG.getNode(PreferredFusedOpcode, SL, VT,
8134 DAG.getNode(ISD::FNEG, SL, VT, X.getOperand(1)), Y,
8137 return DAG.getNode(PreferredFusedOpcode, SL, VT,
8138 DAG.getNode(ISD::FNEG, SL, VT, X.getOperand(1)), Y,
8139 DAG.getNode(ISD::FNEG, SL, VT, Y));
8143 return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y,
8144 DAG.getNode(ISD::FNEG, SL, VT, Y));
8146 return DAG.getNode(PreferredFusedOpcode, SL, VT, X.getOperand(0), Y, Y);
8176 return DAG.getNode(ISD::FADD, DL, VT, N0, N1, Flags);
8180 return DAG.getNode(ISD::FADD, DL, VT, N1, N0, Flags);
8185 return DAG.getNode(ISD::FSUB, DL, VT, N0,
8191 return DAG.getNode(ISD::FSUB, DL, VT, N1,
8206 if (N1CFP && N0.getOpcode() == ISD::FADD && N0.getNode()->hasOneUse() &&
8208 return DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(0),
8209 DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1), N1,
8231 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1),
8233 return DAG.getNode(ISD::FMUL, DL, VT, N1, NewCFP, Flags);
8240 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N0.getOperand(1),
8242 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0), NewCFP, Flags);
8252 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N1.getOperand(1),
8254 return DAG.getNode(ISD::FMUL, DL, VT, N0, NewCFP, Flags);
8261 SDValue NewCFP = DAG.getNode(ISD::FADD, DL, VT, N1.getOperand(1),
8263 return DAG.getNode(ISD::FMUL, DL, VT, N1.getOperand(0), NewCFP, Flags);
8272 return DAG.getNode(ISD::FMUL, DL, VT,
8282 return DAG.getNode(ISD::FMUL, DL, VT,
8293 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0),
8301 AddToWorklist(Fused.getNode());
8325 return DAG.getNode(ISD::FSUB, dl, VT, N0, N1, Flags);
8329 return DAG.getNode(ISD::FADD, dl, VT, N0,
8343 return DAG.getNode(ISD::FNEG, dl, VT, N1);
8366 AddToWorklist(Fused.getNode());
8392 return DAG.getNode(ISD::FMUL, DL, VT, N0, N1, Flags);
8397 return DAG.getNode(ISD::FMUL, DL, VT, N1, N0, Flags);
8426 SDValue MulConsts = DAG.getNode(ISD::FMUL, DL, VT, N01, N1, Flags);
8427 return DAG.getNode(ISD::FMUL, DL, VT, N00, MulConsts, Flags);
8440 SDValue MulConsts = DAG.getNode(ISD::FMUL, DL, VT, Two, N1, Flags);
8441 return DAG.getNode(ISD::FMUL, DL, VT, N0.getOperand(0), MulConsts, Flags);
8447 return DAG.getNode(ISD::FADD, DL, VT, N0, N0, Flags);
8452 return DAG.getNode(ISD::FNEG, DL, VT, N0);
8460 return DAG.getNode(ISD::FMUL, DL, VT,
8469 AddToWorklist(Fused.getNode());
8490 return DAG.getNode(ISD::FMA, dl, VT, N0, N1, N2);
8501 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N2);
8503 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N2);
8508 return DAG.getNode(ISD::FMA, SDLoc(N), VT, N1, N0, N2);
8520 return DAG.getNode(ISD::FMUL, dl, VT, N0,
8521 DAG.getNode(ISD::FADD, dl, VT, N1, N2.getOperand(1),
8529 return DAG.getNode(ISD::FMA, dl, VT,
8531 DAG.getNode(ISD::FMUL, dl, VT, N1, N0.getOperand(1),
8542 return DAG.getNode(ISD::FADD, dl, VT, N0, N2);
8546 SDValue RHSNeg = DAG.getNode(ISD::FNEG, dl, VT, N0);
8547 AddToWorklist(RHSNeg.getNode());
8549 return DAG.getNode(ISD::FADD, dl, VT, N2, RHSNeg);
8556 return DAG.getNode(ISD::FMUL, dl, VT, N0,
8557 DAG.getNode(ISD::FADD, dl, VT,
8564 return DAG.getNode(ISD::FMUL, dl, VT, N0,
8565 DAG.getNode(ISD::FADD, dl, VT,
8620 SDValue Reciprocal = DAG.getNode(ISD::FDIV, DL, VT, FPOne, N1, Flags);
8626 SDValue NewNode = DAG.getNode(ISD::FMUL, SDLoc(U), VT, Dividend,
8629 } else if (U != Reciprocal.getNode()) {
8655 return DAG.getNode(ISD::FDIV, SDLoc(N), VT, N0, N1, Flags);
8673 return DAG.getNode(ISD::FMUL, DL, VT, N0,
8681 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
8687 RV = DAG.getNode(ISD::FP_EXTEND, SDLoc(N1), VT, RV);
8688 AddToWorklist(RV.getNode());
8689 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
8695 RV = DAG.getNode(ISD::FP_ROUND, SDLoc(N1), VT, RV, N1.getOperand(1));
8696 AddToWorklist(RV.getNode());
8697 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
8711 if (SqrtOp.getNode()) {
8715 RV = DAG.getNode(ISD::FDIV, SDLoc(N1), VT, RV, OtherOp, Flags);
8716 AddToWorklist(RV.getNode());
8717 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
8724 AddToWorklist(RV.getNode());
8725 return DAG.getNode(ISD::FMUL, DL, VT, N0, RV, Flags);
8735 return DAG.getNode(ISD::FDIV, SDLoc(N), VT,
8757 return DAG.getNode(ISD::FREM, SDLoc(N), VT, N0, N1,
8779 RV = DAG.getNode(ISD::FMUL, DL, VT, N->getOperand(0), RV, &Flags);
8780 AddToWorklist(RV.getNode());
8787 AddToWorklist(ZeroCmp.getNode());
8788 AddToWorklist(RV.getNode());
8790 return DAG.getNode(VT.isVector() ? ISD::VSELECT : ISD::SELECT, DL, VT,
8818 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0, N1);
8826 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
8829 return DAG.getNode(ISD::FNEG, SDLoc(N), VT,
8830 DAG.getNode(ISD::FABS, SDLoc(N0), VT, N0));
8839 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
8844 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
8848 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
8854 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
8870 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
8878 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
8893 return DAG.getNode(ISD::SELECT_CC, DL, VT, Ops);
8907 return DAG.getNode(ISD::SELECT_CC, DL, VT, Ops);
8924 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
8932 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
8947 return DAG.getNode(ISD::SELECT_CC, DL, VT, Ops);
8987 return DAG.getNode(ExtOp, SDLoc(N), VT, Src);
8990 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Src);
8993 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Src);
9004 return DAG.getNode(ISD::FP_TO_SINT, SDLoc(N), VT, N0);
9015 return DAG.getNode(ISD::FP_TO_UINT, SDLoc(N), VT, N0);
9028 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0, N1);
9037 const bool N0IsTrunc = N0.getNode()->getConstantOperandVal(1) == 1;
9056 return DAG.getNode(ISD::FP_ROUND, DL, VT, N0.getOperand(0),
9062 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse()) {
9063 SDValue Tmp = DAG.getNode(ISD::FP_ROUND, SDLoc(N0), VT,
9065 AddToWorklist(Tmp.getNode());
9066 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
9083 return DAG.getNode(ISD::FP_EXTEND, DL, VT, Round);
9100 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, N0);
9105 return DAG.getNode(ISD::FP16_TO_FP, SDLoc(N), VT, N0.getOperand(0));
9110 && N0.getNode()->getConstantOperandVal(1) == 1) {
9114 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT,
9116 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, In);
9120 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
9128 CombineTo(N0.getNode(),
9129 DAG.getNode(ISD::FP_ROUND, SDLoc(N0),
9145 return DAG.getNode(ISD::FCEIL, SDLoc(N), VT, N0);
9156 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0);
9167 return DAG.getNode(ISD::FFLOOR, SDLoc(N), VT, N0);
9179 return DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0);
9189 N0.getNode()->hasOneUse()) {
9204 Int = DAG.getNode(ISD::XOR, DL0, IntVT, Int,
9206 AddToWorklist(Int.getNode());
9207 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT, Int);
9213 (N0.getNode()->hasOneUse() || !TLI.isFNegFree(VT))) {
9221 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0.getOperand(0),
9222 DAG.getNode(ISD::FNEG, SDLoc(N), VT,
9247 return DAG.getNode(ISD::FMINNUM, SDLoc(N), VT, N1, N0);
9268 return DAG.getNode(ISD::FMAXNUM, SDLoc(N), VT, N1, N0);
9279 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
9288 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0.getOperand(0));
9294 N0.getNode()->hasOneUse()) {
9309 Int = DAG.getNode(ISD::AND, DL, IntVT, Int,
9311 AddToWorklist(Int.getNode());
9312 return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0), Int);
9335 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
9347 Trunc = N1.getNode();
9387 SDValue NewBRCond = DAG.getNode(ISD::BRCOND, DL,
9398 deleteAndRecombine(N1.getNode());
9412 SDNode *TheXor = N1.getNode();
9418 if (Tmp.getNode() != TheXor) {
9422 Tmp.getNode()->dump(&DAG);
9427 return DAG.getNode(ISD::BRCOND, SDLoc(N),
9441 TheXor = Op0.getNode();
9455 deleteAndRecombine(N1.getNode());
9456 return DAG.getNode(ISD::BRCOND, SDLoc(N),
9480 if (Simp.getNode()) AddToWorklist(Simp.getNode());
9483 if (Simp.getNode() && Simp.getOpcode() == ISD::SETCC)
9484 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
9501 if (LD->isIndexed() || LD->getBasePtr().getNode() != N)
9506 if (ST->isIndexed() || ST->getBasePtr().getNode() != N)
9573 Ptr.getNode()->hasOneUse())
9612 if (Val == BasePtr || BasePtr.getNode()->isPredecessorOf(Val.getNode()))
9621 for (SDNode::use_iterator UI = BasePtr.getNode()->use_begin(),
9622 UE = BasePtr.getNode()->use_end();
9627 if (Use.getUser() == Ptr.getNode() || Use != BasePtr)
9664 for (SDNode *Use : Ptr.getNode()->uses()) {
9672 if (!canFoldInAddressingMode(Ptr.getNode(), Use, DAG, TLI))
9691 Result.getNode()->dump(&DAG);
9710 if (OtherUses[i]->getOperand(OffsetIdx).getNode() == BasePtr.getNode())
9712 assert(OtherUses[i]->getOperand(!OffsetIdx).getNode() ==
9713 BasePtr.getNode() && "Expected BasePtr operand");
9750 SDValue NewUse = DAG.getNode(Opcode,
9759 deleteAndRecombine(Ptr.getNode());
9796 if (Ptr.getNode()->hasOneUse())
9799 for (SDNode *Op : Ptr.getNode()->uses()) {
9824 for (SDNode *Use : BasePtr.getNode()->uses()) {
9825 if (Use == Ptr.getNode())
9859 Result.getNode()->dump(&DAG);
9905 return DAG.getNode(Opc, SDLoc(LD), BP.getSimpleValueType(), BP, Inc);
9929 Chain.getNode()->dump(&DAG);
9964 Undef.getNode()->dump(&DAG);
9981 if (ISD::isNON_TRUNCStore(Chain.getNode())) {
10000 if (NewLoad.getNode() != N)
10001 return CombineTo(N, NewLoad, SDValue(NewLoad.getNode(), 1), true);
10033 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
10037 AddToWorklist(Token.getNode());
10292 BaseAddr = DAG->getNode(ISD::ADD, DL, ArithType, BaseAddr,
10309 DAG->getNode(ISD::ZERO_EXTEND, SDLoc(LastInst), FinalType, LastInst);
10585 if (SliceInst.getNode()->getOpcode() != ISD::LOAD)
10592 SDValue Chain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other,
10608 !ISD::isNormalLoad(V->getOperand(0).getNode()))
10617 if (LD == Chain.getNode())
10624 if (ChainOp.getNode() == LD) {
10701 IVal = DAG.getNode(ISD::SRL, DL, IVal.getValueType(), IVal,
10718 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(),
10724 IVal = DAG.getNode(ISD::TRUNCATE, SDLoc(IVal), VT, IVal);
10729 false, false, NewAlign).getNode();
10778 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
10779 Chain == SDValue(N0.getNode(), 1)) {
10831 SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(LD),
10841 SDValue NewVal = DAG.getNode(Opc, SDLoc(Value), NewVT, NewLD,
10849 AddToWorklist(NewPtr.getNode());
10850 AddToWorklist(NewLD.getNode());
10851 AddToWorklist(NewVal.getNode());
10869 if (ISD::isNormalStore(ST) && ISD::isNormalLoad(Value.getNode()) &&
10871 Chain == SDValue(Value.getNode(), 1)) {
10906 AddToWorklist(NewLD.getNode());
10907 AddToWorklist(NewST.getNode());
11026 if (AddNode.getNode()->hasOneUse())
11037 SDNode *MulVar = AddNode.getOperand(0).getNode();
11041 OtherOp = Use->getOperand(1).getNode();
11043 OtherOp = Use->getOperand(0).getNode();
11073 OtherOp->getOperand(0).getNode() == MulVar)
11095 return DAG.getNode(ISD::BUILD_VECTOR, SL, Ty, BuildVector);
11151 StoredVal = DAG.getNode(IsVec ? ISD::CONCAT_VECTORS : ISD::BUILD_VECTOR,
11187 SDValue NewChain = DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Chains);
11227 if (!BasePtr.Base.getNode())
11311 SDNode *NextInChain = Index->getChain().getNode();
11325 NextInChain = Ldn->getChain().getNode();
11568 if (LdBasePtr.Base.getNode()) {
11704 DAG.getNode(ISD::TokenFactor, StoreDL, MVT::Other, MergeStoreChains);
11714 SDValue(NewLoad.getNode(), 1));
11747 SDValue Token = DAG.getNode(ISD::TokenFactor, SL,
11751 AddToWorklist(Token.getNode());
11825 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
11832 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other,
11876 if (NewStore.getNode() != N)
11924 AddToWorklist(Value.getNode());
11925 if (Shorter.getNode())
11965 && Value.getNode()->hasOneUse() && ST->isUnindexed() &&
12037 SDValue NewOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(N), VT,
12039 AddToWorklist(NewOp.getNode());
12040 return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(InVec.getNode()),
12052 Ops.append(InVec.getNode()->op_begin(),
12053 InVec.getNode()->op_end());
12068 DAG.getNode(ISD::ANY_EXTEND, dl, OpVT, InVal) :
12069 DAG.getNode(ISD::TRUNCATE, dl, OpVT, InVal);
12074 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
12102 Offset = DAG.getNode(
12107 NewPtr = DAG.getNode(ISD::ADD, DL, PtrType, NewPtr, Offset);
12136 Load = DAG.getNode(ISD::TRUNCATE, SDLoc(EVE), ResultVT, Load);
12138 Load = DAG.getNode(ISD::BITCAST, SDLoc(EVE), ResultVT, Load);
12146 AddToWorklist(Load.getNode());
12147 AddUsersToWorklist(Load.getNode()); // Add users too
12232 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N), NVT, SVInVec,
12262 ISD::isNormalLoad(InVec.getNode()) &&
12263 !N->getOperand(1)->hasPredecessor(InVec.getNode())) {
12283 if (ISD::isNormalLoad(InVec.getNode())) {
12287 ISD::isNormalLoad(InVec.getOperand(0).getNode())) {
12319 if (ISD::isNormalLoad(InVec.getNode())) {
12443 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VecVT, Ops);
12446 AddToWorklist(BV.getNode());
12448 return DAG.getNode(ISD::BITCAST, dl, VT, BV);
12516 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, Opnds);
12517 AddToWorklist(BV.getNode());
12519 return DAG.getNode(Opcode, dl, VT, BV);
12557 if (!VecIn2.getNode() && (isNullConstant(Op) || isNullFPConstant(Op))) {
12575 if (!VecIn1.getNode()) {
12577 } else if (!VecIn2.getNode() && !UsesZeroVector) {
12587 if (VecIn1.getNode()) {
12630 (VecIn2.getNode() &&
12640 if (!VecIn2.getNode())
12641 VecIn1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, VecIn1,
12645 VecIn1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT, VecIn1, VecIn2);
12654 if (UsesZeroVector || VecIn2.getNode())
12662 VecIn2 = DAG.getNode(
12666 VecIn1 = DAG.getNode(
12678 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
12709 SDValue ScalarUndef = DAG.getNode(ISD::UNDEF, DL, SVT);
12739 ScalarUndef = DAG.getNode(ISD::UNDEF, DL, SVT);
12747 Op = DAG.getNode(ISD::BITCAST, DL, SVT, Op);
12754 return DAG.getNode(ISD::BITCAST, DL, VT,
12755 DAG.getNode(ISD::BUILD_VECTOR, DL, VecVT, Ops));
12882 SDValue Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NVT, Scalar);
12883 return DAG.getNode(ISD::BITCAST, dl, VT, Res);
12928 DAG.getNode(ISD::TRUNCATE, SDLoc(N), MinVT, Op.getOperand(i)));
12935 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, Opnds);
12965 if (SingleSource.getNode()) {
12989 if (SingleSource.getNode())
13042 return DAG.getNode(ISD::BITCAST, dl, NVT, V->getOperand(1));
13043 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT,
13044 DAG.getNode(ISD::BITCAST, dl,
13084 V = DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, NewOps);
13113 V = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, VT,
13163 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, N0, N1);
13200 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Ops);
13266 SDNode *V = N0.getNode();
13275 V = ConvInput.getNode();
13290 if (!Base.getNode())
13305 SDValue NewBV = DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N),
13311 NewBV = DAG.getNode(ISD::BITCAST, SDLoc(N), VT, NewBV);
13329 if (V.getNode())
13366 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, Ops);
13435 SV0 = DAG.getNode(ISD::BITCAST, SDLoc(N), ScaleVT, SV0);
13436 SV1 = DAG.getNode(ISD::BITCAST, SDLoc(N), ScaleVT, SV1);
13437 return DAG.getNode(
13473 if (N0.getOpcode() == ISD::VECTOR_SHUFFLE && N->isOnlyUserOf(N0.getNode()) &&
13521 if (!SV0.getNode() || SV0 == CurrentVec) {
13530 if (SV1.getNode() && SV1 != CurrentVec)
13547 if (!SV0.getNode())
13549 if (!SV1.getNode())
13616 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
13622 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
13646 return DAG.getNode(ISD::FP16_TO_FP, SDLoc(N), N->getValueType(0),
13780 SDValue NewBinOp = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
13802 if (SCC.getNode()) {
13806 SDValue SETCC = DAG.getNode(ISD::SETCC, SDLoc(N0),
13810 AddToWorklist(SETCC.getNode());
13907 SDNode *CondNode = TheSelect->getOperand(0).getNode();
13920 SDNode *CondLHS = TheSelect->getOperand(0).getNode();
13921 SDNode *CondRHS = TheSelect->getOperand(1).getNode();
13929 Addr = DAG.getNode(ISD::SELECT_CC, SDLoc(TheSelect),
13966 CombineTo(LHS.getNode(), Load.getValue(0), Load.getValue(1));
13967 CombineTo(RHS.getNode(), Load.getValue(0), Load.getValue(1));
13983 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
13984 ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
13989 if (SCC.getNode()) AddToWorklist(SCC.getNode());
13991 if (ConstantSDNode *SCCC = dyn_cast_or_null<ConstantSDNode>(SCC.getNode())) {
14005 return DAG.getNode(ISD::FABS, DL, VT, N0);
14011 return DAG.getNode(ISD::FABS, DL, VT, N3);
14056 AddToWorklist(Cond.getNode());
14059 AddToWorklist(CstOffset.getNode());
14060 CPIdx = DAG.getNode(ISD::ADD, DL, CPIdx.getValueType(), CPIdx,
14062 AddToWorklist(CPIdx.getNode());
14085 SDValue Shift = DAG.getNode(ISD::SRL, SDLoc(N0),
14087 AddToWorklist(Shift.getNode());
14090 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
14091 AddToWorklist(Shift.getNode());
14094 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
14097 SDValue Shift = DAG.getNode(ISD::SRA, SDLoc(N0),
14102 AddToWorklist(Shift.getNode());
14105 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
14106 AddToWorklist(Shift.getNode());
14109 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
14129 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N0), VT, AndLHS, ShlAmt);
14136 SDValue Shr = DAG.getNode(ISD::SRA, SDLoc(N0), VT, Shl, ShrAmt);
14138 return DAG.getNode(ISD::AND, DL, VT, Shr, N3);
14165 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2),
14169 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2),
14173 AddToWorklist(SCC.getNode());
14174 AddToWorklist(Temp.getNode());
14180 return DAG.getNode(
14207 SDValue Shift = DAG.getNode(ISD::SRA, DL, XType,
14211 SDValue Add = DAG.getNode(ISD::ADD, DL,
14213 AddToWorklist(Shift.getNode());
14214 AddToWorklist(Add.getNode());
14215 return DAG.getNode(ISD::XOR, DL, XType, Add, Shift);
14314 AddToWorklist(Est.getNode());
14318 SDValue NewEst = DAG.getNode(ISD::FMUL, DL, VT, Op, Est, Flags);
14319 AddToWorklist(NewEst.getNode());
14321 NewEst = DAG.getNode(ISD::FSUB, DL, VT, FPOne, NewEst, Flags);
14322 AddToWorklist(NewEst.getNode());
14324 NewEst = DAG.getNode(ISD::FMUL, DL, VT, Est, NewEst, Flags);
14325 AddToWorklist(NewEst.getNode());
14327 Est = DAG.getNode(ISD::FADD, DL, VT, Est, NewEst, Flags);
14328 AddToWorklist(Est.getNode());
14352 SDValue HalfArg = DAG.getNode(ISD::FMUL, DL, VT, ThreeHalves, Arg, Flags);
14353 AddToWorklist(HalfArg.getNode());
14355 HalfArg = DAG.getNode(ISD::FSUB, DL, VT, HalfArg, Arg, Flags);
14356 AddToWorklist(HalfArg.getNode());
14360 SDValue NewEst = DAG.getNode(ISD::FMUL, DL, VT, Est, Est, Flags);
14361 AddToWorklist(NewEst.getNode());
14363 NewEst = DAG.getNode(ISD::FMUL, DL, VT, HalfArg, NewEst, Flags);
14364 AddToWorklist(NewEst.getNode());
14366 NewEst = DAG.getNode(ISD::FSUB, DL, VT, ThreeHalves, NewEst, Flags);
14367 AddToWorklist(NewEst.getNode());
14369 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, NewEst, Flags);
14370 AddToWorklist(Est.getNode());
14390 SDValue HalfEst = DAG.getNode(ISD::FMUL, DL, VT, Est, MinusHalf, Flags);
14391 AddToWorklist(HalfEst.getNode());
14393 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, Est, Flags);
14394 AddToWorklist(Est.getNode());
14396 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, Arg, Flags);
14397 AddToWorklist(Est.getNode());
14399 Est = DAG.getNode(ISD::FADD, DL, VT, Est, MinusThree, Flags);
14400 AddToWorklist(Est.getNode());
14402 Est = DAG.getNode(ISD::FMUL, DL, VT, Est, HalfEst, Flags);
14403 AddToWorklist(Est.getNode());
14417 AddToWorklist(Est.getNode());
14597 if (!Visited.insert(Chain.getNode()).second)
14608 bool IsOpLoad = isa<LoadSDNode>(Chain.getNode()) &&
14609 !cast<LSBaseSDNode>(Chain.getNode())->isVolatile();
14613 isAlias(cast<LSBaseSDNode>(N), cast<LSBaseSDNode>(Chain.getNode()))) {
14627 // likelihood that getNode will find a matching token factor (CSE.)
14673 if (N != OriginalChain.getNode())
14719 return DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other, Aliases);
14728 if (!BasePtr.Base.getNode())
14761 SDNode *NextInChain = Index->getChain().getNode();
14773 NextInChain = Ldn->getChain().getNode();
