Lines Matching refs:SDValue
64 SDValue Chain;
65 SDValue FloatPtr;
66 SDValue IntPtr;
69 SDValue IntValue;
114 SDValue OptimizeFloatStore(StoreSDNode *ST);
123 SDValue PerformInsertVectorEltInMemory(SDValue Vec, SDValue Val, SDValue Idx,
125 SDValue ExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val, SDValue Idx,
132 SDValue ShuffleWithNarrowerEltType(EVT NVT, EVT VT, const SDLoc &dl,
133 SDValue N1, SDValue N2,
136 bool LegalizeSetCCCondCode(EVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC,
137 bool &NeedInvert, const SDLoc &dl, SDValue &Chain,
140 SDValue ExpandLibCall(RTLIB::Libcall LC, SDNode *Node, bool isSigned);
146 SmallVectorImpl<SDValue> &Results);
147 SDValue ExpandIntLibCall(SDNode *Node, bool isSigned,
157 SmallVectorImpl<SDValue> &Results);
158 void ExpandDivRemLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results);
159 void ExpandSinCosLibCall(SDNode *Node, SmallVectorImpl<SDValue> &Results);
161 SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT,
163 SDValue EmitStackConvert(SDValue SrcOp, EVT SlotVT, EVT DestVT,
164 const SDLoc &dl, SDValue ChainIn);
165 SDValue ExpandBUILD_VECTOR(SDNode *Node);
166 SDValue ExpandSPLAT_VECTOR(SDNode *Node);
167 SDValue ExpandSCALAR_TO_VECTOR(SDNode *Node);
169 SmallVectorImpl<SDValue> &Results);
171 SDValue Value) const;
172 SDValue modifySignAsInt(const FloatSignAsInt &State, const SDLoc &DL,
173 SDValue NewIntValue) const;
174 SDValue ExpandFCOPYSIGN(SDNode *Node) const;
175 SDValue ExpandFABS(SDNode *Node) const;
176 SDValue ExpandLegalINT_TO_FP(SDNode *Node, SDValue &Chain);
178 SmallVectorImpl<SDValue> &Results);
180 SmallVectorImpl<SDValue> &Results);
182 SDValue ExpandBITREVERSE(SDValue Op, const SDLoc &dl);
183 SDValue ExpandBSWAP(SDValue Op, const SDLoc &dl);
185 SDValue ExpandExtractFromVectorThroughStack(SDValue Op);
186 SDValue ExpandInsertToVectorThroughStack(SDValue Op);
187 SDValue ExpandVectorBuildThroughStack(SDNode* Node);
189 SDValue ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP);
190 SDValue ExpandConstant(ConstantSDNode *CP);
219 void ReplaceNode(SDValue Old, SDValue New) {
229 void ReplaceNode(SDNode *Old, const SDValue *New) {
242 void ReplaceNodeWithValue(SDValue Old, SDValue New) {
259 SDValue SelectionDAGLegalize::ShuffleWithNarrowerEltType(
260 EVT NVT, EVT VT, const SDLoc &dl, SDValue N1, SDValue N2,
288 SDValue
329 SDValue CPIdx =
333 SDValue Result = DAG.getExtLoad(
339 SDValue Result = DAG.getLoad(
346 SDValue SelectionDAGLegalize::ExpandConstant(ConstantSDNode *CP) {
349 SDValue CPIdx = DAG.getConstantPool(CP->getConstantIntValue(),
352 SDValue Result = DAG.getLoad(
362 SDValue SelectionDAGLegalize::PerformInsertVectorEltInMemory(SDValue Vec,
363 SDValue Val,
364 SDValue Idx,
366 SDValue Tmp1 = Vec;
367 SDValue Tmp2 = Val;
368 SDValue Tmp3 = Idx;
378 SDValue StackPtr = DAG.CreateStackTemporary(VT);
383 SDValue Ch = DAG.getStore(
387 SDValue StackPtr2 = TLI.getVectorElementPointer(DAG, StackPtr, VT, Tmp3);
398 SDValue SelectionDAGLegalize::ExpandINSERT_VECTOR_ELT(SDValue Vec, SDValue Val,
399 SDValue Idx,
408 SDValue ScVec = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl,
425 SDValue SelectionDAGLegalize::OptimizeFloatStore(StoreSDNode* ST) {
427 return SDValue();
437 SDValue Chain = ST->getChain();
438 SDValue Ptr = ST->getBasePtr();
445 SDValue Con = DAG.getConstant(CFP->getValueAPF().
455 SDValue Con = DAG.getConstant(CFP->getValueAPF().bitcastToAPInt().
466 SDValue Lo = DAG.getConstant(IntVal.trunc(32), dl, MVT::i32);
467 SDValue Hi = DAG.getConstant(IntVal.lshr(32).trunc(32), dl, MVT::i32);
482 return SDValue(nullptr, 0);
487 SDValue Chain = ST->getChain();
488 SDValue Ptr = ST->getBasePtr();
501 SDValue Value = ST->getValue();
513 SDValue Result = TLI.expandUnalignedStore(ST, DAG);
514 ReplaceNode(SDValue(ST, 0), Result);
521 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
522 if (Res && Res != SDValue(Node, 0))
523 ReplaceNode(SDValue(Node, 0), Res);
531 SDValue Result = DAG.getStore(Chain, dl, Value, Ptr, ST->getPointerInfo(),
533 ReplaceNode(SDValue(Node, 0), Result);
541 SDValue Value = ST->getValue();
553 SDValue Result =
556 ReplaceNode(SDValue(Node, 0), Result);
570 SDValue Lo, Hi;
611 SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
612 ReplaceNode(SDValue(Node, 0), Result);
622 SDValue Result = TLI.expandUnalignedStore(ST, DAG);
623 ReplaceNode(SDValue(ST, 0), Result);
628 SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG);
629 if (Res && Res != SDValue(Node, 0))
630 ReplaceNode(SDValue(Node, 0), Res);
637 SDValue Result;
655 ReplaceNode(SDValue(Node, 0), Result);
663 SDValue Chain = LD->getChain(); // The chain.
664 SDValue Ptr = LD->getBasePtr(); // The base pointer.
665 SDValue Value; // The value returned by the load op.
672 SDValue RVal = SDValue(Node, 0);
673 SDValue RChain = SDValue(Node, 1);
689 if (SDValue Res = TLI.LowerOperation(RVal, DAG)) {
700 SDValue Res = DAG.getLoad(NVT, dl, Chain, Ptr, LD->getMemOperand());
708 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), RVal);
709 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), RChain);
740 SDValue Ch;
748 SDValue Result = DAG.getExtLoad(NewExtType, dl, Node->getValueType(0),
780 SDValue Lo, Hi, Ch;
851 Value = SDValue(Node, 0);
852 Chain = SDValue(Node, 1);
855 if (SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG)) {
884 SDValue Load = DAG.getExtLoad(MidExtType, dl, LoadVT, Chain, Ptr,
902 SDValue Result = DAG.getExtLoad(ISD::ZEXTLOAD, dl, ILoadVT, Chain,
921 SDValue Result = DAG.getExtLoad(ISD::EXTLOAD, dl,
925 SDValue ValRes;
943 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Value);
944 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Chain);
968 for (const SDValue &Op : Node->op_values())
1110 SDValue NewVal;
1182 SDValue Op0 = Node->getOperand(0);
1183 SDValue Op1 = Node->getOperand(1);
1185 SDValue SAO = DAG.getShiftAmountOperand(Op0.getValueType(), Op1);
1203 SDValue Op0 = Node->getOperand(0);
1204 SDValue Op1 = Node->getOperand(1);
1205 SDValue Op2 = Node->getOperand(2);
1207 SDValue SAO = DAG.getShiftAmountOperand(Op0.getValueType(), Op2);
1230 if (SDValue Res = TLI.LowerOperation(SDValue(Node, 0), DAG)) {
1237 ReplaceNode(SDValue(Node, 0), Res);
1241 SmallVector<SDValue, 8> ResultVals;
1282 SDValue SelectionDAGLegalize::ExpandExtractFromVectorThroughStack(SDValue Op) {
1283 SDValue Vec = Op.getOperand(0);
1284 SDValue Idx = Op.getOperand(1);
1299 SDValue StackPtr, Ch;
1323 Ch = SDValue(ST, 0);
1339 SDValue NewLoad;
1350 DAG.ReplaceAllUsesOfValueWith(Ch, SDValue(NewLoad.getNode(), 1));
1354 SmallVector<SDValue, 6> NewLoadOperands(NewLoad->op_begin(),
1358 SDValue(DAG.UpdateNodeOperands(NewLoad.getNode(), NewLoadOperands), 0);
1362 SDValue SelectionDAGLegalize::ExpandInsertToVectorThroughStack(SDValue Op) {
1365 SDValue Vec = Op.getOperand(0);
1366 SDValue Part = Op.getOperand(1);
1367 SDValue Idx = Op.getOperand(2);
1372 SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
1378 SDValue Ch = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr, PtrInfo);
1381 SDValue SubStackPtr = TLI.getVectorElementPointer(DAG, StackPtr, VecVT, Idx);
1392 SDValue SelectionDAGLegalize::ExpandVectorBuildThroughStack(SDNode* Node) {
1405 SDValue FIPtr = DAG.CreateStackTemporary(VT);
1411 SmallVector<SDValue, 8> Stores;
1421 SDValue Idx = DAG.getMemBasePlusOffset(FIPtr, Offset, dl);
1434 SDValue StoreChain;
1449 SDValue Value) const {
1466 SDValue StackPtr = DAG.CreateStackTemporary(FloatVT, LoadTy);
1475 SDValue IntPtr;
1498 SDValue SelectionDAGLegalize::modifySignAsInt(const FloatSignAsInt &State,
1500 SDValue NewIntValue) const {
1505 SDValue Chain = DAG.getTruncStore(State.Chain, DL, NewIntValue, State.IntPtr,
1511 SDValue SelectionDAGLegalize::ExpandFCOPYSIGN(SDNode *Node) const {
1513 SDValue Mag = Node->getOperand(0);
1514 SDValue Sign = Node->getOperand(1);
1521 SDValue SignMask = DAG.getConstant(SignAsInt.SignMask, DL, IntVT);
1522 SDValue SignBit = DAG.getNode(ISD::AND, DL, IntVT, SignAsInt.IntValue,
1529 SDValue AbsValue = DAG.getNode(ISD::FABS, DL, FloatVT, Mag);
1530 SDValue NegValue = DAG.getNode(ISD::FNEG, DL, FloatVT, AbsValue);
1531 SDValue Cond = DAG.getSetCC(DL, getSetCCResultType(IntVT), SignBit,
1540 SDValue ClearSignMask = DAG.getConstant(~MagAsInt.SignMask, DL, MagVT);
1541 SDValue ClearedSign = DAG.getNode(ISD::AND, DL, MagVT, MagAsInt.IntValue,
1552 SDValue ShiftCnst = DAG.getConstant(ShiftAmount, DL, ShiftVT);
1555 SDValue ShiftCnst = DAG.getConstant(-ShiftAmount, DL, ShiftVT);
1563 SDValue CopiedSign = DAG.getNode(ISD::OR, DL, MagVT, ClearedSign, SignBit);
1567 SDValue SelectionDAGLegalize::ExpandFABS(SDNode *Node) const {
1569 SDValue Value = Node->getOperand(0);
1574 SDValue Zero = DAG.getConstantFP(0.0, DL, FloatVT);
1582 SDValue ClearSignMask = DAG.getConstant(~ValueAsInt.SignMask, DL, IntVT);
1583 SDValue ClearedSign = DAG.getNode(ISD::AND, DL, IntVT, ValueAsInt.IntValue,
1589 SmallVectorImpl<SDValue> &Results) {
1595 SDValue Tmp1 = SDValue(Node, 0);
1596 SDValue Tmp2 = SDValue(Node, 1);
1597 SDValue Tmp3 = Node->getOperand(2);
1598 SDValue Chain = Tmp1.getOperand(0);
1604 SDValue Size = Tmp2.getOperand(1);
1605 SDValue SP = DAG.getCopyFromReg(Chain, dl, SPReg, VT);
1621 DAG.getIntPtrConstant(0, dl, true), SDValue(), dl);
1631 /// will be stored in LHS. RHS and CC will be set to SDValue(). NeedInvert
1646 EVT VT, SDValue &LHS, SDValue &RHS, SDValue &CC, bool &NeedInvert,
1647 const SDLoc &dl, SDValue &Chain, bool IsSignaling) {
1726 SDValue SetCC1, SetCC2;
1741 RHS = SDValue();
1742 CC = SDValue();
1753 SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, EVT SlotVT,
1758 SDValue SelectionDAGLegalize::EmitStackConvert(SDValue SrcOp, EVT SlotVT,
1760 SDValue Chain) {
1764 SDValue FIPtr = DAG.CreateStackTemporary(SlotVT, SrcAlign);
1779 SDValue Store;
1799 SDValue SelectionDAGLegalize::ExpandSCALAR_TO_VECTOR(SDNode *Node) {
1803 SDValue StackPtr = DAG.CreateStackTemporary(Node->getValueType(0));
1808 SDValue Ch = DAG.getTruncStore(
1819 const TargetLowering &TLI, SDValue &Res) {
1832 SmallVector<std::pair<SDValue, SmallVector<int, 16>>, 16> IntermedVals,
1835 SDValue V = Node->getOperand(i);
1839 SDValue Vec;
1868 SDValue Shuffle;
1889 SDValue Vec1 = IntermedVals[0].first;
1890 SDValue Vec2;
1913 SDValue SelectionDAGLegalize::ExpandBUILD_VECTOR(SDNode *Node) {
1915 SDValue Value1, Value2;
1927 SDValue V = Node->getOperand(i);
1977 SDValue CPIdx =
1986 SmallSet<SDValue, 16> DefinedValues;
1997 SDValue V = Node->getOperand(i);
2004 SDValue Vec1 = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Value1);
2005 SDValue Vec2;
2015 SDValue Res;
2025 SDValue SelectionDAGLegalize::ExpandSPLAT_VECTOR(SDNode *Node) {
2028 SDValue SplatVal = Node->getOperand(0);
2037 SDValue SelectionDAGLegalize::ExpandLibCall(RTLIB::Libcall LC, SDNode *Node,
2041 for (const SDValue &Op : Node->op_values()) {
2050 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2060 SDValue InChain = DAG.getEntryNode();
2064 SDValue TCChain = InChain;
2083 std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
2101 SmallVectorImpl<SDValue> &Results) {
2114 SmallVector<SDValue, 4> Ops(Node->op_begin() + 1, Node->op_end());
2117 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, RetVT,
2124 SDValue Tmp = ExpandLibCall(LC, Node, false);
2129 SDValue SelectionDAGLegalize::ExpandIntLibCall(SDNode* Node, bool isSigned,
2155 SmallVectorImpl<SDValue> &Results) {
2170 SmallVector<SDValue, 4> Ops(Node->op_begin() + 1, Node->op_end());
2173 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, RetVT,
2180 SDValue Tmp = ExpandLibCall(LC, Node, false);
2188 SmallVectorImpl<SDValue> &Results) {
2205 SDValue InChain = DAG.getEntryNode();
2212 for (const SDValue &Op : Node->op_values()) {
2223 SDValue FIPtr = DAG.CreateStackTemporary(RetVT);
2230 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2242 std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
2245 SDValue Rem =
2270 SDValue Op0 = Node->getOperand(0);
2286 SmallVectorImpl<SDValue> &Results) {
2300 SDValue InChain = DAG.getEntryNode();
2316 SDValue SinPtr = DAG.CreateStackTemporary(RetVT);
2324 SDValue CosPtr = DAG.CreateStackTemporary(RetVT);
2331 SDValue Callee = DAG.getExternalSymbol(TLI.getLibcallName(LC),
2340 std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
2352 SDValue SelectionDAGLegalize::ExpandLegalINT_TO_FP(SDNode *Node,
2353 SDValue &Chain) {
2359 SDValue Op0 = Node->getOperand(OpNo);
2369 SDValue StackSlot = DAG.CreateStackTemporary(MVT::f64);
2371 SDValue Lo = Op0;
2379 SDValue Hi = DAG.getConstant(0x43300000u, dl, MVT::i32);
2385 SDValue MemChain = DAG.getEntryNode();
2388 SDValue Store1 = DAG.getStore(MemChain, dl, Lo, StackSlot,
2391 SDValue HiPtr = DAG.getMemBasePlusOffset(StackSlot, 4, dl);
2392 SDValue Store2 =
2397 SDValue Load =
2400 SDValue Bias = DAG.getConstantFP(isSigned ?
2405 SDValue Sub;
2406 SDValue Result;
2412 std::pair<SDValue, SDValue> ResultPair;
2442 SDValue SignBitTest = DAG.getSetCC(
2446 SDValue ShiftConst = DAG.getConstant(1, dl, ShiftVT);
2447 SDValue Shr = DAG.getNode(ISD::SRL, dl, SrcVT, Op0, ShiftConst);
2448 SDValue AndConst = DAG.getConstant(1, dl, SrcVT);
2449 SDValue And = DAG.getNode(ISD::AND, dl, SrcVT, Op0, AndConst);
2450 SDValue Or = DAG.getNode(ISD::OR, dl, SrcVT, And, Shr);
2452 SDValue Slow, Fast;
2456 SDValue InCvt = DAG.getSelect(dl, SrcVT, SignBitTest, Or, Op0);
2471 SDValue SignCvt = DAG.getNode(ISD::SINT_TO_FP, dl, DestVT, Or);
2486 SDValue Tmp1;
2493 SDValue SignSet = DAG.getSetCC(dl, getSetCCResultType(SrcVT), Op0,
2495 SDValue Zero = DAG.getIntPtrConstant(0, dl),
2497 SDValue CstOffset = DAG.getSelect(dl, Zero.getValueType(),
2516 SDValue CPIdx =
2521 SDValue FudgeInReg;
2528 SDValue Load = DAG.getExtLoad(
2538 SDValue Result = DAG.getNode(ISD::STRICT_FADD, dl, { DestVT, MVT::Other },
2553 SDNode *N, const SDLoc &dl, SmallVectorImpl<SDValue> &Results) {
2558 SDValue LegalOp = N->getOperand(IsStrict ? 1 : 0);
2592 SDValue Res =
2614 SmallVectorImpl<SDValue> &Results) {
2619 SDValue LegalOp = N->getOperand(IsStrict ? 1 : 0);
2645 SDValue Operation;
2654 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, DestVT, Operation);
2661 SDValue SelectionDAGLegalize::ExpandBITREVERSE(SDValue Op, const SDLoc &dl) {
2666 SDValue Tmp, Tmp2, Tmp3;
2725 SDValue SelectionDAGLegalize::ExpandBSWAP(SDValue Op, const SDLoc &dl) {
2728 SDValue Tmp1, Tmp2, Tmp3, Tmp4, Tmp5, Tmp6, Tmp7, Tmp8;
2778 SmallVector<SDValue, 8> Results;
2780 SDValue Tmp1, Tmp2, Tmp3, Tmp4;
2813 SDValue CfaArg = DAG.getSExtOrTrunc(Node->getOperand(0), dl,
2815 SDValue Offset = DAG.getNode(ISD::ADD, dl,
2820 SDValue FA = DAG.getNode(
2855 SDValue Zero = DAG.getConstant(0, dl, Node->getValueType(0));
2857 SDValue Swap = DAG.getAtomicCmpSwap(
2867 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
2880 SDValue Res = DAG.getAtomicCmpSwap(
2885 SDValue ExtRes = Res;
2886 SDValue LHS = Res;
2887 SDValue RHS = Node->getOperand(1);
2913 SDValue Success =
3001 SDValue One = DAG.getConstant(1, dl, VT);
3002 SDValue And = DAG.getNode(ISD::AND, dl, VT, Node->getOperand(0), One);
3003 SDValue Zero = DAG.getConstant(0, dl, VT);
3004 SDValue Neg = DAG.getNode(ISD::SUB, dl, VT, Zero, And);
3014 SDValue ShiftCst = DAG.getConstant(BitsDiff, dl, ShiftAmountTy);
3055 DAG.ReplaceAllUsesOfValueWith(SDValue(Node,1), Tmp2);
3057 ReplaceNodeWithValue(SDValue(Node, 0), Tmp1);
3075 Tmp1 = ExpandExtractFromVectorThroughStack(SDValue(Node, 0));
3079 Results.push_back(ExpandExtractFromVectorThroughStack(SDValue(Node, 0)));
3082 Results.push_back(ExpandInsertToVectorThroughStack(SDValue(Node, 0)));
3101 SDValue Op0 = Node->getOperand(0);
3102 SDValue Op1 = Node->getOperand(1);
3147 SmallVector<SDValue, 16> Ops;
3248 if (SDValue Expanded = TLI.expandFMINNUM_FMAXNUM(Node, DAG))
3276 SDValue Res =
3287 SDValue Res =
3300 SDValue Op = Node->getOperand(0);
3306 SDValue FloatVal = DAG.getNode(ISD::FP_ROUND, dl, MVT::f32, Op,
3382 SDValue LHS = Node->getOperand(0);
3383 SDValue RHS = Node->getOperand(1);
3394 SmallVector<SDValue, 4> Halves;
3401 SDValue Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Halves[2 * i]);
3402 SDValue Hi = DAG.getNode(ISD::ANY_EXTEND, dl, VT, Halves[2 * i + 1]);
3403 SDValue Shift = DAG.getConstant(
3441 SDValue Lo, Hi;
3451 SDValue Shift =
3485 if (SDValue V = TLI.expandFixedPointDiv(Node->getOpcode(), SDLoc(Node),
3503 SDValue LHS = Node->getOperand(0);
3504 SDValue RHS = Node->getOperand(1);
3505 SDValue Carry = Node->getOperand(2);
3512 SDValue Sum = DAG.getNode(Op, dl, VT, LHS, RHS);
3518 SDValue Overflow = DAG.getSetCC(dl, SetCCType, Sum, LHS, CC);
3521 SDValue One = DAG.getConstant(1, dl, VT);
3522 SDValue CarryExt =
3524 SDValue Sum2 = DAG.getNode(Op, dl, VT, Sum, CarryExt);
3530 SDValue Zero = DAG.getConstant(0, dl, VT);
3531 SDValue Overflow2 =
3537 SDValue ResultCarry =
3546 SDValue Result, Overflow;
3554 SDValue Result, Overflow;
3562 SDValue Result, Overflow;
3597 SDValue Chain = Node->getOperand(0);
3598 SDValue Table = Node->getOperand(1);
3599 SDValue Index = Node->getOperand(2);
3618 SDValue Addr = DAG.getNode(ISD::ADD, dl, Index.getValueType(),
3622 SDValue LD = DAG.getExtLoad(
3670 SDValue Chain = IsStrict ? Node->getOperand(0) : SDValue();
3730 SDValue Chain;
3731 SDValue CC = Node->getOperand(4);
3742 SDValue Cond = DAG.getNode(ISD::SETCC, dl, CCVT, Tmp1, Tmp2, CC, Node->getFlags());
3800 SDValue Chain;
3843 SmallVector<SDValue, 8> Scalars;
3845 SDValue Ex =
3848 SDValue Sh =
3855 SDValue Result = DAG.getBuildVector(Node->getValueType(0), dl, Scalars);
3929 SmallVector<SDValue, 8> Results;
3948 std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
3974 SmallVector<SDValue, 4> Ops(Node->op_begin() + 1, Node->op_end());
3976 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, RetVT,
3994 std::pair<SDValue, SDValue> CallResult = TLI.LowerCallTo(CLI);
4124 SDValue Exponent = DAG.getNode(ISD::SINT_TO_FP, SDLoc(Node),
4208 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(
4229 std::pair<SDValue, SDValue> Tmp =
4314 SmallVector<SDValue, 8> Results;
4330 SDValue Tmp1, Tmp2, Tmp3;
4391 SDValue Chain = Node->getOperand(0); // Get the chain.
4392 SDValue Ptr = Node->getOperand(1); // Get the pointer.
4412 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 0), Tmp2);
4413 DAG.ReplaceAllUsesOfValueWith(SDValue(Node, 1), Chain);
4654 SmallVector<SDValue, 8> NewOps;
4656 SDValue Op = Node->getOperand(I);
4661 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, SL, NVT, NewOps);
4662 SDValue CvtVec = DAG.getNode(ISD::BITCAST, SL, OVT, Concat);
4688 SDValue Idx = Node->getOperand(1);
4691 SDValue Factor = DAG.getConstant(NewEltsPerOldElt, SL, IdxVT);
4692 SDValue NewBaseIdx = DAG.getNode(ISD::MUL, SL, IdxVT, Idx, Factor);
4694 SDValue CastVec = DAG.getNode(ISD::BITCAST, SL, NVT, Node->getOperand(0));
4696 SmallVector<SDValue, 8> NewOps;
4698 SDValue IdxOffset = DAG.getConstant(I, SL, IdxVT);
4699 SDValue TmpIdx = DAG.getNode(ISD::ADD, SL, IdxVT, NewBaseIdx, IdxOffset);
4701 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, NewEltVT,
4706 SDValue NewVec = DAG.getBuildVector(MidVT, SL, NewOps);
4734 SDValue Val = Node->getOperand(1);
4735 SDValue Idx = Node->getOperand(2);
4739 SDValue Factor = DAG.getConstant(NewEltsPerOldElt, SDLoc(), IdxVT);
4740 SDValue NewBaseIdx = DAG.getNode(ISD::MUL, SL, IdxVT, Idx, Factor);
4742 SDValue CastVec = DAG.getNode(ISD::BITCAST, SL, NVT, Node->getOperand(0));
4743 SDValue CastVal = DAG.getNode(ISD::BITCAST, SL, MidVT, Val);
4745 SDValue NewVec = CastVec;
4747 SDValue IdxOffset = DAG.getConstant(I, SL, IdxVT);
4748 SDValue InEltIdx = DAG.getNode(ISD::ADD, SL, IdxVT, NewBaseIdx, IdxOffset);
4750 SDValue Elt = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SL, NewEltVT,
4772 SDValue Val = Node->getOperand(0);
4775 SDValue CastVal = DAG.getNode(ISD::BITCAST, SL, MidVT, Val);
4776 SDValue Undef = DAG.getUNDEF(MidVT);
4778 SmallVector<SDValue, 8> NewElts;
4783 SDValue Concat = DAG.getNode(ISD::CONCAT_VECTORS, SL, NVT, NewElts);
4784 SDValue CvtVec = DAG.getNode(ISD::BITCAST, SL, OVT, Concat);
4791 SDValue CastVal = DAG.getNode(ISD::BITCAST, SL, NVT, AM->getVal());
4797 SDValue NewAtomic