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 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(),
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;
539 assert(NVT.bitsLE(SVT) && "Integer type overpromoted?");
541 return DAG.getNode(ISD::TRUNCATE, dl, NVT, SetCC);
584 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
602 assert(NumElts == NVT.getVectorNumElements() &&
610 EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
615 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
618 // Truncate to NVT instead of VT
619 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
631 EVT NVT = LHS.getValueType();
636 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
735 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
736 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
738 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
740 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
743 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
1275 EVT NVT = InL.getValueType();
1277 unsigned NVTBits = NVT.getSizeInBits();
1282 Lo = Hi = DAG.getConstant(0, NVT);
1284 Lo = DAG.getConstant(0, NVT);
1286 NVT, InL, DAG.getConstant(Amt-NVTBits, ShTy));
1288 Lo = DAG.getConstant(0, NVT);
1292 TLI.getTypeToExpandTo(*DAG.getContext(), NVT))) {
1294 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1300 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, ShTy));
1301 Hi = DAG.getNode(ISD::OR, DL, NVT,
1302 DAG.getNode(ISD::SHL, DL, NVT, InH,
1304 DAG.getNode(ISD::SRL, DL, NVT, InL,
1312 Lo = DAG.getConstant(0, NVT);
1313 Hi = DAG.getConstant(0, NVT);
1316 NVT, InH, DAG.getConstant(Amt-NVTBits,ShTy));
1317 Hi = DAG.getConstant(0, NVT);
1320 Hi = DAG.getConstant(0, NVT);
1322 Lo = DAG.getNode(ISD::OR, DL, NVT,
1323 DAG.getNode(ISD::SRL, DL, NVT, InL,
1325 DAG.getNode(ISD::SHL, DL, NVT, InH,
1327 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1334 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1337 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1339 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1343 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1346 Lo = DAG.getNode(ISD::OR, DL, NVT,
1347 DAG.getNode(ISD::SRL, DL, NVT, InL,
1349 DAG.getNode(ISD::SHL, DL, NVT, InH,
1351 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1362 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1365 unsigned NVTBits = NVT.getScalarType().getSizeInBits();
1392 Lo = DAG.getConstant(0, NVT); // Low part is zero.
1393 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1396 Hi = DAG.getConstant(0, NVT); // Hi part is zero.
1397 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1400 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1402 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1430 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, ShTy));
1432 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
1434 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1435 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1450 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1452 unsigned NVTBits = NVT.getSizeInBits();
1472 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
1473 HiS = DAG.getNode(ISD::OR, dl, NVT,
1474 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
1477 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
1480 LoL = DAG.getConstant(0, NVT); // Lo part is zero.
1481 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1483 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1484 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1488 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
1489 LoS = DAG.getNode(ISD::OR, dl, NVT,
1490 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1493 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1496 HiL = DAG.getConstant(0, NVT); // Hi part is zero.
1497 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1499 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1500 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1504 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
1505 LoS = DAG.getNode(ISD::OR, dl, NVT,
1506 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1509 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1512 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1514 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1516 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1517 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1530 EVT NVT = LHSL.getValueType();
1542 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1545 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1559 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps, 2);
1560 Hi = DAG.getNode(ISD::ADD, dl, NVT, HiOps, 2);
1561 SDValue Cmp1 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
1563 SDValue Carry1 = DAG.getSelect(dl, NVT, Cmp1,
1564 DAG.getConstant(1, NVT),
1565 DAG.getConstant(0, NVT));
1566 SDValue Cmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[1],
1568 SDValue Carry2 = DAG.getSelect(dl, NVT, Cmp2,
1569 DAG.getConstant(1, NVT), Carry1);
1570 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1572 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps, 2);
1573 Hi = DAG.getNode(ISD::SUB, dl, NVT, HiOps, 2);
1577 SDValue Borrow = DAG.getSelect(dl, NVT, Cmp,
1578 DAG.getConstant(1, NVT),
1579 DAG.getConstant(0, NVT));
1580 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1638 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1641 if (Op.getValueType().bitsLE(NVT)) {
1643 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1644 Hi = DAG.getUNDEF(NVT); // The high part is undefined.
1663 EVT NVT = Lo.getValueType();
1665 unsigned NVTBits = NVT.getSizeInBits();
1669 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1673 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1675 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1684 EVT NVT = Lo.getValueType();
1686 unsigned NVTBits = NVT.getSizeInBits();
1690 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1694 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1696 Hi = DAG.getConstant(0, NVT);
1710 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1711 unsigned NBitWidth = NVT.getSizeInBits();
1713 Lo = DAG.getConstant(Cst.trunc(NBitWidth), NVT);
1714 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), NVT);
1722 EVT NVT = Lo.getValueType();
1724 SDValue HiNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Hi,
1725 DAG.getConstant(0, NVT), ISD::SETNE);
1727 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1728 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1730 Lo = DAG.getSelect(dl, NVT, HiNotZero, HiLZ,
1731 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
1732 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1733 Hi = DAG.getConstant(0, NVT);
1741 EVT NVT = Lo.getValueType();
1742 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1743 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1744 Hi = DAG.getConstant(0, NVT);
1752 EVT NVT = Lo.getValueType();
1754 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
1755 DAG.getConstant(0, NVT), ISD::SETNE);
1757 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1758 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
1760 Lo = DAG.getSelect(dl, NVT, LoNotZero, LoLZ,
1761 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
1762 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1763 Hi = DAG.getConstant(0, NVT);
1798 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1808 assert(NVT.isByteSized() && "Expanded type not byte sized!");
1810 if (N->getMemoryVT().bitsLE(NVT)) {
1813 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1823 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1827 Hi = DAG.getConstant(0, NVT);
1831 Hi = DAG.getUNDEF(NVT);
1835 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
1839 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
1843 unsigned IncrementSize = NVT.getSizeInBits()/8;
1846 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
1860 unsigned IncrementSize = NVT.getSizeInBits()/8;
1864 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1873 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
1884 if (ExcessBits < NVT.getSizeInBits()) {
1886 Lo = DAG.getNode(ISD::OR, dl, NVT, Lo,
1887 DAG.getNode(ISD::SHL, dl, NVT, Hi,
1892 NVT, Hi,
1893 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
1916 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1919 bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, NVT);
1920 bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, NVT);
1921 bool HasSMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, NVT);
1922 bool HasUMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, NVT);
1928 unsigned InnerBitSize = NVT.getSizeInBits();
1938 Lo = DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1944 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1945 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1953 Lo = DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1959 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1960 Hi = DAG.getNode(ISD::MULHS, dl, NVT, LL, RL);
1967 DAG.getVTList(NVT, NVT), LL, RL);
1970 RH = DAG.getNode(ISD::MUL, dl, NVT, LL, RH);
1971 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1972 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1973 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
1977 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1978 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1979 RH = DAG.getNode(ISD::MUL, dl, NVT, LL, RH);
1980 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1981 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1982 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
2094 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2095 TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT);
2096 if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) ||
2168 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2171 if (Op.getValueType().bitsLE(NVT)) {
2173 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2175 unsigned LoSize = NVT.getSizeInBits();
2176 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2190 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2246 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2248 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2251 DAG.getConstant(NVT.getSizeInBits(), TLI.getPointerTy()));
2252 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2406 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2409 if (Op.getValueType().bitsLE(NVT)) {
2411 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2412 Hi = DAG.getConstant(0, NVT); // The high part is just a zero.
2425 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2699 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2708 assert(NVT.isByteSized() && "Expanded type not byte sized!");
2710 if (N->getMemoryVT().bitsLE(NVT)) {
2725 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
2729 unsigned IncrementSize = NVT.getSizeInBits()/8;
2745 unsigned IncrementSize = NVT.getSizeInBits()/8;
2750 if (ExcessBits < NVT.getSizeInBits()) {
2752 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
2753 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
2755 Hi = DAG.getNode(ISD::OR, dl, NVT, Hi,
2756 DAG.getNode(ISD::SRL, dl, NVT, Lo,
