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 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);
565 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
567 return DAG.getNode(ISD::SRL, N->getDebugLoc(), NVT, Res, N->getOperand(1));
571 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
589 assert(NumElts == NVT.getVectorNumElements() &&
596 EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
606 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
609 // Truncate to NVT instead of VT
610 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
622 EVT NVT = LHS.getValueType();
627 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
718 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
719 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
721 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
723 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
726 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
1268 EVT NVT = InL.getValueType();
1270 unsigned NVTBits = NVT.getSizeInBits();
1275 Lo = Hi = DAG.getConstant(0, NVT);
1277 Lo = DAG.getConstant(0, NVT);
1279 NVT, InL, DAG.getConstant(Amt-NVTBits, ShTy));
1281 Lo = DAG.getConstant(0, NVT);
1285 TLI.getTypeToExpandTo(*DAG.getContext(), NVT))) {
1287 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1293 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, ShTy));
1294 Hi = DAG.getNode(ISD::OR, DL, NVT,
1295 DAG.getNode(ISD::SHL, DL, NVT, InH,
1297 DAG.getNode(ISD::SRL, DL, NVT, InL,
1305 Lo = DAG.getConstant(0, NVT);
1306 Hi = DAG.getConstant(0, NVT);
1309 NVT, InH, DAG.getConstant(Amt-NVTBits,ShTy));
1310 Hi = DAG.getConstant(0, NVT);
1313 Hi = DAG.getConstant(0, NVT);
1315 Lo = DAG.getNode(ISD::OR, DL, NVT,
1316 DAG.getNode(ISD::SRL, DL, NVT, InL,
1318 DAG.getNode(ISD::SHL, DL, NVT, InH,
1320 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1327 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1330 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1332 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1336 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1339 Lo = DAG.getNode(ISD::OR, DL, NVT,
1340 DAG.getNode(ISD::SRL, DL, NVT, InL,
1342 DAG.getNode(ISD::SHL, DL, NVT, InH,
1344 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1355 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1358 unsigned NVTBits = NVT.getScalarType().getSizeInBits();
1385 Lo = DAG.getConstant(0, NVT); // Low part is zero.
1386 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1389 Hi = DAG.getConstant(0, NVT); // Hi part is zero.
1390 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1393 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1395 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1423 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, ShTy));
1425 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
1427 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1428 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1443 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1445 unsigned NVTBits = NVT.getSizeInBits();
1465 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
1466 HiS = DAG.getNode(ISD::OR, dl, NVT,
1467 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
1470 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
1473 LoL = DAG.getConstant(0, NVT); // Lo part is zero.
1474 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1476 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1477 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1481 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
1482 LoS = DAG.getNode(ISD::OR, dl, NVT,
1483 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1486 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1489 HiL = DAG.getConstant(0, NVT); // Hi part is zero.
1490 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1492 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1493 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1497 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
1498 LoS = DAG.getNode(ISD::OR, dl, NVT,
1499 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1502 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1505 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1507 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1509 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1510 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1523 EVT NVT = LHSL.getValueType();
1535 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1538 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1552 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps, 2);
1553 Hi = DAG.getNode(ISD::ADD, dl, NVT, HiOps, 2);
1554 SDValue Cmp1 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo, LoOps[0],
1556 SDValue Carry1 = DAG.getNode(ISD::SELECT, dl, NVT, Cmp1,
1557 DAG.getConstant(1, NVT),
1558 DAG.getConstant(0, NVT));
1559 SDValue Cmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo, LoOps[1],
1561 SDValue Carry2 = DAG.getNode(ISD::SELECT, dl, NVT, Cmp2,
1562 DAG.getConstant(1, NVT), Carry1);
1563 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1565 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps, 2);
1566 Hi = DAG.getNode(ISD::SUB, dl, NVT, HiOps, 2);
1570 SDValue Borrow = DAG.getNode(ISD::SELECT, dl, NVT, Cmp,
1571 DAG.getConstant(1, NVT),
1572 DAG.getConstant(0, NVT));
1573 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1631 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1634 if (Op.getValueType().bitsLE(NVT)) {
1636 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1637 Hi = DAG.getUNDEF(NVT); // The high part is undefined.
1656 EVT NVT = Lo.getValueType();
1658 unsigned NVTBits = NVT.getSizeInBits();
1662 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1666 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1668 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1677 EVT NVT = Lo.getValueType();
1679 unsigned NVTBits = NVT.getSizeInBits();
1683 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1687 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1689 Hi = DAG.getConstant(0, NVT);
1703 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1704 unsigned NBitWidth = NVT.getSizeInBits();
1706 Lo = DAG.getConstant(Cst.trunc(NBitWidth), NVT);
1707 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), NVT);
1715 EVT NVT = Lo.getValueType();
1717 SDValue HiNotZero = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Hi,
1718 DAG.getConstant(0, NVT), ISD::SETNE);
1720 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1721 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1723 Lo = DAG.getNode(ISD::SELECT, dl, NVT, HiNotZero, HiLZ,
1724 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
1725 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1726 Hi = DAG.getConstant(0, NVT);
1734 EVT NVT = Lo.getValueType();
1735 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1736 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1737 Hi = DAG.getConstant(0, NVT);
1745 EVT NVT = Lo.getValueType();
1747 SDValue LoNotZero = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo,
1748 DAG.getConstant(0, NVT), ISD::SETNE);
1750 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1751 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
1753 Lo = DAG.getNode(ISD::SELECT, dl, NVT, LoNotZero, LoLZ,
1754 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
1755 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1756 Hi = DAG.getConstant(0, NVT);
1789 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1799 assert(NVT.isByteSized() && "Expanded type not byte sized!");
1801 if (N->getMemoryVT().bitsLE(NVT)) {
1804 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1814 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1818 Hi = DAG.getConstant(0, NVT);
1822 Hi = DAG.getUNDEF(NVT);
1826 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
1830 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
1834 unsigned IncrementSize = NVT.getSizeInBits()/8;
1837 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
1851 unsigned IncrementSize = NVT.getSizeInBits()/8;
1855 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1864 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
1875 if (ExcessBits < NVT.getSizeInBits()) {
1877 Lo = DAG.getNode(ISD::OR, dl, NVT, Lo,
1878 DAG.getNode(ISD::SHL, dl, NVT, Hi,
1883 NVT, Hi,
1884 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
1907 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1910 bool HasMULHS = TLI.isOperationLegalOrCustom(ISD::MULHS, NVT);
1911 bool HasMULHU = TLI.isOperationLegalOrCustom(ISD::MULHU, NVT);
1912 bool HasSMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::SMUL_LOHI, NVT);
1913 bool HasUMUL_LOHI = TLI.isOperationLegalOrCustom(ISD::UMUL_LOHI, NVT);
1919 unsigned InnerBitSize = NVT.getSizeInBits();
1929 Lo = DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1935 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1936 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1944 Lo = DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1950 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1951 Hi = DAG.getNode(ISD::MULHS, dl, NVT, LL, RL);
1958 DAG.getVTList(NVT, NVT), LL, RL);
1961 NVT, LL, RH);
1962 LH = DAG.getNode(ISD::MUL, dl, NVT, LH, RL);
1963 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1964 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
1968 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1969 Hi = DAG.getNode(ISD::MULHU, dl, 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);
2084 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2085 TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT);
2086 if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) ||
2147 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2150 if (Op.getValueType().bitsLE(NVT)) {
2152 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2154 unsigned LoSize = NVT.getSizeInBits();
2155 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2169 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2225 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2227 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2230 DAG.getConstant(NVT.getSizeInBits(), TLI.getPointerTy()));
2231 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2381 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2384 if (Op.getValueType().bitsLE(NVT)) {
2386 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2387 Hi = DAG.getConstant(0, NVT); // The high part is just a zero.
2400 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2674 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2683 assert(NVT.isByteSized() && "Expanded type not byte sized!");
2685 if (N->getMemoryVT().bitsLE(NVT)) {
2700 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
2704 unsigned IncrementSize = NVT.getSizeInBits()/8;
2720 unsigned IncrementSize = NVT.getSizeInBits()/8;
2725 if (ExcessBits < NVT.getSizeInBits()) {
2727 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
2728 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
2730 Hi = DAG.getNode(ISD::OR, dl, NVT, Hi,
2731 DAG.getNode(ISD::SRL, dl, NVT, Lo,
