Lines Matching full:getnode
169 // SDValue.getNode() == 0 - No change was made
170 // SDValue.getNode() == N - N was replaced, is dead and has been handled.
494 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
499 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
513 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
524 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
530 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
537 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
541 return DAG.getNode(ISD::FP_ROUND, SDLoc(Op), Op.getValueType(),
580 if (isSetCCEquivalent(N, N0, N1, N2) && N.getNode()->hasOneUse())
595 return DAG.getNode(Opc, DL, VT, N0.getOperand(0), OpNode);
599 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT,
601 AddToWorkList(OpNode.getNode());
602 return DAG.getNode(Opc, DL, VT, OpNode, N0.getOperand(1));
613 return DAG.getNode(Opc, DL, VT, N1.getOperand(0), OpNode);
617 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT,
619 AddToWorkList(OpNode.getNode());
620 return DAG.getNode(Opc, DL, VT, OpNode, N1.getOperand(1));
634 To[0].getNode()->dump(&DAG);
637 assert((!To[i].getNode() ||
645 if (To[i].getNode()) {
646 AddToWorkList(To[i].getNode());
647 AddUsersToWorkList(To[i].getNode());
674 AddToWorkList(TLO.New.getNode());
675 AddUsersToWorkList(TLO.New.getNode());
680 if (TLO.Old.getNode()->use_empty()) {
681 removeFromWorkList(TLO.Old.getNode());
685 for (unsigned i = 0, e = TLO.Old.getNode()->getNumOperands(); i != e; ++i)
686 if (TLO.Old.getNode()->getOperand(i).getNode()->hasOneUse())
687 AddToWorkList(TLO.Old.getNode()->getOperand(i).getNode());
689 DAG.DeleteNode(TLO.Old.getNode());
703 AddToWorkList(Op.getNode());
708 TLO.Old.getNode()->dump(&DAG);
710 TLO.New.getNode()->dump(&DAG);
720 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, VT, SDValue(ExtLoad, 0));
725 Trunc.getNode()->dump(&DAG);
732 AddToWorkList(Trunc.getNode());
756 return DAG.getNode(ISD::AssertSext, dl, PVT,
760 return DAG.getNode(ISD::AssertZext, dl, PVT,
766 return DAG.getNode(ExtOpc, dl, PVT, Op);
772 return DAG.getNode(ISD::ANY_EXTEND, dl, PVT, Op);
782 if (NewOp.getNode() == 0)
784 AddToWorkList(NewOp.getNode());
787 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
788 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NewOp.getValueType(), NewOp,
797 if (NewOp.getNode() == 0)
799 AddToWorkList(NewOp.getNode());
802 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
832 if (NN0.getNode() == 0)
842 if (NN1.getNode() == 0)
846 AddToWorkList(NN0.getNode());
847 if (NN1.getNode())
848 AddToWorkList(NN1.getNode());
851 ReplaceLoadWithPromotedLoad(N0.getNode(), NN0.getNode());
853 ReplaceLoadWithPromotedLoad(N1.getNode(), NN1.getNode());
856 Op.getNode
858 return DAG.getNode(ISD::TRUNCATE, dl, VT,
859 DAG.getNode(Opc, dl, PVT, NN0, NN1));
895 if (N0.getNode() == 0)
898 AddToWorkList(N0.getNode());
900 ReplaceLoadWithPromotedLoad(Op.getOperand(0).getNode(), N0.getNode());
903 Op.getNode()->dump(&DAG));
905 return DAG.getNode(ISD::TRUNCATE, dl, VT,
906 DAG.getNode(Opc, dl, PVT, N0, Op.getOperand(1)));
934 Op.getNode()->dump(&DAG));
935 return DAG.getNode(Op.getOpcode(), SDLoc(Op), VT, Op.getOperand(0));
961 SDNode *N = Op.getNode();
973 SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, VT, NewLD);
978 Result.getNode()->dump(&DAG);
985 AddToWorkList(Result.getNode());
1033 AddToWorkList(N->getOperand(i).getNode());
1041 if (RV.getNode() == 0)
1050 if (RV.getNode() == N)
1054 RV.getNode()->getOpcode() != ISD::DELETED_NODE &&
1060 RV.getNode()->dump(&DAG);
1066 if (N->getNumValues() == RV.getNode()->getNumValues())
1067 DAG.ReplaceAllUsesWith(N, RV.getNode());
1076 AddToWorkList(RV.getNode());
1077 AddUsersToWorkList(RV.getNode());
1083 AddToWorkList(N->getOperand(i).getNode());
1186 if (RV.getNode() == 0) {
1202 if (RV.getNode() == 0) {
1232 if (RV.getNode() == 0 &&
1270 if (getInputChainForNode(N->getOperand(0).getNode()) == N->getOperand(1))
1272 if (getInputChainForNode(N->getOperand(1).getNode()) == N->getOperand(0))
1302 std::find(TFs.begin(), TFs.end(), Op.getNode()) == TFs.end()) {
1304 TFs.push_back(Op.getNode());
1306 AddToWorkList(Op.getNode());
1314 if (SeenOps.insert(Op.getNode()))
1332 Result = DAG.getNode(ISD::TokenFactor, SDLoc(N),
1369 if (N01C && N00.getOpcode() == ISD::ADD && N00.getNode()->hasOneUse() &&
1372 N0 = DAG.getNode(ISD::ADD, SDLoc(N0), VT,
1373 DAG.getNode(ISD::SHL, SDLoc(N00), VT,
1375 DAG.getNode(ISD::SHL, SDLoc(N01), VT,
1377 return DAG.getNode(ISD::ADD, DL, VT, N0, N1);
1393 if (FoldedVOp.getNode()) return FoldedVOp;
1396 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1398 if (ISD::isBuildVectorAllZeros(N0.getNode()))
1412 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N1, N0);
1426 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1432 if (RADD.getNode() != 0)
1437 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1, N0.getOperand(1));
1441 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1.getOperand(1));
1451 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1456 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1462 return DAG.getNode(N1.getOpcode(), SDLoc(N), VT,
1473 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1474 DAG.getNode(ISD::ADD, SDLoc(N0), VT, N00, N10),
1475 DAG.getNode(ISD::ADD, SDLoc(N1), VT, N01, N11));
1493 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1);
1498 if (N0.getOpcode() == ISD::SHL && N0.getNode()->hasOneUse()) {
1500 if (Result.getNode()) return Result;
1502 if (N1.getOpcode() == ISD::SHL && N1.getNode()->hasOneUse()) {
1504 if (Result.getNode()) return Result;
1513 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0,
1514 DAG.getNode(ISD::SHL, SDLoc(N), VT,
1522 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1,
1523 DAG.getNode(ISD::SHL, SDLoc(N), VT,
1537 return DAG.getNode(ISD::SUB, DL, VT, N->getOperand(0), AndOp0);
1546 SDValue ZExt = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
1547 return DAG.getNode(ISD::SUB, DL, VT, N1, ZExt);
1562 return CombineTo(N, DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N1),
1563 DAG.getNode(ISD::CARRY_FALSE,
1568 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N1, N0);
1572 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE,
1586 return CombineTo(N, DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1),
1587 DAG.getNode(ISD::CARRY_FALSE,
1603 return DAG.getNode(ISD::ADDE, SDLoc(N), N->getVTList(),
1608 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N0, N1);
1630 return DAG.getNode(ISD::BUILD_VECTOR, DL, VT,
1639 ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.getNode());
1640 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
1642 dyn_cast<ConstantSDNode>(N1.getOperand(1).getNode());
1648 if (FoldedVOp.getNode()) return FoldedVOp;
1651 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1664 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0,
1668 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
1682 return DAG.getNode(ISD::SUB, SDLoc(N), VT, NewC,
1690 return DAG.getNode(N0.getOperand(1).getOpcode(), SDLoc(N), VT,
1696 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
1702 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1738 return CombineTo(N, DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1),
1739 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1745 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1750 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1755 return CombineTo(N, DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0),
1756 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1769 return DAG.getNode(ISD::SUBC, SDLoc(N), N->getVTList(), N0, N1);
1805 if (FoldedVOp.getNode()) return FoldedVOp;
1807 N0IsConst = isConstantSplatVector(N0.getNode(), ConstValue0);
1808 N1IsConst = isConstantSplatVector(N1.getNode(), ConstValue1);
1818 return DAG.FoldConstantArithmetic(ISD::MUL, VT, N0.getNode(), N1.getNode());
1822 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N1, N0);
1831 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1835 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
1843 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1845 DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
1853 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1855 SDValue C3 = DAG.getNode(ISD::SHL, SDLoc(N), VT,
1857 AddToWorkList(C3.getNode());
1858 return DAG.getNode(ISD::MUL, SDLoc(N), VT,
1868 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1870 N0.getNode()->hasOneUse()) {
1874 N1.getNode()->hasOneUse()) {
1878 if (Sh.getNode()) {
1879 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
1881 return DAG.getNode(ISD::SHL, SDLoc(N), VT,
1887 if (N1IsConst && N0.getOpcode() == ISD::ADD && N0.getNode()->hasOneUse() &&
1888 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1890 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
1891 DAG.getNode(ISD::MUL, SDLoc(N0), VT,
1893 DAG.getNode(ISD::MUL, SDLoc(N1), VT,
1898 if (RMUL.getNode() != 0)
1907 ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.getNode());
1908 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
1914 if (FoldedVOp.getNode()) return FoldedVOp;
1925 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1931 return DAG.getNode(ISD::UDIV, SDLoc(N), N1.getValueType(),
1946 SDValue SGN = DAG.getNode(ISD::SRA, SDLoc(N), VT, N0,
1949 AddToWorkList(SGN.getNode());
1952 SDValue SRL = DAG.getNode(ISD::SRL, SDLoc(N), VT, SGN,
1955 SDValue ADD = DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, SRL);
1956 AddToWorkList(SRL.getNode());
1957 AddToWorkList(ADD.getNode()); // Divide by pow2
1958 SDValue SRA = DAG.getNode(ISD::SRA, SDLoc(N), VT, ADD,
1966 AddToWorkList(SRA.getNode());
1967 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1975 if (Op.getNode()) return Op;
1991 ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.getNode());
1992 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
1998 if (FoldedVOp.getNode()) return FoldedVOp;
2006 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0,
2014 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N), ADDVT,
2019 AddToWorkList(Add.getNode());
2020 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, Add);
2027 if (Op.getNode()) return Op;
2054 return DAG.getNode(ISD::UREM, SDLoc(N), VT, N0, N1);
2060 SDValue Div = DAG.getNode(ISD::SDIV, SDLoc(N), VT, N0, N1);
2061 AddToWorkList(Div.getNode());
2062 SDValue OptimizedDiv = combine(Div.getNode());
2063 if (OptimizedDiv.getNode() && OptimizedDiv.getNode() != Div.getNode()) {
2064 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
2066 SDValue Sub = DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, Mul);
2067 AddToWorkList(Mul.getNode());
2094 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0,
2101 DAG.getNode(ISD::ADD, SDLoc(N), VT, N1,
2104 AddToWorkList(Add.getNode());
2105 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, Add);
2113 SDValue Div = DAG.getNode(ISD::UDIV, SDLoc(N), VT, N0, N1);
2114 AddToWorkList(Div.getNode());
2115 SDValue OptimizedDiv = combine(Div.getNode());
2116 if (OptimizedDiv.getNode() && OptimizedDiv.getNode() != Div.getNode()) {
2117 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
2119 SDValue Sub = DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, Mul);
2120 AddToWorkList(Mul.getNode());
2147 return DAG.getNode(ISD::SRA, SDLoc(N), N0.getValueType(), N0,
2161 N0 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N0);
2162 N1 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N1);
2163 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2164 getNode(ISD::SRL, DL, NewVT, N1,
2166 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2197 N0 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N0);
2198 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N1);
2199 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2200 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2202 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2220 SDValue Res = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0),
2230 SDValue Res = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1),
2241 SDValue Lo = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0),
2243 AddToWorkList(Lo.getNode());
2244 SDValue LoOpt = combine(Lo.getNode());
2245 if (LoOpt.getNode() && LoOpt.getNode() != Lo.getNode() &&
2252 SDValue Hi = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1),
2254 AddToWorkList(Hi.getNode());
2255 SDValue HiOpt = combine(Hi.getNode());
2256 if (HiOpt.getNode() && HiOpt != Hi &&
2267 if (Res.getNode()) return Res;
2279 SDValue Lo = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(0));
2280 SDValue Hi = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(1));
2281 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
2283 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
2285 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
2287 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
2297 if (Res.getNode()) return Res;
2309 SDValue Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(0));
2310 SDValue Hi = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(1));
2311 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
2313 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
2315 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
2317 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
2329 return DAG.getNode(ISD::SADDO, SDLoc(N), N->getVTList(),
2339 return DAG.getNode(ISD::UADDO, SDLoc(N), N->getVTList(),
2347 if (Res.getNode()) return Res;
2354 if (Res.getNode()) return Res;
2367 if (N0.getNode()->getNumOperands() == 0) return SDValue();
2390 SDValue ORNode = DAG.getNode(N->getOpcode(), SDLoc(N0),
2393 AddToWorkList(ORNode.getNode());
2394 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, ORNode);
2404 SDValue ORNode = DAG.getNode(N->getOpcode(), SDLoc(N0),
2407 AddToWorkList(ORNode.getNode());
2408 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
2430 SDValue Op = DAG.getNode(N->getOpcode(), DL, In0Ty, In0, In1);
2431 SDValue BC = DAG.getNode(N0.getOpcode(), DL, VT, Op);
2432 AddToWorkList(Op.getNode());
2468 SDValue Op = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
2470 AddToWorkList(Op.getNode());
2491 if (FoldedVOp.getNode()) return FoldedVOp;
2494 if (ISD::isBuildVectorAllZeros(N0.getNode()))
2496 if (ISD::isBuildVectorAllZeros(N1.getNode()))
2500 if (ISD::isBuildVectorAllOnes(N0.getNode()))
2502 if (ISD::isBuildVectorAllOnes(N1.getNode()))
2514 return DAG.getNode(ISD::AND, SDLoc(N), VT, N1, N0);
2524 if (RAND.getNode() != 0)
2537 SDValue Zext = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N),
2546 CombineTo(N0.getNode(), Zext);
2644 CombineTo(N, (N0.getNode() == Load) ? NewLoad : N0);
2658 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(N0),
2660 AddToWorkList(ORNode.getNode());
2665 SDValue ANDNode = DAG.getNode(ISD::AND, SDLoc(N0),
2667 AddToWorkList(ANDNode.getNode());
2672 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(N0),
2674 AddToWorkList(ORNode.getNode());
2699 if (Tmp.getNode()) return Tmp;
2709 if (ISD::isEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode())) {
2725 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
2730 if (ISD::isSEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
2748 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
2802 NewPtr = DAG.getNode(ISD::ADD, SDLoc(LN0), PtrType,
2807 AddToWorkList(NewPtr.getNode());
2840 DAG.getNode(ISD::ADD, SDLoc(N0), VT,
2842 CombineTo(N0.getNode(), NewAdd);
2875 if (!N0.getNode()->hasOneUse())
2885 if (!N1.getNode()->hasOneUse())
2898 if (!N0.getNode()->hasOneUse() ||
2899 !N1.getNode()->hasOneUse())
2912 if (!N00.getNode()->hasOneUse())
2923 if (!N10.getNode()->hasOneUse())
2943 SDValue Res = DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N00);
2945 Res = DAG.getNode(ISD::SRL, SDLoc(N), VT, Res,
2954 if (!N.getNode()->hasOneUse())
3016 Parts[Num] = N0.getOperand(0).getNode();
3078 SDValue BSwap = DAG.getNode(ISD::BSWAP, SDLoc(N), VT,
3085 return DAG.getNode(ISD::ROTL, SDLoc(N), VT, BSwap, ShAmt);
3087 return DAG.getNode(ISD::ROTR, SDLoc(N), VT, BSwap, ShAmt);
3088 return DAG.getNode(ISD::OR, SDLoc(N), VT,
3089 DAG.getNode(ISD::SHL, SDLoc(N), VT, BSwap, ShAmt),
3090 DAG.getNode(ISD::SRL, SDLoc(N), VT, BSwap, ShAmt));
3104 if (FoldedVOp.getNode()) return FoldedVOp;
3107 if (ISD::isBuildVectorAllZeros(N0.getNode()))
3109 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3113 if (ISD::isBuildVectorAllOnes(N0.getNode()))
3115 if (ISD::isBuildVectorAllOnes(N1.getNode()))
3130 return DAG.getNode(ISD::OR, SDLoc(N), VT, N1, N0);
3143 if (BSwap.getNode() != 0)
3146 if (BSwap.getNode() != 0)
3151 if (ROR.getNode() != 0)
3155 if (N1C && N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
3159 return DAG.getNode(ISD::AND, SDLoc(N), VT,
3160 DAG.getNode(ISD::OR, SDLoc(N0), VT,
3175 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(LR),
3177 AddToWorkList(ORNode.getNode());
3184 SDValue ANDNode = DAG.getNode(ISD::AND, SDLoc(LR),
3186 AddToWorkList(ANDNode.getNode());
3211 if (Tmp.getNode()) return Tmp;
3220 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
3230 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
3232 return DAG.getNode(ISD::AND, SDLoc(N), VT, X,
3319 SDValue Rot = DAG.getNode(HasROTL ? ISD::ROTL : ISD::ROTR, DL, VT,
3323 if (LHSMask.getNode() || RHSMask.getNode()) {
3326 if (LHSMask.getNode()) {
3330 if (RHSMask.getNode()) {
3335 Rot = DAG.getNode(ISD::AND, DL, VT, Rot, DAG.getConstant(Mask, VT));
3338 return Rot.getNode();
3343 if (LHSMask.getNode() || RHSMask.getNode())
3353 return DAG.getNode(HasROTL ? ISD::ROTL : ISD::ROTR, DL, VT, LHSShiftArg,
3354 HasROTL ? LHSShiftAmt : RHSShiftAmt).getNode();
3365 return DAG.getNode(HasROTR ? ISD::ROTR : ISD::ROTL, DL, VT, LHSShiftArg,
3366 HasROTR ? RHSShiftAmt : LHSShiftAmt).getNode();
3388 return DAG.getNode(HasROTL ? ISD::ROTL : ISD::ROTR, DL, VT,
3390 HasROTL ? LHSShiftAmt : RHSShiftAmt).getNode();
3400 return DAG.getNode(HasROTR ? ISD::ROTR : ISD::ROTL, DL, VT,
3402 HasROTR ? RHSShiftAmt : LHSShiftAmt).getNode();
3420 if (FoldedVOp.getNode()) return FoldedVOp;
3423 if (ISD::isBuildVectorAllZeros(N0.getNode()))
3425 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3442 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
3448 if (RXOR.getNode() != 0)
3473 N0.getNode()->hasOneUse() &&
3476 V = DAG.getNode(ISD::XOR, SDLoc(N0), V.getValueType(), V,
3478 AddToWorkList(V.getNode());
3479 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, V);
3488 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
3489 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
3490 AddToWorkList(LHS.getNode()); AddToWorkList(RHS.getNode());
3491 return DAG.getNode(NewOpcode, SDLoc(N), VT, LHS, RHS);
3500 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
3501 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
3502 AddToWorkList(LHS.getNode()); AddToWorkList(RHS.getNode());
3503 return DAG.getNode(NewOpcode, SDLoc(N), VT, LHS, RHS);
3507 if (N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
3511 AddToWorkList(NotX.getNode());
3512 return DAG.getNode(ISD::AND, SDLoc(N), VT, NotX, N1);
3519 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N0.getOperand(1),
3523 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N0.getOperand(0),
3534 if (Tmp.getNode()) return Tmp;
3548 SDNode *LHS = N->getOperand(0).getNode();
3582 SDNode *BinOpLHSVal = LHS->getOperand(0).getNode();
3602 SDValue NewRHS = DAG.getNode(N->getOpcode(), SDLoc(LHS->getOperand(1)),
3607 SDValue NewShift = DAG.getNode(N->getOpcode(),
3612 return DAG.getNode(LHS->getOpcode(), SDLoc(N), VT, NewShift, NewRHS);
3652 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
3653 DAG.getNode(ISD::AND, SDLoc(N), TruncVT,
3654 DAG.getNode(ISD::TRUNCATE,
3671 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0.getOperand(0),
3693 return DAG.getNode(ISD::SHL, SDLoc(N0), VT,
3694 DAG.getNode(N0.getOpcode(), SDLoc(N0), VT,
3714 Shift = DAG.getNode(ISD::SHL, SDLoc(N), VT, N0.getOperand(0),
3718 Shift = DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0),
3721 return DAG.getNode(ISD::AND, SDLoc(N0), VT, Shift,
3732 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0.getOperand(0),
3738 if (NewSHL.getNode())
3778 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
3787 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0.getOperand(0),
3819 SDValue Shift = DAG.getNode(ISD::SRL, SDLoc(N0), VT,
3821 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), TruncVT,
3823 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N),
3839 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0,
3840 DAG.getNode(ISD::AND, SDLoc(N),
3842 DAG.getNode(ISD::TRUNCATE,
3866 SDValue SRA = DAG.getNode(ISD::SRA, SDLoc(N), LargeVT,
3868 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, SRA);
3879 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, N1);
3883 if (NewSRA.getNode())
3922 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0),
3940 return DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT,
3941 DAG.getNode(ISD::SRL, SDLoc(N0), InnerShiftVT,
3951 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0.getOperand(0),
3964 SDValue SmallShift = DAG.getNode(ISD::SRL, SDLoc(N0), SmallVT,
3967 AddToWorkList(SmallShift.getNode());
3969 return DAG.getNode(ISD::AND, SDLoc(N), VT,
3970 DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, SmallShift),
3979 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0), N1);
4007 Op = DAG.getNode(ISD::SRL, SDLoc(N0), VT, Op,
4009 AddToWorkList(Op.getNode());
4012 return DAG.getNode(ISD::XOR, SDLoc(N), VT,
4027 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0,
4028 DAG.getNode(ISD::AND, SDLoc(N),
4030 DAG.getNode(ISD::TRUNCATE,
4044 if (NewSRL.getNode())
4050 if (NarrowLoad.getNode())
4091 return DAG.getNode(ISD::CTLZ, SDLoc(N), VT, N0);
4101 return DAG.getNode(ISD::CTLZ_ZERO_UNDEF, SDLoc(N), VT, N0);
4111 return DAG.getNode(ISD::CTTZ, SDLoc(N), VT, N0);
4121 return DAG.getNode(ISD::CTTZ_ZERO_UNDEF, SDLoc(N), VT, N0);
4131 return DAG.getNode(ISD::CTPOP, SDLoc(N), VT, N0);
4156 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N2);
4166 return DAG.getNode(ISD::XOR, SDLoc(N), VT0,
4168 XORNode = DAG.getNode(ISD::XOR, SDLoc(N0), VT0,
4170 AddToWorkList(XORNode.getNode());
4172 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, XORNode);
4173 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, XORNode);
4178 AddToWorkList(NOTNode.getNode());
4179 return DAG.getNode(ISD::AND, SDLoc(N), VT, NOTNode, N2);
4184 AddToWorkList(NOTNode.getNode());
4185 return DAG.getNode(ISD::OR, SDLoc(N), VT, NOTNode, N1);
4189 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
4193 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N2);
4197 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
4211 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT,
4235 bool RHSIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
4238 (ISD::isBuildVectorAllOnes(RHS.getNode()) && CC == ISD::SETGT)) &&
4240 isAbs = ISD::isBuildVectorAllZeros(N2.getOperand(0).getNode());
4243 isAbs = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
4247 SDValue Shift = DAG.getNode(
4250 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, LHS, Shift);
4251 AddToWorkList(Shift.getNode());
4252 AddToWorkList(Add.getNode());
4253 return DAG.getNode(ISD::XOR, DL, VT, Add, Shift);
4275 if (SCC.getNode()) {
4276 AddToWorkList(SCC.getNode());
4278 if (ConstantSDNode *SCCC = dyn_cast<ConstantSDNode>(SCC.getNode())) {
4287 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), N2.getValueType(),
4316 for (SDNode::use_iterator UI = N0.getNode()->use_begin(),
4317 UE = N0.getNode()->use_end();
4383 Ops.push_back(DAG.getNode(ExtType, DL, ExtLoad->getValueType(0), SOp));
4387 CombineTo(SetCC, DAG.getNode(ISD::SETCC, DL, SetCC->getValueType(0),
4398 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N0);
4403 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT,
4409 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
4410 if (NarrowLoad.getNode()) {
4411 SDNode* oye = N0.getNode()->getOperand(0).getNode();
4412 if (NarrowLoad.getNode() != N0.getNode()) {
4413 CombineTo(N0.getNode(), NarrowLoad);
4437 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, Op);
4442 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
4449 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N0), VT, Op);
4451 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT, Op);
4452 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, Op,
4461 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
4477 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
4479 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
4488 if ((ISD::isSEXTLoad(N0.getNode()) || ISD::isEXTLoad(N0.getNode())) &&
4489 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
4501 CombineTo(N0.getNode(),
4502 DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
4534 SDValue And = DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
4536 SDValue Trunc = DAG.getNode(ISD::TRUNCATE,
4540 CombineTo(N0.getOperand(0).getNode(), Trunc, ExtLoad.getValue(1));
4590 if (SCC.getNode()) return SCC;
4606 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, N0);
4655 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, N0);
4659 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT,
4678 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, Op);
4680 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
4689 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
4690 if (NarrowLoad.getNode()) {
4691 SDNode* oye = N0.getNode()->getOperand(0).getNode();
4692 if (NarrowLoad.getNode() != N0.getNode()) {
4693 CombineTo(N0.getNode(), NarrowLoad);
4707 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
4708 if (NarrowLoad.getNode()) {
4709 SDNode* oye = N0.getNode()->getOperand(0).getNode();
4710 if (NarrowLoad.getNode() != N0.getNode()) {
4711 CombineTo(N0.getNode(), NarrowLoad);
4720 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, Op);
4721 AddToWorkList(Op.getNode());
4723 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
4724 AddToWorkList(Op.getNode());
4740 X = DAG.getNode(ISD::ANY_EXTEND, SDLoc(X), VT, X);
4742 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
4746 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4754 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
4770 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
4772 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
4805 SDValue And = DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
4807 SDValue Trunc = DAG.getNode(ISD::TRUNCATE,
4811 CombineTo(N0.getOperand(0).getNode(), Trunc, ExtLoad.getValue(1));
4821 if ((ISD::isZEXTLoad(N0.getNode()) || ISD::isEXTLoad(N0.getNode())) &&
4822 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
4834 CombineTo(N0.getNode(),
4835 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(),
4856 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4860 DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT,
4876 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4878 DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT,
4887 if (SCC.getNode()) return SCC;
4911 ShAmt = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShAmt);
4913 return DAG.getNode(N0.getOpcode(), DL, VT,
4914 DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0)),
4927 return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, N0);
4934 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, N0.getOperand(0));
4939 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
4940 if (NarrowLoad.getNode()) {
4941 SDNode* oye = N0.getNode()->getOperand(0).getNode();
4942 if (NarrowLoad.getNode() != N0.getNode()) {
4943 CombineTo(N0.getNode(), NarrowLoad);
4957 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, TruncOp);
4958 return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, TruncOp);
4970 X = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, X);
4972 X = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, X);
4976 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4984 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
5000 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5002 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
5013 !ISD::isNON_EXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
5023 CombineTo(N0.getNode(),
5024 DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5067 if (SCC.getNode())
5081 const ConstantSDNode *CV = cast<ConstantSDNode>(V.getNode());
5099 if (!V.getNode()->hasOneUse())
5109 if (SimplifyLHS.getNode())
5110 return DAG.getNode(ISD::SRL, SDLoc(V), V.getValueType(),
5243 SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(LN0),
5246 AddToWorkList(NewPtr.getNode());
5277 Result = DAG.getNode(ISD::SHL, SDLoc(N0), VT,
5295 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0, N1);
5304 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
5314 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00, N1);
5329 if (NarrowLoad.getNode())
5342 return DAG.getNode(ISD::SRA, SDLoc(N), VT,
5348 if (ISD::isEXTLoad(N0.getNode()) &&
5349 ISD::isUNINDEXEDLoad(N0.getNode()) &&
5361 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
5362 AddToWorkList(ExtLoad.getNode());
5366 if (ISD::isZEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
5379 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
5385 SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
5387 if (BSwap.getNode() != 0)
5388 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
5405 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0);
5408 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
5415 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
5419 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
5454 SDValue V = DAG.getNode(ISD::BITCAST, SDLoc(N),
5457 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT,
5490 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, &Opnds[0],
5504 if (Shorter.getNode())
5505 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Shorter);
5511 if (Reduced.getNode())
5541 assert(V.getNode() && "The single defined operand is empty!");
5548 SDValue NV = DAG.getNode(ISD::TRUNCATE, SDLoc(V), VTs[i], V);
5549 AddToWorkList(NV.getNode());
5552 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
5568 return Elt.getNode();
5569 return Elt.getOperand(Elt.getResNo()).getNode();
5615 N0.getOpcode() == ISD::BUILD_VECTOR && N0.getNode()->hasOneUse() &&
5630 return ConstantFoldBITCASTofBUILD_VECTOR(N0.getNode(), DestEltVT);
5633 // If the input is a constant, let getNode fold it.
5635 SDValue Res = DAG.getNode(ISD::BITCAST, SDLoc(N), VT, N0);
5636 if (Res.getNode() != N) {
5638 TLI.isOperationLegal(Res.getNode()->getOpcode(), VT))
5646 DAG.DeleteNode(Res.getNode());
5652 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT,
5657 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
5672 CombineTo(N0.getNode(),
5673 DAG.getNode(ISD::BITCAST, SDLoc(N0),
5685 N0.getNode()->hasOneUse() && VT.isInteger() &&
5687 SDValue NewConv = DAG.getNode(ISD::BITCAST, SDLoc(N0), VT,
5689 AddToWorkList(NewConv.getNode());
5693 return DAG.getNode(ISD::XOR, SDLoc(N), VT,
5696 return DAG.getNode(ISD::AND, SDLoc(N), VT,
5704 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse() &&
5710 SDValue X = DAG.getNode(ISD::BITCAST, SDLoc(N0),
5712 AddToWorkList(X.getNode());
5717 X = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, X);
5718 AddToWorkList(X.getNode());
5722 X = DAG.getNode(ISD::SRL, SDLoc(X),
5725 AddToWorkList(X.getNode());
5726 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
5727 AddToWorkList(X.getNode());
5731 X = DAG.getNode(ISD::AND, SDLoc(X), VT,
5733 AddToWorkList(X.getNode());
5735 SDValue Cst = DAG.getNode(ISD::BITCAST, SDLoc(N0),
5737 Cst = DAG.getNode(ISD::AND, SDLoc(Cst), VT,
5739 AddToWorkList(Cst.getNode());
5741 return DAG.getNode(ISD::OR, SDLoc(N), VT, X, Cst);
5747 SDValue CombineLD = CombineConsecutiveLoads(N0.getNode(), VT);
5748 if (CombineLD.getNode())
5782 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(BV), VT,
5783 DAG.getNode(ISD::BITCAST, SDLoc(BV),
5792 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(BV), SrcEltVT, Op);
5793 Ops.push_back(DAG.getNode(ISD::BITCAST, SDLoc(BV),
5795 AddToWorkList(Ops.back().getNode());
5797 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT,
5809 BV = ConstantFoldBITCASTofBUILD_VECTOR(BV, IntVT).getNode();
5818 SDNode *Tmp = ConstantFoldBITCASTofBUILD_VECTOR(BV, TmpVT).getNode();
5854 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT,
5881 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(BV), VT,
5891 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT,
5905 if (FoldedVOp.getNode()) return FoldedVOp;
5910 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N1);
5913 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N0);
5921 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N0,
5926 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N1,
5931 N0.getOpcode() == ISD::FADD && N0.getNode()->hasOneUse() &&
5933 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0.getOperand(0),
5934 DAG.getNode(ISD::FADD, SDLoc(N), VT,
5970 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
5973 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
5979 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
5982 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
5990 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
5993 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6001 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6004 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6015 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6018 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6024 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6027 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6036 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6039 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6047 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6050 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6060 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6069 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6079 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6092 return DAG.getNode(ISD::FMA, SDLoc(N), VT,
6098 return DAG.getNode(ISD::FMA, SDLoc(N), VT,
6116 if (FoldedVOp.getNode()) return FoldedVOp;
6121 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N0, N1);
6132 return DAG.getNode(ISD::FNEG, dl, VT, N1);
6136 return DAG.getNode(ISD::FADD, dl, VT, N0,
6169 return DAG.getNode(ISD::FMA, dl, VT,
6171 DAG.getNode(ISD::FNEG, dl, VT, N1));
6176 return DAG.getNode(ISD::FMA, dl, VT,
6177 DAG.getNode(ISD::FNEG, dl, VT,
6187 return DAG.getNode(ISD::FMA, dl, VT,
6188 DAG.getNode(ISD::FNEG, dl, VT, N00), N01,
6189 DAG.getNode(ISD::FNEG, dl, VT, N1));
6207 if (FoldedVOp.getNode()) return FoldedVOp;
6212 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0, N1);
6215 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N1, N0);
6222 ISD::isBuildVectorAllZeros(N1.getNode()))
6229 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N0);
6233 return DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0);
6243 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6252 N0.getNode()->hasOneUse() && isa<ConstantFPSDNode>(N0.getOperand(1)))
6253 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0.getOperand(0),
6254 DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6276 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N2);
6278 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N2);
6282 return DAG.getNode(ISD::FMA, SDLoc(N), VT, N1, N0, N2);
6289 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6290 DAG.getNode(ISD::FADD, dl, VT, N1, N2.getOperand(1)));
6298 return DAG.getNode(ISD::FMA, dl, VT,
6300 DAG.getNode(ISD::FMUL, dl, VT, N1, N0.getOperand(1)),
6308 return DAG.getNode(ISD::FADD, dl, VT, N0, N2);
6312 SDValue RHSNeg = DAG.getNode(ISD::FNEG, dl, VT, N0);
6313 AddToWorkList(RHSNeg.getNode());
6314 return DAG.getNode(ISD::FADD, dl, VT, N2, RHSNeg);
6320 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6321 DAG.getNode(ISD::FADD, dl, VT,
6327 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6328 DAG.getNode(ISD::FADD, dl, VT,
6346 if (FoldedVOp.getNode()) return FoldedVOp;
6351 return DAG.getNode(ISD::FDIV, SDLoc(N), VT, N0, N1);
6368 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0,
6380 return DAG.getNode(ISD::FDIV, SDLoc(N), VT,
6398 return DAG.getNode(ISD::FREM, SDLoc(N), VT, N0, N1);
6411 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0, N1);
6419 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
6422 return DAG.getNode(ISD::FNEG, SDLoc(N), VT,
6423 DAG.getNode(ISD::FABS, SDLoc(N0), VT, N0));
6432 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
6437 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
6441 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
6447 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
6464 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
6472 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
6490 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops, 5);
6503 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops, 5);
6521 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
6529 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
6547 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops, 5);
6561 return DAG.getNode(ISD::FP_TO_SINT, SDLoc(N), VT, N0);
6573 return DAG.getNode(ISD::FP_TO_UINT, SDLoc(N), VT, N0);
6586 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0, N1);
6596 N0.getNode
6597 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0.getOperand(0),
6602 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse()) {
6603 SDValue Tmp = DAG.getNode(ISD::FP_ROUND, SDLoc(N0), VT,
6605 AddToWorkList(Tmp.getNode());
6606 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
6622 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, Round);
6640 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, N0);
6645 && N0.getNode()->getConstantOperandVal(1) == 1) {
6649 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT,
6651 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, In);
6655 if (ISD::isNON_EXTLoad(N0.getNode()) && N0.hasOneUse() &&
6666 CombineTo(N0.getNode(),
6667 DAG.getNode(ISD::FP_ROUND, SDLoc(N0),
6682 if (FoldedVOp.getNode()) return FoldedVOp;
6693 N0.getNode()->hasOneUse() &&
6698 Int = DAG.getNode(ISD::XOR, SDLoc(N0), IntVT, Int,
6700 AddToWorkList(Int.getNode());
6701 return DAG.getNode(ISD::BITCAST, SDLoc(N),
6710 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6712 DAG.getNode(ISD::FNEG, SDLoc(N), VT,
6726 return DAG.getNode(ISD::FCEIL, SDLoc(N), VT, N0);
6738 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0);
6750 return DAG.getNode(ISD::FFLOOR, SDLoc(N), VT, N0);
6762 if (FoldedVOp.getNode()) return FoldedVOp;
6767 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
6774 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0.getOperand(0));
6779 N0.getOpcode() == ISD::BITCAST && N0.getNode()->hasOneUse() &&
6785 Int = DAG.getNode(ISD::AND, SDLoc(N0), IntVT, Int,
6787 AddToWorkList(Int.getNode());
6788 return DAG.getNode(ISD::BITCAST, SDLoc(N),
6812 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
6824 Trunc = N1.getNode();
6863 SDValue NewBRCond = DAG.getNode(ISD::BRCOND, SDLoc(N),
6876 removeFromWorkList(N1.getNode());
6877 DAG.DeleteNode(N1.getNode());
6891 SDNode *TheXor = N1.getNode();
6897 if (Tmp.getNode()) {
6898 if (Tmp.getNode() != TheXor) {
6902 Tmp.getNode()->dump(&DAG);
6908 return DAG.getNode(ISD::BRCOND, SDLoc(N),
6923 TheXor = Op0.getNode();
6937 removeFromWorkList(N1.getNode());
6938 DAG.DeleteNode(N1.getNode());
6939 return DAG.getNode(ISD::BRCOND, SDLoc(N),
6963 if (Simp.getNode()) AddToWorkList(Simp.getNode());
6966 if (Simp.getNode() && Simp.getOpcode() == ISD::SETCC)
6967 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
6983 if (LD->isIndexed() || LD->getBasePtr().getNode() != N)
6987 if (ST->isIndexed() || ST->getBasePtr().getNode() != N)
7053 Ptr.getNode()->hasOneUse())
7093 if (Val == BasePtr || BasePtr.getNode()->isPredecessorOf(Val.getNode()))
7102 for (SDNode::use_iterator I = BasePtr.getNode()->use_begin(),
7103 E = BasePtr.getNode()->use_end(); I != E; ++I) {
7105 if (Use == Ptr.getNode())
7117 if (Op1.getNode() == BasePtr.getNode())
7119 assert(Op0.getNode() == BasePtr.getNode() &&
7146 for (SDNode::use_iterator I = Ptr.getNode()->use_begin(),
7147 E = Ptr.getNode()->use_end(); I != E; ++I) {
7156 if (!canFoldInAddressingMode(Ptr.getNode(), Use, DAG, TLI))
7175 Result.getNode()->dump(&DAG);
7194 if (OtherUses[i]->getOperand(OffsetIdx).getNode() == BasePtr.getNode())
7196 assert(OtherUses[i]->getOperand(!OffsetIdx).getNode() ==
7197 BasePtr.getNode() && "Expected BasePtr operand");
7232 SDValue NewUse = DAG.getNode(Opcode,
7242 removeFromWorkList(Ptr.getNode());
7243 DAG.DeleteNode(Ptr.getNode());
7281 if (Ptr.getNode()->hasOneUse())
7284 for (SDNode::use_iterator I = Ptr.getNode()->use_begin(),
7285 E = Ptr.getNode()->use_end(); I != E; ++I) {
7312 for (SDNode::use_iterator II = BasePtr.getNode()->use_begin(),
7313 EE = BasePtr.getNode()->use_end(); II != EE; ++II) {
7315 if (Use == Ptr.getNode())
7351 Result.getNode()->dump(&DAG);
7398 Chain.getNode()->dump(&DAG);
7418 Undef.getNode()->dump(&DAG);
7437 if (ISD::isNON_TRUNCStore(Chain.getNode())) {
7455 return CombineTo(N, NewLoad, SDValue(NewLoad.getNode(), 1), true);
7485 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
7489 AddToWorkList(Token.getNode());
7514 getNode()))
7523 if (LD == Chain.getNode())
7530 if (Chain->getOperand(i).getNode() == LD) {
7606 IVal = DAG.getNode(ISD::SRL, SDLoc(IVal), IVal.getValueType(), IVal,
7621 Ptr = DAG.getNode(ISD::ADD, SDLoc(IVal), Ptr.getValueType(),
7627 IVal = DAG.getNode(ISD::TRUNCATE, SDLoc(IVal), VT, IVal);
7632 false, false, NewAlign).getNode();
7681 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
7682 Chain == SDValue(N0.getNode(), 1)) {
7731 SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(LD),
7739 SDValue NewVal = DAG.getNode(Opc, SDLoc(Value), NewVT, NewLD,
7746 AddToWorkList(NewPtr.getNode());
7747 AddToWorkList(NewLD.getNode());
7748 AddToWorkList(NewVal.getNode());
7767 if (ISD::isNormalStore(ST) && ISD::isNormalLoad(Value.getNode()) &&
7769 Chain == SDValue(Value.getNode(), 1)) {
7804 AddToWorkList(NewLD.getNode());
7805 AddToWorkList(NewST.getNode());
7942 if (!BasePtr.Base.getNode())
8003 SDNode *NextInChain = Index->getChain().getNode();
8012 NextInChain = Ldn->getChain().getNode();
8230 if (LdBasePtr.Base.getNode()) {
8342 SDValue(NewLoad.getNode(), 1));
8448 Ptr = DAG.getNode(ISD::ADD, SDLoc(N), Ptr.getValueType(), Ptr,
8455 return DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other,
8477 if (NewST.getNode())
8502 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
8506 AddToWorkList(Token.getNode());
8528 AddToWorkList(Value.getNode());
8529 if (Shorter.getNode())
8560 && Value.getNode()->hasOneUse() && ST->isUnindexed() &&
8618 Ops.append(InVec.getNode()->op_begin(),
8619 InVec.getNode()->op_end());
8634 DAG.getNode(ISD::ANY_EXTEND, dl, OpVT, InVal) :
8635 DAG.getNode(ISD::TRUNCATE, dl, OpVT, InVal);
8640 return DAG.getNode(ISD::BUILD_VECTOR, dl,
8691 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N), NVT,
8732 if (ISD::isNormalLoad(InVec.getNode())) {
8736 ISD::isNormalLoad(InVec.getOperand(0).getNode())) {
8768 if (ISD::isNormalLoad(InVec.getNode())) {
8805 NewPtr = DAG.getNode(ISD::ADD, SDLoc(N), PtrType, NewPtr,
8833 Load = DAG.getNode(ISD::TRUNCATE, SDLoc(N), NVT, Load);
8835 Load = DAG.getNode(ISD::BITCAST, SDLoc(N), NVT, Load);
8843 AddToWorkList(Load.getNode());
8844 AddUsersToWorkList(Load.getNode()); // Add users too
8955 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VecVT, &Ops[0], Ops.size());
8958 AddToWorkList(BV.getNode());
8960 return DAG.getNode(ISD::BITCAST, dl, VT, BV);
9023 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT,
9025 AddToWorkList(BV.getNode());
9027 return DAG.getNode(Opcode, dl, VT, BV);
9040 if (V.getNode())
9044 if (V.getNode())
9074 if (VecIn1.getNode() == 0) {
9076 } else if (VecIn2.getNode() == 0) {
9086 if (VecIn1.getNode()) {
9115 if (VecIn2.getNode() != 0)
9130 VecIn1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
9135 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
9189 if (SingleSource.getNode()) {
9213 if (SingleSource.getNode())
9265 return DAG.getNode(ISD::BITCAST, dl, NVT, V->getOperand(1));
9266 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT,
9267 DAG.getNode(ISD::BITCAST, dl,
9324 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Ops.data(),
9391 SDNode *V = N0.getNode();
9400 V = ConvInput.getNode();
9415 if (!Base.getNode())
9436 if (V.getNode())
9513 SDValue Zero = DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N),
9515 LHS = DAG.getNode(ISD::BITCAST, dl, RVT, LHS);
9517 return DAG.getNode(ISD::BITCAST, dl, VT, Shuf);
9532 if (Shuffle.getNode()) return Shuffle;
9555 cast<ConstantSDNode>(RHSOp.getNode())->isNullValue()) ||
9557 cast<ConstantFPSDNode>(RHSOp.getNode())->getValueAPF().isZero()))
9569 RHSOp = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, RHSOp);
9571 LHSOp = DAG.getNode(ISD::TRUNCATE, SDLoc(N), RVT, LHSOp);
9575 SDValue FoldOp = DAG.getNode(N->getOpcode(), SDLoc(LHS), VT,
9582 AddToWorkList(FoldOp.getNode());
9586 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N),
9611 SDValue FoldOp = DAG.getNode(N->getOpcode(), SDLoc(N0), EltVT, Op);
9616 AddToWorkList(FoldOp.getNode());
9622 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N),
9636 if (SCC.getNode()) {
9640 SDValue SETCC = DAG.getNode(ISD::SETCC, SDLoc(N0),
9644 AddToWorkList(SETCC.getNode());
9707 SDNode *CondNode = TheSelect->getOperand(0).getNode();
9720 SDNode *CondLHS = TheSelect->getOperand(0).getNode();
9721 SDNode *CondRHS = TheSelect->getOperand(1).getNode();
9729 Addr = DAG.getNode(ISD::SELECT_CC, SDLoc(TheSelect),
9761 CombineTo(LHS.getNode(), Load.getValue(0), Load.getValue(1));
9762 CombineTo(RHS.getNode(), Load.getValue(0), Load.getValue(1));
9778 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
9779 ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
9780 ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N3.getNode());
9785 if (SCC.getNode()) AddToWorkList(SCC.getNode());
9786 ConstantSDNode *SCCC = dyn_cast_or_null<ConstantSDNode>(SCC.getNode());
9803 return DAG.getNode(ISD::FABS, DL, VT, N0);
9809 return DAG.getNode(ISD::FABS, DL, VT, N3);
9851 AddToWorkList(Cond.getNode());
9854 AddToWorkList(CstOffset.getNode());
9855 CPIdx = DAG.getNode(ISD::ADD, DL, TLI.getPointerTy(), CPIdx,
9857 AddToWorkList(CPIdx.getNode());
9880 SDValue Shift = DAG.getNode(ISD::SRL, SDLoc(N0),
9882 AddToWorkList(Shift.getNode());
9885 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
9886 AddToWorkList(Shift.getNode());
9889 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
9892 SDValue Shift = DAG.getNode(ISD::SRA, SDLoc(N0),
9896 AddToWorkList(Shift.getNode());
9899 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
9900 AddToWorkList(Shift.getNode());
9903 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
9925 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N0), VT, AndLHS, ShlAmt);
9932 SDValue Shr = DAG.getNode(ISD::SRA, SDLoc(N0), VT, Shl, ShrAmt);
9934 return DAG.getNode(ISD::AND, DL, VT, Shr, N3);
9962 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2),
9966 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2),
9970 AddToWorkList(SCC.getNode());
9971 AddToWorkList(Temp.getNode());
9977 return DAG.getNode(ISD::SHL, DL, N2.getValueType(), Temp,
9992 Res = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Res);
10000 SDValue Ctlz = DAG.getNode(ISD::CTLZ, SDLoc(N0), XType, N0);
10001 return DAG.getNode(ISD::SRL, DL, XType, Ctlz,
10007 SDValue NegN0 = DAG.getNode(ISD::SUB, SDLoc(N0),
10010 return DAG.getNode(ISD::SRL, DL, XType,
10011 DAG.getNode(ISD::AND, DL, XType, NegN0, NotN0),
10017 SDValue Sign = DAG.getNode(ISD::SRL, SDLoc(N0), XType, N0,
10020 return DAG.getNode(ISD::XOR, DL, XType, Sign, DAG.getConstant(1, XType));
10043 SDValue Shift = DAG.getNode(ISD::SRA, SDLoc(N0), XType,
10047 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N0),
10049 AddToWorkList(Shift.getNode());
10050 AddToWorkList(Add.getNode());
10051 return DAG.getNode(ISD::XOR, DL, XType, Add, Shift);
10285 if (!Visited.insert(Chain.getNode()))
10302 bool IsOpLoad = FindAliasInfo(Chain.getNode(), OpPtr, OpSize,
10326 // likelihood that getNode will find a matching token factor (CSE.)
10361 return DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other,
