Lines Matching refs:NVT
266 EVT NVT = Op.getValueType();
269 unsigned DiffBits = NVT.getSizeInBits() - OVT.getSizeInBits();
270 return DAG.getNode(ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op),
314 EVT NVT = Op.getValueType();
315 Op = DAG.getNode(N->getOpcode(), dl, NVT, Op);
317 return DAG.getNode(ISD::SUB, dl, NVT, Op,
318 DAG.getConstant(NVT.getSizeInBits() -
319 OVT.getSizeInBits(), NVT));
331 EVT NVT = Op.getValueType();
337 APInt TopBit(NVT.getSizeInBits(), 0);
339 Op = DAG.getNode(ISD::OR, dl, NVT, Op, DAG.getConstant(TopBit, NVT));
341 return DAG.getNode(N->getOpcode(), dl, NVT, Op);
346 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
347 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NVT, N->getOperand(0),
352 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
361 !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) &&
362 TLI.isOperationLegalOrCustom(ISD::FP_TO_SINT, NVT))
365 SDValue Res = DAG.getNode(NewOpc, dl, NVT, N->getOperand(0));
371 ISD::AssertZext : ISD::AssertSext, dl, NVT, Res,
376 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
379 NVT, N->getOperand(0));
382 NVT, Res, DAG.getValueType(N->getValueType(0)));
386 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
392 assert(Res.getValueType().bitsLE(NVT) && "Extension doesn't make sense!");
396 if (NVT == Res.getValueType()) {
399 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
410 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
415 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
419 SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(),
433 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
434 EVT ValueVTs[] = { N->getValueType(0), NVT };
455 EVT NVT = LHS.getValueType();
460 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
464 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
513 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
516 // otherwise just use the promoted result type (NVT).
518 SVT = NVT;
528 assert(NVT.bitsLE(SVT) && "Integer type overpromoted?");
530 return DAG.getNode(ISD::TRUNCATE, dl, NVT, SetCC);
573 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
591 assert(NumElts == NVT.getVectorNumElements() &&
599 EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
604 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
607 // Truncate to NVT instead of VT
608 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
620 EVT NVT = LHS.getValueType();
625 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
724 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
725 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
727 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
729 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
732 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
1274 EVT NVT = InL.getValueType();
1276 unsigned NVTBits = NVT.getSizeInBits();
1281 Lo = Hi = DAG.getConstant(0, NVT);
1283 Lo = DAG.getConstant(0, NVT);
1285 NVT, InL, DAG.getConstant(Amt-NVTBits, ShTy));
1287 Lo = DAG.getConstant(0, NVT);
1291 TLI.getTypeToExpandTo(*DAG.getContext(), NVT))) {
1293 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1299 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, ShTy));
1300 Hi = DAG.getNode(ISD::OR, DL, NVT,
1301 DAG.getNode(ISD::SHL, DL, NVT, InH,
1303 DAG.getNode(ISD::SRL, DL, NVT, InL,
1311 Lo = DAG.getConstant(0, NVT);
1312 Hi = DAG.getConstant(0, NVT);
1315 NVT, InH, DAG.getConstant(Amt-NVTBits,ShTy));
1316 Hi = DAG.getConstant(0, NVT);
1319 Hi = DAG.getConstant(0, NVT);
1321 Lo = DAG.getNode(ISD::OR, DL, NVT,
1322 DAG.getNode(ISD::SRL, DL, NVT, InL,
1324 DAG.getNode(ISD::SHL, DL, NVT, InH,
1326 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1333 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1336 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1338 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1342 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1345 Lo = DAG.getNode(ISD::OR, DL, NVT,
1346 DAG.getNode(ISD::SRL, DL, NVT, InL,
1348 DAG.getNode(ISD::SHL, DL, NVT, InH,
1350 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1361 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1364 unsigned NVTBits = NVT.getScalarType().getSizeInBits();
1391 Lo = DAG.getConstant(0, NVT); // Low part is zero.
1392 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1395 Hi = DAG.getConstant(0, NVT); // Hi part is zero.
1396 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1399 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1401 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1429 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, ShTy));
1431 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
1433 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1434 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1449 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1451 unsigned NVTBits = NVT.getSizeInBits();
1471 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
1472 HiS = DAG.getNode(ISD::OR, dl, NVT,
1473 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
1476 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
1479 LoL = DAG.getConstant(0, NVT); // Lo part is zero.
1480 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1482 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1483 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1487 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
1488 LoS = DAG.getNode(ISD::OR, dl, NVT,
1489 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1492 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1495 HiL = DAG.getConstant(0, NVT); // Hi part is zero.
1496 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1498 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1499 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1503 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
1504 LoS = DAG.getNode(ISD::OR, dl, NVT,
1505 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1508 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1511 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1513 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1515 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1516 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1529 EVT NVT = LHSL.getValueType();
1541 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1544 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1558 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps, 2);
1559 Hi = DAG.getNode(ISD::ADD, dl, NVT, HiOps, 2);
1560 SDValue Cmp1 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo, LoOps[0],
1562 SDValue Carry1 = DAG.getNode(ISD::SELECT, dl, NVT, Cmp1,
1563 DAG.getConstant(1, NVT),
1564 DAG.getConstant(0, NVT));
1565 SDValue Cmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo, LoOps[1],
1567 SDValue Carry2 = DAG.getNode(ISD::SELECT, dl, NVT, Cmp2,
1568 NVT), Carry1);
1569 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1571 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps, 2);
1572 Hi = DAG.getNode(ISD::SUB, dl, NVT, HiOps, 2);
1576 SDValue Borrow = DAG.getNode(ISD::SELECT, dl, NVT, Cmp,
1577 DAG.getConstant(1, NVT),
1578 DAG.getConstant(0, NVT));
1579 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1637 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1640 if (Op.getValueType().bitsLE(NVT)) {
1642 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1643 Hi = DAG.getUNDEF(NVT); // The high part is undefined.
1662 EVT NVT = Lo.getValueType();
1664 unsigned NVTBits = NVT.getSizeInBits();
1668 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1672 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1674 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1683 EVT NVT = Lo.getValueType();
1685 unsigned NVTBits = NVT.getSizeInBits();
1689 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1693 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1695 Hi = DAG.getConstant(0, NVT);
1709 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1710 unsigned NBitWidth = NVT.getSizeInBits();
1712 Lo = DAG.getConstant(Cst.trunc(NBitWidth), NVT);
1713 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), NVT);
1721 EVT NVT = Lo.getValueType();
1723 SDValue HiNotZero = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Hi,
1724 DAG.getConstant(0, NVT), ISD::SETNE);
1726 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1727 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1729 Lo = DAG.getNode(ISD::SELECT, dl, NVT, HiNotZero, HiLZ,
1730 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
1731 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1732 Hi = DAG.getConstant(0, NVT);
1740 EVT NVT = Lo.getValueType();
1741 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1742 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1743 Hi = DAG.getConstant(0, NVT);
1751 EVT NVT = Lo.getValueType();
1753 SDValue LoNotZero = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo,
1754 DAG.getConstant(0, NVT), ISD::SETNE);
1756 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1757 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
1759 Lo = DAG.getNode(ISD::SELECT, dl, NVT, LoNotZero, LoLZ,
1760 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
1761 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1762 Hi = DAG.getConstant(0, NVT);
1797 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1807 assert(NVT.isByteSized() && "Expanded type not byte sized!");
1809 if (N->getMemoryVT().bitsLE(NVT)) {
1812 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1822 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1826 Hi = DAG.getConstant(0, NVT);
1830 Hi = DAG.getUNDEF(NVT);
1834 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
1838 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
1842 unsigned IncrementSize = NVT.getSizeInBits()/8;
1845 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
1859 unsigned IncrementSize = NVT.getSizeInBits()/8;
1863 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1872 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
1883 if (ExcessBits < NVT.getSizeInBits()) {
1885 Lo = DAG.getNode(ISD::OR, dl, NVT, Lo,
1886 DAG.getNode(ISD::SHL, dl, NVT, Hi,
1891 NVT, Hi,
1892 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
1915 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1918 bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, NVT);
1919 bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, NVT);
1920 bool HasSMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, NVT);
1921 bool HasUMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, NVT);
1927 unsigned InnerBitSize = NVT.getSizeInBits();
1937 Lo = DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1943 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1944 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1952 Lo = DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1958 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1959 Hi = DAG.getNode(ISD::MULHS, dl, NVT, LL, RL);
1966 DAG.getVTList(NVT, NVT), LL, RL);
1969 RH = DAG.getNode(ISD::MUL, dl, NVT, LL, RH);
1970 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1971 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1972 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
1976 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1977 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1978 RH = DAG.getNode(ISD::MUL, dl, NVT, LL, RH);
1979 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1980 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1981 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
2093 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2094 TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT);
2095 if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) ||
2167 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2170 if (Op.getValueType().bitsLE(NVT)) {
2172 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2174 unsigned LoSize = NVT.getSizeInBits();
2175 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2189 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2245 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2247 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2250 DAG.getConstant(NVT.getSizeInBits(), TLI.getPointerTy()));
2251 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2405 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2408 if (Op.getValueType().bitsLE(NVT)) {
2410 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2411 Hi = DAG.getConstant(0, NVT); // The high part is just a zero.
2424 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2698 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2707 assert(NVT.isByteSized() && "Expanded type not byte sized!");
2709 if (N->getMemoryVT().bitsLE(NVT)) {
2724 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
2728 unsigned IncrementSize = NVT.getSizeInBits()/8;
2744 unsigned IncrementSize = NVT.getSizeInBits()/8;
2749 if (ExcessBits < NVT.getSizeInBits()) {
2751 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
2752 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
2754 Hi = DAG.getNode(ISD::OR, dl, NVT, Hi,
2755 DAG.getNode(ISD::SRL, dl, NVT, Lo,
