Lines Matching refs:DAG
37 N->dump(&DAG);
45 N->dump(&DAG);
138 return DAG.getNode(N->getOpcode(), SDLoc(N),
146 return DAG.getNode(N->getOpcode(), SDLoc(N),
158 return DAG.getNode(ISD::BITCAST, SDLoc(N),
168 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, InOp);
175 return DAG.getConvertRndSat(NewVT, SDLoc(N),
176 Op0, DAG.getValueType(NewVT),
177 DAG.getValueType(Op0.getValueType()),
184 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
192 return DAG.getNode(ISD::FP_ROUND, SDLoc(N),
198 return DAG.getNode(ISD::FPOWI, SDLoc(N),
209 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, Op);
216 SDValue Result = DAG.getLoad(ISD::UNINDEXED,
221 DAG.getUNDEF(N->getBasePtr().getValueType()),
238 return DAG.getNode(N->getOpcode(), SDLoc(N), DestVT, Op);
245 return DAG.getNode(N->getOpcode(), SDLoc(N), EltVT,
246 LHS, DAG.getValueType(ExtVT));
255 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, InOp);
291 Cond = DAG.getNode(ISD::AND, SDLoc(N), CondVT,
292 Cond, DAG.getConstant(1, CondVT));
298 Cond = DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), CondVT,
299 Cond, DAG.getValueType(MVT::i1));
304 return DAG.getSelect(SDLoc(N),
311 return DAG.getSelect(SDLoc(N),
318 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), LHS.getValueType(),
336 return DAG.getNode(ISD::SETCC, DL, MVT::i1, LHS, RHS, N->getOperand(2));
340 return DAG.getUNDEF(N->getValueType(0).getVectorElementType());
347 return DAG.getUNDEF(N->getValueType(0).getVectorElementType());
368 LHS = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, LHS,
369 DAG.getConstant(0, TLI.getVectorIdxTy()));
370 RHS = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, VT, RHS,
371 DAG.getConstant(0, TLI.getVectorIdxTy()));
375 SDValue Res = DAG.getNode(ISD::SETCC, DL, MVT::i1, LHS, RHS,
381 return DAG.getNode(ExtendCode, DL, NVT, Res);
391 N->dump(&DAG);
400 N->dump(&DAG);
450 return DAG.getNode(ISD::BITCAST, SDLoc(N),
460 SDValue Op = DAG.getNode(N->getOpcode(), SDLoc(N),
464 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), N->getValueType(0), Op);
473 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), N->getValueType(0), Ops);
482 Res = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), N->getValueType(0),
495 return DAG.getNode(ISD::SELECT, SDLoc(N), VT, ScalarCond, N->getOperand(1),
507 return DAG.getTruncStore(N->getChain(), dl,
514 return DAG.getStore(N->getChain(), dl, GetScalarizedVector(N->getOperand(1)),
524 SDValue Res = DAG.getNode(ISD::FP_ROUND, SDLoc(N),
527 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N), N->getValueType(0), Res);
541 N->dump(&DAG);
553 N->dump(&DAG);
663 Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo, RHSLo);
664 Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi, RHSHi);
677 Lo = DAG.getNode(N->getOpcode(), dl, Op0Lo.getValueType(),
679 Hi = DAG.getNode(N->getOpcode(), dl, Op0Hi.getValueType(),
688 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
711 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
712 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
720 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
721 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
726 EVT LoIntVT = EVT::getIntegerVT(*DAG.getContext(), LoVT.getSizeInBits());
727 EVT HiIntVT = EVT::getIntegerVT(*DAG.getContext(), HiVT.getSizeInBits());
735 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
736 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
743 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
746 Lo = DAG.getNode(ISD::BUILD_VECTOR, dl, LoVT, LoOps);
749 Hi = DAG.getNode(ISD::BUILD_VECTOR, dl, HiVT, HiOps);
764 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
767 Lo = DAG.getNode(ISD::CONCAT_VECTORS, dl, LoVT, LoOps);
770 Hi = DAG.getNode(ISD::CONCAT_VECTORS, dl, HiVT, HiOps);
780 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
782 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, LoVT, Vec, Idx);
784 Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, HiVT, Vec,
785 DAG.getConstant(IdxVal + LoVT.getVectorNumElements(),
800 SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
801 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
806 Type *VecType = VecVT.getTypeForEVT(*DAG.getContext());
808 Store = DAG.getStore(Store, dl, SubVec, SubVecPtr, MachinePointerInfo(),
812 Lo = DAG.getLoad(Lo.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
818 DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
819 DAG.getConstant(IncrementSize, StackPtr.getValueType()));
822 Hi = DAG.getLoad(Hi.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
830 Lo = DAG.getNode(ISD::FPOWI, dl, Lo.getValueType(), Lo, N->getOperand(1));
831 Hi = DAG.getNode(ISD::FPOWI, dl, Hi.getValueType(), Hi, N->getOperand(1));
842 DAG.GetSplitDestVTs(cast<VTSDNode>(N->getOperand(1))->getVT());
844 Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo,
845 DAG.getValueType(LoVT));
846 Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi,
847 DAG.getValueType(HiVT));
862 Lo = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
865 Hi = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, Hi.getValueType(), Hi, Elt,
866 DAG.getConstant(IdxVal - LoNumElts,
874 SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
875 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
881 Type *VecType = VecVT.getTypeForEVT(*DAG.getContext());
884 Store = DAG.getTruncStore(Store, dl, Elt, EltPtr, MachinePointerInfo(), EltVT,
888 Lo = DAG.getLoad(Lo.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
893 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
894 DAG.getConstant(IncrementSize, StackPtr.getValueType()));
897 Hi = DAG.getLoad(Hi.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
905 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
906 Lo = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoVT, N->getOperand(0));
907 Hi = DAG.getUNDEF(HiVT);
915 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(LD->getValueType(0));
920 SDValue Offset = DAG.getUNDEF(Ptr.getValueType());
929 std::tie(LoMemVT, HiMemVT) = DAG.GetSplitDestVTs(MemoryVT);
931 Lo = DAG.getLoad(ISD::UNINDEXED, ExtType, LoVT, dl, Ch, Ptr, Offset,
936 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
937 DAG.getConstant(IncrementSize, Ptr.getValueType()));
938 Hi = DAG.getLoad(ISD::UNINDEXED, ExtType, HiVT, dl, Ch, Ptr, Offset,
945 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
960 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
964 std::tie(LL, LH) = DAG.SplitVectorOperand(N, 0);
965 std::tie(RL, RH) = DAG.SplitVectorOperand(N, 1);
967 Lo = DAG.getNode(N->getOpcode(), DL, LoVT, LL, RL, N->getOperand(2));
968 Hi = DAG.getNode(N->getOpcode(), DL, HiVT, LH, RH, N->getOperand(2));
976 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
984 std::tie(Lo, Hi) = DAG.SplitVectorOperand(N, 0);
987 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo, N->getOperand(1));
988 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi, N->getOperand(1));
990 SDValue DTyOpLo = DAG.getValueType(LoVT);
991 SDValue DTyOpHi = DAG.getValueType(HiVT);
992 SDValue STyOpLo = DAG.getValueType(Lo.getValueType());
993 SDValue STyOpHi = DAG.getValueType(Hi.getValueType());
997 Lo = DAG.getConvertRndSat(LoVT, dl, Lo, DTyOpLo, STyOpLo, RndOp, SatOp,
999 Hi = DAG.getConvertRndSat(HiVT, dl, Hi, DTyOpHi, STyOpHi, RndOp, SatOp,
1002 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
1003 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi);
1013 std::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(DestVT);
1031 LLVMContext &Ctx = *DAG.getContext();
1039 std::tie(SplitLoVT, SplitHiVT) = DAG.GetSplitDestVTs(NewSrcVT);
1043 N->dump(&DAG); dbgs() << "\n");
1046 DAG.getNode(N->getOpcode(), dl, NewSrcVT, N->getOperand(0));
1048 std::tie(Lo, Hi) = DAG.SplitVector(NewSrc, dl);
1050 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
1051 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi);
1137 SVOps.push_back(DAG.getUNDEF(EltVT));
1145 SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
1146 Inputs[Input], DAG.getConstant(Idx,
1151 Output = DAG.getNode(ISD::BUILD_VECTOR, dl, NewVT, SVOps);
1154 Output = DAG.getUNDEF(NewVT);
1159 DAG.getUNDEF(NewVT) : Inputs[InputUsed[1]];
1161 Output = DAG.getVectorShuffle(NewVT, dl, Op0, Op1, &Ops[0]);
1179 N->dump(&DAG);
1192 N->dump(&DAG);
1261 std::tie(LoOpVT, HiOpVT) = DAG.GetSplitDestVTs(Src0VT);
1265 std::tie(LoOp0, HiOp0) = DAG.SplitVector(Src0, DL);
1266 std::tie(LoOp1, HiOp1) = DAG.SplitVector(Src1, DL);
1267 std::tie(LoMask, HiMask) = DAG.SplitVector(Mask, DL);
1270 DAG.getNode(ISD::VSELECT, DL, LoOpVT, LoMask, LoOp0, LoOp1);
1272 DAG.getNode(ISD::VSELECT, DL, HiOpVT, HiMask, HiOp0, HiOp1);
1274 return DAG.getNode(ISD::CONCAT_VECTORS, DL, Src0VT, LoSelect, HiSelect);
1285 EVT OutVT = EVT::getVectorVT(*DAG.getContext(), ResVT.getVectorElementType(),
1288 Lo = DAG.getNode(N->getOpcode(), dl, OutVT, Lo);
1289 Hi = DAG.getNode(N->getOpcode(), dl, OutVT, Hi);
1291 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
1306 return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0),
1324 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Lo, Idx);
1326 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Hi,
1327 DAG.getConstant(IdxVal - LoElts, Idx.getValueType()));
1346 return SDValue(DAG.UpdateNodeOperands(N, Lo, Idx), 0);
1347 return SDValue(DAG.UpdateNodeOperands(N, Hi,
1348 DAG.getConstant(IdxVal - LoElts,
1355 SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
1356 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
1361 return DAG.getExtLoad(ISD::EXTLOAD, dl, N->getValueType(0), Store, StackPtr,
1382 std::tie(LoMemVT, HiMemVT) = DAG.GetSplitDestVTs(MemoryVT);
1387 Lo = DAG.getTruncStore(Ch, DL, Lo, Ptr, N->getPointerInfo(),
1390 Lo = DAG.getStore(Ch, DL, Lo, Ptr, N->getPointerInfo(),
1394 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
1395 DAG.getConstant(IncrementSize, Ptr.getValueType()));
1398 Hi = DAG.getTruncStore(Ch, DL, Hi, Ptr,
1402 Hi = DAG.getStore(Ch, DL, Hi, Ptr,
1406 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
1423 Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT,
1424 Op, DAG.getConstant(i, TLI.getVectorIdxTy())));
1429 return DAG.getNode(ISD::BUILD_VECTOR, DL, N->getValueType(0), Elts);
1470 std::tie(InLoVec, InHiVec) = DAG.SplitVector(InVec, DL);
1472 EVT HalfElementVT = EVT::getIntegerVT(*DAG.getContext(), InElementSize/2);
1473 EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), HalfElementVT,
1475 SDValue HalfLo = DAG.getNode(ISD::TRUNCATE, DL, HalfVT, InLoVec);
1476 SDValue HalfHi = DAG.getNode(ISD::TRUNCATE, DL, HalfVT, InHiVec);
1478 EVT InterVT = EVT::getVectorVT(*DAG.getContext(), HalfElementVT, NumElements);
1479 SDValue InterVec = DAG.getNode(ISD::CONCAT_VECTORS, DL, InterVT, HalfLo,
1485 return DAG.getNode(ISD::TRUNCATE, DL, OutVT, InterVec);
1498 EVT PartResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, PartElements);
1499 EVT WideResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, 2*PartElements);
1501 LoRes = DAG.getNode(ISD::SETCC, DL, PartResVT, Lo0, Lo1, N->getOperand(2));
1502 HiRes = DAG.getNode(ISD::SETCC, DL, PartResVT, Hi0, Hi1, N->getOperand(2));
1503 SDValue Con = DAG.getNode(ISD::CONCAT_VECTORS, DL, WideResVT, LoRes, HiRes);
1516 EVT OutVT = EVT::getVectorVT(*DAG.getContext(), ResVT.getVectorElementType(),
1519 Lo = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Lo, N->getOperand(1));
1520 Hi = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Hi, N->getOperand(1));
1522 return DAG.getNode(ISD::CONCAT_VECTORS, DL, ResVT, Lo, Hi);
1533 N->dump(&DAG);
1545 N->dump(&DAG);
1653 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1657 return DAG.getNode(N->getOpcode(), dl, WidenVT, InOp1, InOp2, InOp3);
1663 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1666 return DAG.getNode(N->getOpcode(), dl, WidenVT, InOp1, InOp2);
1673 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1679 VT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NumElts);
1686 return DAG.getNode(N->getOpcode(), dl, WidenVT, InOp1, InOp2);
1691 return DAG.UnrollVectorOp(N, WidenVT.getVectorNumElements());
1710 SDValue EOp1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, InOp1,
1711 DAG.getConstant(Idx, TLI.getVectorIdxTy()));
1712 SDValue EOp2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, InOp2,
1713 DAG.getConstant(Idx, TLI.getVectorIdxTy()));
1714 ConcatOps[ConcatEnd++] = DAG.getNode(Opcode, dl, VT, EOp1, EOp2);
1720 VT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NumElts);
1725 SDValue EOp1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, WidenEltVT,
1726 InOp1, DAG.getConstant(Idx,
1728 SDValue EOp2 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, WidenEltVT,
1729 InOp2, DAG.getConstant(Idx,
1731 ConcatOps[ConcatEnd++] = DAG.getNode(Opcode, dl, WidenEltVT,
1759 NextVT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NextSize);
1764 SDValue VecOp = DAG.getUNDEF(NextVT);
1767 VecOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NextVT, VecOp,
1768 ConcatOps[OpIdx], DAG.getConstant(i,
1775 SDValue undefVec = DAG.getUNDEF(VT);
1785 ConcatOps[SubConcatIdx] = DAG.getNode(ISD::CONCAT_VECTORS, dl,
1801 SDValue UndefVal = DAG.getUNDEF(MaxVT);
1805 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT,
1813 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1818 EVT InWidenVT = EVT::getVectorVT(*DAG.getContext(), InEltVT, WidenNumElts);
1829 return DAG.getNode(Opcode, DL, WidenVT, InOp);
1830 return DAG.getNode(Opcode, DL, WidenVT, InOp, N->getOperand(1));
1845 SDValue UndefVal = DAG.getUNDEF(InVT);
1848 SDValue InVec = DAG.getNode(ISD::CONCAT_VECTORS, DL, InWidenVT, Ops);
1850 return DAG.getNode(Opcode, DL, WidenVT, InVec);
1851 return DAG.getNode(Opcode, DL, WidenVT, InVec, N->getOperand(1));
1855 SDValue InVal = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, InWidenVT,
1856 InOp, DAG.getConstant(0,
1860 return DAG.getNode(Opcode, DL, WidenVT, InVal);
1861 return DAG.getNode(Opcode, DL, WidenVT, InVal, N->getOperand(1));
1871 SDValue Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, InEltVT, InOp,
1872 DAG.getConstant(i, TLI.getVectorIdxTy()));
1874 Ops[i] = DAG.getNode(Opcode, DL, EltVT, Val);
1876 Ops[i] = DAG.getNode(Opcode, DL, EltVT, Val, N->getOperand(1));
1879 SDValue UndefVal = DAG.getUNDEF(EltVT);
1883 return DAG.getNode(ISD::BUILD_VECTOR, DL, WidenVT, Ops);
1887 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1890 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, ShOp);
1894 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1903 EVT ShWidenVT = EVT::getVectorVT(*DAG.getContext(),
1909 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, ShOp);
1914 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1916 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp);
1920 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1921 EVT ExtVT = EVT::getVectorVT(*DAG.getContext(),
1926 return DAG.getNode(N->getOpcode(), SDLoc(N),
1927 WidenVT, WidenLHS, DAG.getValueType(ExtVT));
1939 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1957 return DAG.getNode(ISD::BITCAST, dl, WidenVT, InOp);
1972 return DAG.getNode(ISD::BITCAST, dl, WidenVT, InOp);
1987 NewInVT = EVT::getVectorVT(*DAG.getContext(), InEltVT,
1990 NewInVT = EVT::getVectorVT(*DAG.getContext(), InVT, NewNumElts);
2000 SDValue UndefVal = DAG.getUNDEF(InVT);
2007 NewVec = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewInVT, Ops);
2009 NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl, NewInVT, Ops);
2010 return DAG.getNode(ISD::BITCAST, dl, WidenVT, NewVec);
2027 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2032 NewOps.append(WidenNumElts - NumElts, DAG.getUNDEF(EltVT));
2034 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, NewOps);
2039 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2051 SDValue UndefVal = DAG.getUNDEF(InVT);
2057 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, Ops);
2061 if (WidenVT == TLI.getTypeToTransformTo(*DAG.getContext(), InVT)) {
2080 return DAG.getVectorShuffle(WidenVT, dl,
2097 Ops[Idx++] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
2098 DAG.getConstant(j, TLI.getVectorIdxTy()));
2100 SDValue UndefVal = DAG.getUNDEF(EltVT);
2103 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, Ops);
2112 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2117 EVT InWidenVT = EVT::getVectorVT(*DAG.getContext(), InEltVT, WidenNumElts);
2119 SDValue DTyOp = DAG.getValueType(WidenVT);
2120 SDValue STyOp = DAG.getValueType(InWidenVT);
2129 return DAG.getConvertRndSat(WidenVT, dl, InOp, DTyOp, STyOp, RndOp,
2144 SDValue UndefVal = DAG.getUNDEF(InVT);
2148 InOp = DAG.getNode(ISD::CONCAT_VECTORS, dl, InWidenVT, Ops);
2149 return DAG.getConvertRndSat(WidenVT, dl, InOp, DTyOp, STyOp, RndOp,
2155 InOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InWidenVT, InOp,
2156 DAG.getConstant(0, TLI.getVectorIdxTy()));
2157 return DAG.getConvertRndSat(WidenVT, dl, InOp, DTyOp, STyOp, RndOp,
2165 DTyOp = DAG.getValueType(EltVT);
2166 STyOp = DAG.getValueType(InEltVT);
2171 SDValue ExtVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, InEltVT, InOp,
2172 DAG.getConstant(i, TLI.getVectorIdxTy()));
2173 Ops[i] = DAG.getConvertRndSat(WidenVT, dl, ExtVal, DTyOp, STyOp, RndOp,
2177 SDValue UndefVal = DAG.getUNDEF(EltVT);
2181 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, Ops);
2186 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2205 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, WidenVT, InOp, Idx);
2214 Ops[i] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
2215 DAG.getConstant(IdxVal+i, TLI.getVectorIdxTy()));
2217 SDValue UndefVal = DAG.getUNDEF(EltVT);
2220 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, Ops);
2225 return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(N),
2248 NewChain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other, LdChain);
2258 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2259 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N),
2264 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2271 EVT CondWidenVT = EVT::getVectorVT(*DAG.getContext(),
2294 return DAG.getNode(N->getOpcode(), SDLoc(N),
2301 return DAG.getNode(ISD::SELECT_CC, SDLoc(N),
2312 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2315 return DAG.getNode(ISD::SETCC, SDLoc(N), WidenVT,
2320 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2321 return DAG.getUNDEF(WidenVT);
2328 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2346 return DAG.getVectorShuffle(WidenVT, dl, InOp1, InOp2, &NewMask[0]);
2353 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2359 EVT WidenInVT = EVT::getVectorVT(*DAG.getContext(),
2370 return DAG.getNode(ISD::SETCC, SDLoc(N),
2380 N->dump(&DAG);
2392 N->dump(&DAG);
2467 InOp = DAG.getNode(ISD::INSERT_SUBVECTOR, DL, FixedVT,
2468 DAG.getUNDEF(FixedVT), InOp,
2469 DAG.getConstant(0, TLI.getVectorIdxTy()));
2471 InOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, FixedVT, InOp,
2472 DAG.getConstant(0, TLI.getVectorIdxTy()));
2484 // Use special DAG nodes to represent the operation of extending the
2490 return DAG.getAnyExtendVectorInReg(InOp, DL, VT);
2492 return DAG.getSignExtendVectorInReg(InOp, DL, VT);
2494 return DAG.getZeroExtendVectorInReg(InOp, DL, VT);
2515 Ops[i] = DAG.getNode(Opcode, dl, EltVT,
2516 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, InEltVT, InOp,
2517 DAG.getConstant(i, TLI.getVectorIdxTy())));
2519 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
2534 EVT NewVT = EVT::getVectorVT(*DAG.getContext(), VT, NewNumElts);
2536 SDValue BitOp = DAG.getNode(ISD::BITCAST, dl, NewVT, InOp);
2537 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, BitOp,
2538 DAG.getConstant(0, TLI.getVectorIdxTy()));
2565 Ops[Idx++] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
2566 DAG.getConstant(j, TLI.getVectorIdxTy()));
2568 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
2573 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N),
2579 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
2597 return DAG.getNode(ISD::TokenFactor, SDLoc(ST), MVT::Other, StChain);
2611 EVT SVT = TLI.getSetCCResultType(*DAG.getContext(), InOp0.getValueType());
2612 SDValue WideSETCC = DAG.getNode(ISD::SETCC, SDLoc(N),
2616 EVT ResVT = EVT::getVectorVT(*DAG.getContext(),
2619 SDValue CC = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl,
2620 ResVT, WideSETCC, DAG.getConstant(0,
2638 static EVT FindMemType(SelectionDAG& DAG, const TargetLowering &TLI,
2691 static SDValue BuildVectorFromScalar(SelectionDAG& DAG, EVT VecTy,
2694 const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2699 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), LdTy, NumElts);
2702 SDValue VecOp = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NewVecVT,LdOps[Start]);
2708 NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewLdTy, NumElts);
2709 VecOp = DAG.getNode(ISD::BITCAST, dl, NewVecVT, VecOp);
2714 VecOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, VecOp, LdOps[i],
2715 DAG.getConstant(Idx++, TLI.getVectorIdxTy()));
2717 return DAG.getNode(ISD::BITCAST, dl, VecTy, VecOp);
2726 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
2747 EVT NewVT = FindMemType(DAG, TLI, LdWidth, WidenVT, LdAlign, WidthDiff);
2749 SDValue LdOp = DAG.getLoad(NewVT, dl, Chain, BasePtr, LD->getPointerInfo(),
2758 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NumElts);
2759 SDValue VecOp = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NewVecVT, LdOp);
2760 return DAG.getNode(ISD::BITCAST, dl, WidenVT, VecOp);
2768 SDValue UndefVal = DAG.getUNDEF(NewVT);
2772 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, ConcatOps);
2785 BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
2786 DAG.getConstant(Increment, BasePtr.getValueType()));
2791 NewVT = FindMemType(DAG, TLI, LdWidth, WidenVT, LdAlign, WidthDiff);
2793 L = DAG.getLoad(NewVT, dl, Chain, BasePtr,
2803 Loads.push_back(DAG.getUNDEF(L->getValueType(0)));
2806 L = DAG.getNode(ISD::CONCAT_VECTORS, dl, LdOp->getValueType(0), Loads);
2809 L = DAG.getLoad(NewVT, dl, Chain, BasePtr,
2826 return BuildVectorFromScalar(DAG, WidenVT, LdOps, 0, End);
2842 ConcatOps[--Idx] = BuildVectorFromScalar(DAG, LdTy, LdOps, i+1, End);
2849 ConcatOps[End-1] = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewLdTy,
2858 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT,
2864 SDValue UndefVal = DAG.getUNDEF(LdTy);
2872 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, WidenOps);
2881 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
2902 Ops[0] = DAG.getExtLoad(ExtType, dl, EltVT, Chain, BasePtr,
2908 SDValue NewBasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(),
2910 DAG.getConstant(Offset,
2912 Ops[i] = DAG.getExtLoad(ExtType, dl, EltVT, Chain, NewBasePtr,
2919 SDValue UndefVal = DAG.getUNDEF(EltVT);
2923 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, Ops);
2953 EVT NewVT = FindMemType(DAG, TLI, StWidth, ValVT);
2959 SDValue EOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NewVT, ValOp,
2960 DAG.getConstant(Idx, TLI.getVectorIdxTy()));
2961 StChain.push_back(DAG.getStore(Chain, dl, EOp, BasePtr,
2968 BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
2969 DAG.getConstant(Increment, BasePtr.getValueType()));
2974 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NumElts);
2975 SDValue VecOp = DAG.getNode(ISD::BITCAST, dl, NewVecVT, ValOp);
2979 SDValue EOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, VecOp,
2980 DAG.getConstant(Idx++, TLI.getVectorIdxTy()));
2981 StChain.push_back(DAG.getStore(Chain, dl, EOp, BasePtr,
2987 BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
2988 DAG.getConstant(Increment, BasePtr.getValueType()));
3025 SDValue EOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ValEltVT, ValOp,
3026 DAG.getConstant(0, TLI.getVectorIdxTy()));
3027 StChain.push_back(DAG.getTruncStore(Chain, dl, EOp, BasePtr,
3033 SDValue NewBasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(),
3034 BasePtr, DAG.getConstant(Offset,
3036 SDValue EOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ValEltVT, ValOp,
3037 DAG.getConstant(0, TLI.getVectorIdxTy()));
3038 StChain.push_back(DAG.getTruncStore(Chain, dl, EOp, NewBasePtr,
3064 SDValue UndefVal = DAG.getUNDEF(InVT);
3069 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, Ops);
3073 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT, InOp,
3074 DAG.getConstant(0, TLI.getVectorIdxTy()));
3082 Ops[Idx] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
3083 DAG.getConstant(Idx, TLI.getVectorIdxTy()));
3085 SDValue UndefVal = DAG.getUNDEF(EltVT);
3088 return DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, Ops);