Lines Matching refs:getNode
182 // SDValue.getNode() == 0 - No change was made
183 // SDValue.getNode() == N - N was replaced, is dead and has been handled.
515 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
520 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
534 return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
545 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
551 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
558 return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
562 return DAG.getNode(ISD::FP_ROUND, SDLoc(Op), Op.getValueType(),
601 if (isSetCCEquivalent(N, N0, N1, N2) && N.getNode()->hasOneUse())
616 return DAG.getNode(Opc, DL, VT, N0.getOperand(0), OpNode);
620 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT,
622 AddToWorkList(OpNode.getNode());
623 return DAG.getNode(Opc, DL, VT, OpNode, N0.getOperand(1));
634 return DAG.getNode(Opc, DL, VT, N1.getOperand(0), OpNode);
638 SDValue OpNode = DAG.getNode(Opc, SDLoc(N0), VT,
640 AddToWorkList(OpNode.getNode());
641 return DAG.getNode(Opc, DL, VT, OpNode, N1.getOperand(1));
655 To[0].getNode()->dump(&DAG);
658 assert((!To[i].getNode() ||
666 if (To[i].getNode()) {
667 AddToWorkList(To[i].getNode());
668 AddUsersToWorkList(To[i].getNode());
695 AddToWorkList(TLO.New.getNode());
696 AddUsersToWorkList(TLO.New.getNode());
701 if (TLO.Old.getNode()->use_empty()) {
702 removeFromWorkList(TLO.Old.getNode());
706 for (unsigned i = 0, e = TLO.Old.getNode()->getNumOperands(); i != e; ++i)
707 if (TLO.Old.getNode()->getOperand(i).getNode()->hasOneUse())
708 AddToWorkList(TLO.Old.getNode()->getOperand(i).getNode());
710 DAG.DeleteNode(TLO.Old.getNode());
724 AddToWorkList(Op.getNode());
729 TLO.Old.getNode()->dump(&DAG);
731 TLO.New.getNode()->dump(&DAG);
741 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, VT, SDValue(ExtLoad, 0));
746 Trunc.getNode()->dump(&DAG);
753 AddToWorkList(Trunc.getNode());
775 return DAG.getNode(ISD::AssertSext, dl, PVT,
779 return DAG.getNode(ISD::AssertZext, dl, PVT,
785 return DAG.getNode(ExtOpc, dl, PVT, Op);
791 return DAG.getNode(ISD::ANY_EXTEND, dl, PVT, Op);
801 if (NewOp.getNode() == 0)
803 AddToWorkList(NewOp.getNode());
806 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
807 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NewOp.getValueType(), NewOp,
816 if (NewOp.getNode() == 0)
818 AddToWorkList(NewOp.getNode());
821 ReplaceLoadWithPromotedLoad(Op.getNode(), NewOp.getNode());
851 if (NN0.getNode() == 0)
861 if (NN1.getNode() == 0)
865 AddToWorkList(NN0.getNode());
866 if (NN1.getNode())
867 AddToWorkList(NN1.getNode());
870 ReplaceLoadWithPromotedLoad(N0.getNode(), NN0.getNode());
872 ReplaceLoadWithPromotedLoad(N1.getNode(), NN1.getNode());
875 Op.getNode()->dump(&DAG));
877 return DAG.getNode(ISD::TRUNCATE, dl, VT,
878 DAG.getNode(Opc, dl, PVT, NN0, NN1));
914 if (N0.getNode() == 0)
917 AddToWorkList(N0.getNode());
919 ReplaceLoadWithPromotedLoad(Op.getOperand(0).getNode(), N0.getNode());
922 Op.getNode()->dump(&DAG));
924 return DAG.getNode(ISD::TRUNCATE, dl, VT,
925 DAG.getNode(Opc, dl, PVT, N0, Op.getOperand(1)));
953 Op.getNode()->dump(&DAG));
954 return DAG.getNode(Op.getOpcode(), SDLoc(Op), VT, Op.getOperand(0));
980 SDNode *N = Op.getNode();
990 SDValue Result = DAG.getNode(ISD::TRUNCATE, dl, VT, NewLD);
995 Result.getNode()->dump(&DAG);
1002 AddToWorkList(Result.getNode());
1051 AddToWorkList(N->getOperand(i).getNode());
1059 if (RV.getNode() == 0)
1068 if (RV.getNode() == N)
1072 RV.getNode()->getOpcode() != ISD::DELETED_NODE &&
1078 RV.getNode()->dump(&DAG);
1084 if (N->getNumValues() == RV.getNode()->getNumValues())
1085 DAG.ReplaceAllUsesWith(N, RV.getNode());
1094 AddToWorkList(RV.getNode());
1095 AddUsersToWorkList(RV.getNode());
1101 AddToWorkList(N->getOperand(i).getNode());
1204 if (RV.getNode() == 0) {
1220 if (RV.getNode() == 0) {
1250 if (RV.getNode() == 0 &&
1288 if (getInputChainForNode(N->getOperand(0).getNode()) == N->getOperand(1))
1290 if (getInputChainForNode(N->getOperand(1).getNode()) == N->getOperand(0))
1320 std::find(TFs.begin(), TFs.end(), Op.getNode()) == TFs.end()) {
1322 TFs.push_back(Op.getNode());
1324 AddToWorkList(Op.getNode());
1332 if (SeenOps.insert(Op.getNode()))
1350 Result = DAG.getNode(ISD::TokenFactor, SDLoc(N),
1387 if (N01C && N00.getOpcode() == ISD::ADD && N00.getNode()->hasOneUse() &&
1390 N0 = DAG.getNode(ISD::ADD, SDLoc(N0), VT,
1391 DAG.getNode(ISD::SHL, SDLoc(N00), VT,
1393 DAG.getNode(ISD::SHL, SDLoc(N01), VT,
1395 return DAG.getNode(ISD::ADD, DL, VT, N0, N1);
1411 if (FoldedVOp.getNode()) return FoldedVOp;
1414 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1416 if (ISD::isBuildVectorAllZeros(N0.getNode()))
1430 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N1, N0);
1444 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1450 if (RADD.getNode() != 0)
1455 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1, N0.getOperand(1));
1459 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1.getOperand(1));
1469 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1474 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1.getOperand(0),
1480 return DAG.getNode(N1.getOpcode(), SDLoc(N), VT,
1491 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1492 DAG.getNode(ISD::ADD, SDLoc(N0), VT, N00, N10),
1493 DAG.getNode(ISD::ADD, SDLoc(N1), VT, N01, N11));
1511 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1);
1516 if (N0.getOpcode() == ISD::SHL && N0.getNode()->hasOneUse()) {
1518 if (Result.getNode()) return Result;
1520 if (N1.getOpcode() == ISD::SHL && N1.getNode()->hasOneUse()) {
1522 if (Result.getNode()) return Result;
1531 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N0,
1532 DAG.getNode(ISD::SHL, SDLoc(N), VT,
1540 return DAG.getNode(ISD::SUB, SDLoc(N), VT, N1,
1541 DAG.getNode(ISD::SHL, SDLoc(N), VT,
1555 return DAG.getNode(ISD::SUB, DL, VT, N->getOperand(0), AndOp0);
1564 SDValue ZExt = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0));
1565 return DAG.getNode(ISD::SUB, DL, VT, N1, ZExt);
1580 return CombineTo(N, DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, N1),
1581 DAG.getNode(ISD::CARRY_FALSE,
1586 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N1, N0);
1590 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE,
1604 return CombineTo(N, DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N1),
1605 DAG.getNode(ISD::CARRY_FALSE,
1621 return DAG.getNode(ISD::ADDE, SDLoc(N), N->getVTList(),
1626 return DAG.getNode(ISD::ADDC, SDLoc(N), N->getVTList(), N0, N1);
1646 ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.getNode());
1647 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
1649 dyn_cast<ConstantSDNode>(N1.getOperand(1).getNode());
1655 if (FoldedVOp.getNode()) return FoldedVOp;
1658 if (ISD::isBuildVectorAllZeros(N1.getNode()))
1671 return DAG.getNode(ISD::ADD, SDLoc(N), VT, N0,
1675 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
1689 return DAG.getNode(ISD::SUB, SDLoc(N), VT, NewC,
1697 return DAG.getNode(N0.getOperand(1).getOpcode(), SDLoc(N), VT,
1703 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
1709 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1745 return CombineTo(N, DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, N1),
1746 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1752 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1757 return CombineTo(N, N0, DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1762 return CombineTo(N, DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0),
1763 DAG.getNode(ISD::CARRY_FALSE, SDLoc(N),
1776 return DAG.getNode(ISD::SUBC, SDLoc(N), N->getVTList(), N0, N1);
1812 if (FoldedVOp.getNode()) return FoldedVOp;
1814 N0IsConst = isConstantSplatVector(N0.getNode(), ConstValue0);
1815 N1IsConst = isConstantSplatVector(N1.getNode(), ConstValue1);
1827 return DAG.FoldConstantArithmetic(ISD::MUL, VT, N0.getNode(), N1.getNode());
1831 return DAG.getNode(ISD::MUL, SDLoc(N), VT, N1, N0);
1844 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1848 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
1856 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1858 DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
1866 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1868 SDValue C3 = DAG.getNode(ISD::SHL, SDLoc(N), VT,
1870 AddToWorkList(C3.getNode());
1871 return DAG.getNode(ISD::MUL, SDLoc(N), VT,
1881 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1883 N0.getNode()->hasOneUse()) {
1887 N1.getNode()->hasOneUse()) {
1891 if (Sh.getNode()) {
1892 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
1894 return DAG.getNode(ISD::SHL, SDLoc(N), VT,
1900 if (N1IsConst && N0.getOpcode() == ISD::ADD && N0.getNode()->hasOneUse() &&
1901 (isConstantSplatVector(N0.getOperand(1).getNode(), Val) ||
1903 return DAG.getNode(ISD::ADD, SDLoc(N), VT,
1904 DAG.getNode(ISD::MUL, SDLoc(N0), VT,
1906 DAG.getNode(ISD::MUL, SDLoc(N1), VT,
1911 if (RMUL.getNode() != 0)
1920 ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.getNode());
1921 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
1927 if (FoldedVOp.getNode()) return FoldedVOp;
1938 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1944 return DAG.getNode(ISD::UDIV, SDLoc(N), N1.getValueType(),
1959 SDValue SGN = DAG.getNode(ISD::SRA, SDLoc(N), VT, N0,
1962 AddToWorkList(SGN.getNode());
1965 SDValue SRL = DAG.getNode(ISD::SRL, SDLoc(N), VT, SGN,
1968 SDValue ADD = DAG.getNode(ISD::ADD, SDLoc(N), VT, N0, SRL);
1969 AddToWorkList(SRL.getNode());
1970 AddToWorkList(ADD.getNode()); // Divide by pow2
1971 SDValue SRA = DAG.getNode(ISD::SRA, SDLoc(N), VT, ADD,
1979 AddToWorkList(SRA.getNode());
1980 return DAG.getNode(ISD::SUB, SDLoc(N), VT,
1988 if (Op.getNode()) return Op;
2004 ConstantSDNode *N0C = dyn_cast<ConstantSDNode>(N0.getNode());
2005 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
2011 if (FoldedVOp.getNode()) return FoldedVOp;
2019 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0,
2027 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N), ADDVT,
2032 AddToWorkList(Add.getNode());
2033 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, Add);
2040 if (Op.getNode()) return Op;
2067 return DAG.getNode(ISD::UREM, SDLoc(N), VT, N0, N1);
2073 SDValue Div = DAG.getNode(ISD::SDIV, SDLoc(N), VT, N0, N1);
2074 AddToWorkList(Div.getNode());
2075 SDValue OptimizedDiv = combine(Div.getNode());
2076 if (OptimizedDiv.getNode() && OptimizedDiv.getNode() != Div.getNode()) {
2077 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
2079 SDValue Sub = DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, Mul);
2080 AddToWorkList(Mul.getNode());
2107 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0,
2114 DAG.getNode(ISD::ADD, SDLoc(N), VT, N1,
2117 AddToWorkList(Add.getNode());
2118 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, Add);
2126 SDValue Div = DAG.getNode(ISD::UDIV, SDLoc(N), VT, N0, N1);
2127 AddToWorkList(Div.getNode());
2128 SDValue OptimizedDiv = combine(Div.getNode());
2129 if (OptimizedDiv.getNode() && OptimizedDiv.getNode() != Div.getNode()) {
2130 SDValue Mul = DAG.getNode(ISD::MUL, SDLoc(N), VT,
2132 SDValue Sub = DAG.getNode(ISD::SUB, SDLoc(N), VT, N0, Mul);
2133 AddToWorkList(Mul.getNode());
2160 return DAG.getNode(ISD::SRA, SDLoc(N), N0.getValueType(), N0,
2174 N0 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N0);
2175 N1 = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N1);
2176 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2177 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2179 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2210 N0 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N0);
2211 N1 = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N1);
2212 N1 = DAG.getNode(ISD::MUL, DL, NewVT, N0, N1);
2213 N1 = DAG.getNode(ISD::SRL, DL, NewVT, N1,
2215 return DAG.getNode(ISD::TRUNCATE, DL, VT, N1);
2233 SDValue Res = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0),
2243 SDValue Res = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1),
2254 SDValue Lo = DAG.getNode(LoOp, SDLoc(N), N->getValueType(0),
2256 AddToWorkList(Lo.getNode());
2257 SDValue LoOpt = combine(Lo.getNode());
2258 if (LoOpt.getNode() && LoOpt.getNode() != Lo.getNode() &&
2265 SDValue Hi = DAG.getNode(HiOp, SDLoc(N), N->getValueType(1),
2267 AddToWorkList(Hi.getNode());
2268 SDValue HiOpt = combine(Hi.getNode());
2269 if (HiOpt.getNode() && HiOpt != Hi &&
2280 if (Res.getNode()) return Res;
2292 SDValue Lo = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(0));
2293 SDValue Hi = DAG.getNode(ISD::SIGN_EXTEND, DL, NewVT, N->getOperand(1));
2294 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
2296 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
2298 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
2300 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
2310 if (Res.getNode()) return Res;
2322 SDValue Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(0));
2323 SDValue Hi = DAG.getNode(ISD::ZERO_EXTEND, DL, NewVT, N->getOperand(1));
2324 Lo = DAG.getNode(ISD::MUL, DL, NewVT, Lo, Hi);
2326 Hi = DAG.getNode(ISD::SRL, DL, NewVT, Lo,
2328 Hi = DAG.getNode(ISD::TRUNCATE, DL, VT, Hi);
2330 Lo = DAG.getNode(ISD::TRUNCATE, DL, VT, Lo);
2342 return DAG.getNode(ISD::SADDO, SDLoc(N), N->getVTList(),
2352 return DAG.getNode(ISD::UADDO, SDLoc(N), N->getVTList(),
2360 if (Res.getNode()) return Res;
2367 if (Res.getNode()) return Res;
2380 if (N0.getNode()->getNumOperands() == 0) return SDValue();
2403 SDValue ORNode = DAG.getNode(N->getOpcode(), SDLoc(N0),
2406 AddToWorkList(ORNode.getNode());
2407 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, ORNode);
2417 SDValue ORNode = DAG.getNode(N->getOpcode(), SDLoc(N0),
2420 AddToWorkList(ORNode.getNode());
2421 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
2443 SDValue Op = DAG.getNode(N->getOpcode(), DL, In0Ty, In0, In1);
2444 SDValue BC = DAG.getNode(N0.getOpcode(), DL, VT, Op);
2445 AddToWorkList(Op.getNode());
2481 SDValue Op = DAG.getNode(N->getOpcode(), SDLoc(N), VT,
2483 AddToWorkList(Op.getNode());
2504 if (FoldedVOp.getNode()) return FoldedVOp;
2507 if (ISD::isBuildVectorAllZeros(N0.getNode()))
2509 if (ISD::isBuildVectorAllZeros(N1.getNode()))
2513 if (ISD::isBuildVectorAllOnes(N0.getNode()))
2515 if (ISD::isBuildVectorAllOnes(N1.getNode()))
2527 return DAG.getNode(ISD::AND, SDLoc(N), VT, N1, N0);
2537 if (RAND.getNode() != 0)
2550 SDValue Zext = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N),
2559 CombineTo(N0.getNode(), Zext);
2657 CombineTo(N, (N0.getNode() == Load) ? NewLoad : N0);
2671 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(N0),
2673 AddToWorkList(ORNode.getNode());
2678 SDValue ANDNode = DAG.getNode(ISD::AND, SDLoc(N0),
2680 AddToWorkList(ANDNode.getNode());
2685 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(N0),
2687 AddToWorkList(ORNode.getNode());
2698 SDValue ADDNode = DAG.getNode(ISD::ADD, SDLoc(N0), LL.getValueType(),
2700 AddToWorkList(ADDNode.getNode());
2725 if (Tmp.getNode()) return Tmp;
2735 if (ISD::isEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode())) {
2749 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
2754 if (ISD::isSEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
2769 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
2821 NewPtr = DAG.getNode(ISD::ADD, SDLoc(LN0), PtrType,
2826 AddToWorkList(NewPtr.getNode());
2859 DAG.getNode(ISD::ADD, SDLoc(N0), VT,
2861 CombineTo(N0.getNode(), NewAdd);
2872 SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
2874 if (BSwap.getNode())
2902 if (!N0.getNode()->hasOneUse())
2912 if (!N1.getNode()->hasOneUse())
2925 if (!N0.getNode()->hasOneUse() ||
2926 !N1.getNode()->hasOneUse())
2939 if (!N00.getNode()->hasOneUse())
2950 if (!N10.getNode()->hasOneUse())
2980 SDValue Res = DAG.getNode(ISD::BSWAP, SDLoc(N), VT, N00);
2982 Res = DAG.getNode(ISD::SRL, SDLoc(N), VT, Res,
2991 if (!N.getNode()->hasOneUse())
3053 Parts[Num] = N0.getOperand(0).getNode();
3115 SDValue BSwap = DAG.getNode(ISD::BSWAP, SDLoc(N), VT,
3122 return DAG.getNode(ISD::ROTL, SDLoc(N), VT, BSwap, ShAmt);
3124 return DAG.getNode(ISD::ROTR, SDLoc(N), VT, BSwap, ShAmt);
3125 return DAG.getNode(ISD::OR, SDLoc(N), VT,
3126 DAG.getNode(ISD::SHL, SDLoc(N), VT, BSwap, ShAmt),
3127 DAG.getNode(ISD::SRL, SDLoc(N), VT, BSwap, ShAmt));
3141 if (FoldedVOp.getNode()) return FoldedVOp;
3144 if (ISD::isBuildVectorAllZeros(N0.getNode()))
3146 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3150 if (ISD::isBuildVectorAllOnes(N0.getNode()))
3152 if (ISD::isBuildVectorAllOnes(N1.getNode()))
3167 return DAG.getNode(ISD::OR, SDLoc(N), VT, N1, N0);
3180 if (BSwap.getNode() != 0)
3183 if (BSwap.getNode() != 0)
3188 if (ROR.getNode() != 0)
3192 if (N1C && N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
3196 return DAG.getNode(ISD::AND, SDLoc(N), VT,
3197 DAG.getNode(ISD::OR, SDLoc(N0), VT,
3212 SDValue ORNode = DAG.getNode(ISD::OR, SDLoc(LR),
3214 AddToWorkList(ORNode.getNode());
3221 SDValue ANDNode = DAG.getNode(ISD::AND, SDLoc(LR),
3223 AddToWorkList(ANDNode.getNode());
3248 if (Tmp.getNode()) return Tmp;
3257 (N0.getNode()->hasOneUse() || N1.getNode()->hasOneUse())) {
3267 SDValue X = DAG.getNode(ISD::OR, SDLoc(N0), VT,
3269 return DAG.getNode(ISD::AND, SDLoc(N), VT, X,
3356 SDValue Rot = DAG.getNode(HasROTL ? ISD::ROTL : ISD::ROTR, DL, VT,
3360 if (LHSMask.getNode() || RHSMask.getNode()) {
3363 if (LHSMask.getNode()) {
3367 if (RHSMask.getNode()) {
3372 Rot = DAG.getNode(ISD::AND, DL, VT, Rot, DAG.getConstant(Mask, VT));
3375 return Rot.getNode();
3380 if (LHSMask.getNode() || RHSMask.getNode())
3406 return DAG.getNode(HasROTL ? ISD::ROTL : ISD::ROTR, DL, VT, LHSShiftArg,
3407 HasROTL ? LHSShiftAmt : RHSShiftAmt).getNode();
3417 return DAG.getNode(HasROTR ? ISD::ROTR : ISD::ROTL, DL, VT, LHSShiftArg,
3418 HasROTR ? RHSShiftAmt : LHSShiftAmt).getNode();
3435 if (FoldedVOp.getNode()) return FoldedVOp;
3438 if (ISD::isBuildVectorAllZeros(N0.getNode()))
3440 if (ISD::isBuildVectorAllZeros(N1.getNode()))
3457 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N1, N0);
3463 if (RXOR.getNode() != 0)
3488 N0.getNode()->hasOneUse() &&
3491 V = DAG.getNode(ISD::XOR, SDLoc(N0), V.getValueType(), V,
3493 AddToWorkList(V.getNode());
3494 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, V);
3503 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
3504 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
3505 AddToWorkList(LHS.getNode()); AddToWorkList(RHS.getNode());
3506 return DAG.getNode(NewOpcode, SDLoc(N), VT, LHS, RHS);
3515 LHS = DAG.getNode(ISD::XOR, SDLoc(LHS), VT, LHS, N1); // LHS = ~LHS
3516 RHS = DAG.getNode(ISD::XOR, SDLoc(RHS), VT, RHS, N1); // RHS = ~RHS
3517 AddToWorkList(LHS.getNode()); AddToWorkList(RHS.getNode());
3518 return DAG.getNode(NewOpcode, SDLoc(N), VT, LHS, RHS);
3522 if (N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() &&
3526 AddToWorkList(NotX.getNode());
3527 return DAG.getNode(ISD::AND, SDLoc(N), VT, NotX, N1);
3534 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N0.getOperand(1),
3538 return DAG.getNode(ISD::XOR, SDLoc(N), VT, N0.getOperand(0),
3549 if (Tmp.getNode()) return Tmp;
3563 SDNode *LHS = N->getOperand(0).getNode();
3597 SDNode *BinOpLHSVal = LHS->getOperand(0).getNode();
3617 SDValue NewRHS = DAG.getNode(N->getOpcode(), SDLoc(LHS->getOperand(1)),
3622 SDValue NewShift = DAG.getNode(N->getOpcode(),
3627 return DAG.getNode(LHS->getOpcode(), SDLoc(N), VT, NewShift, NewRHS);
3641 if (FoldedVOp.getNode()) return FoldedVOp;
3673 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0,
3674 DAG.getNode(ISD::AND, SDLoc(N), TruncVT,
3675 DAG.getNode(ISD::TRUNCATE,
3692 return DAG.getNode(ISD::SHL, SDLoc(N), VT, N0.getOperand(0),
3714 return DAG.getNode(ISD::SHL, SDLoc(N0), VT,
3715 DAG.getNode(N0.getOpcode(), SDLoc(N0), VT,
3734 SDValue NewSHL = DAG.getNode(ISD::SHL, SDLoc(N), NewOp0.getValueType(),
3736 AddToWorkList(NewSHL.getNode());
3737 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N0), VT, NewSHL);
3756 Shift = DAG.getNode(ISD::SHL, SDLoc(N), VT, N0.getOperand(0),
3760 Shift = DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0),
3763 return DAG.getNode(ISD::AND, SDLoc(N0), VT, Shift,
3774 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0.getOperand(0),
3780 if (NewSHL.getNode())
3798 if (FoldedVOp.getNode()) return FoldedVOp;
3826 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
3835 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0.getOperand(0),
3867 SDValue Shift = DAG.getNode(ISD::SRL, SDLoc(N0), VT,
3869 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), TruncVT,
3871 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N),
3887 return DAG.getNode(ISD::SRA, SDLoc(N), VT, N0,
3888 DAG.getNode(ISD::AND, SDLoc(N),
3890 DAG.getNode(ISD::TRUNCATE,
3914 SDValue SRA = DAG.getNode(ISD::SRA, SDLoc(N), LargeVT,
3916 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, SRA);
3927 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0, N1);
3931 if (NewSRA.getNode())
3949 if (FoldedVOp.getNode()) return FoldedVOp;
3976 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0),
3994 return DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT,
3995 DAG.getNode(ISD::SRL, SDLoc(N0), InnerShiftVT,
4005 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0.getOperand(0),
4018 SDValue SmallShift = DAG.getNode(ISD::SRL, SDLoc(N0), SmallVT,
4021 AddToWorkList(SmallShift.getNode());
4023 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4024 DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, SmallShift),
4033 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0.getOperand(0), N1);
4061 Op = DAG.getNode(ISD::SRL, SDLoc(N0), VT, Op,
4063 AddToWorkList(Op.getNode());
4066 return DAG.getNode(ISD::XOR, SDLoc(N), VT,
4081 return DAG.getNode(ISD::SRL, SDLoc(N), VT, N0,
4082 DAG.getNode(ISD::AND, SDLoc(N),
4084 DAG.getNode(ISD::TRUNCATE,
4098 if (NewSRL.getNode())
4104 if (NarrowLoad.getNode())
4145 return DAG.getNode(ISD::CTLZ, SDLoc(N), VT, N0);
4155 return DAG.getNode(ISD::CTLZ_ZERO_UNDEF, SDLoc(N), VT, N0);
4165 return DAG.getNode(ISD::CTTZ, SDLoc(N), VT, N0);
4175 return DAG.getNode(ISD::CTTZ_ZERO_UNDEF, SDLoc(N), VT, N0);
4185 return DAG.getNode(ISD::CTPOP, SDLoc(N), VT, N0);
4210 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N2);
4220 return DAG.getNode(ISD::XOR, SDLoc(N), VT0,
4222 XORNode = DAG.getNode(ISD::XOR, SDLoc(N0), VT0,
4224 AddToWorkList(XORNode.getNode());
4226 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, XORNode);
4227 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, XORNode);
4232 AddToWorkList(NOTNode.getNode());
4233 return DAG.getNode(ISD::AND, SDLoc(N), VT, NOTNode, N2);
4238 AddToWorkList(NOTNode.getNode());
4239 return DAG.getNode(ISD::OR, SDLoc(N), VT, NOTNode, N1);
4243 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
4247 return DAG.getNode(ISD::OR, SDLoc(N), VT, N0, N2);
4251 return DAG.getNode(ISD::AND, SDLoc(N), VT, N0, N1);
4265 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT,
4285 Lo = DAG.getNode(N->getOpcode(), DL, LoVT, LL, RL, N->getOperand(2));
4286 Hi = DAG.getNode(N->getOpcode(), DL, HiVT, LH, RH, N->getOperand(2));
4306 bool RHSIsAllZeros = ISD::isBuildVectorAllZeros(RHS.getNode());
4309 (ISD::isBuildVectorAllOnes(RHS.getNode()) && CC == ISD::SETGT)) &&
4311 isAbs = ISD::isBuildVectorAllZeros(N2.getOperand(0).getNode());
4314 isAbs = ISD::isBuildVectorAllZeros(N1.getOperand(0).getNode());
4318 SDValue Shift = DAG.getNode(
4321 SDValue Add = DAG.getNode(ISD::ADD, DL, VT, LHS, Shift);
4322 AddToWorkList(Shift.getNode());
4323 AddToWorkList(Add.getNode());
4324 return DAG.getNode(ISD::XOR, DL, VT, Add, Shift);
4341 llvm::tie(CCLo, CCHi) = SplitVSETCC(N0.getNode(), DAG);
4345 Lo = DAG.getNode(N->getOpcode(), DL, LL.getValueType(), CCLo, LL, RL);
4346 Hi = DAG.getNode(N->getOpcode(), DL, LH.getValueType(), CCHi, LH, RH);
4350 AddToWorkList(Lo.getNode());
4351 AddToWorkList(Hi.getNode());
4353 return DAG.getNode(ISD::CONCAT_VECTORS, DL, VT, Lo, Hi);
4374 if (SCC.getNode()) {
4375 AddToWorkList(SCC.getNode());
4377 if (ConstantSDNode *SCCC = dyn_cast<ConstantSDNode>(SCC.getNode())) {
4386 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), N2.getValueType(),
4415 for (SDNode::use_iterator UI = N0.getNode()->use_begin(),
4416 UE = N0.getNode()->use_end();
4482 Ops.push_back(DAG.getNode(ExtType, DL, ExtLoad->getValueType(0), SOp));
4486 CombineTo(SetCC, DAG.getNode(ISD::SETCC, DL, SetCC->getValueType(0),
4497 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N0);
4502 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT,
4508 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
4509 if (NarrowLoad.getNode()) {
4510 SDNode* oye = N0.getNode()->getOperand(0).getNode();
4511 if (NarrowLoad.getNode() != N0.getNode()) {
4512 CombineTo(N0.getNode(), NarrowLoad);
4536 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, Op);
4541 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
4548 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N0), VT, Op);
4550 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N0), VT, Op);
4551 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, Op,
4560 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
4574 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
4576 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
4585 if ((ISD::isSEXTLoad(N0.getNode()) || ISD::isEXTLoad(N0.getNode())) &&
4586 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
4596 CombineTo(N0.getNode(),
4597 DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
4626 SDValue And = DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
4628 SDValue Trunc = DAG.getNode(ISD::TRUNCATE,
4632 CombineTo(N0.getOperand(0).getNode(), Trunc, ExtLoad.getValue(1));
4682 if (SCC.getNode()) return SCC;
4698 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, N0);
4747 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, N0);
4751 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT,
4770 return DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N), VT, Op);
4772 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
4781 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
4782 if (NarrowLoad.getNode()) {
4783 SDNode* oye = N0.getNode()->getOperand(0).getNode();
4784 if (NarrowLoad.getNode() != N0.getNode()) {
4785 CombineTo(N0.getNode(), NarrowLoad);
4799 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
4800 if (NarrowLoad.getNode()) {
4801 SDNode* oye = N0.getNode()->getOperand(0).getNode();
4802 if (NarrowLoad.getNode() != N0.getNode()) {
4803 CombineTo(N0.getNode(), NarrowLoad);
4812 Op = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, Op);
4813 AddToWorkList(Op.getNode());
4815 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Op);
4816 AddToWorkList(Op.getNode());
4832 X = DAG.getNode(ISD::ANY_EXTEND, SDLoc(X), VT, X);
4834 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
4838 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4846 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
4860 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
4862 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
4892 SDValue And = DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
4894 SDValue Trunc = DAG.getNode(ISD::TRUNCATE,
4898 CombineTo(N0.getOperand(0).getNode(), Trunc, ExtLoad.getValue(1));
4908 if ((ISD::isZEXTLoad(N0.getNode()) || ISD::isEXTLoad(N0.getNode())) &&
4909 ISD::isUNINDEXEDLoad(N0.getNode()) && N0.hasOneUse()) {
4919 CombineTo(N0.getNode(),
4920 DAG.getNode(ISD::TRUNCATE, SDLoc(N0), N0.getValueType(),
4941 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4945 DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT,
4961 return DAG.getNode(ISD::AND, SDLoc(N), VT,
4963 DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT,
4972 if (SCC.getNode()) return SCC;
4996 ShAmt = DAG.getNode(ISD::ZERO_EXTEND, DL, MVT::i32, ShAmt);
4998 return DAG.getNode(N0.getOpcode(), DL, VT,
4999 DAG.getNode(ISD::ZERO_EXTEND, DL, VT, N0.getOperand(0)),
5012 return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, N0);
5019 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT, N0.getOperand(0));
5024 SDValue NarrowLoad = ReduceLoadWidth(N0.getNode());
5025 if (NarrowLoad.getNode()) {
5026 SDNode* oye = N0.getNode()->getOperand(0).getNode();
5027 if (NarrowLoad.getNode() != N0.getNode()) {
5028 CombineTo(N0.getNode(), NarrowLoad);
5042 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, TruncOp);
5043 return DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, TruncOp);
5055 X = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), VT, X);
5057 X = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, X);
5061 return DAG.getNode(ISD::AND, SDLoc(N), VT,
5069 if (ISD::isNON_EXTLoad(N0.getNode()) && !VT.isVector() &&
5083 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5085 CombineTo(N0.getNode(), Trunc, ExtLoad.getValue(1));
5096 !ISD::isNON_EXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
5104 CombineTo(N0.getNode(),
5105 DAG.getNode(ISD::TRUNCATE, SDLoc(N0),
5148 if (SCC.getNode())
5162 const ConstantSDNode *CV = cast<ConstantSDNode>(V.getNode());
5180 if (!V.getNode()->hasOneUse())
5190 if (SimplifyLHS.getNode())
5191 return DAG.getNode(ISD::SRL, SDLoc(V), V.getValueType(),
5324 SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(LN0),
5327 AddToWorkList(NewPtr.getNode());
5358 Result = DAG.getNode(ISD::SHL, SDLoc(N0), VT,
5376 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT, N0, N1);
5385 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
5395 return DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, N00, N1);
5410 if (NarrowLoad.getNode())
5423 return DAG.getNode(ISD::SRA, SDLoc(N), VT,
5429 if (ISD::isEXTLoad(N0.getNode()) &&
5430 ISD::isUNINDEXEDLoad(N0.getNode()) &&
5440 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
5441 AddToWorkList(ExtLoad.getNode());
5445 if (ISD::isZEXTLoad(N0.getNode()) && ISD::isUNINDEXEDLoad(N0.getNode()) &&
5456 CombineTo(N0.getNode(), ExtLoad, ExtLoad.getValue(1));
5462 SDValue BSwap = MatchBSwapHWordLow(N0.getNode(), N0.getOperand(0),
5464 if (BSwap.getNode() != 0)
5465 return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), VT,
5482 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0);
5485 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
5492 return DAG.getNode(N0.getOpcode(), SDLoc(N), VT,
5496 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, N0.getOperand(0));
5531 SDValue V = DAG.getNode(ISD::BITCAST, SDLoc(N),
5534 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT,
5567 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), VT, &Opnds[0],
5581 if (Shorter.getNode())
5582 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, Shorter);
5588 if (Reduced.getNode())
5618 assert(V.getNode() && "The single defined operand is empty!");
5625 SDValue NV = DAG.getNode(ISD::TRUNCATE, SDLoc(V), VTs[i], V);
5626 AddToWorkList(NV.getNode());
5629 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT,
5645 return Elt.getNode();
5646 return Elt.getOperand(Elt.getResNo()).getNode();
5692 N0.getOpcode() == ISD::BUILD_VECTOR && N0.getNode()->hasOneUse() &&
5707 return ConstantFoldBITCASTofBUILD_VECTOR(N0.getNode(), DestEltVT);
5710 // If the input is a constant, let getNode fold it.
5712 SDValue Res = DAG.getNode(ISD::BITCAST, SDLoc(N), VT, N0);
5713 if (Res.getNode() != N) {
5715 TLI.isOperationLegal(Res.getNode()->getOpcode(), VT))
5723 DAG.DeleteNode(Res.getNode());
5729 return DAG.getNode(ISD::BITCAST, SDLoc(N), VT,
5734 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
5751 CombineTo(N0.getNode(),
5752 DAG.getNode(ISD::BITCAST, SDLoc(N0),
5764 N0.getNode()->hasOneUse() && VT.isInteger() &&
5766 SDValue NewConv = DAG.getNode(ISD::BITCAST, SDLoc(N0), VT,
5768 AddToWorkList(NewConv.getNode());
5772 return DAG.getNode(ISD::XOR, SDLoc(N), VT,
5775 return DAG.getNode(ISD::AND, SDLoc(N), VT,
5783 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse() &&
5789 SDValue X = DAG.getNode(ISD::BITCAST, SDLoc(N0),
5791 AddToWorkList(X.getNode());
5796 X = DAG.getNode(ISD::SIGN_EXTEND, SDLoc(N), VT, X);
5797 AddToWorkList(X.getNode());
5801 X = DAG.getNode(ISD::SRL, SDLoc(X),
5804 AddToWorkList(X.getNode());
5805 X = DAG.getNode(ISD::TRUNCATE, SDLoc(X), VT, X);
5806 AddToWorkList(X.getNode());
5810 X = DAG.getNode(ISD::AND, SDLoc(X), VT,
5812 AddToWorkList(X.getNode());
5814 SDValue Cst = DAG.getNode(ISD::BITCAST, SDLoc(N0),
5816 Cst = DAG.getNode(ISD::AND, SDLoc(Cst), VT,
5818 AddToWorkList(Cst.getNode());
5820 return DAG.getNode(ISD::OR, SDLoc(N), VT, X, Cst);
5826 SDValue CombineLD = CombineConsecutiveLoads(N0.getNode(), VT);
5827 if (CombineLD.getNode())
5861 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(BV), VT,
5862 DAG.getNode(ISD::BITCAST, SDLoc(BV),
5871 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(BV), SrcEltVT, Op);
5872 Ops.push_back(DAG.getNode(ISD::BITCAST, SDLoc(BV),
5874 AddToWorkList(Ops.back().getNode());
5876 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT,
5888 BV = ConstantFoldBITCASTofBUILD_VECTOR(BV, IntVT).getNode();
5897 SDNode *Tmp = ConstantFoldBITCASTofBUILD_VECTOR(BV, TmpVT).getNode();
5933 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT,
5960 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(BV), VT,
5970 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(BV), VT,
5984 if (FoldedVOp.getNode()) return FoldedVOp;
5989 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N1);
5992 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N0);
6000 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N0,
6005 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N1,
6010 N0.getOpcode() == ISD::FADD && N0.getNode()->hasOneUse() &&
6012 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0.getOperand(0),
6013 DAG.getNode(ISD::FADD, SDLoc(N), VT,
6049 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6052 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6058 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6061 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6069 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6072 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6080 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6083 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6094 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6097 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6103 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6106 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6115 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6118 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6126 SDValue NewCFP = DAG.getNode(ISD::FADD, SDLoc(N), VT,
6129 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6139 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6148 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6158 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6171 return DAG.getNode(ISD::FMA, SDLoc(N), VT,
6177 return DAG.getNode(ISD::FMA, SDLoc(N), VT,
6195 if (FoldedVOp.getNode()) return FoldedVOp;
6200 return DAG.getNode(ISD::FSUB, SDLoc(N), VT, N0, N1);
6211 return DAG.getNode(ISD::FNEG, dl, VT, N1);
6215 return DAG.getNode(ISD::FADD, dl, VT, N0,
6248 return DAG.getNode(ISD::FMA, dl, VT,
6250 DAG.getNode(ISD::FNEG, dl, VT, N1));
6255 return DAG.getNode(ISD::FMA, dl, VT,
6256 DAG.getNode(ISD::FNEG, dl, VT,
6266 return DAG.getNode(ISD::FMA, dl, VT,
6267 DAG.getNode(ISD::FNEG, dl, VT, N00), N01,
6268 DAG.getNode(ISD::FNEG, dl, VT, N1));
6286 if (FoldedVOp.getNode()) return FoldedVOp;
6291 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0, N1);
6294 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N1, N0);
6301 ISD::isBuildVectorAllZeros(N1.getNode()))
6308 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N0);
6312 return DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0);
6322 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6331 N0.getNode()->hasOneUse() && isa<ConstantFPSDNode>(N0.getOperand(1)))
6332 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0.getOperand(0),
6333 DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6355 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N1, N2);
6357 return DAG.getNode(ISD::FADD, SDLoc(N), VT, N0, N2);
6361 return DAG.getNode(ISD::FMA, SDLoc(N), VT, N1, N0, N2);
6368 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6369 DAG.getNode(ISD::FADD, dl, VT, N1, N2.getOperand(1)));
6377 return DAG.getNode(ISD::FMA, dl, VT,
6379 DAG.getNode(ISD::FMUL, dl, VT, N1, N0.getOperand(1)),
6387 return DAG.getNode(ISD::FADD, dl, VT, N0, N2);
6391 SDValue RHSNeg = DAG.getNode(ISD::FNEG, dl, VT, N0);
6392 AddToWorkList(RHSNeg.getNode());
6393 return DAG.getNode(ISD::FADD, dl, VT, N2, RHSNeg);
6399 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6400 DAG.getNode(ISD::FADD, dl, VT,
6406 return DAG.getNode(ISD::FMUL, dl, VT, N0,
6407 DAG.getNode(ISD::FADD, dl, VT,
6425 if (FoldedVOp.getNode()) return FoldedVOp;
6430 return DAG.getNode(ISD::FDIV, SDLoc(N), VT, N0, N1);
6447 return DAG.getNode(ISD::FMUL, SDLoc(N), VT, N0,
6459 return DAG.getNode(ISD::FDIV, SDLoc(N), VT,
6477 return DAG.getNode(ISD::FREM, SDLoc(N), VT, N0, N1);
6490 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT, N0, N1);
6498 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
6501 return DAG.getNode(ISD::FNEG, SDLoc(N), VT,
6502 DAG.getNode(ISD::FABS, SDLoc(N0), VT, N0));
6511 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
6516 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
6520 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
6526 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
6543 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
6551 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
6569 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops, 5);
6582 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops, 5);
6600 return DAG.getNode(ISD::UINT_TO_FP, SDLoc(N), VT, N0);
6608 return DAG.getNode(ISD::SINT_TO_FP, SDLoc(N), VT, N0);
6626 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), VT, Ops, 5);
6640 return DAG.getNode(ISD::FP_TO_SINT, SDLoc(N), VT, N0);
6652 return DAG.getNode(ISD::FP_TO_UINT, SDLoc(N), VT, N0);
6665 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0, N1);
6675 N0.getNode()->getConstantOperandVal(1) == 1;
6676 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT, N0.getOperand(0),
6681 if (N0.getOpcode() == ISD::FCOPYSIGN && N0.getNode()->hasOneUse()) {
6682 SDValue Tmp = DAG.getNode(ISD::FP_ROUND, SDLoc(N0), VT,
6684 AddToWorkList(Tmp.getNode());
6685 return DAG.getNode(ISD::FCOPYSIGN, SDLoc(N), VT,
6701 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, Round);
6719 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, N0);
6724 && N0.getNode()->getConstantOperandVal(1) == 1) {
6728 return DAG.getNode(ISD::FP_ROUND, SDLoc(N), VT,
6730 return DAG.getNode(ISD::FP_EXTEND, SDLoc(N), VT, In);
6734 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
6743 CombineTo(N0.getNode(),
6744 DAG.getNode(ISD::FP_ROUND, SDLoc(N0),
6759 if (FoldedVOp.getNode()) return FoldedVOp;
6770 N0.getNode()->hasOneUse() &&
6775 Int = DAG.getNode(ISD::XOR, SDLoc(N0), IntVT, Int,
6777 AddToWorkList(Int.getNode());
6778 return DAG.getNode(ISD::BITCAST, SDLoc(N),
6787 return DAG.getNode(ISD::FMUL, SDLoc(N), VT,
6789 DAG.getNode(ISD::FNEG, SDLoc(N), VT,
6803 return DAG.getNode(ISD::FCEIL, SDLoc(N), VT, N0);
6815 return DAG.getNode(ISD::FTRUNC, SDLoc(N), VT, N0);
6827 return DAG.getNode(ISD::FFLOOR, SDLoc(N), VT, N0);
6839 if (FoldedVOp.getNode()) return FoldedVOp;
6844 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0);
6851 return DAG.getNode(ISD::FABS, SDLoc(N), VT, N0.getOperand(0));
6856 N0.getOpcode() == ISD::BITCAST && N0.getNode()->hasOneUse() &&
6862 Int = DAG.getNode(ISD::AND, SDLoc(N0), IntVT, Int,
6864 AddToWorkList(Int.getNode());
6865 return DAG.getNode(ISD::BITCAST, SDLoc(N),
6889 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
6901 Trunc = N1.getNode();
6940 SDValue NewBRCond = DAG.getNode(ISD::BRCOND, SDLoc(N),
6953 removeFromWorkList(N1.getNode());
6954 DAG.DeleteNode(N1.getNode());
6968 SDNode *TheXor = N1.getNode();
6974 if (Tmp.getNode()) {
6975 if (Tmp.getNode() != TheXor) {
6979 Tmp.getNode()->dump(&DAG);
6985 return DAG.getNode(ISD::BRCOND, SDLoc(N),
7000 TheXor = Op0.getNode();
7014 removeFromWorkList(N1.getNode());
7015 DAG.DeleteNode(N1.getNode());
7016 return DAG.getNode(ISD::BRCOND, SDLoc(N),
7040 if (Simp.getNode()) AddToWorkList(Simp.getNode());
7043 if (Simp.getNode() && Simp.getOpcode() == ISD::SETCC)
7044 return DAG.getNode(ISD::BR_CC, SDLoc(N), MVT::Other,
7060 if (LD->isIndexed() || LD->getBasePtr().getNode() != N)
7064 if (ST->isIndexed() || ST->getBasePtr().getNode() != N)
7130 Ptr.getNode()->hasOneUse())
7170 if (Val == BasePtr || BasePtr.getNode()->isPredecessorOf(Val.getNode()))
7179 for (SDNode::use_iterator I = BasePtr.getNode()->use_begin(),
7180 E = BasePtr.getNode()->use_end(); I != E; ++I) {
7182 if (Use == Ptr.getNode())
7194 if (Op1.getNode() == BasePtr.getNode())
7196 assert(Op0.getNode() == BasePtr.getNode() &&
7223 for (SDNode::use_iterator I = Ptr.getNode()->use_begin(),
7224 E = Ptr.getNode()->use_end(); I != E; ++I) {
7233 if (!canFoldInAddressingMode(Ptr.getNode(), Use, DAG, TLI))
7252 Result.getNode()->dump(&DAG);
7271 if (OtherUses[i]->getOperand(OffsetIdx).getNode() == BasePtr.getNode())
7273 assert(OtherUses[i]->getOperand(!OffsetIdx).getNode() ==
7274 BasePtr.getNode() && "Expected BasePtr operand");
7309 SDValue NewUse = DAG.getNode(Opcode,
7319 removeFromWorkList(Ptr.getNode());
7320 DAG.DeleteNode(Ptr.getNode());
7358 if (Ptr.getNode()->hasOneUse())
7361 for (SDNode::use_iterator I = Ptr.getNode()->use_begin(),
7362 E = Ptr.getNode()->use_end(); I != E; ++I) {
7389 for (SDNode::use_iterator II = BasePtr.getNode()->use_begin(),
7390 EE = BasePtr.getNode()->use_end(); II != EE; ++II) {
7392 if (Use == Ptr.getNode())
7428 Result.getNode()->dump(&DAG);
7475 Chain.getNode()->dump(&DAG);
7495 Undef.getNode()->dump(&DAG);
7514 if (ISD::isNON_TRUNCStore(Chain.getNode())) {
7533 return CombineTo(N, NewLoad, SDValue(NewLoad.getNode(), 1), true);
7560 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
7564 AddToWorkList(Token.getNode());
7822 BaseAddr = DAG->getNode(ISD::ADD, SDLoc(Origin), ArithType, BaseAddr,
7839 DAG->getNode(ISD::ZERO_EXTEND, SDLoc(LastInst), FinalType, LastInst);
8119 if (SliceInst.getNode()->getOpcode() != ISD::LOAD)
8126 SDValue Chain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other,
8142 !ISD::isNormalLoad(V->getOperand(0).getNode()))
8151 if (LD == Chain.getNode())
8158 if (Chain->getOperand(i).getNode() == LD) {
8234 IVal = DAG.getNode(ISD::SRL, SDLoc(IVal), IVal.getValueType(), IVal,
8249 Ptr = DAG.getNode(ISD::ADD, SDLoc(IVal), Ptr.getValueType(),
8255 IVal = DAG.getNode(ISD::TRUNCATE, SDLoc(IVal), VT, IVal);
8260 false, false, NewAlign).getNode();
8309 if (ISD::isNormalLoad(N0.getNode()) && N0.hasOneUse() &&
8310 Chain == SDValue(N0.getNode(), 1)) {
8359 SDValue NewPtr = DAG.getNode(ISD::ADD, SDLoc(LD),
8368 SDValue NewVal = DAG.getNode(Opc, SDLoc(Value), NewVT, NewLD,
8375 AddToWorkList(NewPtr.getNode());
8376 AddToWorkList(NewLD.getNode());
8377 AddToWorkList(NewVal.getNode());
8396 if (ISD::isNormalStore(ST) && ISD::isNormalLoad(Value.getNode()) &&
8398 Chain == SDValue(Value.getNode(), 1)) {
8433 AddToWorkList(NewLD.getNode());
8434 AddToWorkList(NewST.getNode());
8585 if (!BasePtr.Base.getNode())
8646 SDNode *NextInChain = Index->getChain().getNode();
8660 NextInChain = Ldn->getChain().getNode();
8878 if (LdBasePtr.Base.getNode()) {
8990 SDValue(NewLoad.getNode(), 1));
9096 Ptr = DAG.getNode(ISD::ADD, SDLoc(N), Ptr.getValueType(), Ptr,
9103 return DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other,
9126 if (NewST.getNode())
9149 SDValue Token = DAG.getNode(ISD::TokenFactor, SDLoc(N),
9153 AddToWorkList(Token.getNode());
9175 AddToWorkList(Value.getNode());
9176 if (Shorter.getNode())
9205 && Value.getNode()->hasOneUse() && ST->isUnindexed() &&
9261 Ops.append(InVec.getNode()->op_begin(),
9262 InVec.getNode()->op_end());
9277 DAG.getNode(ISD::ANY_EXTEND, dl, OpVT, InVal) :
9278 DAG.getNode(ISD::TRUNCATE, dl, OpVT, InVal);
9283 return DAG.getNode(ISD::BUILD_VECTOR, dl,
9334 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N), NVT,
9375 if (ISD::isNormalLoad(InVec.getNode())) {
9379 ISD::isNormalLoad(InVec.getOperand(0).getNode())) {
9411 if (ISD::isNormalLoad(InVec.getNode())) {
9448 NewPtr = DAG.getNode(ISD::ADD, SDLoc(N), PtrType, NewPtr,
9477 Load = DAG.getNode(ISD::TRUNCATE, SDLoc(N), NVT, Load);
9479 Load = DAG.getNode(ISD::BITCAST, SDLoc(N), NVT, Load);
9487 AddToWorkList(Load.getNode());
9488 AddUsersToWorkList(Load.getNode()); // Add users too
9599 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, VecVT, &Ops[0], Ops.size());
9602 AddToWorkList(BV.getNode());
9604 return DAG.getNode(ISD::BITCAST, dl, VT, BV);
9667 SDValue BV = DAG.getNode(ISD::BUILD_VECTOR, dl, NVT,
9669 AddToWorkList(BV.getNode());
9671 return DAG.getNode(Opcode, dl, VT, BV);
9684 if (V.getNode())
9688 if (V.getNode())
9718 if (VecIn1.getNode() == 0) {
9720 } else if (VecIn2.getNode() == 0) {
9730 if (VecIn1.getNode()) {
9759 if (VecIn2.getNode() != 0)
9774 VecIn1 = DAG.getNode(ISD::CONCAT_VECTORS, dl, VT,
9779 VecIn2 = VecIn2.getNode() ? VecIn2 : DAG.getUNDEF(VT);
9837 SDValue Res = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NVT, Scalar);
9838 return DAG.getNode(ISD::BITCAST, dl, VT, Res);
9860 if (SingleSource.getNode()) {
9884 if (SingleSource.getNode())
9937 return DAG.getNode(ISD::BITCAST, dl, NVT, V->getOperand(1));
9938 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT,
9939 DAG.getNode(ISD::BITCAST, dl,
9996 return DAG.getNode(ISD::CONCAT_VECTORS, SDLoc(N), VT, Ops.data(),
10063 SDNode *V = N0.getNode();
10072 V = ConvInput.getNode();
10087 if (!Base.getNode())
10108 if (V.getNode())
10185 SDValue Zero = DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N),
10187 LHS = DAG.getNode(ISD::BITCAST, dl, RVT, LHS);
10189 return DAG.getNode(ISD::BITCAST, dl, VT, Shuf);
10204 if (Shuffle.getNode()) return Shuffle;
10227 cast<ConstantSDNode>(RHSOp.getNode())->isNullValue()) ||
10229 cast<ConstantFPSDNode>(RHSOp.getNode())->getValueAPF().isZero()))
10241 RHSOp = DAG.getNode(ISD::TRUNCATE, SDLoc(N), VT, RHSOp);
10243 LHSOp = DAG.getNode(ISD::TRUNCATE, SDLoc(N), RVT, LHSOp);
10247 SDValue FoldOp = DAG.getNode(N->getOpcode(), SDLoc(LHS), VT,
10254 AddToWorkList(FoldOp.getNode());
10258 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N),
10283 SDValue FoldOp = DAG.getNode(N->getOpcode(), SDLoc(N0), EltVT, Op);
10288 AddToWorkList(FoldOp.getNode());
10294 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N),
10308 if (SCC.getNode()) {
10312 SDValue SETCC = DAG.getNode(ISD::SETCC, SDLoc(N0),
10316 AddToWorkList(SETCC.getNode());
10379 SDNode *CondNode = TheSelect->getOperand(0).getNode();
10392 SDNode *CondLHS = TheSelect->getOperand(0).getNode();
10393 SDNode *CondRHS = TheSelect->getOperand(1).getNode();
10401 Addr = DAG.getNode(ISD::SELECT_CC, SDLoc(TheSelect),
10433 CombineTo(LHS.getNode(), Load.getValue(0), Load.getValue(1));
10434 CombineTo(RHS.getNode(), Load.getValue(0), Load.getValue(1));
10450 ConstantSDNode *N1C = dyn_cast<ConstantSDNode>(N1.getNode());
10451 ConstantSDNode *N2C = dyn_cast<ConstantSDNode>(N2.getNode());
10452 ConstantSDNode *N3C = dyn_cast<ConstantSDNode>(N3.getNode());
10457 if (SCC.getNode()) AddToWorkList(SCC.getNode());
10458 ConstantSDNode *SCCC = dyn_cast_or_null<ConstantSDNode>(SCC.getNode());
10475 return DAG.getNode(ISD::FABS, DL, VT, N0);
10481 return DAG.getNode(ISD::FABS, DL, VT, N3);
10523 AddToWorkList(Cond.getNode());
10526 AddToWorkList(CstOffset.getNode());
10527 CPIdx = DAG.getNode(ISD::ADD, DL, CPIdx.getValueType(), CPIdx,
10529 AddToWorkList(CPIdx.getNode());
10552 SDValue Shift = DAG.getNode(ISD::SRL, SDLoc(N0),
10554 AddToWorkList(Shift.getNode());
10557 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
10558 AddToWorkList(Shift.getNode());
10561 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
10564 SDValue Shift = DAG.getNode(ISD::SRA, SDLoc(N0),
10568 AddToWorkList(Shift.getNode());
10571 Shift = DAG.getNode(ISD::TRUNCATE, DL, AType, Shift);
10572 AddToWorkList(Shift.getNode());
10575 return DAG.getNode(ISD::AND, DL, AType, Shift, N2);
10597 SDValue Shl = DAG.getNode(ISD::SHL, SDLoc(N0), VT, AndLHS, ShlAmt);
10604 SDValue Shr = DAG.getNode(ISD::SRA, SDLoc(N0), VT, Shl, ShrAmt);
10606 return DAG.getNode(ISD::AND, DL, VT, Shr, N3);
10634 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2),
10638 Temp = DAG.getNode(ISD::ZERO_EXTEND, SDLoc(N2),
10642 AddToWorkList(SCC.getNode());
10643 AddToWorkList(Temp.getNode());
10649 return DAG.getNode(
10665 Res = DAG.getNode(ISD::ZERO_EXTEND, DL, VT, Res);
10673 SDValue Ctlz = DAG.getNode(ISD::CTLZ, SDLoc(N0), XType, N0);
10674 return DAG.getNode(ISD::SRL, DL, XType, Ctlz,
10680 SDValue NegN0 = DAG.getNode(ISD::SUB, SDLoc(N0),
10683 return DAG.getNode(ISD::SRL, DL, XType,
10684 DAG.getNode(ISD::AND, DL, XType, NegN0, NotN0),
10690 SDValue Sign = DAG.getNode(ISD::SRL, SDLoc(N0), XType, N0,
10693 return DAG.getNode(ISD::XOR, DL, XType, Sign, DAG.getConstant(1, XType));
10716 SDValue Shift = DAG.getNode(ISD::SRA, SDLoc(N0), XType,
10720 SDValue Add = DAG.getNode(ISD::ADD, SDLoc(N0),
10722 AddToWorkList(Shift.getNode());
10723 AddToWorkList(Add.getNode());
10724 return DAG.getNode(ISD::XOR, DL, XType, Add, Shift);
10966 if (!Visited.insert(Chain.getNode()))
10984 bool IsOpLoad = FindAliasInfo(Chain.getNode(), OpPtr, OpSize,
11008 // likelihood that getNode will find a matching token factor (CSE.)
11043 return DAG.getNode(ISD::TokenFactor, SDLoc(N), MVT::Other,