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 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
443 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
449 assert(Res.getValueType().bitsLE(NVT) && "Extension doesn't make sense!");
453 if (NVT == Res.getValueType()) {
456 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
467 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
472 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
476 SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(),
486 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
490 SDValue Res = DAG.getMaskedLoad(NVT, dl, N->getChain(), N->getBasePtr(),
500 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
502 assert(NVT == ExtSrc0.getValueType() &&
508 SDValue Res = DAG.getMaskedGather(DAG.getVTList(NVT, MVT::Other),
520 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
521 EVT ValueVTs[] = { N->getValueType(0), NVT };
542 EVT NVT = LHS.getValueType();
547 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
551 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
592 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
595 // otherwise just use the promoted result type (NVT).
597 SVT = NVT;
618 assert(NVT.bitsLE(SVT) && "Integer type overpromoted?");
620 return DAG.getNode(ISD::TRUNCATE, dl, NVT, SetCC);
688 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
706 assert(NumElts == NVT.getVectorNumElements() &&
714 EVT HalfNVT = EVT::getVectorVT(*DAG.getContext(), NVT.getScalarType(),
719 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
722 // Truncate to NVT instead of VT
723 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
735 EVT NVT = LHS.getValueType();
740 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
833 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
834 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
836 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
838 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
841 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
1427 EVT NVT = InL.getValueType();
1429 unsigned NVTBits = NVT.getSizeInBits();
1434 Lo = Hi = DAG.getConstant(0, DL, NVT);
1436 Lo = DAG.getConstant(0, DL, NVT);
1438 NVT, InL, DAG.getConstant(Amt - NVTBits, DL, ShTy));
1440 Lo = DAG.getConstant(0, DL, NVT);
1444 TLI.getTypeToExpandTo(*DAG.getContext(), NVT))) {
1446 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1452 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, DL, ShTy));
1453 Hi = DAG.getNode(ISD::OR, DL, NVT,
1454 DAG.getNode(ISD::SHL, DL, NVT, InH,
1456 DAG.getNode(ISD::SRL, DL, NVT, InL,
1464 Lo = Hi = DAG.getConstant(0, DL, NVT);
1467 NVT, InH, DAG.getConstant(Amt - NVTBits, DL, ShTy));
1468 Hi = DAG.getConstant(0, DL, NVT);
1471 Hi = DAG.getConstant(0, DL, NVT);
1473 Lo = DAG.getNode(ISD::OR, DL, NVT,
1474 DAG.getNode(ISD::SRL, DL, NVT, InL,
1476 DAG.getNode(ISD::SHL, DL, NVT, InH,
1478 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, DL, ShTy));
1485 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1488 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1490 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1494 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1497 Lo = DAG.getNode(ISD::OR, DL, NVT,
1498 DAG.getNode(ISD::SRL, DL, NVT, InL,
1500 DAG.getNode(ISD::SHL, DL, NVT, InH,
1502 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, DL, ShTy));
1513 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1516 unsigned NVTBits = NVT.getScalarType().getSizeInBits();
1543 Lo = DAG.getConstant(0, dl, NVT); // Low part is zero.
1544 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1547 Hi = DAG.getConstant(0, dl, NVT); // Hi part is zero.
1548 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1551 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1553 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1581 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, dl, ShTy));
1583 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
1585 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1586 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1601 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1603 unsigned NVTBits = NVT.getSizeInBits();
1626 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
1627 HiS = DAG.getNode(ISD::OR, dl, NVT,
1628 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
1629 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
1632 LoL = DAG.getConstant(0, dl, NVT); // Lo part is zero.
1633 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1635 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1636 Hi = DAG.getSelect(dl, NVT, isZero, InH,
1637 DAG.getSelect(dl, NVT, isShort, HiS, HiL));
1641 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
1642 LoS = DAG.getNode(ISD::OR, dl, NVT,
1643 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1646 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1649 HiL = DAG.getConstant(0, dl, NVT); // Hi part is zero.
1650 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1652 Lo = DAG.getSelect(dl, NVT, isZero, InL,
1653 DAG.getSelect(dl, NVT, isShort, LoS, LoL));
1654 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1658 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
1659 LoS = DAG.getNode(ISD::OR, dl, NVT,
1660 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
1661 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
1664 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1666 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1668 Lo = DAG.getSelect(dl, NVT, isZero, InL,
1669 DAG.getSelect(dl, NVT, isShort, LoS, LoL));
1670 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
1683 EVT NVT = LHSL.getValueType();
1695 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1698 SDVTList VTList = DAG.getVTList(NVT, MVT::Glue);
1714 TLI.getTypeToExpandTo(*DAG.getContext(), NVT));
1716 SDVTList VTList = DAG.getVTList(NVT, NVT);
1717 TargetLoweringBase::BooleanContent BoolType = TLI.getBooleanContents(NVT);
1722 Hi = DAG.getNode(ISD::ADD, dl, NVT, makeArrayRef(HiOps, 2));
1726 Hi = DAG.getNode(ISD::SUB, dl, NVT, makeArrayRef(HiOps, 2));
1732 OVF = DAG.getNode(ISD::AND, dl, NVT, DAG.getConstant(1, dl, NVT), OVF);
1735 Hi = DAG.getNode(N->getOpcode(), dl, NVT, Hi, OVF);
1738 Hi = DAG.getNode(RevOpc, dl, NVT, Hi, OVF);
1744 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps);
1745 Hi = DAG.getNode(ISD::ADD, dl, NVT, makeArrayRef(HiOps, 2));
1746 SDValue Cmp1 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
1748 SDValue Carry1 = DAG.getSelect(dl, NVT, Cmp1,
1749 DAG.getConstant(1, dl, NVT),
1750 DAG.getConstant(0, dl, NVT));
1751 SDValue Cmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[1],
1753 SDValue Carry2 = DAG.getSelect(dl, NVT, Cmp2,
1754 DAG.getConstant(1, dl, NVT), Carry1);
1755 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1757 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps);
1758 Hi = DAG.getNode(ISD::SUB, dl, NVT, makeArrayRef(HiOps, 2));
1762 SDValue Borrow = DAG.getSelect(dl, NVT, Cmp,
1763 DAG.getConstant(1, dl, NVT),
1764 DAG.getConstant(0, dl, NVT));
1765 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1817 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1820 if (Op.getValueType().bitsLE(NVT)) {
1822 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1823 Hi = DAG.getUNDEF(NVT); // The high part is undefined.
1842 EVT NVT = Lo.getValueType();
1844 unsigned NVTBits = NVT.getSizeInBits();
1848 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1852 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1854 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1864 EVT NVT = Lo.getValueType();
1866 unsigned NVTBits = NVT.getSizeInBits();
1870 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1874 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1876 Hi = DAG.getConstant(0, dl, NVT);
1898 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
1899 unsigned NBitWidth = NVT.getSizeInBits();
1905 Lo = DAG.getConstant(Cst.trunc(NBitWidth), dl, NVT, IsTarget, IsOpaque);
1906 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), dl, NVT, IsTarget,
1915 EVT NVT = Lo.getValueType();
1917 SDValue HiNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Hi,
1918 DAG.getConstant(0, dl, NVT), ISD::SETNE);
1920 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1921 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1923 Lo = DAG.getSelect(dl, NVT, HiNotZero, HiLZ,
1924 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
1925 DAG.getConstant(NVT.getSizeInBits(), dl,
1926 NVT)));
1927 Hi = DAG.getConstant(0, dl, NVT);
1935 EVT NVT = Lo.getValueType();
1936 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1937 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1938 Hi = DAG.getConstant(0, dl, NVT);
1946 EVT NVT = Lo.getValueType();
1948 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
1949 DAG.getConstant(0, dl, NVT), ISD::SETNE);
1951 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1952 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
1954 Lo = DAG.getSelect(dl, NVT, LoNotZero, LoLZ,
1955 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
1956 DAG.getConstant(NVT.getSizeInBits(), dl,
1957 NVT)));
1958 Hi = DAG.getConstant(0, dl, NVT);
2001 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2012 assert(NVT.isByteSized() && "Expanded type not byte sized!");
2014 if (N->getMemoryVT().bitsLE(NVT)) {
2017 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
2028 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2033 Hi = DAG.getConstant(0, dl, NVT);
2037 Hi = DAG.getUNDEF(NVT);
2041 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
2046 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
2050 unsigned IncrementSize = NVT.getSizeInBits()/8;
2053 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
2067 unsigned IncrementSize = NVT.getSizeInBits()/8;
2071 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
2081 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
2092 if (ExcessBits < NVT.getSizeInBits()) {
2095 ISD::OR, dl, NVT, Lo,
2096 DAG.getNode(ISD::SHL, dl, NVT, Hi,
2100 Hi = DAG.getNode(ExtType == ISD::SEXTLOAD ? ISD::SRA : ISD::SRL, dl, NVT,
2102 DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
2125 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2132 if (TLI.expandMUL(N, Lo, Hi, NVT, DAG, LL, LH, RL, RH))
2155 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2156 SDVTList VTs = DAG.getVTList(NVT, NVT, MVT::Other);
2259 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2260 TargetLowering::LegalizeAction Action = TLI.getOperationAction(PartsOpc, NVT);
2261 if ((Action == TargetLowering::Legal && TLI.isTypeLegal(NVT)) ||
2333 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2336 if (Op.getValueType().bitsLE(NVT)) {
2338 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2340 unsigned LoSize = NVT.getSizeInBits();
2342 ISD::SRA, dl, NVT, Lo,
2356 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2418 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2420 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2423 DAG.getConstant(NVT.getSizeInBits(), dl,
2425 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2591 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
2594 if (Op.getValueType().bitsLE(NVT)) {
2596 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2597 Hi = DAG.getConstant(0, dl, NVT); // The high part is just a zero.
2610 Op.getValueType().getSizeInBits() - NVT.getSizeInBits();
2952 EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
2962 assert(NVT.isByteSized() && "Expanded type not byte sized!");
2964 if (N->getMemoryVT().bitsLE(NVT)) {
2979 N->getMemoryVT().getSizeInBits() - NVT.getSizeInBits();
2983 unsigned IncrementSize = NVT.getSizeInBits()/8;
2999 unsigned IncrementSize = NVT.getSizeInBits()/8;
3004 if (ExcessBits < NVT.getSizeInBits()) {
3006 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
3007 DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
3010 ISD::OR, dl, NVT, Hi,
3011 DAG.getNode(ISD::SRL, dl, NVT, Lo,
