Lines Matching refs:NVT
212 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
215 // otherwise just use the promoted result type (NVT).
217 SVT = NVT;
310 EVT NVT = Op.getValueType();
313 unsigned DiffBits = NVT.getScalarSizeInBits() - OVT.getScalarSizeInBits();
315 ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op),
317 TLI.getShiftAmountTy(NVT, DAG.getDataLayout())));
323 EVT NVT = Op.getValueType();
326 unsigned DiffBits = NVT.getScalarSizeInBits() - OVT.getScalarSizeInBits();
328 ISD::SRL, dl, NVT, DAG.getNode(ISD::BITREVERSE, dl, NVT, Op),
330 TLI.getShiftAmountTy(NVT, DAG.getDataLayout())));
373 EVT NVT = Op.getValueType();
374 Op = DAG.getNode(N->getOpcode(), dl, NVT, Op);
377 ISD::SUB, dl, NVT, Op,
378 DAG.getConstant(NVT.getScalarSizeInBits() - OVT.getScalarSizeInBits(), dl,
379 NVT));
391 EVT NVT = Op.getValueType();
397 auto TopBit = APInt::getOneBitSet(NVT.getScalarSizeInBits(),
399 Op = DAG.getNode(ISD::OR, dl, NVT, Op, DAG.getConstant(TopBit, dl, NVT));
401 return DAG.getNode(N->getOpcode(), dl, NVT, Op);
406 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
407 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NVT, N->getOperand(0),
412 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
421 !TLI.isOperationLegal(ISD::FP_TO_UINT, NVT) &&
422 TLI.isOperationLegalOrCustom(ISD::FP_TO_SINT, NVT))
425 SDValue Res = DAG.getNode(NewOpc, dl, NVT, N->getOperand(0));
431 ISD::AssertZext : ISD::AssertSext, dl, NVT, Res,
436 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
439 SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
442 NVT, Res, DAG.getValueType(N->getValueType(0)));
446 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
452 assert(Res.getValueType().bitsLE(NVT) && "Extension doesn't make sense!");
456 if (NVT == Res.getValueType()) {
459 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
470 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
475 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
479 SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(),
489 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
493 SDValue Res = DAG.getMaskedLoad(NVT, dl, N->getChain(), N->getBasePtr(),
503 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
505 assert(NVT == ExtSrc0.getValueType() &&
511 SDValue Res = DAG.getMaskedGather(DAG.getVTList(NVT, MVT::Other),
523 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
524 EVT ValueVTs[] = { N->getValueType(0), NVT };
545 EVT NVT = LHS.getValueType();
550 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
554 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
595 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
598 // otherwise just use the promoted result type (NVT).
600 SVT = NVT;
621 assert(NVT.bitsLE(SVT) && "Integer type overpromoted?");
623 return DAG.getNode(ISD::TRUNCATE, dl, NVT, SetCC);
691 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
709 assert(NumElts == NVT.getVectorNumElements() &&
717 EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
722 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
725 // Truncate to NVT instead of VT
726 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
738 EVT NVT = LHS.getValueType();
743 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
836 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
837 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
839 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
841 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
844 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
1430 EVT NVT = InL.getValueType();
1432 unsigned NVTBits = NVT.getSizeInBits();
1437 Lo = Hi = DAG.getConstant(0, DL, NVT);
1439 Lo = DAG.getConstant(0, DL, NVT);
1441 NVT, InL, DAG.getConstant(Amt - NVTBits, DL, ShTy));
1443 Lo = DAG.getConstant(0, DL, NVT);
1447 TLI.getTypeToExpandTo(*DAG.getContext(), NVT))) {
1449 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1455 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, DL, ShTy));
1456 Hi = DAG.getNode(ISD::OR, DL, NVT,
1457 DAG.getNode(ISD::SHL, DL, NVT, InH,
1459 DAG.getNode(ISD::SRL, DL, NVT, InL,
1467 Lo = Hi = DAG.getConstant(0, DL, NVT);
1470 NVT, InH, DAG.getConstant(Amt - NVTBits, DL, ShTy));
1471 Hi = DAG.getConstant(0, DL, NVT);
1474 Hi = DAG.getConstant(0, DL, NVT);
1476 Lo = DAG.getNode(ISD::OR, DL, NVT,
1477 DAG.getNode(ISD::SRL, DL, NVT, InL,
1479 DAG.getNode(ISD::SHL, DL, NVT, InH,
1481 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, DL, ShTy));
1488 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1491 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1493 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1497 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1500 Lo = DAG.getNode(ISD::OR, DL, NVT,
1501 DAG.getNode(ISD::SRL, DL, NVT, InL,
1503 DAG.getNode(ISD::SHL, DL, NVT, InH,
1505 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, DL, ShTy));
1516 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1519 unsigned NVTBits = NVT.getScalarType().getSizeInBits();
1546 Lo = DAG.getConstant(0, dl, NVT); // Low part is zero.
1547 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1550 Hi = DAG.getConstant(0, dl, NVT); // Hi part is zero.
1551 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1554 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1556 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1584 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, dl, ShTy));
1586 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
1588 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1589 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1604 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1606 unsigned NVTBits = NVT.getSizeInBits();
1629 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
1630 HiS = DAG.getNode(ISD::OR, dl, NVT,
1631 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
1632 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
1635 LoL = DAG.getConstant(0, dl, NVT); // Lo part is zero.
1636 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1638 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1639 Hi = DAG.getSelect(dl, NVT, isZero, InH,
1640 DAG.getSelect(dl, NVT, isShort, HiS, HiL));
1644 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
1645 LoS = DAG.getNode(ISD::OR, dl, NVT,
1646 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1649 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1652 HiL = DAG.getConstant(0, dl, NVT); // Hi part is zero.
1653 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1655 Lo = DAG.getSelect(dl, NVT, isZero, InL,
1656 DAG.getSelect(dl, NVT, isShort, LoS, LoL));
1657 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1661 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
1662 LoS = DAG.getNode(ISD::OR, dl, NVT,
1663 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1664 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1667 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1669 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1671 Lo = DAG.getSelect(dl, NVT, isZero, InL,
1672 DAG.getSelect(dl, NVT, isShort, LoS, LoL));
1673 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1686 EVT NVT = LHSL.getValueType();
1698 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1701 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1717 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1719 SDVTList VTList = DAG.getVTList(NVT, NVT);
1720 TargetLoweringBase::BooleanContent BoolType = TLI.getBooleanContents(NVT);
1725 Hi = DAG.getNode(ISD::ADD, dl, NVT, makeArrayRef(HiOps, 2));
1729 Hi = DAG.getNode(ISD::SUB, dl, NVT, makeArrayRef(HiOps, 2));
1735 OVF = DAG.getNode(ISD::AND, dl, NVT, DAG.getConstant(1, dl, NVT), OVF);
1738 Hi = DAG.getNode(N->getOpcode(), dl, NVT, Hi, OVF);
1741 Hi = DAG.getNode(RevOpc, dl, NVT, Hi, OVF);
1747 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps);
1748 Hi = DAG.getNode(ISD::ADD, dl, NVT, makeArrayRef(HiOps, 2));
1749 SDValue Cmp1 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
1751 SDValue Carry1 = DAG.getSelect(dl, NVT, Cmp1,
1752 DAG.getConstant(1, dl, NVT),
1753 DAG.getConstant(0, dl, NVT));
1754 SDValue Cmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[1],
1756 SDValue Carry2 = DAG.getSelect(dl, NVT, Cmp2,
1757 DAG.getConstant(1, dl, NVT), Carry1);
1758 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1760 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps);
1761 Hi = DAG.getNode(ISD::SUB, dl, NVT, makeArrayRef(HiOps, 2));
1765 SDValue Borrow = DAG.getSelect(dl, NVT, Cmp,
1766 DAG.getConstant(1, dl, NVT),
1767 DAG.getConstant(0, dl, NVT));
1768 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1820 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1823 if (Op.getValueType().bitsLE(NVT)) {
1825 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1826 Hi = DAG.getUNDEF(NVT); // The high part is undefined.
1845 EVT NVT = Lo.getValueType();
1847 unsigned NVTBits = NVT.getSizeInBits();
1851 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1855 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1857 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1867 EVT NVT = Lo.getValueType();
1869 unsigned NVTBits = NVT.getSizeInBits();
1873 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1877 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1879 Hi = DAG.getConstant(0, dl, NVT);
1901 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1902 unsigned NBitWidth = NVT.getSizeInBits();
1908 Lo = DAG.getConstant(Cst.trunc(NBitWidth), dl, NVT, IsTarget, IsOpaque);
1909 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), dl, NVT, IsTarget,
1918 EVT NVT = Lo.getValueType();
1920 SDValue HiNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Hi,
1921 DAG.getConstant(0, dl, NVT), ISD::SETNE);
1923 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1924 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1926 Lo = DAG.getSelect(dl, NVT, HiNotZero, HiLZ,
1927 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
1928 DAG.getConstant(NVT.getSizeInBits(), dl,
1929 NVT)));
1930 Hi = DAG.getConstant(0, dl, NVT);
1938 EVT NVT = Lo.getValueType();
1939 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1940 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1941 Hi = DAG.getConstant(0, dl, NVT);
1949 EVT NVT = Lo.getValueType();
1951 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
1952 DAG.getConstant(0, dl, NVT), ISD::SETNE);
1954 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1955 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
1957 Lo = DAG.getSelect(dl, NVT, LoNotZero, LoLZ,
1958 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
1959 DAG.getConstant(NVT.getSizeInBits(), dl,
1960 NVT)));
1961 Hi = DAG.getConstant(0, dl, NVT);
2004 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2015 assert(NVT.isByteSized() && "Expanded type not byte sized!");
2017 if (N->getMemoryVT().bitsLE(NVT)) {
2020 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
2031 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2036 Hi = DAG.getConstant(0, dl, NVT);
2040 Hi = DAG.getUNDEF(NVT);
2044 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
2049 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
2053 unsigned IncrementSize = NVT.getSizeInBits()/8;
2056 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
2070 unsigned IncrementSize = NVT.getSizeInBits()/8;
2074 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
2084 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
2095 if (ExcessBits < NVT.getSizeInBits()) {
2098 ISD::OR, dl, NVT, Lo,
2099 DAG.getNode(ISD::SHL, dl, NVT, Hi,
2103 Hi = DAG.getNode(ExtType == ISD::SEXTLOAD ? ISD::SRA : ISD::SRL, dl, NVT,
2105 DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
2128 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2135 if (TLI.expandMUL(N, Lo, Hi, NVT, DAG, LL, LH, RL, RH))
2158 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2159 SDVTList VTs = DAG.getVTList(NVT, NVT, MVT::Other);
2262 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2263 TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT);
2264 if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) ||
2336 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2339 if (Op.getValueType().bitsLE(NVT)) {
2341 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2343 unsigned LoSize = NVT.getSizeInBits();
2345 ISD::SRA, dl, NVT, Lo,
2359 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2421 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2423 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2426 DAG.getConstant(NVT.getSizeInBits(), dl,
2428 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2594 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2597 if (Op.getValueType().bitsLE(NVT)) {
2599 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2600 Hi = DAG.getConstant(0, dl, NVT); // The high part is just a zero.
2613 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2955 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2965 assert(NVT.isByteSized() && "Expanded type not byte sized!");
2967 if (N->getMemoryVT().bitsLE(NVT)) {
2982 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
2986 unsigned IncrementSize = NVT.getSizeInBits()/8;
3002 unsigned IncrementSize = NVT.getSizeInBits()/8;
3007 if (ExcessBits < NVT.getSizeInBits()) {
3009 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
3010 DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
3013 ISD::OR, dl, NVT, Hi,
3014 DAG.getNode(ISD::SRL, dl, NVT, Lo,