Lines Matching refs:NVT
202 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
205 // otherwise just use the promoted result type (NVT).
207 SVT = NVT;
295 EVT NVT = Op.getValueType();
298 unsigned DiffBits = NVT.getScalarSizeInBits() - OVT.getScalarSizeInBits();
299 return DAG.getNode(ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op),
300 DAG.getConstant(DiffBits, TLI.getShiftAmountTy(NVT)));
343 EVT NVT = Op.getValueType();
344 Op = DAG.getNode(N->getOpcode(), dl, NVT, Op);
347 ISD::SUB, dl, NVT, Op,
348 DAG.getConstant(NVT.getScalarSizeInBits() - OVT.getScalarSizeInBits(),
349 NVT));
361 EVT NVT = Op.getValueType();
367 auto TopBit = APInt::getOneBitSet(NVT.getScalarSizeInBits(),
369 Op = DAG.getNode(ISD::OR, dl, NVT, Op, DAG.getConstant(TopBit, NVT));
371 return DAG.getNode(N->getOpcode(), dl, NVT, Op);
376 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
377 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NVT, N->getOperand(0),
382 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
391 !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) &&
392 TLI.isOperationLegalOrCustom(ISD::FP_TO_SINT, NVT))
395 SDValue Res = DAG.getNode(NewOpc, dl, NVT, N->getOperand(0));
401 ISD::AssertZext : ISD::AssertSext, dl, NVT, Res,
406 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
409 SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
412 NVT, Res, DAG.getValueType(N->getValueType(0)));
416 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
422 assert(Res.getValueType().bitsLE(NVT) && "Extension doesn't make sense!");
426 if (NVT == Res.getValueType()) {
429 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
440 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
445 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
449 SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(),
461 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
462 EVT ValueVTs[] = { N->getValueType(0), NVT };
483 EVT NVT = LHS.getValueType();
488 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
492 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
541 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
544 // otherwise just use the promoted result type (NVT).
546 SVT = NVT;
567 assert(NVT.bitsLE(SVT) && "Integer type overpromoted?");
569 return DAG.getNode(ISD::TRUNCATE, dl, NVT, SetCC);
612 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
630 assert(NumElts == NVT.getVectorNumElements() &&
638 EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
643 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
646 // Truncate to NVT instead of VT
647 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
659 EVT NVT = LHS.getValueType();
664 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
763 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
764 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
766 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
768 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
771 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
1327 EVT NVT = InL.getValueType();
1329 unsigned NVTBits = NVT.getSizeInBits();
1334 Lo = Hi = DAG.getConstant(0, NVT);
1336 Lo = DAG.getConstant(0, NVT);
1338 NVT, InL, DAG.getConstant(Amt-NVTBits, ShTy));
1340 Lo = DAG.getConstant(0, NVT);
1344 TLI.getTypeToExpandTo(*DAG.getContext(), NVT))) {
1346 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1352 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, ShTy));
1353 Hi = DAG.getNode(ISD::OR, DL, NVT,
1354 DAG.getNode(ISD::SHL, DL, NVT, InH,
1356 DAG.getNode(ISD::SRL, DL, NVT, InL,
1364 Lo = DAG.getConstant(0, NVT);
1365 Hi = DAG.getConstant(0, NVT);
1368 NVT, InH, DAG.getConstant(Amt-NVTBits,ShTy));
1369 Hi = DAG.getConstant(0, NVT);
1372 Hi = DAG.getConstant(0, NVT);
1374 Lo = DAG.getNode(ISD::OR, DL, NVT,
1375 DAG.getNode(ISD::SRL, DL, NVT, InL,
1377 DAG.getNode(ISD::SHL, DL, NVT, InH,
1379 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1386 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1389 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1391 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1395 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1398 Lo = DAG.getNode(ISD::OR, DL, NVT,
1399 DAG.getNode(ISD::SRL, DL, NVT, InL,
1401 DAG.getNode(ISD::SHL, DL, NVT, InH,
1403 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1414 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1417 unsigned NVTBits = NVT.getScalarType().getSizeInBits();
1444 Lo = DAG.getConstant(0, NVT); // Low part is zero.
1445 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1448 Hi = DAG.getConstant(0, NVT); // Hi part is zero.
1449 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1452 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1454 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1482 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, ShTy));
1484 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
1486 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1487 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1502 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1504 unsigned NVTBits = NVT.getSizeInBits();
1524 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
1525 HiS = DAG.getNode(ISD::OR, dl, NVT,
1526 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
1529 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
1532 LoL = DAG.getConstant(0, NVT); // Lo part is zero.
1533 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1535 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1536 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1540 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
1541 LoS = DAG.getNode(ISD::OR, dl, NVT,
1542 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1545 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1548 HiL = DAG.getConstant(0, NVT); // Hi part is zero.
1549 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1551 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1552 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1556 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
1557 LoS = DAG.getNode(ISD::OR, dl, NVT,
1558 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1561 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1564 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1566 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1568 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1569 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1582 EVT NVT = LHSL.getValueType();
1594 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1597 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1611 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps);
1612 Hi = DAG.getNode(ISD::ADD, dl, NVT, makeArrayRef(HiOps, 2));
1613 SDValue Cmp1 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
1615 SDValue Carry1 = DAG.getSelect(dl, NVT, Cmp1,
1616 DAG.getConstant(1, NVT),
1617 DAG.getConstant(0, NVT));
1618 SDValue Cmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[1],
1620 SDValue Carry2 = DAG.getSelect(dl, NVT, Cmp2,
1621 DAG.getConstant(1, NVT), Carry1);
1622 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1624 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps);
1625 Hi = DAG.getNode(ISD::SUB, dl, NVT, makeArrayRef(HiOps, 2));
1629 SDValue Borrow = DAG.getSelect(dl, NVT, Cmp,
1630 DAG.getConstant(1, NVT),
1631 DAG.getConstant(0, NVT));
1632 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1690 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1693 if (Op.getValueType().bitsLE(NVT)) {
1695 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1696 Hi = DAG.getUNDEF(NVT); // The high part is undefined.
1715 EVT NVT = Lo.getValueType();
1717 unsigned NVTBits = NVT.getSizeInBits();
1721 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1725 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1727 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1736 EVT NVT = Lo.getValueType();
1738 unsigned NVTBits = NVT.getSizeInBits();
1742 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1746 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1748 Hi = DAG.getConstant(0, NVT);
1762 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1763 unsigned NBitWidth = NVT.getSizeInBits();
1768 Lo = DAG.getConstant(Cst.trunc(NBitWidth), NVT, IsTarget, IsOpaque);
1769 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), NVT, IsTarget,
1778 EVT NVT = Lo.getValueType();
1780 SDValue HiNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Hi,
1781 DAG.getConstant(0, NVT), ISD::SETNE);
1783 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1784 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1786 Lo = DAG.getSelect(dl, NVT, HiNotZero, HiLZ,
1787 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
1788 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1789 Hi = DAG.getConstant(0, NVT);
1797 EVT NVT = Lo.getValueType();
1798 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1799 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1800 Hi = DAG.getConstant(0, NVT);
1808 EVT NVT = Lo.getValueType();
1810 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
1811 DAG.getConstant(0, NVT), ISD::SETNE);
1813 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1814 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
1816 Lo = DAG.getSelect(dl, NVT, LoNotZero, LoLZ,
1817 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
1818 DAG.getConstant(NVT.getSizeInBits(), NVT)));
1819 Hi = DAG.getConstant(0, NVT);
1856 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1867 assert(NVT.isByteSized() && "Expanded type not byte sized!");
1869 if (N->getMemoryVT().bitsLE(NVT)) {
1872 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1882 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1886 Hi = DAG.getConstant(0, NVT);
1890 Hi = DAG.getUNDEF(NVT);
1894 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
1899 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
1903 unsigned IncrementSize = NVT.getSizeInBits()/8;
1906 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
1920 unsigned IncrementSize = NVT.getSizeInBits()/8;
1924 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1933 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
1944 if (ExcessBits < NVT.getSizeInBits()) {
1946 Lo = DAG.getNode(ISD::OR, dl, NVT, Lo,
1947 DAG.getNode(ISD::SHL, dl, NVT, Hi,
1952 NVT, Hi,
1953 DAG.getConstant(NVT.getSizeInBits() - ExcessBits,
1976 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
1983 NVT, DAG, LL, LH, RL, RH))
2094 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2095 TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT);
2096 if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) ||
2169 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2172 if (Op.getValueType().bitsLE(NVT)) {
2174 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2176 unsigned LoSize = NVT.getSizeInBits();
2177 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2191 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2247 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2249 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2252 DAG.getConstant(NVT.getSizeInBits(), TLI.getPointerTy()));
2253 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2407 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2410 if (Op.getValueType().bitsLE(NVT)) {
2412 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2413 Hi = DAG.getConstant(0, NVT); // The high part is just a zero.
2426 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,
