Lines Matching defs: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 SDValue Res = DAG.getNode(N->getOpcode(), dl, 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(),
431 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
432 EVT ValueVTs[] = { N->getValueType(0), NVT };
453 EVT NVT = LHS.getValueType();
458 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
462 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
511 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
514 // otherwise just use the promoted result type (NVT).
516 SVT = NVT;
537 assert(NVT.bitsLE(SVT) && "Integer type overpromoted?");
539 return DAG.getNode(ISD::TRUNCATE, dl, NVT, SetCC);
582 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
600 assert(NumElts == NVT.getVectorNumElements() &&
608 EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
613 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
616 // Truncate to NVT instead of VT
617 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
629 EVT NVT = LHS.getValueType();
634 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
733 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
734 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
736 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
738 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
741 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
1278 EVT NVT = InL.getValueType();
1280 unsigned NVTBits = NVT.getSizeInBits();
1285 Lo = Hi = DAG.getConstant(0, NVT);
1287 Lo = DAG.getConstant(0, NVT);
1289 NVT, InL, DAG.getConstant(Amt-NVTBits, ShTy));
1291 Lo = DAG.getConstant(0, NVT);
1295 TLI.getTypeToExpandTo(*DAG.getContext(), NVT))) {
1297 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1303 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, ShTy));
1304 Hi = DAG.getNode(ISD::OR, DL, NVT,
1305 DAG.getNode(ISD::SHL, DL, NVT, InH,
1307 DAG.getNode(ISD::SRL, DL, NVT, InL,
1315 Lo = DAG.getConstant(0, NVT);
1316 Hi = DAG.getConstant(0, NVT);
1319 NVT, InH, DAG.getConstant(Amt-NVTBits,ShTy));
1320 Hi = DAG.getConstant(0, NVT);
1323 Hi = DAG.getConstant(0, NVT);
1325 Lo = DAG.getNode(ISD::OR, DL, NVT,
1326 DAG.getNode(ISD::SRL, DL, NVT, InL,
1328 DAG.getNode(ISD::SHL, DL, NVT, InH,
1330 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1337 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1340 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1342 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1346 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1349 Lo = DAG.getNode(ISD::OR, DL, NVT,
1350 DAG.getNode(ISD::SRL, DL, NVT, InL,
1352 DAG.getNode(ISD::SHL, DL, NVT, InH,
1354 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1365 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1368 unsigned NVTBits = NVT.getScalarType().getSizeInBits();
1395 Lo = DAG.getConstant(0, NVT); // Low part is zero.
1396 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1399 Hi = DAG.getConstant(0, NVT); // Hi part is zero.
1400 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1403 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1405 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1433 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, ShTy));
1435 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
1437 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1438 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1453 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1455 unsigned NVTBits = NVT.getSizeInBits();
1475 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
1476 HiS = DAG.getNode(ISD::OR, dl, NVT,
1477 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
1480 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
1483 LoL = DAG.getConstant(0, NVT); // Lo part is zero.
1484 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1486 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1487 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1491 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
1492 LoS = DAG.getNode(ISD::OR, dl, NVT,
1493 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1496 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1499 HiL = DAG.getConstant(0, NVT); // Hi part is zero.
1500 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1502 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1503 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1507 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
1508 LoS = DAG.getNode(ISD::OR, dl, NVT,
1509 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1512 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1515 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1517 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1519 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1520 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1533 EVT NVT = LHSL.getValueType();
1545 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1548 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1562 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps, 2);
1563 Hi = DAG.getNode(ISD::ADD, dl, NVT, HiOps, 2);
1564 SDValue Cmp1 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
1566 SDValue Carry1 = DAG.getSelect(dl, NVT, Cmp1,
1567 DAG.getConstant(1, NVT),
1568 DAG.getConstant(0, NVT));
1569 SDValue Cmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[1],
1571 SDValue Carry2 = DAG.getSelect(dl, NVT, Cmp2,
1572 DAG.getConstant(1, NVT), Carry1);
1573 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1575 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps, 2);
1576 Hi = DAG.getNode(ISD::SUB, dl, NVT, HiOps, 2);
1580 SDValue Borrow = DAG.getSelect(dl, NVT, Cmp,
1581 DAG.getConstant(1, NVT),
1582 DAG.getConstant(0, NVT));
1583 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1641 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1644 if (Op.getValueType().bitsLE(NVT)) {
1646 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1647 Hi = DAG.getUNDEF(NVT); // The high part is undefined.
1666 EVT NVT = Lo.getValueType();
1668 unsigned NVTBits = NVT.getSizeInBits();
1672 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1676 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1678 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1687 EVT NVT = Lo.getValueType();
1689 unsigned NVTBits = NVT.getSizeInBits();
1693 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1697 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1699 Hi = DAG.getConstant(0, NVT);
1713 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1714 unsigned NBitWidth = NVT.getSizeInBits();
1716 Lo = DAG.getConstant(Cst.trunc(NBitWidth), NVT);
1717 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), NVT);
1725 EVT NVT = Lo.getValueType();
1727 SDValue HiNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Hi,
1728 DAG.getConstant(0, NVT), ISD::SETNE);
1730 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1731 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1733 Lo = DAG.getSelect(dl, NVT, HiNotZero, HiLZ,
1734 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
1735 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1736 Hi = DAG.getConstant(0, NVT);
1744 EVT NVT = Lo.getValueType();
1745 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1746 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1747 Hi = DAG.getConstant(0, NVT);
1755 EVT NVT = Lo.getValueType();
1757 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
1758 DAG.getConstant(0, NVT), ISD::SETNE);
1760 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1761 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
1763 Lo = DAG.getSelect(dl, NVT, LoNotZero, LoLZ,
1764 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
1765 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1766 Hi = DAG.getConstant(0, NVT);
1803 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1814 assert(NVT.isByteSized() && "Expanded type not byte sized!");
1816 if (N->getMemoryVT().bitsLE(NVT)) {
1819 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1829 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1833 Hi = DAG.getConstant(0, NVT);
1837 Hi = DAG.getUNDEF(NVT);
1841 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
1846 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
1850 unsigned IncrementSize = NVT.getSizeInBits()/8;
1853 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
1867 unsigned IncrementSize = NVT.getSizeInBits()/8;
1871 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1880 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
1891 if (ExcessBits < NVT.getSizeInBits()) {
1893 Lo = DAG.getNode(ISD::OR, dl, NVT, Lo,
1894 DAG.getNode(ISD::SHL, dl, NVT, Hi,
1899 NVT, Hi,
1900 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
1923 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1926 bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, NVT);
1927 bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, NVT);
1928 bool HasSMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, NVT);
1929 bool HasUMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, NVT);
1935 unsigned InnerBitSize = NVT.getSizeInBits();
1945 Lo = DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1951 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1952 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1960 Lo = DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1966 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1967 Hi = DAG.getNode(ISD::MULHS, dl, NVT, LL, RL);
1974 DAG.getVTList(NVT, NVT), LL, RL);
1977 RH = DAG.getNode(ISD::MUL, dl, NVT, LL, RH);
1978 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1979 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1980 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
1984 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1985 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1986 RH = DAG.getNode(ISD::MUL, dl, NVT, LL, RH);
1987 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1988 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1989 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
2102 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2103 TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT);
2104 if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) ||
2177 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2180 if (Op.getValueType().bitsLE(NVT)) {
2182 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2184 unsigned LoSize = NVT.getSizeInBits();
2185 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2199 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2255 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2257 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2260 DAG.getConstant(NVT.getSizeInBits(), TLI.getPointerTy()));
2261 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2415 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2418 if (Op.getValueType().bitsLE(NVT)) {
2420 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2421 Hi = DAG.getConstant(0, NVT); // The high part is just a zero.
2434 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2708 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2718 assert(NVT.isByteSized() && "Expanded type not byte sized!");
2720 if (N->getMemoryVT().bitsLE(NVT)) {
2735 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
2739 unsigned IncrementSize = NVT.getSizeInBits()/8;
2755 unsigned IncrementSize = NVT.getSizeInBits()/8;
2760 if (ExcessBits < NVT.getSizeInBits()) {
2762 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
2763 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
2765 Hi = DAG.getNode(ISD::OR, dl, NVT, Hi,
2766 DAG.getNode(ISD::SRL, dl, NVT, Lo,