Lines Matching refs:DAG
35 N->dump(&DAG);
43 N->dump(&DAG);
133 return DAG.getNode(N->getOpcode(), SDLoc(N),
141 return DAG.getNode(N->getOpcode(), SDLoc(N),
153 return DAG.getNode(ISD::BITCAST, SDLoc(N),
163 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, InOp);
170 return DAG.getConvertRndSat(NewVT, SDLoc(N),
171 Op0, DAG.getValueType(NewVT),
172 DAG.getValueType(Op0.getValueType()),
179 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
187 return DAG.getNode(ISD::FP_ROUND, SDLoc(N),
193 return DAG.getNode(ISD::FPOWI, SDLoc(N),
204 Op = DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, Op);
211 SDValue Result = DAG.getLoad(ISD::UNINDEXED,
216 DAG.getUNDEF(N->getBasePtr().getValueType()),
233 return DAG.getNode(N->getOpcode(), SDLoc(N), DestVT, Op);
240 return DAG.getNode(N->getOpcode(), SDLoc(N), EltVT,
241 LHS, DAG.getValueType(ExtVT));
250 return DAG.getNode(ISD::TRUNCATE, SDLoc(N), EltVT, InOp);
268 Cond = DAG.getNode(ISD::AND, SDLoc(N), CondVT,
269 Cond, DAG.getConstant(1, CondVT));
275 Cond = DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N), CondVT,
276 Cond, DAG.getValueType(MVT::i1));
281 return DAG.getSelect(SDLoc(N),
288 return DAG.getSelect(SDLoc(N),
295 return DAG.getNode(ISD::SELECT_CC, SDLoc(N), LHS.getValueType(),
313 return DAG.getNode(ISD::SETCC, DL, MVT::i1, LHS, RHS, N->getOperand(2));
317 return DAG.getUNDEF(N->getValueType(0).getVectorElementType());
324 return DAG.getUNDEF(N->getValueType(0).getVectorElementType());
340 SDValue Res = DAG.getNode(ISD::SETCC, DL, MVT::i1, LHS, RHS,
346 return DAG.getNode(ExtendCode, DL, NVT, Res);
356 N->dump(&DAG);
365 N->dump(&DAG);
409 return DAG.getNode(ISD::BITCAST, SDLoc(N),
420 Ops[0] = DAG.getNode(N->getOpcode(), SDLoc(N),
424 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), N->getValueType(0),
434 return DAG.getNode(ISD::BUILD_VECTOR, SDLoc(N), N->getValueType(0),
444 Res = DAG.getNode(ISD::ANY_EXTEND, SDLoc(N), N->getValueType(0),
457 return DAG.getTruncStore(N->getChain(), dl,
464 return DAG.getStore(N->getChain(), dl, GetScalarizedVector(N->getOperand(1)),
482 N->dump(&DAG);
494 N->dump(&DAG);
603 Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo, RHSLo);
604 Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi, RHSHi);
617 Lo = DAG.getNode(N->getOpcode(), dl, Op0Lo.getValueType(),
619 Hi = DAG.getNode(N->getOpcode(), dl, Op0Hi.getValueType(),
628 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
651 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
652 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
660 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
661 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
666 EVT LoIntVT = EVT::getIntegerVT(*DAG.getContext(), LoVT.getSizeInBits());
667 EVT HiIntVT = EVT::getIntegerVT(*DAG.getContext(), HiVT.getSizeInBits());
675 Lo = DAG.getNode(ISD::BITCAST, dl, LoVT, Lo);
676 Hi = DAG.getNode(ISD::BITCAST, dl, HiVT, Hi);
683 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
686 Lo = DAG.getNode(ISD::BUILD_VECTOR, dl, LoVT, &LoOps[0], LoOps.size());
689 Hi = DAG.getNode(ISD::BUILD_VECTOR, dl, HiVT, &HiOps[0], HiOps.size());
704 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
707 Lo = DAG.getNode(ISD::CONCAT_VECTORS, dl, LoVT, &LoOps[0], LoOps.size());
710 Hi = DAG.getNode(ISD::CONCAT_VECTORS, dl, HiVT, &HiOps[0], HiOps.size());
720 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
722 Lo = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, LoVT, Vec, Idx);
724 Hi = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, HiVT, Vec,
725 DAG.getConstant(IdxVal + LoVT.getVectorNumElements(),
740 SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
741 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
746 Type *VecType = VecVT.getTypeForEVT(*DAG.getContext());
748 Store = DAG.getStore(Store, dl, SubVec, SubVecPtr, MachinePointerInfo(),
752 Lo = DAG.getLoad(Lo.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
758 DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
759 DAG.getConstant(IncrementSize, StackPtr.getValueType()));
762 Hi = DAG.getLoad(Hi.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
770 Lo = DAG.getNode(ISD::FPOWI, dl, Lo.getValueType(), Lo, N->getOperand(1));
771 Hi = DAG.getNode(ISD::FPOWI, dl, Hi.getValueType(), Hi, N->getOperand(1));
782 DAG.GetSplitDestVTs(cast<VTSDNode>(N->getOperand(1))->getVT());
784 Lo = DAG.getNode(N->getOpcode(), dl, LHSLo.getValueType(), LHSLo,
785 DAG.getValueType(LoVT));
786 Hi = DAG.getNode(N->getOpcode(), dl, LHSHi.getValueType(), LHSHi,
787 DAG.getValueType(HiVT));
802 Lo = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl,
805 Hi = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, Hi.getValueType(), Hi, Elt,
806 DAG.getConstant(IdxVal - LoNumElts,
814 SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
815 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
821 Type *VecType = VecVT.getTypeForEVT(*DAG.getContext());
824 Store = DAG.getTruncStore(Store, dl, Elt, EltPtr, MachinePointerInfo(), EltVT,
828 Lo = DAG.getLoad(Lo.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
833 StackPtr = DAG.getNode(ISD::ADD, dl, StackPtr.getValueType(), StackPtr,
834 DAG.getConstant(IncrementSize, StackPtr.getValueType()));
837 Hi = DAG.getLoad(Hi.getValueType(), dl, Store, StackPtr, MachinePointerInfo(),
845 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
846 Lo = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, LoVT, N->getOperand(0));
847 Hi = DAG.getUNDEF(HiVT);
855 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(LD->getValueType(0));
860 SDValue Offset = DAG.getUNDEF(Ptr.getValueType());
869 llvm::tie(LoMemVT, HiMemVT) = DAG.GetSplitDestVTs(MemoryVT);
871 Lo = DAG.getLoad(ISD::UNINDEXED, ExtType, LoVT, dl, Ch, Ptr, Offset,
876 Ptr = DAG.getNode(ISD::ADD, dl, Ptr.getValueType(), Ptr,
877 DAG.getConstant(IncrementSize, Ptr.getValueType()));
878 Hi = DAG.getLoad(ISD::UNINDEXED, ExtType, HiVT, dl, Ch, Ptr, Offset,
885 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
900 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
904 llvm::tie(LL, LH) = DAG.SplitVectorOperand(N, 0);
905 llvm::tie(RL, RH) = DAG.SplitVectorOperand(N, 1);
907 Lo = DAG.getNode(N->getOpcode(), DL, LoVT, LL, RL, N->getOperand(2));
908 Hi = DAG.getNode(N->getOpcode(), DL, HiVT, LH, RH, N->getOperand(2));
916 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(N->getValueType(0));
924 llvm::tie(Lo, Hi) = DAG.SplitVectorOperand(N, 0);
927 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo, N->getOperand(1));
928 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi, N->getOperand(1));
930 SDValue DTyOpLo = DAG.getValueType(LoVT);
931 SDValue DTyOpHi = DAG.getValueType(HiVT);
932 SDValue STyOpLo = DAG.getValueType(Lo.getValueType());
933 SDValue STyOpHi = DAG.getValueType(Hi.getValueType());
937 Lo = DAG.getConvertRndSat(LoVT, dl, Lo, DTyOpLo, STyOpLo, RndOp, SatOp,
939 Hi = DAG.getConvertRndSat(HiVT, dl, Hi, DTyOpHi, STyOpHi, RndOp, SatOp,
942 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
943 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi);
953 llvm::tie(LoVT, HiVT) = DAG.GetSplitDestVTs(DestVT);
971 LLVMContext &Ctx = *DAG.getContext();
979 llvm::tie(SplitLoVT, SplitHiVT) = DAG.GetSplitDestVTs(NewSrcVT);
983 N->dump(&DAG); dbgs() << "\n");
986 DAG.getNode(N->getOpcode(), dl, NewSrcVT, N->getOperand(0));
988 llvm::tie(Lo, Hi) = DAG.SplitVector(NewSrc, dl);
990 Lo = DAG.getNode(N->getOpcode(), dl, LoVT, Lo);
991 Hi = DAG.getNode(N->getOpcode(), dl, HiVT, Hi);
1077 SVOps.push_back(DAG.getUNDEF(EltVT));
1085 SVOps.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT,
1086 Inputs[Input], DAG.getConstant(Idx,
1091 Output = DAG.getNode(ISD::BUILD_VECTOR,dl,NewVT, &SVOps[0], SVOps.size());
1094 Output = DAG.getUNDEF(NewVT);
1099 DAG.getUNDEF(NewVT) : Inputs[InputUsed[1]];
1101 Output = DAG.getVectorShuffle(NewVT, dl, Op0, Op1, &Ops[0]);
1119 N->dump(&DAG);
1132 N->dump(&DAG);
1201 llvm::tie(LoOpVT, HiOpVT) = DAG.GetSplitDestVTs(Src0VT);
1205 llvm::tie(LoOp0, HiOp0) = DAG.SplitVector(Src0, DL);
1206 llvm::tie(LoOp1, HiOp1) = DAG.SplitVector(Src1, DL);
1207 llvm::tie(LoMask, HiMask) = DAG.SplitVector(Mask, DL);
1210 DAG.getNode(ISD::VSELECT, DL, LoOpVT, LoMask, LoOp0, LoOp1);
1212 DAG.getNode(ISD::VSELECT, DL, HiOpVT, HiMask, HiOp0, HiOp1);
1214 return DAG.getNode(ISD::CONCAT_VECTORS, DL, Src0VT, LoSelect, HiSelect);
1225 EVT OutVT = EVT::getVectorVT(*DAG.getContext(), ResVT.getVectorElementType(),
1228 Lo = DAG.getNode(N->getOpcode(), dl, OutVT, Lo);
1229 Hi = DAG.getNode(N->getOpcode(), dl, OutVT, Hi);
1231 return DAG.getNode(ISD::CONCAT_VECTORS, dl, ResVT, Lo, Hi);
1246 return DAG.getNode(ISD::BITCAST, SDLoc(N), N->getValueType(0),
1264 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Lo, Idx);
1266 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, SubVT, Hi,
1267 DAG.getConstant(IdxVal - LoElts, Idx.getValueType()));
1286 return SDValue(DAG.UpdateNodeOperands(N, Lo, Idx), 0);
1287 return SDValue(DAG.UpdateNodeOperands(N, Hi,
1288 DAG.getConstant(IdxVal - LoElts,
1295 SDValue StackPtr = DAG.CreateStackTemporary(VecVT);
1296 SDValue Store = DAG.getStore(DAG.getEntryNode(), dl, Vec, StackPtr,
1301 return DAG.getExtLoad(ISD::EXTLOAD, dl, N->getValueType(0), Store, StackPtr,
1322 llvm::tie(LoMemVT, HiMemVT) = DAG.GetSplitDestVTs(MemoryVT);
1327 Lo = DAG.getTruncStore(Ch, DL, Lo, Ptr, N->getPointerInfo(),
1330 Lo = DAG.getStore(Ch, DL, Lo, Ptr, N->getPointerInfo(),
1334 Ptr = DAG.getNode(ISD::ADD, DL, Ptr.getValueType(), Ptr,
1335 DAG.getConstant(IncrementSize, Ptr.getValueType()));
1338 Hi = DAG.getTruncStore(Ch, DL, Hi, Ptr,
1342 Hi = DAG.getStore(Ch, DL, Hi, Ptr,
1346 return DAG.getNode(ISD::TokenFactor, DL, MVT::Other, Lo, Hi);
1363 Elts.push_back(DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, EltVT,
1364 Op, DAG.getConstant(i, TLI.getVectorIdxTy())));
1369 return DAG.getNode(ISD::BUILD_VECTOR, DL, N->getValueType(0),
1411 llvm::tie(InLoVec, InHiVec) = DAG.SplitVector(InVec, DL);
1413 EVT HalfElementVT = EVT::getIntegerVT(*DAG.getContext(), InElementSize/2);
1414 EVT HalfVT = EVT::getVectorVT(*DAG.getContext(), HalfElementVT,
1416 SDValue HalfLo = DAG.getNode(ISD::TRUNCATE, DL, HalfVT, InLoVec);
1417 SDValue HalfHi = DAG.getNode(ISD::TRUNCATE, DL, HalfVT, InHiVec);
1419 EVT InterVT = EVT::getVectorVT(*DAG.getContext(), HalfElementVT, NumElements);
1420 SDValue InterVec = DAG.getNode(ISD::CONCAT_VECTORS, DL, InterVT, HalfLo,
1426 return DAG.getNode(ISD::TRUNCATE, DL, OutVT, InterVec);
1439 EVT PartResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, PartElements);
1440 EVT WideResVT = EVT::getVectorVT(*DAG.getContext(), MVT::i1, 2*PartElements);
1442 LoRes = DAG.getNode(ISD::SETCC, DL, PartResVT, Lo0, Lo1, N->getOperand(2));
1443 HiRes = DAG.getNode(ISD::SETCC, DL, PartResVT, Hi0, Hi1, N->getOperand(2));
1444 SDValue Con = DAG.getNode(ISD::CONCAT_VECTORS, DL, WideResVT, LoRes, HiRes);
1457 EVT OutVT = EVT::getVectorVT(*DAG.getContext(), ResVT.getVectorElementType(),
1460 Lo = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Lo, N->getOperand(1));
1461 Hi = DAG.getNode(ISD::FP_ROUND, DL, OutVT, Hi, N->getOperand(1));
1463 return DAG.getNode(ISD::CONCAT_VECTORS, DL, ResVT, Lo, Hi);
1474 N->dump(&DAG);
1486 N->dump(&DAG);
1594 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1598 return DAG.getNode(N->getOpcode(), dl, WidenVT, InOp1, InOp2, InOp3);
1604 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1607 return DAG.getNode(N->getOpcode(), dl, WidenVT, InOp1, InOp2);
1614 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1620 VT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NumElts);
1627 return DAG.getNode(N->getOpcode(), dl, WidenVT, InOp1, InOp2);
1632 return DAG.UnrollVectorOp(N, WidenVT.getVectorNumElements());
1651 SDValue EOp1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, InOp1,
1652 DAG.getConstant(Idx, TLI.getVectorIdxTy()));
1653 SDValue EOp2 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, VT, InOp2,
1654 DAG.getConstant(Idx, TLI.getVectorIdxTy()));
1655 ConcatOps[ConcatEnd++] = DAG.getNode(Opcode, dl, VT, EOp1, EOp2);
1661 VT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NumElts);
1666 SDValue EOp1 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, WidenEltVT,
1667 InOp1, DAG.getConstant(Idx,
1669 SDValue EOp2 = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, WidenEltVT,
1670 InOp2, DAG.getConstant(Idx,
1672 ConcatOps[ConcatEnd++] = DAG.getNode(Opcode, dl, WidenEltVT,
1700 NextVT = EVT::getVectorVT(*DAG.getContext(), WidenEltVT, NextSize);
1705 SDValue VecOp = DAG.getUNDEF(NextVT);
1708 VecOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NextVT, VecOp,
1709 ConcatOps[OpIdx], DAG.getConstant(i,
1716 SDValue undefVec = DAG.getUNDEF(VT);
1726 ConcatOps[SubConcatIdx] = DAG.getNode(ISD::CONCAT_VECTORS, dl,
1743 SDValue UndefVal = DAG.getUNDEF(MaxVT);
1747 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, &ConcatOps[0], NumOps);
1754 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1759 EVT InWidenVT = EVT::getVectorVT(*DAG.getContext(), InEltVT, WidenNumElts);
1770 return DAG.getNode(Opcode, DL, WidenVT, InOp);
1771 return DAG.getNode(Opcode, DL, WidenVT, InOp, N->getOperand(1));
1786 SDValue UndefVal = DAG.getUNDEF(InVT);
1789 SDValue InVec = DAG.getNode(ISD::CONCAT_VECTORS, DL, InWidenVT,
1792 return DAG.getNode(Opcode, DL, WidenVT, InVec);
1793 return DAG.getNode(Opcode, DL, WidenVT, InVec, N->getOperand(1));
1797 SDValue InVal = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, InWidenVT,
1798 InOp, DAG.getConstant(0,
1802 return DAG.getNode(Opcode, DL, WidenVT, InVal);
1803 return DAG.getNode(Opcode, DL, WidenVT, InVal, N->getOperand(1));
1813 SDValue Val = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, InEltVT, InOp,
1814 DAG.getConstant(i, TLI.getVectorIdxTy()));
1816 Ops[i] = DAG.getNode(Opcode, DL, EltVT, Val);
1818 Ops[i] = DAG.getNode(Opcode, DL, EltVT, Val, N->getOperand(1));
1821 SDValue UndefVal = DAG.getUNDEF(EltVT);
1825 return DAG.getNode(ISD::BUILD_VECTOR, DL, WidenVT, &Ops[0], WidenNumElts);
1829 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1832 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, ShOp);
1836 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1845 EVT ShWidenVT = EVT::getVectorVT(*DAG.getContext(),
1851 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, ShOp);
1856 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1858 return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp);
1862 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1863 EVT ExtVT = EVT::getVectorVT(*DAG.getContext(),
1868 return DAG.getNode(N->getOpcode(), SDLoc(N),
1869 WidenVT, WidenLHS, DAG.getValueType(ExtVT));
1881 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1899 return DAG.getNode(ISD::BITCAST, dl, WidenVT, InOp);
1914 return DAG.getNode(ISD::BITCAST, dl, WidenVT, InOp);
1929 NewInVT = EVT::getVectorVT(*DAG.getContext(), InEltVT,
1932 NewInVT = EVT::getVectorVT(*DAG.getContext(), InVT, NewNumElts);
1942 SDValue UndefVal = DAG.getUNDEF(InVT);
1949 NewVec = DAG.getNode(ISD::CONCAT_VECTORS, dl,
1952 NewVec = DAG.getNode(ISD::BUILD_VECTOR, dl,
1954 return DAG.getNode(ISD::BITCAST, dl, WidenVT, NewVec);
1971 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1976 NewOps.append(WidenNumElts - NumElts, DAG.getUNDEF(EltVT));
1978 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, &NewOps[0], NewOps.size());
1983 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1995 SDValue UndefVal = DAG.getUNDEF(InVT);
2001 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, &Ops[0], NumConcat);
2005 if (WidenVT == TLI.getTypeToTransformTo(*DAG.getContext(), InVT)) {
2024 return DAG.getVectorShuffle(WidenVT, dl,
2041 Ops[Idx++] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
2042 DAG.getConstant(j, TLI.getVectorIdxTy()));
2044 SDValue UndefVal = DAG.getUNDEF(EltVT);
2047 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, &Ops[0], WidenNumElts);
2056 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2061 EVT InWidenVT = EVT::getVectorVT(*DAG.getContext(), InEltVT, WidenNumElts);
2063 SDValue DTyOp = DAG.getValueType(WidenVT);
2064 SDValue STyOp = DAG.getValueType(InWidenVT);
2073 return DAG.getConvertRndSat(WidenVT, dl, InOp, DTyOp, STyOp, RndOp,
2088 SDValue UndefVal = DAG.getUNDEF(InVT);
2092 InOp = DAG.getNode(ISD::CONCAT_VECTORS, dl, InWidenVT, &Ops[0],NumConcat);
2093 return DAG.getConvertRndSat(WidenVT, dl, InOp, DTyOp, STyOp, RndOp,
2099 InOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, InWidenVT, InOp,
2100 DAG.getConstant(0, TLI.getVectorIdxTy()));
2101 return DAG.getConvertRndSat(WidenVT, dl, InOp, DTyOp, STyOp, RndOp,
2109 DTyOp = DAG.getValueType(EltVT);
2110 STyOp = DAG.getValueType(InEltVT);
2115 SDValue ExtVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, InEltVT, InOp,
2116 DAG.getConstant(i, TLI.getVectorIdxTy()));
2117 Ops[i] = DAG.getConvertRndSat(WidenVT, dl, ExtVal, DTyOp, STyOp, RndOp,
2121 SDValue UndefVal = DAG.getUNDEF(EltVT);
2125 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, &Ops[0], WidenNumElts);
2130 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2149 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, WidenVT, InOp, Idx);
2158 Ops[i] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
2159 DAG.getConstant(IdxVal+i, TLI.getVectorIdxTy()));
2161 SDValue UndefVal = DAG.getUNDEF(EltVT);
2164 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, &Ops[0], WidenNumElts);
2169 return DAG.getNode(ISD::INSERT_VECTOR_ELT, SDLoc(N),
2192 NewChain = DAG.getNode(ISD::TokenFactor, SDLoc(LD), MVT::Other,
2203 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2204 return DAG.getNode(ISD::SCALAR_TO_VECTOR, SDLoc(N),
2209 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2216 EVT CondWidenVT = EVT::getVectorVT(*DAG.getContext(),
2239 return DAG.getNode(N->getOpcode(), SDLoc(N),
2246 return DAG.getNode(ISD::SELECT_CC, SDLoc(N),
2257 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2260 return DAG.getNode(ISD::SETCC, SDLoc(N), WidenVT,
2265 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2266 return DAG.getUNDEF(WidenVT);
2273 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2291 return DAG.getVectorShuffle(WidenVT, dl, InOp1, InOp2, &NewMask[0]);
2298 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2304 EVT WidenInVT = EVT::getVectorVT(*DAG.getContext(),
2315 return DAG.getNode(ISD::SETCC, SDLoc(N),
2325 N->dump(&DAG);
2337 N->dump(&DAG);
2395 Ops[i] = DAG.getNode(Opcode, dl, EltVT,
2396 DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, InEltVT, InOp,
2397 DAG.getConstant(i, TLI.getVectorIdxTy())));
2399 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], NumElts);
2414 EVT NewVT = EVT::getVectorVT(*DAG.getContext(), VT, NewNumElts);
2416 SDValue BitOp = DAG.getNode(ISD::BITCAST, dl, NewVT, InOp);
2417 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, VT, BitOp,
2418 DAG.getConstant(0, TLI.getVectorIdxTy()));
2445 Ops[Idx++] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
2446 DAG.getConstant(j, TLI.getVectorIdxTy()));
2448 return DAG.getNode(ISD::BUILD_VECTOR, dl, VT, &Ops[0], NumElts);
2453 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N),
2459 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
2477 return DAG.getNode(ISD::TokenFactor, SDLoc(ST),
2492 EVT SVT = TLI.getSetCCResultType(*DAG.getContext(), InOp0.getValueType());
2493 SDValue WideSETCC = DAG.getNode(ISD::SETCC, SDLoc(N),
2497 EVT ResVT = EVT::getVectorVT(*DAG.getContext(),
2500 SDValue CC = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl,
2501 ResVT, WideSETCC, DAG.getConstant(0,
2519 static EVT FindMemType(SelectionDAG& DAG, const TargetLowering &TLI,
2572 static SDValue BuildVectorFromScalar(SelectionDAG& DAG, EVT VecTy,
2575 const TargetLowering &TLI = DAG.getTargetLoweringInfo();
2580 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), LdTy, NumElts);
2583 SDValue VecOp = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NewVecVT,LdOps[Start]);
2589 NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewLdTy, NumElts);
2590 VecOp = DAG.getNode(ISD::BITCAST, dl, NewVecVT, VecOp);
2595 VecOp = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NewVecVT, VecOp, LdOps[i],
2596 DAG.getConstant(Idx++, TLI.getVectorIdxTy()));
2598 return DAG.getNode(ISD::BITCAST, dl, VecTy, VecOp);
2607 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
2628 EVT NewVT = FindMemType(DAG, TLI, LdWidth, WidenVT, LdAlign, WidthDiff);
2630 SDValue LdOp = DAG.getLoad(NewVT, dl, Chain, BasePtr, LD->getPointerInfo(),
2639 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NumElts);
2640 SDValue VecOp = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, NewVecVT, LdOp);
2641 return DAG.getNode(ISD::BITCAST, dl, WidenVT, VecOp);
2649 SDValue UndefVal = DAG.getUNDEF(NewVT);
2653 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, &ConcatOps[0],
2667 BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
2668 DAG.getConstant(Increment, BasePtr.getValueType()));
2673 NewVT = FindMemType(DAG, TLI, LdWidth, WidenVT, LdAlign, WidthDiff);
2675 L = DAG.getLoad(NewVT, dl, Chain, BasePtr,
2685 Loads.push_back(DAG.getUNDEF(L->getValueType(0)));
2688 L = DAG.getNode(ISD::CONCAT_VECTORS, dl, LdOp->getValueType(0),
2692 L = DAG.getLoad(NewVT, dl, Chain, BasePtr,
2709 return BuildVectorFromScalar(DAG, WidenVT, LdOps, 0, End);
2725 ConcatOps[--Idx] = BuildVectorFromScalar(DAG, LdTy, LdOps, i+1, End);
2732 ConcatOps[End-1] = DAG.getNode(ISD::CONCAT_VECTORS, dl, NewLdTy,
2741 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT,
2747 SDValue UndefVal = DAG.getUNDEF(LdTy);
2755 return DAG.getNode(ISD::CONCAT_VECTORS, dl, WidenVT, &WidenOps[0],NumOps);
2764 EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(),LD->getValueType(0));
2785 Ops[0] = DAG.getExtLoad(ExtType, dl, EltVT, Chain, BasePtr,
2791 SDValue NewBasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(),
2793 DAG.getConstant(Offset,
2795 Ops[i] = DAG.getExtLoad(ExtType, dl, EltVT, Chain, NewBasePtr,
2802 SDValue UndefVal = DAG.getUNDEF(EltVT);
2806 return DAG.getNode(ISD::BUILD_VECTOR, dl, WidenVT, &Ops[0], Ops.size());
2836 EVT NewVT = FindMemType(DAG, TLI, StWidth, ValVT);
2842 SDValue EOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NewVT, ValOp,
2843 DAG.getConstant(Idx, TLI.getVectorIdxTy()));
2844 StChain.push_back(DAG.getStore(Chain, dl, EOp, BasePtr,
2851 BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
2852 DAG.getConstant(Increment, BasePtr.getValueType()));
2857 EVT NewVecVT = EVT::getVectorVT(*DAG.getContext(), NewVT, NumElts);
2858 SDValue VecOp = DAG.getNode(ISD::BITCAST, dl, NewVecVT, ValOp);
2862 SDValue EOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NewVT, VecOp,
2863 DAG.getConstant(Idx++, TLI.getVectorIdxTy()));
2864 StChain.push_back(DAG.getStore(Chain, dl, EOp, BasePtr,
2870 BasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(), BasePtr,
2871 DAG.getConstant(Increment, BasePtr.getValueType()));
2908 SDValue EOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ValEltVT, ValOp,
2909 DAG.getConstant(0, TLI.getVectorIdxTy()));
2910 StChain.push_back(DAG.getTruncStore(Chain, dl, EOp, BasePtr,
2916 SDValue NewBasePtr = DAG.getNode(ISD::ADD, dl, BasePtr.getValueType(),
2917 BasePtr, DAG.getConstant(Offset,
2919 SDValue EOp = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, ValEltVT, ValOp,
2920 DAG.getConstant(0, TLI.getVectorIdxTy()));
2921 StChain.push_back(DAG.getTruncStore(Chain, dl, EOp, NewBasePtr,
2947 SDValue UndefVal = DAG.getUNDEF(InVT);
2952 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, &Ops[0], NumConcat);
2956 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT, InOp,
2957 DAG.getConstant(0, TLI.getVectorIdxTy()));
2965 Ops[Idx] = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, EltVT, InOp,
2966 DAG.getConstant(Idx, TLI.getVectorIdxTy()));
2968 SDValue UndefVal = DAG.getUNDEF(EltVT);
2971 return DAG.getNode(ISD::BUILD_VECTOR, dl, NVT, &Ops[0], WidenNumElts);