Lines Matching refs:getNode
203 // SDValue.getNode() == 0 - No change was made
204 // SDValue.getNode() == N - N was replaced, is dead and has been handled.
536 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
541 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
555 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
566 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
572 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
579 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
583 return DAG.getNode(ISD::FP_ROUND, SDLoc(Op), Op.getValueType(),
605 !TLI.isConstTrueVal(N.getOperand(2).getNode()) ||
606 !TLI.isConstFalseVal(N.getOperand(3).getNode()))
620 if (isSetCCEquivalent(N, N0, N1, N2) && N.getNode()->hasOneUse())
644 return N.getNode();
680 if (!OpNode.getNode())
682 return DAG.getNode(Opc, DL, VT, N0.getOperand(0), OpNode);
687 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N0.getOperand(0), N1);
688 if (!OpNode.getNode())
690 AddToWorkList(OpNode.getNode());
691 return DAG.getNode(Opc, DL, VT, OpNode, N0.getOperand(1));
701 if (!OpNode.getNode())
703 return DAG.getNode(Opc, DL, VT, N1.getOperand(0), OpNode);
708 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT, N1.getOperand(0), N0);
709 if (!OpNode.getNode())
711 AddToWorkList(OpNode.getNode());
712 return DAG.getNode(Opc, DL, VT, OpNode, N1.getOperand(1));
727 To[0].getNode()->dump(&DAG);
730 assert((!To[i].getNode() ||
738 if (To[i].getNode()) {
739 AddToWorkList(To[i].getNode());
740 AddUsersToWorkList(To[i].getNode());
767 AddToWorkList(TLO.New.getNode());
768 AddUsersToWorkList(TLO.New.getNode());
773 if (TLO.Old.getNode()->use_empty()) {
774 removeFromWorkList(TLO.Old.getNode());
778 for (unsigned i = 0, e = TLO.Old.getNode()->getNumOperands(); i != e; ++i)
779 if (TLO.Old.getNode()->getOperand(i).getNode()->hasOneUse())
780 AddToWorkList(TLO.Old.getNode()->getOperand(i).getNode());
782 DAG.DeleteNode(TLO.Old.getNode());
796 AddToWorkList(Op.getNode());
801 TLO.Old.getNode()->dump(&DAG);
803 TLO.New.getNode()->dump(&DAG);
813 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, VT, SDValue(ExtLoad, 0));
818 Trunc.getNode()->dump(&DAG);
825 AddToWorkList(Trunc.getNode());
847 return DAG.getNode(ISD::AssertSext, dl, PVT,
851 return DAG.getNode(ISD::AssertZext, dl, PVT,
857 return DAG.getNode(ExtOpc, dl, PVT, Op);
863 return DAG.getNode(ISD::ANY_EXTEND, dl, PVT, Op);
873 if (!NewOp.getNode())
875 AddToWorkList(NewOp.getNode());
878 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
879 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NewOp.getValueType(), NewOp,
888 if (!NewOp.getNode())
890 AddToWorkList(NewOp.getNode());
893 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
923 if (!NN0.getNode())
933 if (!NN1.getNode())
937 AddToWorkList(NN0.getNode());
938 if (NN1.getNode())
939 AddToWorkList(NN1.getNode());
942 ReplaceLoadWithPromotedLoad(N0.getNode(), NN0.getNode());
944 ReplaceLoadWithPromotedLoad(N1.getNode(), NN1.getNode());
947 Op.getNode()->dump(&DAG));
949 return DAG.getNode(ISD::TRUNCATE, dl, VT,
950 DAG.getNode(Opc, dl, PVT, NN0, NN1));
986 if (!N0.getNode())
989 AddToWorkList(N0.getNode());
991 ReplaceLoadWithPromotedLoad(Op.getOperand(0).getNode(), N0.getNode());
994 Op.getNode()->dump(&DAG));
996 return DAG.getNode(ISD::TRUNCATE, dl, VT,
997 DAG.getNode(Opc, dl, PVT, N0, Op.getOperand(1)));
1025 Op.getNode()->dump(&DAG));
1026 return DAG.getNode(Op.getOpcode(), SDLoc(Op), VT, Op.getOperand(0));
1052 SDNode *N = Op.getNode();
1062 SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, VT, NewLD);
1067 Result.getNode()->dump(&DAG);
1074 AddToWorkList(Result.getNode());
1123 AddToWorkList(N->getOperand(i).getNode());
1131 if (!RV.getNode())
1140 if (RV.getNode() == N)
1144 RV.getNode()->getOpcode() != ISD::DELETED_NODE &&
1150 RV.getNode()->dump(&DAG);
1156 if (N->getNumValues() == RV.getNode()->getNumValues())
1157 DAG.ReplaceAllUsesWith(N, RV.getNode());
1166 AddToWorkList(RV.getNode());
1167 AddUsersToWorkList(RV.getNode());
1173 AddToWorkList(N->getOperand(i).getNode());
1279 if (!RV.getNode()) {
1295 if (!RV.getNode()) {
1325 if (!RV.getNode() && SelectionDAG::isCommutativeBinOp(N->getOpcode()) &&
1369 if (getInputChainForNode(N->getOperand(0).getNode()) == N->getOperand(1))
1371 if (getInputChainForNode(N->getOperand(1).getNode()) == N->getOperand(0))
1401 std::find(TFs.begin(), TFs.end(), Op.getNode()) == TFs.end()) {
1403 TFs.push_back(Op.getNode());
1405 AddToWorkList(Op.getNode());
1413 if (SeenOps.insert(Op.getNode()))
1431 Result = DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other, Ops);
1467 if (N01C && N00.getOpcode() == ISD::ADD && N00.getNode()->hasOneUse() &&
1470 N0 = DAG.getNode(ISD::ADD, SDLoc(N0), VT,
1471 DAG.getNode(ISD::SHL, SDLoc(N00), VT,
1473 DAG.getNode(ISD::SHL, SDLoc(N01), VT,
1475 return DAG.getNode(ISD::ADD, DL, VT, N0, N1);
1491 if (FoldedVOp.getNode()) return FoldedVOp;
1494 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1496 if (ISD::isBuildVectorAllZeros(N0.getNode()))
1510 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N1, N0);
1524 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1530 if (RADD.getNode())
1535 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1, N0.getOperand(1));
1539 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1.getOperand(1));
1549 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1554 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1560 return DAG.getNode(N1.getOpcode(), SDLoc(N), VT,
1571 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1572 DAG.getNode(ISD::ADD, SDLoc(N0), VT, N00, N10),
1573 DAG.getNode(ISD::ADD, SDLoc(N1), VT, N01, N11));
1592 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1);
1598 if (N0.getOpcode() == ISD::SHL && N0.getNode()->hasOneUse()) {
1600 if (Result.getNode()) return Result;
1602 if (N1.getOpcode() == ISD::SHL && N1.getNode()->hasOneUse()) {
1604 if (Result.getNode()) return Result;
1613 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0,
1614 DAG.getNode(ISD::SHL, SDLoc(N), VT,
1622 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1,
1623 DAG.getNode(ISD::SHL, SDLoc(N), VT,
1637 return DAG.getNode(ISD::SUB, DL, VT, N->getOperand(0), AndOp0);
1646 SDValue ZExt = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
1647 return DAG.getNode(ISD::SUB, DL, VT, N1, ZExt);
1662 return CombineTo(N, DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N1),
1663 DAG.getNode(ISD::CARRY_FALSE,
1668 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N1, N0);
1672 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE,
1686 return CombineTo(N, DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1),
1687 DAG.getNode(ISD::CARRY_FALSE,
1703 return DAG.getNode(ISD::ADDE, SDLoc(N), N->getVTList(),
1708 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N0, N1);
1728 ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.getNode());
1729 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
1731 dyn_cast<ConstantSDNode>(N1.getOperand(1).getNode());
1737 if (FoldedVOp.getNode()) return FoldedVOp;
1740 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1753 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0,
1757 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
1771 return DAG.getNode(ISD::SUB, SDLoc(N), VT, NewC,
1779 return DAG.getNode(N0.getOperand(1).getOpcode(), SDLoc(N), VT,
1785 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
1791 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1827 return CombineTo(N, DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1),
1828 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1834 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1839 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1844 return CombineTo(N, DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0),
1845 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1858 return DAG.getNode(ISD::SUBC, SDLoc(N), N->getVTList(), N0, N1);
1878 if (FoldedVOp.getNode()) return FoldedVOp;
1880 N0IsConst = isConstantSplatVector(N0.getNode(), ConstValue0);
1881 N1IsConst = isConstantSplatVector(N1.getNode(), ConstValue1);
1893 return DAG.FoldConstantArithmetic(ISD::MUL, VT, N0.getNode(), N1.getNode());
1897 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N1, N0);
1910 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1914 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
1922 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1924 DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
1932 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1934 SDValue C3 = DAG.getNode(ISD::SHL, SDLoc(N), VT,
1936 AddToWorkList(C3.getNode());
1937 return DAG.getNode(ISD::MUL, SDLoc(N), VT,
1947 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1949 N0.getNode()->hasOneUse()) {
1953 N1.getNode()->hasOneUse()) {
1957 if (Sh.getNode()) {
1958 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
1960 return DAG.getNode(ISD::SHL, SDLoc(N), VT,
1966 if (N1IsConst && N0.getOpcode() == ISD::ADD && N0.getNode()->hasOneUse() &&
1967 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1969 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
1970 DAG.getNode(ISD::MUL, SDLoc(N0), VT,
1972 DAG.getNode(ISD::MUL, SDLoc(N1), VT,
1977 if (RMUL.getNode())
1993 if (FoldedVOp.getNode()) return FoldedVOp;
2004 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
2010 return DAG.getNode(ISD::UDIV, SDLoc(N), N1.getValueType(),
2026 DAG.getNode(ISD::SRA, SDLoc(N), VT, N0,
2029 AddToWorkList(SGN.getNode());
2033 DAG.getNode(ISD::SRL, SDLoc(N), VT, SGN,
2036 SDValue ADD = DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, SRL);
2037 AddToWorkList(SRL.getNode());
2038 AddToWorkList(ADD.getNode()); // Divide by pow2
2039 SDValue SRA = DAG.getNode(ISD::SRA, SDLoc(N), VT, ADD,
2047 AddToWorkList(SRA.getNode());
2048 return DAG.getNode(ISD::SUB, SDLoc(N), VT, DAG.getConstant(0, VT), SRA);
2055 if (Op.getNode()) return Op;
2078 if (FoldedVOp.getNode()) return FoldedVOp;
2086 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0,
2094 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N), ADDVT,
2099 AddToWorkList(Add.getNode());
2100 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, Add);
2107 if (Op.getNode()) return Op;
2134 return DAG.getNode(ISD::UREM, SDLoc(N), VT, N0, N1);
2140 SDValue Div = DAG.getNode(ISD::SDIV, SDLoc(N), VT, N0, N1);
2141 AddToWorkList(Div.getNode());
2142 SDValue OptimizedDiv = combine(Div.getNode());
2143 if (OptimizedDiv.getNode() && OptimizedDiv.getNode() != Div.getNode()) {
2144 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
2146 SDValue Sub = DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, Mul);
2147 AddToWorkList(Mul.getNode());
2174 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0,
2181 DAG.getNode(ISD::ADD, SDLoc(N), VT, N1,
2184 AddToWorkList(Add.getNode());
2185 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, Add);
2193 SDValue Div = DAG.getNode(ISD::UDIV, SDLoc(N), VT, N0, N1);
2194 AddToWorkList(Div.getNode());
2195 SDValue OptimizedDiv = combine(Div.getNode());
2196 if (OptimizedDiv.getNode() && OptimizedDiv.getNode() != Div.getNode()) {
2197 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
2199 SDValue Sub = DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, Mul);
2200 AddToWorkList(Mul.getNode());
2227 return DAG.getNode(ISD::SRA, SDLoc(N), N0.getValueType(), N0,
2241 N0 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N0);
2242 N1 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N1);
2243 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2244 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2246 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2277 N0 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N0);
2278 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N1);
2279 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2280 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2282 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2300 SDValue Res = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0),
2310 SDValue Res = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1),
2321 SDValue Lo = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0),
2323 AddToWorkList(Lo.getNode());
2324 SDValue LoOpt = combine(Lo.getNode());
2325 if (LoOpt.getNode() && LoOpt.getNode() != Lo.getNode() &&
2332 SDValue Hi = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1),
2334 AddToWorkList(Hi.getNode());
2335 SDValue HiOpt = combine(Hi.getNode());
2336 if (HiOpt.getNode() && HiOpt != Hi &&
2347 if (Res.getNode()) return Res;
2359 SDValue Lo = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(0));
2360 SDValue Hi = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(1));
2361 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
2363 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
2365 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
2367 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
2377 if (Res.getNode()) return Res;
2389 SDValue Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(0));
2390 SDValue Hi = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(1));
2391 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
2393 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
2395 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
2397 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
2409 return DAG.getNode(ISD::SADDO, SDLoc(N), N->getVTList(),
2419 return DAG.getNode(ISD::UADDO, SDLoc(N), N->getVTList(),
2427 if (Res.getNode()) return Res;
2434 if (Res.getNode()) return Res;
2447 if (N0.getNode()->getNumOperands() == 0) return SDValue();
2470 SDValue ORNode = DAG.getNode(N->getOpcode(), SDLoc(N0),
2473 AddToWorkList(ORNode.getNode());
2474 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, ORNode);
2484 SDValue ORNode = DAG.getNode(N->getOpcode(), SDLoc(N0),
2487 AddToWorkList(ORNode.getNode());
2488 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
2510 SDValue Op = DAG.getNode(N->getOpcode(), DL, In0Ty, In0, In1);
2511 SDValue BC = DAG.getNode(N0.getOpcode(), DL, VT, Op);
2512 AddToWorkList(Op.getNode());
2556 if (N0.getOperand(1) == N1.getOperand(1) && ShOp.getNode()) {
2557 SDValue NewNode = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
2559 AddToWorkList(NewNode.getNode());
2577 if (N0->getOperand(0) == N1->getOperand(0) && ShOp.getNode()) {
2578 SDValue NewNode = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
2580 AddToWorkList(NewNode.getNode());
2602 if (FoldedVOp.getNode()) return FoldedVOp;
2605 if (ISD::isBuildVectorAllZeros(N0.getNode()))
2607 if (ISD::isBuildVectorAllZeros(N1.getNode()))
2611 if (ISD::isBuildVectorAllOnes(N0.getNode()))
2613 if (ISD::isBuildVectorAllOnes(N1.getNode()))
2625 return DAG.getNode(ISD::AND, SDLoc(N), VT, N1, N0);
2635 if (RAND.getNode())
2648 SDValue Zext = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N),
2657 CombineTo(N0.getNode(), Zext);
2755 CombineTo(N, (N0.getNode() == Load) ? NewLoad : N0);
2769 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(N0),
2771 AddToWorkList(ORNode.getNode());
2776 SDValue ANDNode = DAG.getNode(ISD::AND, SDLoc(N0),
2778 AddToWorkList(ANDNode.getNode());
2783 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(N0),
2785 AddToWorkList(ORNode.getNode());
2796 SDValue ADDNode = DAG.getNode(ISD::ADD, SDLoc(N0), LL.getValueType(),
2798 AddToWorkList(ADDNode.getNode());
2823 if (Tmp.getNode()) return Tmp;
2833 if (ISD::isEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode())) {
2847 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
2852 if (ISD::isSEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
2867 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
2919 NewPtr = DAG.getNode(ISD::ADD, SDLoc(LN0), PtrType,
2924 AddToWorkList(NewPtr.getNode());
2957 DAG.getNode(ISD::ADD, SDLoc(N0), VT,
2959 CombineTo(N0.getNode(), NewAdd);
2970 SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
2972 if (BSwap.getNode())
3000 if (!N0.getNode()->hasOneUse())
3010 if (!N1.getNode()->hasOneUse())
3023 if (!N0.getNode()->hasOneUse() ||
3024 !N1.getNode()->hasOneUse())
3037 if (!N00.getNode()->hasOneUse())
3048 if (!N10.getNode()->hasOneUse())
3078 SDValue Res = DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N00);
3080 Res = DAG.getNode(ISD::SRL, SDLoc(N), VT, Res,
3089 if (!N.getNode()->hasOneUse())
3151 Parts[Num] = N0.getOperand(0).getNode();
3213 SDValue BSwap = DAG.getNode(ISD::BSWAP, SDLoc(N), VT,
3220 return DAG.getNode(ISD::ROTL, SDLoc(N), VT, BSwap, ShAmt);
3222 return DAG.getNode(ISD::ROTR, SDLoc(N), VT, BSwap, ShAmt);
3223 return DAG.getNode(ISD::OR, SDLoc(N), VT,
3224 DAG.getNode(ISD::SHL, SDLoc(N), VT, BSwap, ShAmt),
3225 DAG.getNode(ISD::SRL, SDLoc(N), VT, BSwap, ShAmt));
3239 if (FoldedVOp.getNode()) return FoldedVOp;
3242 if (ISD::isBuildVectorAllZeros(N0.getNode()))
3244 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3248 if (ISD::isBuildVectorAllOnes(N0.getNode()))
3250 if (ISD::isBuildVectorAllOnes(N1.getNode()))
3259 ISD::isBuildVectorAllZeros(N0.getOperand(1).getNode())) {
3319 return DAG.getNode(ISD::OR, SDLoc(N), VT, N1, N0);
3332 if (BSwap.getNode())
3335 if (BSwap.getNode())
3340 if (ROR.getNode())
3344 if (N1C && N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
3349 if (!COR.getNode())
3351 return DAG.getNode(ISD::AND, SDLoc(N), VT,
3352 DAG.getNode(ISD::OR, SDLoc(N0), VT,
3367 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(LR),
3369 AddToWorkList(ORNode.getNode());
3376 SDValue ANDNode = DAG.getNode(ISD::AND, SDLoc(LR),
3378 AddToWorkList(ANDNode.getNode());
3403 if (Tmp.getNode()) return Tmp;
3412 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
3422 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
3424 return DAG.getNode(ISD::AND, SDLoc(N), VT, X,
3581 return DAG.getNode(HasPos ? PosOpcode : NegOpcode, DL, VT, Shifted,
3582 HasPos ? Pos : Neg).getNode();
3640 SDValue Rot = DAG.getNode(HasROTL ? ISD::ROTL : ISD::ROTR, DL, VT,
3644 if (LHSMask.getNode() || RHSMask.getNode()) {
3647 if (LHSMask.getNode()) {
3651 if (RHSMask.getNode()) {
3656 Rot = DAG.getNode(ISD::AND, DL, VT, Rot, DAG.getConstant(Mask, VT));
3659 return Rot.getNode();
3664 if (LHSMask.getNode() || RHSMask.getNode())
3706 if (FoldedVOp.getNode()) return FoldedVOp;
3709 if (ISD::isBuildVectorAllZeros(N0.getNode()))
3711 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3728 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
3734 if (RXOR.getNode())
3759 N0.getNode()->hasOneUse() &&
3762 V = DAG.getNode(ISD::XOR, SDLoc(N0), V.getValueType(), V,
3764 AddToWorkList(V.getNode());
3765 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, V);
3774 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
3775 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
3776 AddToWorkList(LHS.getNode()); AddToWorkList(RHS.getNode());
3777 return DAG.getNode(NewOpcode, SDLoc(N), VT, LHS, RHS);
3786 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
3787 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
3788 AddToWorkList(LHS.getNode()); AddToWorkList(RHS.getNode());
3789 return DAG.getNode(NewOpcode, SDLoc(N), VT, LHS, RHS);
3793 if (N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
3797 AddToWorkList(NotX.getNode());
3798 return DAG.getNode(ISD::AND, SDLoc(N), VT, NotX, N1);
3805 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N0.getOperand(1),
3809 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N0.getOperand(0),
3820 if (Tmp.getNode()) return Tmp;
3838 SDNode *LHS = N->getOperand(0).getNode();
3872 SDNode *BinOpLHSVal = LHS->getOperand(0).getNode();
3895 SDValue NewRHS = DAG.getNode(N->getOpcode(), SDLoc(LHS->getOperand(1)),
3901 SDValue NewShift = DAG.getNode(N->getOpcode(),
3906 return DAG.getNode(LHS->getOpcode(), SDLoc(N), VT, NewShift, NewRHS);
3923 return DAG.getNode(ISD::AND, SDLoc(N), TruncVT,
3924 DAG.getNode(ISD::TRUNCATE, SDLoc(N), TruncVT, N00),
3936 SDValue NewOp1 = distributeTruncateThroughAnd(N->getOperand(1).getNode());
3937 if (NewOp1.getNode())
3938 return DAG.getNode(N->getOpcode(), SDLoc(N), N->getValueType(0),
3955 if (FoldedVOp.getNode()) return FoldedVOp;
3970 if (C.getNode())
3971 return DAG.getNode(ISD::AND, SDLoc(N), VT, N00, C);
4001 SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode());
4002 if (NewOp1.getNode())
4003 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0, NewOp1);
4016 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0.getOperand(0),
4039 return DAG.getNode(ISD::SHL, SDLoc(N0), VT,
4040 DAG.getNode(N0.getOpcode(), SDLoc(N0), VT,
4060 SDValue NewSHL = DAG.getNode(ISD::SHL, SDLoc(N), NewOp0.getValueType(),
4062 AddToWorkList(NewSHL.getNode());
4063 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N0), VT, NewSHL);
4082 Shift = DAG.getNode(ISD::SHL, SDLoc(N), VT, N0.getOperand(0),
4086 Shift = DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0),
4089 return DAG.getNode(ISD::AND, SDLoc(N0), VT, Shift,
4100 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0.getOperand(0),
4106 if (NewSHL.getNode())
4124 if (FoldedVOp.getNode()) return FoldedVOp;
4154 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
4164 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0.getOperand(0),
4199 SDValue Shift = DAG.getNode(ISD::SRL, SDLoc(N0), VT,
4201 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), TruncVT,
4203 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N),
4212 SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode());
4213 if (NewOp1.getNode())
4214 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0, NewOp1);
4234 SDValue SRA = DAG.getNode(ISD::SRA, SDLoc(N), LargeVT,
4236 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, SRA);
4248 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, N1);
4252 if (NewSRA.getNode())
4270 if (FoldedVOp.getNode()) return FoldedVOp;
4299 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0),
4318 return DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT,
4319 DAG.getNode(ISD::SRL, SDLoc(N0), InnerShiftVT,
4330 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0.getOperand(0),
4345 SDValue SmallShift = DAG.getNode(ISD::SRL, SDLoc(N0), SmallVT,
4348 AddToWorkList(SmallShift.getNode());
4350 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4351 DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, SmallShift),
4360 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0), N1);
4388 Op = DAG.getNode(ISD::SRL, SDLoc(N0), VT, Op,
4390 AddToWorkList(Op.getNode());
4393 return DAG.getNode(ISD::XOR, SDLoc(N), VT,
4401 SDValue NewOp1 = distributeTruncateThroughAnd(N1.getNode());
4402 if (NewOp1.getNode())
4403 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, NewOp1);
4413 if (NewSRL.getNode())
4419 if (NarrowLoad.getNode())
4460 return DAG.getNode(ISD::CTLZ, SDLoc(N), VT, N0);
4470 return DAG.getNode(ISD::CTLZ_ZERO_UNDEF, SDLoc(N), VT, N0);
4480 return DAG.getNode(ISD::CTTZ, SDLoc(N), VT, N0);
4490 return DAG.getNode(ISD::CTTZ_ZERO_UNDEF, SDLoc(N), VT, N0);
4500 return DAG.getNode(ISD::CTPOP, SDLoc(N), VT, N0);
4525 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N2);
4544 return DAG.getNode(ISD::XOR, SDLoc(N), VT0,
4546 XORNode = DAG.getNode(ISD::XOR, SDLoc(N0), VT0,
4548 AddToWorkList(XORNode.getNode());
4550 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, XORNode);
4551 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, XORNode);
4556 AddToWorkList(NOTNode.getNode());
4557 return DAG.getNode(ISD::AND, SDLoc(N), VT, NOTNode, N2);
4562 AddToWorkList(NOTNode.getNode());
4563 return DAG.getNode(ISD::OR, SDLoc(N), VT, NOTNode, N1);
4567 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
4571 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N2);
4575 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
4586 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT,
4606 Lo = DAG.getNode(N->getOpcode(), DL, LoVT, LL, RL, N->getOperand(2));
4607 Hi = DAG.getNode(N->getOpcode(), DL, HiVT, LH, RH, N->getOperand(2));
4637 else if (Cond->getOperand(i).getNode() != BottomHalf)
4649 else if (Cond->getOperand(i).getNode() != TopHalf)
4656 return DAG.getNode(
4677 bool RHSIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
4680 (ISD::isBuildVectorAllOnes(RHS.getNode()) && CC == ISD::SETGT)) &&
4682 isAbs = ISD::isBuildVectorAllZeros(N2.getOperand(0).getNode());
4685 isAbs = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
4689 SDValue Shift = DAG.getNode(
4692 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, LHS, Shift);
4693 AddToWorkList(Shift.getNode());
4694 AddToWorkList(Add.getNode());
4695 return DAG.getNode(ISD::XOR, DL, VT, Add, Shift);
4712 std::tie(CCLo, CCHi) = SplitVSETCC(N0.getNode(), DAG);
4716 Lo = DAG.getNode(N->getOpcode(), DL, LL.getValueType(), CCLo, LL, RL);
4717 Hi = DAG.getNode(N->getOpcode(), DL, LH.getValueType(), CCHi, LH, RH);
4721 AddToWorkList(Lo.getNode());
4722 AddToWorkList(Hi.getNode());
4724 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
4728 if (ISD::isBuildVectorAllOnes(N0.getNode()))
4731 if (ISD::isBuildVectorAllZeros(N0.getNode()))
4739 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())) {
4741 if (CV.getNode())
4763 if (SCC.getNode()) {
4764 AddToWorkList(SCC.getNode());
4766 if (ConstantSDNode *SCCC = dyn_cast<ConstantSDNode>(SCC.getNode())) {
4775 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), N2.getValueType(),
4814 return DAG.getNode(Opcode, SDLoc(N), VT, N0).getNode();
4822 ISD::isBuildVectorOfConstantSDNodes(N0.getNode())))
4850 return DAG.getNode(ISD::BUILD_VECTOR, DL, VT, Elts).getNode();
4863 for (SDNode::use_iterator UI = N0.getNode()->use_begin(),
4864 UE = N0.getNode()->use_end();
4930 Ops.push_back(DAG.getNode(ExtType, DL, ExtLoad->getValueType(0), SOp));
4934 CombineTo(SetCC, DAG.getNode(ISD::SETCC, DL, SetCC->getValueType(0), Ops));
4949 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT,
4955 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
4956 if (NarrowLoad.getNode()) {
4957 SDNode* oye = N0.getNode()->getOperand(0).getNode();
4958 if (NarrowLoad.getNode() != N0.getNode()) {
4959 CombineTo(N0.getNode(), NarrowLoad);
4983 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, Op);
4988 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
4995 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N0), VT, Op);
4997 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT, Op);
4998 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, Op,
5007 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
5008 ISD::isUNINDEXEDLoad(N0.getNode()) &&
5022 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5024 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
5033 if ((ISD::isSEXTLoad(N0.getNode()) || ISD::isEXTLoad(N0.getNode())) &&
5034 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
5044 CombineTo(N0.getNode(),
5045 DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5074 SDValue And = DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
5076 SDValue Trunc = DAG.getNode(ISD::TRUNCATE,
5080 CombineTo(N0.getOperand(0).getNode(), Trunc, ExtLoad.getValue(1));
5130 if (SCC.getNode()) return SCC;
5152 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, N0);
5206 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT,
5225 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, Op);
5227 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
5236 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
5237 if (NarrowLoad.getNode()) {
5238 SDNode* oye = N0.getNode()->getOperand(0).getNode();
5239 if (NarrowLoad.getNode() != N0.getNode()) {
5240 CombineTo(N0.getNode(), NarrowLoad);
5254 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
5255 if (NarrowLoad.getNode()) {
5256 SDNode* oye = N0.getNode()->getOperand(0).getNode();
5257 if (NarrowLoad.getNode() != N0.getNode()) {
5258 CombineTo(N0.getNode(), NarrowLoad);
5267 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, Op);
5268 AddToWorkList(Op.getNode());
5270 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
5271 AddToWorkList(Op.getNode());
5287 X = DAG.getNode(ISD::ANY_EXTEND, SDLoc(X), VT, X);
5289 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
5293 return DAG.getNode(ISD::AND, SDLoc(N), VT,
5301 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
5302 ISD::isUNINDEXEDLoad(N0.getNode()) &&
5316 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5318 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
5348 SDValue And = DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
5350 SDValue Trunc = DAG.getNode(ISD::TRUNCATE,
5354 CombineTo(N0.getOperand(0).getNode(), Trunc, ExtLoad.getValue(1));
5364 if ((ISD::isZEXTLoad(N0.getNode()) || ISD::isEXTLoad(N0.getNode())) &&
5365 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
5375 CombineTo(N0.getNode(),
5376 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(),
5401 return DAG.getNode(ISD::AND, SDLoc(N), VT,
5405 DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT,
5421 return DAG.getNode(ISD::AND, SDLoc(N), VT,
5423 DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, OneOps));
5431 if (SCC.getNode()) return SCC;
5455 ShAmt = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShAmt);
5457 return DAG.getNode(N0.getOpcode(), DL, VT,
5458 DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0)),
5479 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, N0.getOperand(0));
5484 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
5485 if (NarrowLoad.getNode()) {
5486 SDNode* oye = N0.getNode()->getOperand(0).getNode();
5487 if (NarrowLoad.getNode() != N0.getNode()) {
5488 CombineTo(N0.getNode(), NarrowLoad);
5502 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, TruncOp);
5503 return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, TruncOp);
5515 X = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, X);
5517 X = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, X);
5521 return DAG.getNode(ISD::AND, SDLoc(N), VT,
5529 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
5530 ISD::isUNINDEXEDLoad(N0.getNode()) &&
5544 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5546 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
5557 !ISD::isNON_EXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
5567 CombineTo(N0.getNode(),
5568 DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5610 if (SCC.getNode())
5624 const ConstantSDNode *CV = cast<ConstantSDNode>(V.getNode());
5642 if (!V.getNode()->hasOneUse())
5652 if (SimplifyLHS.getNode())
5653 return DAG.getNode(ISD::SRL, SDLoc(V), V.getValueType(),
5786 SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(LN0),
5789 AddToWorkList(NewPtr.getNode());
5820 Result = DAG.getNode(ISD::SHL, SDLoc(N0), VT,
5838 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0, N1);
5847 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
5857 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00, N1);
5872 if (NarrowLoad.getNode())
5885 return DAG.getNode(ISD::SRA, SDLoc(N), VT,
5891 if (ISD::isEXTLoad(N0.getNode()) &&
5892 ISD::isUNINDEXEDLoad(N0.getNode()) &&
5902 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
5903 AddToWorkList(ExtLoad.getNode());
5907 if (ISD::isZEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
5918 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
5924 SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
5926 if (BSwap.getNode())
5927 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
5933 if (ISD::isBuildVectorOfConstantSDNodes(N0.getNode())) {
5951 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, Elts);
5967 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0);
5970 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
5977 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
5981 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
6016 SDValue V = DAG.getNode(ISD::BITCAST, SDLoc(N),
6019 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT,
6052 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, Opnds);
6065 if (Shorter.getNode())
6066 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Shorter);
6072 if (Reduced.getNode())
6076 if (N0.hasOneUse() && ISD::isUNINDEXEDLoad(N0.getNode())) {
6116 assert(V.getNode() && "The single defined operand is empty!");
6123 SDValue NV = DAG.getNode(ISD::TRUNCATE, SDLoc(V), VTs[i], V);
6124 AddToWorkList(NV.getNode());
6127 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Opnds);
6142 return Elt.getNode();
6143 return Elt.getOperand(Elt.getResNo()).getNode();
6188 N0.getOpcode() == ISD::BUILD_VECTOR && N0.getNode()->hasOneUse() &&
6196 return ConstantFoldBITCASTofBUILD_VECTOR(N0.getNode(), DestEltVT);
6199 // If the input is a constant, let getNode fold it.
6201 SDValue Res = DAG.getNode(ISD::BITCAST, SDLoc(N), VT, N0);
6202 if (Res.getNode() != N) {
6204 TLI.isOperationLegal(Res.getNode()->getOpcode(), VT))
6212 DAG.DeleteNode(Res.getNode());
6218 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT,
6223 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
6243 CombineTo(N0.getNode(),
6244 DAG.getNode(ISD::BITCAST, SDLoc(N0),
6256 N0.getNode()->hasOneUse() && VT.isInteger() &&
6258 SDValue NewConv = DAG.getNode(ISD::BITCAST, SDLoc(N0), VT,
6260 AddToWorkList(NewConv.getNode());
6264 return DAG.getNode(ISD::XOR, SDLoc(N), VT,
6267 return DAG.getNode(ISD::AND, SDLoc(N), VT,
6275 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse() &&
6281 SDValue X = DAG.getNode(ISD::BITCAST, SDLoc(N0),
6283 AddToWorkList(X.getNode());
6288 X = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, X);
6289 AddToWorkList(X.getNode());
6293 X = DAG.getNode(ISD::SRL, SDLoc(X),
6296 AddToWorkList(X.getNode());
6297 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
6298 AddToWorkList(X.getNode());
6302 X = DAG.getNode(ISD::AND, SDLoc(X), VT,
6304 AddToWorkList(X.getNode());
6306 SDValue Cst = DAG.getNode(ISD::BITCAST, SDLoc(N0),
6308 Cst = DAG.getNode(ISD::AND, SDLoc(Cst), VT,
6310 AddToWorkList(Cst.getNode());
6312 return DAG.getNode(ISD::OR, SDLoc(N), VT, X, Cst);
6318 SDValue CombineLD = CombineConsecutiveLoads(N0.getNode(), VT);
6319 if (CombineLD.getNode())
6353 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(BV), VT,
6354 DAG.getNode(ISD::BITCAST, SDLoc(BV),
6363 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(BV), SrcEltVT, Op);
6364 Ops.push_back(DAG.getNode(ISD::BITCAST, SDLoc(BV),
6366 AddToWorkList(Ops.back().getNode());
6368 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT, Ops);
6379 BV = ConstantFoldBITCASTofBUILD_VECTOR(BV, IntVT).getNode();
6388 SDNode *Tmp = ConstantFoldBITCASTofBUILD_VECTOR(BV, TmpVT).getNode();
6424 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT, Ops);
6450 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(BV), VT,
6460 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT, Ops);
6473 if (FoldedVOp.getNode()) return FoldedVOp;
6478 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N1);
6481 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N0);
6489 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N0,
6494 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N1,
6499 N0.getOpcode() == ISD::FADD && N0.getNode()->hasOneUse() &&
6501 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0.getOperand(0),
6502 DAG.getNode(ISD::FADD, SDLoc(N), VT,
6538 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6541 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6547 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6550 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6558 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6561 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6569 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6572 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6583 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6586 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6592 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6595 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6604 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6607 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6615 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6618 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6628 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6637 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6647 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6660 return DAG.getNode(ISD::FMA, SDLoc(N), VT,
6666 return DAG.getNode(ISD::FMA, SDLoc(N), VT,
6684 if (FoldedVOp.getNode()) return FoldedVOp;
6689 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N0, N1);
6700 return DAG.getNode(ISD::FNEG, dl, VT, N1);
6704 return DAG.getNode(ISD::FADD, dl, VT, N0,
6737 return DAG.getNode(ISD::FMA, dl, VT,
6739 DAG.getNode(ISD::FNEG, dl, VT, N1));
6744 return DAG.getNode(ISD::FMA, dl, VT,
6745 DAG.getNode(ISD::FNEG, dl, VT,
6755 return DAG.getNode(ISD::FMA, dl, VT,
6756 DAG.getNode(ISD::FNEG, dl, VT, N00), N01,
6757 DAG.getNode(ISD::FNEG, dl, VT, N1));
6775 if (FoldedVOp.getNode()) return FoldedVOp;
6780 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0, N1);
6783 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N1, N0);
6790 ISD::isBuildVectorAllZeros(N1.getNode()))
6797 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N0);
6801 return DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0);
6811 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6820 N0.getNode()->hasOneUse() && isa<ConstantFPSDNode>(N0.getOperand(1)))
6821 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0.getOperand(0),
6822 DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6844 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N2);
6846 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N2);
6850 return DAG.getNode(ISD::FMA, SDLoc(N), VT, N1, N0, N2);
6857 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6858 DAG.getNode(ISD::FADD, dl, VT, N1, N2.getOperand(1)));
6866 return DAG.getNode(ISD::FMA, dl, VT,
6868 DAG.getNode(ISD::FMUL, dl, VT, N1, N0.getOperand(1)),
6876 return DAG.getNode(ISD::FADD, dl, VT, N0, N2);
6880 SDValue RHSNeg = DAG.getNode(ISD::FNEG, dl, VT, N0);
6881 AddToWorkList(RHSNeg.getNode());
6882 return DAG.getNode(ISD::FADD, dl, VT, N2, RHSNeg);
6888 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6889 DAG.getNode(ISD::FADD, dl, VT,
6895 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6896 DAG.getNode(ISD::FADD, dl, VT,
6914 if (FoldedVOp.getNode()) return FoldedVOp;
6919 return DAG.getNode(ISD::FDIV, SDLoc(N), VT, N0, N1);
6936 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0,
6948 return DAG.getNode(ISD::FDIV, SDLoc(N), VT,
6966 return DAG.getNode(ISD::FREM, SDLoc(N), VT, N0, N1);
6979 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0, N1);
6987 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
6990 return DAG.getNode(ISD::FNEG, SDLoc(N), VT,
6991 DAG.getNode(ISD::FABS, SDLoc(N0), VT, N0));
7000 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
7005 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
7009 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
7015 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
7032 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
7040 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
7054 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops);
7067 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops);
7085 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
7093 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
7107 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops);
7121 return DAG.getNode(ISD::FP_TO_SINT, SDLoc(N), VT, N0);
7133 return DAG.getNode(ISD::FP_TO_UINT, SDLoc(N), VT, N0);
7146 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0, N1);
7156 N0.getNode()->getConstantOperandVal(1) == 1;
7157 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0.getOperand(0),
7162 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse()) {
7163 SDValue Tmp = DAG.getNode(ISD::FP_ROUND, SDLoc(N0), VT,
7165 AddToWorkList(Tmp.getNode());
7166 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
7182 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, Round);
7200 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, N0);
7205 && N0.getNode()->getConstantOperandVal(1) == 1) {
7209 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT,
7211 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, In);
7215 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
7224 CombineTo(N0.getNode(),
7225 DAG.getNode(ISD::FP_ROUND, SDLoc(N0),
7240 if (FoldedVOp.getNode()) return FoldedVOp;
7251 N0.getNode()->hasOneUse() &&
7256 Int = DAG.getNode(ISD::XOR, SDLoc(N0), IntVT, Int,
7258 AddToWorkList(Int.getNode());
7259 return DAG.getNode(ISD::BITCAST, SDLoc(N),
7273 return DAG.getNode(
7275 DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0.getOperand(1)));
7289 return DAG.getNode(ISD::FCEIL, SDLoc(N), VT, N0);
7301 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0);
7313 return DAG.getNode(ISD::FFLOOR, SDLoc(N), VT, N0);
7325 if (FoldedVOp.getNode()) return FoldedVOp;
7330 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
7337 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0.getOperand(0));
7342 N0.getOpcode() == ISD::BITCAST && N0.getNode()->hasOneUse() &&
7348 Int = DAG.getNode(ISD::AND, SDLoc(N0), IntVT, Int,
7350 AddToWorkList(Int.getNode());
7351 return DAG.getNode(ISD::BITCAST, SDLoc(N),
7375 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
7387 Trunc = N1.getNode();
7426 SDValue NewBRCond = DAG.getNode(ISD::BRCOND, SDLoc(N),
7439 removeFromWorkList(N1.getNode());
7440 DAG.DeleteNode(N1.getNode());
7454 SDNode *TheXor = N1.getNode();
7460 if (Tmp.getNode()) {
7461 if (Tmp.getNode() != TheXor) {
7465 Tmp.getNode()->dump(&DAG);
7471 return DAG.getNode(ISD::BRCOND, SDLoc(N),
7486 TheXor = Op0.getNode();
7500 removeFromWorkList(N1.getNode());
7501 DAG.DeleteNode(N1.getNode());
7502 return DAG.getNode(ISD::BRCOND, SDLoc(N),
7526 if (Simp.getNode()) AddToWorkList(Simp.getNode());
7529 if (Simp.getNode() && Simp.getOpcode() == ISD::SETCC)
7530 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
7546 if (LD->isIndexed() || LD->getBasePtr().getNode() != N)
7550 if (ST->isIndexed() || ST->getBasePtr().getNode() != N)
7616 Ptr.getNode()->hasOneUse())
7656 if (Val == BasePtr || BasePtr.getNode()->isPredecessorOf(Val.getNode()))
7665 for (SDNode *Use : BasePtr.getNode()->uses()) {
7666 if (Use == Ptr.getNode())
7678 if (Op1.getNode() == BasePtr.getNode())
7680 assert(Op0.getNode() == BasePtr.getNode() &&
7707 for (SDNode *Use : Ptr.getNode()->uses()) {
7715 if (!canFoldInAddressingMode(Ptr.getNode(), Use, DAG, TLI))
7734 Result.getNode()->dump(&DAG);
7753 if (OtherUses[i]->getOperand(OffsetIdx).getNode() == BasePtr.getNode())
7755 assert(OtherUses[i]->getOperand(!OffsetIdx).getNode() ==
7756 BasePtr.getNode() && "Expected BasePtr operand");
7791 SDValue NewUse = DAG.getNode(Opcode,
7801 removeFromWorkList(Ptr.getNode());
7802 DAG.DeleteNode(Ptr.getNode());
7840 if (Ptr.getNode()->hasOneUse())
7843 for (SDNode *Op : Ptr.getNode()->uses()) {
7869 for (SDNode *Use : BasePtr.getNode()->uses()) {
7870 if (Use == Ptr.getNode())
7904 Result.getNode()->dump(&DAG);
7951 Chain.getNode()->dump(&DAG);
7971 Undef.getNode()->dump(&DAG);
7990 if (ISD::isNON_TRUNCStore(Chain.getNode())) {
8009 return CombineTo(N, NewLoad, SDValue(NewLoad.getNode(), 1), true);
8041 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
8045 AddToWorkList(Token.getNode());
8303 BaseAddr = DAG->getNode(ISD::ADD, SDLoc(Origin), ArithType, BaseAddr,
8320 DAG->getNode(ISD::ZERO_EXTEND, SDLoc(LastInst), FinalType, LastInst);
8596 if (SliceInst.getNode()->getOpcode() != ISD::LOAD)
8603 SDValue Chain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other,
8619 !ISD::isNormalLoad(V->getOperand(0).getNode()))
8628 if (LD == Chain.getNode())
8635 if (Chain->getOperand(i).getNode() == LD) {
8711 IVal = DAG.getNode(ISD::SRL, SDLoc(IVal), IVal.getValueType(), IVal,
8726 Ptr = DAG.getNode(ISD::ADD, SDLoc(IVal), Ptr.getValueType(),
8732 IVal = DAG.getNode(ISD::TRUNCATE, SDLoc(IVal), VT, IVal);
8737 false, false, NewAlign).getNode();
8786 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
8787 Chain == SDValue(N0.getNode(), 1)) {
8836 SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(LD),
8845 SDValue NewVal = DAG.getNode(Opc, SDLoc(Value), NewVT, NewLD,
8852 AddToWorkList(NewPtr.getNode());
8853 AddToWorkList(NewLD.getNode());
8854 AddToWorkList(NewVal.getNode());
8873 if (ISD::isNormalStore(ST) && ISD::isNormalLoad(Value.getNode()) &&
8875 Chain == SDValue(Value.getNode(), 1)) {
8910 AddToWorkList(NewLD.getNode());
8911 AddToWorkList(NewST.getNode());
9051 if (!BasePtr.Base.getNode())
9112 SDNode *NextInChain = Index->getChain().getNode();
9126 NextInChain = Ldn->getChain().getNode();
9348 if (LdBasePtr.Base.getNode()) {
9460 SDValue(NewLoad.getNode(), 1));
9566 Ptr = DAG.getNode(ISD::ADD, SDLoc(N), Ptr.getValueType(), Ptr,
9573 return DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other,
9596 if (NewST.getNode())
9624 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
9628 AddToWorkList(Token.getNode());
9650 AddToWorkList(Value.getNode());
9651 if (Shorter.getNode())
9680 && Value.getNode()->hasOneUse() && ST->isUnindexed() &&
9742 SDValue NewOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(N), VT,
9744 AddToWorkList(NewOp.getNode());
9745 return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(InVec.getNode()),
9757 Ops.append(InVec.getNode()->op_begin(),
9758 InVec.getNode()->op_end());
9773 DAG.getNode(ISD::ANY_EXTEND, dl, OpVT, InVal) :
9774 DAG.getNode(ISD::TRUNCATE, dl, OpVT, InVal);
9779 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
9807 Offset = DAG.getNode(
9811 Offset = DAG.getNode(
9816 NewPtr = DAG.getNode(ISD::ADD, SDLoc(EVE), PtrType, NewPtr, Offset);
9844 Load = DAG.getNode(ISD::TRUNCATE, SDLoc(EVE), ResultVT, Load);
9846 Load = DAG.getNode(ISD::BITCAST, SDLoc(EVE), ResultVT, Load);
9854 AddToWorkList(Load.getNode());
9855 AddUsersToWorkList(Load.getNode()); // Add users too
9925 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N), NVT,
9955 ISD::isNormalLoad(InVec.getNode())) {
9975 if (ISD::isNormalLoad(InVec.getNode())) {
9979 ISD::isNormalLoad(InVec.getOperand(0).getNode())) {
10011 if (ISD::isNormalLoad(InVec.getNode())) {
10135 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VecVT, Ops);
10138 AddToWorkList(BV.getNode());
10140 return DAG.getNode(ISD::BITCAST, dl, VT, BV);
10203 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, Opnds);
10204 AddToWorkList(BV.getNode());
10206 return DAG.getNode(Opcode, dl, VT, BV);
10219 if (V.getNode())
10223 if (V.getNode())
10253 if (!VecIn1.getNode()) {
10255 } else if (!VecIn2.getNode()) {
10265 if (VecIn1.getNode()) {
10294 if (VecIn2.getNode())
10309 VecIn1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
10314 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
10372 SDValue Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NVT, Scalar);
10373 return DAG.getNode(ISD::BITCAST, dl, VT, Res);
10400 Opnds.push_back(DAG.getNode(ISD::TRUNCATE, SDLoc(N), MinTy,
10403 Opnds.push_back(DAG.getNode(ISD::TRUNCATE, SDLoc(N), MinTy,
10407 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, Opnds);
10428 if (SingleSource.getNode()) {
10452 if (SingleSource.getNode())
10505 return DAG.getNode(ISD::BITCAST, dl, NVT, V->getOperand(1));
10506 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT,
10507 DAG.getNode(ISD::BITCAST, dl,
10564 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Ops);
10630 SDNode *V = N0.getNode();
10639 V = ConvInput.getNode();
10654 if (!Base.getNode())
10675 if (V.getNode())
10784 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
10790 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
10834 SDValue Zero = DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), RVT, ZeroOps);
10835 LHS = DAG.getNode(ISD::BITCAST, dl, RVT, LHS);
10837 return DAG.getNode(ISD::BITCAST, dl, VT, Shuf);
10852 if (Shuffle.getNode()) return Shuffle;
10872 cast<ConstantSDNode>(RHSOp.getNode())->isNullValue()) ||
10874 cast<ConstantFPSDNode>(RHSOp.getNode())->getValueAPF().isZero()))
10886 RHSOp = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, RHSOp);
10888 LHSOp = DAG.getNode(ISD::TRUNCATE, SDLoc(N), RVT, LHSOp);
10892 SDValue FoldOp = DAG.getNode(N->getOpcode(), SDLoc(LHS), VT,
10899 AddToWorkList(FoldOp.getNode());
10903 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), LHS.getValueType(), Ops);
10919 SDValue NewBinOp = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
10948 SDValue FoldOp = DAG.getNode(N->getOpcode(), SDLoc(N0), EltVT, Op);
10953 AddToWorkList(FoldOp.getNode());
10959 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), N0.getValueType(), Ops);
10972 if (SCC.getNode()) {
10976 SDValue SETCC = DAG.getNode(ISD::SETCC, SDLoc(N0),
10980 AddToWorkList(SETCC.getNode());
11043 SDNode *CondNode = TheSelect->getOperand(0).getNode();
11056 SDNode *CondLHS = TheSelect->getOperand(0).getNode();
11057 SDNode *CondRHS = TheSelect->getOperand(1).getNode();
11065 Addr = DAG.getNode(ISD::SELECT_CC, SDLoc(TheSelect),
11097 CombineTo(LHS.getNode(), Load.getValue(0), Load.getValue(1));
11098 CombineTo(RHS.getNode(), Load.getValue(0), Load.getValue(1));
11114 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
11115 ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
11116 ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N3.getNode());
11121 if (SCC.getNode()) AddToWorkList(SCC.getNode());
11122 ConstantSDNode *SCCC = dyn_cast_or_null<ConstantSDNode>(SCC.getNode());
11139 return DAG.getNode(ISD::FABS, DL, VT, N0);
11145 return DAG.getNode(ISD::FABS, DL, VT, N3);
11189 AddToWorkList(Cond.getNode());
11192 AddToWorkList(CstOffset.getNode());
11193 CPIdx = DAG.getNode(ISD::ADD, DL, CPIdx.getValueType(), CPIdx,
11195 AddToWorkList(CPIdx.getNode());
11218 SDValue Shift = DAG.getNode(ISD::SRL, SDLoc(N0),
11220 AddToWorkList(Shift.getNode());
11223 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
11224 AddToWorkList(Shift.getNode());
11227 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
11230 SDValue Shift = DAG.getNode(ISD::SRA, SDLoc(N0),
11234 AddToWorkList(Shift.getNode());
11237 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
11238 AddToWorkList(Shift.getNode());
11241 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
11263 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N0), VT, AndLHS, ShlAmt);
11270 SDValue Shr = DAG.getNode(ISD::SRA, SDLoc(N0), VT, Shl, ShrAmt);
11272 return DAG.getNode(ISD::AND, DL, VT, Shr, N3);
11300 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2),
11304 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2),
11308 AddToWorkList(SCC.getNode());
11309 AddToWorkList(Temp.getNode());
11315 return DAG.getNode(
11331 Res = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Res);
11339 SDValue Ctlz = DAG.getNode(ISD::CTLZ, SDLoc(N0), XType, N0);
11340 return DAG.getNode(ISD::SRL, DL, XType, Ctlz,
11346 SDValue NegN0 = DAG.getNode(ISD::SUB, SDLoc(N0),
11349 return DAG.getNode(ISD::SRL, DL, XType,
11350 DAG.getNode(ISD::AND, DL, XType, NegN0, NotN0),
11356 SDValue Sign = DAG.getNode(ISD::SRL, SDLoc(N0), XType, N0,
11359 return DAG.getNode(ISD::XOR, DL, XType, Sign, DAG.getConstant(1, XType));
11382 SDValue Shift = DAG.getNode(ISD::SRA, SDLoc(N0), XType,
11386 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N0),
11388 AddToWorkList(Shift.getNode());
11389 AddToWorkList(Add.getNode());
11390 return DAG.getNode(ISD::XOR, DL, XType, Add, Shift);
11615 if (!Visited.insert(Chain.getNode()))
11626 bool IsOpLoad = isa<LoadSDNode>(Chain.getNode()) &&
11627 !cast<LSBaseSDNode>(Chain.getNode())->isVolatile();
11631 isAlias(cast<LSBaseSDNode>(N), cast<LSBaseSDNode>(Chain.getNode()))) {
11645 // likelihood that getNode will find a matching token factor (CSE.)
11692 if (*I != OriginalChain.getNode())
11737 return DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other, Aliases);