Lines Matching refs:SDValue
40 SDValue Res = SDValue();
212 SetPromotedInteger(SDValue(N, ResNo), Res);
215 SDValue DAGTypeLegalizer::PromoteIntRes_MERGE_VALUES(SDNode *N,
217 SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
221 SDValue DAGTypeLegalizer::PromoteIntRes_AssertSext(SDNode *N) {
223 SDValue Op = SExtPromotedInteger(N->getOperand(0));
228 SDValue DAGTypeLegalizer::PromoteIntRes_AssertZext(SDNode *N) {
230 SDValue Op = ZExtPromotedInteger(N->getOperand(0));
235 SDValue DAGTypeLegalizer::PromoteIntRes_Atomic0(AtomicSDNode *N) {
237 SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),
243 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
247 SDValue DAGTypeLegalizer::PromoteIntRes_Atomic1(AtomicSDNode *N) {
248 SDValue Op2 = GetPromotedInteger(N->getOperand(2));
249 SDValue Res = DAG.getAtomic(N->getOpcode(), SDLoc(N),
255 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
259 SDValue DAGTypeLegalizer::PromoteIntRes_AtomicCmpSwap(AtomicSDNode *N,
272 SDValue Res = DAG.getAtomicCmpSwap(
276 ReplaceValueWith(SDValue(N, 0), Res.getValue(0));
277 ReplaceValueWith(SDValue(N, 2), Res.getValue(2));
283 SDValue Op2 = N->getOperand(2);
284 SDValue Op3 = GetPromotedInteger(N->getOperand(3));
301 SDValue Res = DAG.getAtomicCmpSwap(
306 ReplaceValueWith(SDValue(N, i), Res.getValue(i));
310 SDValue DAGTypeLegalizer::PromoteIntRes_BITCAST(SDNode *N) {
311 SDValue InOp = N->getOperand(0);
353 SDValue Lo, Hi;
374 SDValue Res =
426 SDValue DAGTypeLegalizer::PromoteIntRes_FREEZE(SDNode *N) {
427 SDValue V = GetPromotedInteger(N->getOperand(0));
432 SDValue DAGTypeLegalizer::PromoteIntRes_BSWAP(SDNode *N) {
433 SDValue Op = GetPromotedInteger(N->getOperand(0));
444 SDValue DAGTypeLegalizer::PromoteIntRes_BITREVERSE(SDNode *N) {
445 SDValue Op = GetPromotedInteger(N->getOperand(0));
457 SDValue DAGTypeLegalizer::PromoteIntRes_BUILD_PAIR(SDNode *N) {
466 SDValue DAGTypeLegalizer::PromoteIntRes_Constant(SDNode *N) {
473 SDValue Result = DAG.getNode(Opc, dl,
475 SDValue(N, 0));
480 SDValue DAGTypeLegalizer::PromoteIntRes_CTLZ(SDNode *N) {
482 SDValue Op = ZExtPromotedInteger(N->getOperand(0));
494 SDValue DAGTypeLegalizer::PromoteIntRes_CTPOP(SDNode *N) {
496 SDValue Op = ZExtPromotedInteger(N->getOperand(0));
500 SDValue DAGTypeLegalizer::PromoteIntRes_CTTZ(SDNode *N) {
501 SDValue Op = GetPromotedInteger(N->getOperand(0));
516 SDValue DAGTypeLegalizer::PromoteIntRes_EXTRACT_VECTOR_ELT(SDNode *N) {
520 SDValue Op0 = N->getOperand(0);
521 SDValue Op1 = N->getOperand(1);
527 SDValue In = GetPromotedInteger(Op0);
533 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT, In, Op1);
541 SDValue DAGTypeLegalizer::PromoteIntRes_FP_TO_XINT(SDNode *N) {
560 SDValue Res;
566 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
583 SDValue DAGTypeLegalizer::PromoteIntRes_FP_TO_FP16(SDNode *N) {
590 SDValue DAGTypeLegalizer::PromoteIntRes_FLT_ROUNDS(SDNode *N) {
594 SDValue Res =
599 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
603 SDValue DAGTypeLegalizer::PromoteIntRes_INT_EXTEND(SDNode *N) {
609 SDValue Res = GetPromotedInteger(N->getOperand(0));
630 SDValue DAGTypeLegalizer::PromoteIntRes_LOAD(LoadSDNode *N) {
636 SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(),
641 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
645 SDValue DAGTypeLegalizer::PromoteIntRes_MLOAD(MaskedLoadSDNode *N) {
647 SDValue ExtPassThru = GetPromotedInteger(N->getPassThru());
650 SDValue Res = DAG.getMaskedLoad(NVT, dl, N->getChain(), N->getBasePtr(),
656 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
660 SDValue DAGTypeLegalizer::PromoteIntRes_MGATHER(MaskedGatherSDNode *N) {
662 SDValue ExtPassThru = GetPromotedInteger(N->getPassThru());
667 SDValue Ops[] = {N->getChain(), ExtPassThru, N->getMask(), N->getBasePtr(),
669 SDValue Res = DAG.getMaskedGather(DAG.getVTList(NVT, MVT::Other),
674 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
679 SDValue DAGTypeLegalizer::PromoteIntRes_Overflow(SDNode *N) {
685 SDValue Ops[3] = { N->getOperand(0), N->getOperand(1) };
692 SDValue Res = DAG.getNode(N->getOpcode(), dl, DAG.getVTList(VT, SVT),
697 ReplaceValueWith(SDValue(N, 0), Res);
703 SDValue DAGTypeLegalizer::PromoteIntRes_ADDSUBSAT(SDNode *N) {
712 SDValue Op1 = N->getOperand(0);
713 SDValue Op2 = N->getOperand(1);
718 SDValue Op1Promoted, Op2Promoted;
747 SDValue ShiftAmount = DAG.getConstant(SHLAmount, dl, SHVT);
753 SDValue Result =
758 SDValue Max =
765 SDValue SatMax = DAG.getConstant(MaxVal, dl, PromotedType);
766 SDValue Add =
774 SDValue SatMin = DAG.getConstant(MinVal, dl, PromotedType);
775 SDValue SatMax = DAG.getConstant(MaxVal, dl, PromotedType);
776 SDValue Result =
784 SDValue DAGTypeLegalizer::PromoteIntRes_MULFIX(SDNode *N) {
787 SDValue Op1Promoted, Op2Promoted;
812 SDValue Result = DAG.getNode(N->getOpcode(), dl, PromotedType, Op1Promoted,
822 static SDValue SaturateWidenedDIVFIX(SDValue V, SDLoc &dl,
850 static SDValue earlyExpandDIVFIX(SDNode *N, SDValue LHS, SDValue RHS,
875 SDValue Res = TLI.expandFixedPointDiv(N->getOpcode(), dl, LHS, RHS, Scale,
890 SDValue DAGTypeLegalizer::PromoteIntRes_DIVFIX(SDNode *N) {
892 SDValue Op1Promoted, Op2Promoted;
919 SDValue Res = DAG.getNode(N->getOpcode(), dl, PromotedType, Op1Promoted,
929 if (SDValue Res = TLI.expandFixedPointDiv(N->getOpcode(), dl, Op1Promoted,
944 SDValue DAGTypeLegalizer::PromoteIntRes_SADDSUBO(SDNode *N, unsigned ResNo) {
950 SDValue LHS = SExtPromotedInteger(N->getOperand(0));
951 SDValue RHS = SExtPromotedInteger(N->getOperand(1));
958 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
962 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
968 ReplaceValueWith(SDValue(N, 1), Ofl);
973 SDValue DAGTypeLegalizer::PromoteIntRes_SELECT(SDNode *N) {
974 SDValue LHS = GetPromotedInteger(N->getOperand(1));
975 SDValue RHS = GetPromotedInteger(N->getOperand(2));
980 SDValue DAGTypeLegalizer::PromoteIntRes_VSELECT(SDNode *N) {
981 SDValue Mask = N->getOperand(0);
983 SDValue LHS = GetPromotedInteger(N->getOperand(1));
984 SDValue RHS = GetPromotedInteger(N->getOperand(2));
989 SDValue DAGTypeLegalizer::PromoteIntRes_SELECT_CC(SDNode *N) {
990 SDValue LHS = GetPromotedInteger(N->getOperand(2));
991 SDValue RHS = GetPromotedInteger(N->getOperand(3));
997 SDValue DAGTypeLegalizer::PromoteIntRes_SETCC(SDNode *N) {
1022 SDValue SetCC;
1025 SDValue Opers[] = {N->getOperand(0), N->getOperand(1),
1030 ReplaceValueWith(SDValue(N, 1), SetCC.getValue(1));
1039 SDValue DAGTypeLegalizer::PromoteIntRes_SHL(SDNode *N) {
1040 SDValue LHS = GetPromotedInteger(N->getOperand(0));
1041 SDValue RHS = N->getOperand(1);
1047 SDValue DAGTypeLegalizer::PromoteIntRes_SIGN_EXTEND_INREG(SDNode *N) {
1048 SDValue Op = GetPromotedInteger(N->getOperand(0));
1053 SDValue DAGTypeLegalizer::PromoteIntRes_SimpleIntBinOp(SDNode *N) {
1057 SDValue LHS = GetPromotedInteger(N->getOperand(0));
1058 SDValue RHS = GetPromotedInteger(N->getOperand(1));
1063 SDValue DAGTypeLegalizer::PromoteIntRes_SExtIntBinOp(SDNode *N) {
1065 SDValue LHS = SExtPromotedInteger(N->getOperand(0));
1066 SDValue RHS = SExtPromotedInteger(N->getOperand(1));
1071 SDValue DAGTypeLegalizer::PromoteIntRes_ZExtIntBinOp(SDNode *N) {
1073 SDValue LHS = ZExtPromotedInteger(N->getOperand(0));
1074 SDValue RHS = ZExtPromotedInteger(N->getOperand(1));
1079 SDValue DAGTypeLegalizer::PromoteIntRes_SRA(SDNode *N) {
1081 SDValue LHS = SExtPromotedInteger(N->getOperand(0));
1082 SDValue RHS = N->getOperand(1);
1088 SDValue DAGTypeLegalizer::PromoteIntRes_SRL(SDNode *N) {
1090 SDValue LHS = ZExtPromotedInteger(N->getOperand(0));
1091 SDValue RHS = N->getOperand(1);
1097 SDValue DAGTypeLegalizer::PromoteIntRes_TRUNCATE(SDNode *N) {
1099 SDValue Res;
1100 SDValue InOp = N->getOperand(0);
1121 SDValue EOp1, EOp2;
1132 SDValue WideInOp = GetWidenedVector(InOp);
1138 SDValue WideTrunc = DAG.getNode(ISD::TRUNCATE, dl, TruncVT, WideInOp);
1143 SDValue WideExt = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, WideTrunc);
1146 SDValue ZeroIdx = DAG.getVectorIdxConstant(0, dl);
1155 SDValue DAGTypeLegalizer::PromoteIntRes_UADDSUBO(SDNode *N, unsigned ResNo) {
1161 SDValue LHS = ZExtPromotedInteger(N->getOperand(0));
1162 SDValue RHS = ZExtPromotedInteger(N->getOperand(1));
1169 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
1173 SDValue Ofl = DAG.getZeroExtendInReg(Res, dl, OVT);
1178 ReplaceValueWith(SDValue(N, 1), Ofl);
1186 SDValue DAGTypeLegalizer::PromoteIntRes_ADDSUBCARRY(SDNode *N, unsigned ResNo) {
1200 SDValue LHS = SExtPromotedInteger(N->getOperand(0));
1201 SDValue RHS = SExtPromotedInteger(N->getOperand(1));
1206 SDValue Res = DAG.getNode(N->getOpcode(), SDLoc(N), DAG.getVTList(ValueVTs),
1210 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
1212 return SDValue(Res.getNode(), 0);
1215 SDValue DAGTypeLegalizer::PromoteIntRes_ABS(SDNode *N) {
1216 SDValue Op0 = SExtPromotedInteger(N->getOperand(0));
1220 SDValue DAGTypeLegalizer::PromoteIntRes_XMULO(SDNode *N, unsigned ResNo) {
1225 SDValue LHS = N->getOperand(0), RHS = N->getOperand(1);
1241 SDValue Mul = DAG.getNode(N->getOpcode(), DL, VTs, LHS, RHS);
1246 SDValue Overflow;
1251 SDValue Hi = DAG.getNode(ISD::SRL, DL, Mul.getValueType(), Mul,
1258 SDValue SExt = DAG.getNode(ISD::SIGN_EXTEND_INREG, DL, Mul.getValueType(),
1266 SDValue(Mul.getNode(), 1));
1269 ReplaceValueWith(SDValue(N, 1), Overflow);
1273 SDValue DAGTypeLegalizer::PromoteIntRes_UNDEF(SDNode *N) {
1278 SDValue DAGTypeLegalizer::PromoteIntRes_VSCALE(SDNode *N) {
1285 SDValue DAGTypeLegalizer::PromoteIntRes_VAARG(SDNode *N) {
1286 SDValue Chain = N->getOperand(0); // Get the chain.
1287 SDValue Ptr = N->getOperand(1); // Get the pointer.
1295 SmallVector<SDValue, 8> Parts(NumRegs);
1308 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
1310 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
1320 ReplaceValueWith(SDValue(N, 1), Chain);
1336 SDValue Res = SDValue();
1442 ReplaceValueWith(SDValue(N, 0), Res);
1444 ReplaceValueWith(SDValue(N, 1), SDValue(Res.getNode(), 1));
1451 void DAGTypeLegalizer::PromoteSetCCOperands(SDValue &NewLHS,SDValue &NewRHS,
1461 SDValue OpL = GetPromotedInteger(NewLHS);
1462 SDValue OpR = GetPromotedInteger(NewRHS);
1499 SDValue DAGTypeLegalizer::PromoteIntOp_ANY_EXTEND(SDNode *N) {
1500 SDValue Op = GetPromotedInteger(N->getOperand(0));
1504 SDValue DAGTypeLegalizer::PromoteIntOp_ATOMIC_STORE(AtomicSDNode *N) {
1505 SDValue Op2 = GetPromotedInteger(N->getOperand(2));
1510 SDValue DAGTypeLegalizer::PromoteIntOp_BITCAST(SDNode *N) {
1516 SDValue DAGTypeLegalizer::PromoteIntOp_BR_CC(SDNode *N, unsigned OpNo) {
1519 SDValue LHS = N->getOperand(2);
1520 SDValue RHS = N->getOperand(3);
1525 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1530 SDValue DAGTypeLegalizer::PromoteIntOp_BRCOND(SDNode *N, unsigned OpNo) {
1534 SDValue Cond = PromoteTargetBoolean(N->getOperand(1), MVT::Other);
1537 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0), Cond,
1541 SDValue DAGTypeLegalizer::PromoteIntOp_BUILD_PAIR(SDNode *N) {
1544 SDValue Lo = ZExtPromotedInteger(N->getOperand(0));
1545 SDValue Hi = GetPromotedInteger(N->getOperand(1));
1555 SDValue DAGTypeLegalizer::PromoteIntOp_BUILD_VECTOR(SDNode *N) {
1571 SmallVector<SDValue, 16> NewOps;
1575 return SDValue(DAG.UpdateNodeOperands(N, NewOps), 0);
1578 SDValue DAGTypeLegalizer::PromoteIntOp_INSERT_VECTOR_ELT(SDNode *N,
1588 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1597 SDValue Idx = DAG.getZExtOrTrunc(N->getOperand(2), SDLoc(N),
1599 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1603 SDValue DAGTypeLegalizer::PromoteIntOp_SCALAR_TO_VECTOR(SDNode *N) {
1606 return SDValue(DAG.UpdateNodeOperands(N,
1610 SDValue DAGTypeLegalizer::PromoteIntOp_SPLAT_VECTOR(SDNode *N) {
1613 return SDValue(
1617 SDValue DAGTypeLegalizer::PromoteIntOp_SELECT(SDNode *N, unsigned OpNo) {
1619 SDValue Cond = N->getOperand(0);
1623 if (SDValue Res = WidenVSELECTAndMask(N))
1630 return SDValue(DAG.UpdateNodeOperands(N, Cond, N->getOperand(1),
1634 SDValue DAGTypeLegalizer::PromoteIntOp_SELECT_CC(SDNode *N, unsigned OpNo) {
1637 SDValue LHS = N->getOperand(0);
1638 SDValue RHS = N->getOperand(1);
1642 return SDValue(DAG.UpdateNodeOperands(N, LHS, RHS, N->getOperand(2),
1646 SDValue DAGTypeLegalizer::PromoteIntOp_SETCC(SDNode *N, unsigned OpNo) {
1649 SDValue LHS = N->getOperand(0);
1650 SDValue RHS = N->getOperand(1);
1654 return SDValue(DAG.UpdateNodeOperands(N, LHS, RHS, N->getOperand(2)), 0);
1657 SDValue DAGTypeLegalizer::PromoteIntOp_Shift(SDNode *N) {
1658 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1662 SDValue DAGTypeLegalizer::PromoteIntOp_SIGN_EXTEND(SDNode *N) {
1663 SDValue Op = GetPromotedInteger(N->getOperand(0));
1670 SDValue DAGTypeLegalizer::PromoteIntOp_SINT_TO_FP(SDNode *N) {
1671 return SDValue(DAG.UpdateNodeOperands(N,
1675 SDValue DAGTypeLegalizer::PromoteIntOp_STRICT_SINT_TO_FP(SDNode *N) {
1676 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1680 SDValue DAGTypeLegalizer::PromoteIntOp_STORE(StoreSDNode *N, unsigned OpNo){
1682 SDValue Ch = N->getChain(), Ptr = N->getBasePtr();
1685 SDValue Val = GetPromotedInteger(N->getValue()); // Get promoted value.
1692 SDValue DAGTypeLegalizer::PromoteIntOp_MSTORE(MaskedStoreSDNode *N,
1695 SDValue DataOp = N->getValue();
1697 SDValue Mask = N->getMask();
1704 SmallVector<SDValue, 4> NewOps(N->op_begin(), N->op_end());
1706 return SDValue(DAG.UpdateNodeOperands(N, NewOps), 0);
1719 SDValue DAGTypeLegalizer::PromoteIntOp_MLOAD(MaskedLoadSDNode *N,
1723 SDValue Mask = PromoteTargetBoolean(N->getOperand(OpNo), DataVT);
1724 SmallVector<SDValue, 4> NewOps(N->op_begin(), N->op_end());
1728 return SDValue(Res, 0);
1731 ReplaceValueWith(SDValue(N, 0), SDValue(Res, 0));
1732 ReplaceValueWith(SDValue(N, 1), SDValue(Res, 1));
1733 return SDValue();
1736 SDValue DAGTypeLegalizer::PromoteIntOp_MGATHER(MaskedGatherSDNode *N,
1739 SmallVector<SDValue, 5> NewOps(N->op_begin(), N->op_end());
1756 return SDValue(Res, 0);
1759 ReplaceValueWith(SDValue(N, 0), SDValue(Res, 0));
1760 ReplaceValueWith(SDValue(N, 1), SDValue(Res, 1));
1761 return SDValue();
1764 SDValue DAGTypeLegalizer::PromoteIntOp_MSCATTER(MaskedScatterSDNode *N,
1766 SmallVector<SDValue, 5> NewOps(N->op_begin(), N->op_end());
1780 return SDValue(DAG.UpdateNodeOperands(N, NewOps), 0);
1783 SDValue DAGTypeLegalizer::PromoteIntOp_TRUNCATE(SDNode *N) {
1784 SDValue Op = GetPromotedInteger(N->getOperand(0));
1788 SDValue DAGTypeLegalizer::PromoteIntOp_UINT_TO_FP(SDNode *N) {
1789 return SDValue(DAG.UpdateNodeOperands(N,
1793 SDValue DAGTypeLegalizer::PromoteIntOp_STRICT_UINT_TO_FP(SDNode *N) {
1794 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1798 SDValue DAGTypeLegalizer::PromoteIntOp_ZERO_EXTEND(SDNode *N) {
1800 SDValue Op = GetPromotedInteger(N->getOperand(0));
1805 SDValue DAGTypeLegalizer::PromoteIntOp_ADDSUBCARRY(SDNode *N, unsigned OpNo) {
1808 SDValue LHS = N->getOperand(0);
1809 SDValue RHS = N->getOperand(1);
1810 SDValue Carry = N->getOperand(2);
1815 return SDValue(DAG.UpdateNodeOperands(N, LHS, RHS, Carry), 0);
1818 SDValue DAGTypeLegalizer::PromoteIntOp_FIX(SDNode *N) {
1819 SDValue Op2 = ZExtPromotedInteger(N->getOperand(2));
1820 return SDValue(
1824 SDValue DAGTypeLegalizer::PromoteIntOp_FRAMERETURNADDR(SDNode *N) {
1826 SDValue Op = ZExtPromotedInteger(N->getOperand(0));
1827 return SDValue(DAG.UpdateNodeOperands(N, Op), 0);
1830 SDValue DAGTypeLegalizer::PromoteIntOp_PREFETCH(SDNode *N, unsigned OpNo) {
1834 SDValue Op2 = ZExtPromotedInteger(N->getOperand(2));
1835 SDValue Op3 = ZExtPromotedInteger(N->getOperand(3));
1836 SDValue Op4 = ZExtPromotedInteger(N->getOperand(4));
1837 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0), N->getOperand(1),
1842 SDValue DAGTypeLegalizer::PromoteIntOp_FPOWI(SDNode *N) {
1843 SDValue Op = SExtPromotedInteger(N->getOperand(1));
1844 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0), Op), 0);
1847 SDValue DAGTypeLegalizer::PromoteIntOp_VECREDUCE(SDNode *N) {
1849 SDValue Op;
1876 SDValue Reduce = DAG.getNode(N->getOpcode(), dl, EltVT, Op);
1891 SDValue Lo, Hi;
1892 Lo = Hi = SDValue();
1966 std::pair<SDValue, SDValue> Tmp = ExpandAtomic(N);
1968 ReplaceValueWith(SDValue(N, 1), Tmp.second);
1974 SDValue Tmp = DAG.getAtomicCmpSwap(
1982 SDValue Success = DAG.getSetCC(SDLoc(N), N->getValueType(1), Tmp,
1986 ReplaceValueWith(SDValue(N, 1), Success);
1987 ReplaceValueWith(SDValue(N, 2), Tmp.getValue(1));
2051 SetExpandedInteger(SDValue(N, ResNo), Lo, Hi);
2055 std::pair <SDValue, SDValue> DAGTypeLegalizer::ExpandAtomic(SDNode *Node) {
2062 SmallVector<SDValue, 4> Ops(Node->op_begin() + 1, Node->op_end());
2071 SDValue &Lo, SDValue &Hi) {
2074 SDValue InL, InH;
2160 ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
2161 SDValue Amt = N->getOperand(1);
2178 SDValue InL, InH;
2212 SDValue Amt2 = DAG.getNode(ISD::XOR, dl, ShTy, Amt,
2229 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, dl, ShTy));
2231 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
2247 ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
2248 SDValue Amt = N->getOperand(1);
2257 SDValue InL, InH;
2260 SDValue NVBitsNode = DAG.getConstant(NVTBits, dl, ShTy);
2261 SDValue AmtExcess = DAG.getNode(ISD::SUB, dl, ShTy, Amt, NVBitsNode);
2262 SDValue AmtLack = DAG.getNode(ISD::SUB, dl, ShTy, NVBitsNode, Amt);
2263 SDValue isShort = DAG.getSetCC(dl, getSetCCResultType(ShTy),
2265 SDValue isZero = DAG.getSetCC(dl, getSetCCResultType(ShTy),
2269 SDValue LoS, HiS, LoL, HiL;
2339 SDValue &Lo, SDValue &Hi) {
2346 SDValue LHSL, LHSH, RHSL, RHSH;
2359 SDValue IsHiLeft = DAG.getSetCC(DL, CCT, LHSH, RHSH, CondC);
2360 SDValue IsHiEq = DAG.getSetCC(DL, CCT, LHSH, RHSH, ISD::SETEQ);
2363 SDValue LoCmp = DAG.getSelect(DL, NVT, IsHiLeft, LHSL, RHSL);
2366 SDValue LoMinMax = DAG.getNode(LoOpc, DL, NVT, {LHSL, RHSL});
2372 SDValue &Lo, SDValue &Hi) {
2375 SDValue LHSL, LHSH, RHSL, RHSH;
2380 SDValue LoOps[2] = { LHSL, RHSL };
2381 SDValue HiOps[3] = { LHSH, RHSH };
2443 SDValue OVF = Lo.getValue(1);
2463 SDValue Cmp1 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
2467 SDValue Carry = DAG.getZExtOrTrunc(Cmp1, dl, NVT);
2472 SDValue Carry1 = DAG.getSelect(dl, NVT, Cmp1,
2475 SDValue Cmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[1],
2477 SDValue Carry2 = DAG.getSelect(dl, NVT, Cmp2,
2483 SDValue Cmp =
2487 SDValue Borrow;
2499 SDValue &Lo, SDValue &Hi) {
2501 SDValue LHSL, LHSH, RHSL, RHSH;
2506 SDValue LoOps[2] = { LHSL, RHSL };
2507 SDValue HiOps[3] = { LHSH, RHSH };
2521 ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
2525 SDValue &Lo, SDValue &Hi) {
2527 SDValue LHSL, LHSH, RHSL, RHSH;
2532 SDValue LoOps[3] = { LHSL, RHSL, N->getOperand(2) };
2533 SDValue HiOps[3] = { LHSH, RHSH };
2541 ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
2545 SDValue &Lo, SDValue &Hi) {
2546 SDValue LHS = N->getOperand(0);
2547 SDValue RHS = N->getOperand(1);
2550 SDValue Ovf;
2574 SDValue LHSL, LHSH, RHSL, RHSH;
2578 SDValue LoOps[2] = { LHSL, RHSL };
2579 SDValue HiOps[3] = { LHSH, RHSH };
2589 SDValue Sum = DAG.getNode(NoCarryOp, dl, LHS.getValueType(), LHS, RHS);
2599 ReplaceValueWith(SDValue(N, 1), Ovf);
2603 SDValue &Lo, SDValue &Hi) {
2605 SDValue LHSL, LHSH, RHSL, RHSH;
2610 SDValue LoOps[3] = { LHSL, RHSL, N->getOperand(2) };
2611 SDValue HiOps[3] = { LHSH, RHSH, SDValue() };
2619 ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
2623 SDValue &Lo, SDValue &Hi) {
2626 SDValue Op = N->getOperand(0);
2637 SDValue Res = GetPromotedInteger(Op);
2646 SDValue &Lo, SDValue &Hi) {
2668 SDValue &Lo, SDValue &Hi) {
2688 SDValue &Lo, SDValue &Hi) {
2696 SDValue &Lo, SDValue &Hi) {
2704 SDValue &Lo, SDValue &Hi) {
2717 void DAGTypeLegalizer::ExpandIntRes_ABS(SDNode *N, SDValue &Lo, SDValue &Hi) {
2722 SDValue N0 = N->getOperand(0);
2723 SDValue Neg = DAG.getNode(ISD::SUB, dl, VT,
2725 SDValue NegLo, NegHi;
2730 SDValue HiIsNeg = DAG.getSetCC(dl, getSetCCResultType(NVT),
2737 SDValue &Lo, SDValue &Hi) {
2743 SDValue HiNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Hi,
2746 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
2747 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
2757 SDValue &Lo, SDValue &Hi) {
2768 SDValue &Lo, SDValue &Hi) {
2774 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
2777 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
2778 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
2787 void DAGTypeLegalizer::ExpandIntRes_FLT_ROUNDS(SDNode *N, SDValue &Lo,
2788 SDValue &Hi) {
2795 SDValue Chain = Lo.getValue(1);
2802 ReplaceValueWith(SDValue(N, 1), Chain);
2805 void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDValue &Lo,
2806 SDValue &Hi) {
2811 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
2812 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
2826 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, VT, Op,
2831 ReplaceValueWith(SDValue(N, 1), Tmp.second);
2834 void DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDValue &Lo,
2835 SDValue &Hi) {
2840 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
2841 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
2854 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, VT, Op,
2859 ReplaceValueWith(SDValue(N, 1), Tmp.second);
2862 void DAGTypeLegalizer::ExpandIntRes_LLROUND_LLRINT(SDNode *N, SDValue &Lo,
2863 SDValue &Hi) {
2864 SDValue Op = N->getOperand(N->isStrictFPOpcode() ? 1 : 0);
2903 SDValue Chain = N->isStrictFPOpcode() ? N->getOperand(0) : SDValue();
2907 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, RetVT,
2913 ReplaceValueWith(SDValue(N, 1), Tmp.second);
2917 SDValue &Lo, SDValue &Hi) {
2923 SDValue Zero = DAG.getConstant(0, dl, VT);
2924 SDValue Swap = DAG.getAtomicCmpSwap(
2928 ReplaceValueWith(SDValue(N, 0), Swap.getValue(0));
2929 ReplaceValueWith(SDValue(N, 1), Swap.getValue(2));
2942 SDValue Ch = N->getChain();
2943 SDValue Ptr = N->getBasePtr();
3039 ReplaceValueWith(SDValue(N, 1), Ch);
3043 SDValue &Lo, SDValue &Hi) {
3045 SDValue LL, LH, RL, RH;
3053 SDValue &Lo, SDValue &Hi) {
3058 SDValue LL, LH, RL, RH;
3085 SDValue Mask = DAG.getConstant(APInt::getLowBitsSet(Bits, HalfBits), dl,
3087 SDValue LLL = DAG.getNode(ISD::AND, dl, NVT, LL, Mask);
3088 SDValue RLL = DAG.getNode(ISD::AND, dl, NVT, RL, Mask);
3090 SDValue T = DAG.getNode(ISD::MUL, dl, NVT, LLL, RLL);
3091 SDValue TL = DAG.getNode(ISD::AND, dl, NVT, T, Mask);
3099 SDValue Shift = DAG.getConstant(HalfBits, dl, ShiftAmtTy);
3100 SDValue TH = DAG.getNode(ISD::SRL, dl, NVT, T, Shift);
3101 SDValue LLH = DAG.getNode(ISD::SRL, dl, NVT, LL, Shift);
3102 SDValue RLH = DAG.getNode(ISD::SRL, dl, NVT, RL, Shift);
3104 SDValue U = DAG.getNode(ISD::ADD, dl, NVT,
3106 SDValue UL = DAG.getNode(ISD::AND, dl, NVT, U, Mask);
3107 SDValue UH = DAG.getNode(ISD::SRL, dl, NVT, U, Shift);
3109 SDValue V = DAG.getNode(ISD::ADD, dl, NVT,
3111 SDValue VH = DAG.getNode(ISD::SRL, dl, NVT, V, Shift);
3113 SDValue W = DAG.getNode(ISD::ADD, dl, NVT,
3126 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
3133 void DAGTypeLegalizer::ExpandIntRes_READCYCLECOUNTER(SDNode *N, SDValue &Lo,
3134 SDValue &Hi) {
3138 SDValue R = DAG.getNode(N->getOpcode(), DL, VTs, N->getOperand(0));
3141 ReplaceValueWith(SDValue(N, 1), R.getValue(2));
3144 void DAGTypeLegalizer::ExpandIntRes_ADDSUBSAT(SDNode *N, SDValue &Lo,
3145 SDValue &Hi) {
3146 SDValue Result = TLI.expandAddSubSat(N, DAG);
3155 void DAGTypeLegalizer::ExpandIntRes_MULFIX(SDNode *N, SDValue &Lo,
3156 SDValue &Hi) {
3160 SDValue LHS = N->getOperand(0);
3161 SDValue RHS = N->getOperand(1);
3170 SDValue Result;
3177 SDValue Product = Result.getValue(0);
3178 SDValue Overflow = Result.getValue(1);
3182 SDValue SatMin = DAG.getConstant(MinVal, dl, VT);
3183 SDValue SatMax = DAG.getConstant(MaxVal, dl, VT);
3184 SDValue Zero = DAG.getConstant(0, dl, VT);
3185 SDValue ProdNeg = DAG.getSetCC(dl, BoolVT, Product, Zero, ISD::SETLT);
3192 SDValue SatMax = DAG.getConstant(MaxVal, dl, VT);
3205 SDValue LL, LH, RL, RH;
3208 SmallVector<SDValue, 4> Result;
3244 SDValue ShiftAmount = DAG.getConstant(Scale % NVTSize, dl, ShiftTy);
3274 SDValue ResultHL = Result[2];
3275 SDValue ResultHH = Result[3];
3277 SDValue SatMax, SatMin;
3278 SDValue NVTZero = DAG.getConstant(0, dl, NVT);
3279 SDValue NVTNeg1 = DAG.getConstant(-1, dl, NVT);
3285 SDValue HLAdjusted = DAG.getNode(ISD::SRL, dl, NVT, ResultHL,
3287 SDValue Tmp = DAG.getNode(ISD::OR, dl, NVT, HLAdjusted, ResultHH);
3294 SDValue HLAdjusted = DAG.getNode(ISD::SRL, dl, NVT, ResultHL,
3315 SDValue HLHiMask = DAG.getConstant(
3317 SDValue HLLoMask = DAG.getConstant(
3320 SDValue HHGT0 = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETGT);
3321 SDValue HHEQ0 = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETEQ);
3322 SDValue HLUGT = DAG.getSetCC(dl, BoolNVT, ResultHL, HLLoMask, ISD::SETUGT);
3326 SDValue HHLT = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTNeg1, ISD::SETLT);
3327 SDValue HHEQ = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTNeg1, ISD::SETEQ);
3328 SDValue HLULT = DAG.getSetCC(dl, BoolNVT, ResultHL, HLHiMask, ISD::SETULT);
3333 SDValue HHGT0 = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETGT);
3334 SDValue HHEQ0 = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETEQ);
3335 SDValue HLNeg = DAG.getSetCC(dl, BoolNVT, ResultHL, NVTZero, ISD::SETLT);
3339 SDValue HHLT = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTNeg1, ISD::SETLT);
3340 SDValue HHEQ = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTNeg1, ISD::SETEQ);
3341 SDValue HLPos = DAG.getSetCC(dl, BoolNVT, ResultHL, NVTZero, ISD::SETGE);
3348 SDValue HHHiMask = DAG.getConstant(
3350 SDValue HHLoMask = DAG.getConstant(
3368 void DAGTypeLegalizer::ExpandIntRes_DIVFIX(SDNode *N, SDValue &Lo,
3369 SDValue &Hi) {
3372 SDValue Res = TLI.expandFixedPointDiv(N->getOpcode(), dl, N->getOperand(0),
3383 SDValue &Lo, SDValue &Hi) {
3384 SDValue LHS = Node->getOperand(0);
3385 SDValue RHS = Node->getOperand(1);
3390 SDValue Sum = DAG.getNode(Node->getOpcode() == ISD::SADDO ?
3407 SDValue Zero = DAG.getConstant(0, dl, LHS.getValueType());
3409 SDValue LHSSign = DAG.getSetCC(dl, OType, LHS, Zero, ISD::SETGE);
3410 SDValue RHSSign = DAG.getSetCC(dl, OType, RHS, Zero, ISD::SETGE);
3411 SDValue SignsMatch = DAG.getSetCC(dl, OType, LHSSign, RHSSign,
3415 SDValue SumSign = DAG.getSetCC(dl, OType, Sum, Zero, ISD::SETGE);
3416 SDValue SumSignNE = DAG.getSetCC(dl, OType, LHSSign, SumSign, ISD::SETNE);
3418 SDValue Cmp = DAG.getNode(ISD::AND, dl, OType, SignsMatch, SumSignNE);
3421 ReplaceValueWith(SDValue(Node, 1), Cmp);
3425 SDValue &Lo, SDValue &Hi) {
3428 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
3431 SDValue Res = DAG.getNode(ISD::SDIVREM, dl, DAG.getVTList(VT, VT), Ops);
3453 SDValue &Lo, SDValue &Hi) {
3489 SDValue LHSL, LHSH;
3496 SDValue ShiftOp = N->getOperand(1);
3504 SDValue Ops[] = { LHSL, LHSH, ShiftOp };
3547 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
3559 SDValue &Lo, SDValue &Hi) {
3562 SDValue Op = N->getOperand(0);
3577 SDValue Res = GetPromotedInteger(Op);
3590 ExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi) {
3616 SDValue &Lo, SDValue &Hi) {
3619 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
3622 SDValue Res = DAG.getNode(ISD::SDIVREM, dl, DAG.getVTList(VT, VT), Ops);
3644 SDValue &Lo, SDValue &Hi) {
3656 SDValue &Lo, SDValue &Hi) {
3673 SDValue LHS = N->getOperand(0), RHS = N->getOperand(1);
3674 SDValue LHSHigh, LHSLow, RHSHigh, RHSLow;
3682 SDValue HalfZero = DAG.getConstant(0, dl, HalfVT);
3683 SDValue Overflow = DAG.getNode(ISD::AND, dl, BitVT,
3687 SDValue One = DAG.getNode(ISD::UMULO, dl, VTHalfMulO, LHSHigh, RHSLow);
3689 SDValue OneInHigh = DAG.getNode(ISD::BUILD_PAIR, dl, VT, HalfZero,
3692 SDValue Two = DAG.getNode(ISD::UMULO, dl, VTHalfMulO, RHSHigh, LHSLow);
3694 SDValue TwoInHigh = DAG.getNode(ISD::BUILD_PAIR, dl, VT, HalfZero,
3703 SDValue Three = DAG.getNode(ISD::MUL, dl, VT,
3706 SDValue Four = DAG.getNode(ISD::ADD, dl, VT, OneInHigh, TwoInHigh);
3707 SDValue Five = DAG.getNode(ISD::UADDO, dl, VTFullAddO, Three, Four);
3710 ReplaceValueWith(SDValue(N, 1), Overflow);
3728 SDValue Temp = DAG.CreateStackTemporary(PtrVT);
3730 SDValue Chain =
3736 for (const SDValue &Op : N->op_values()) {
3753 SDValue Func = DAG.getExternalSymbol(TLI.getLibcallName(LC), PtrVT);
3761 std::pair<SDValue, SDValue> CallInfo = TLI.LowerCallTo(CLI);
3764 SDValue Temp2 =
3766 SDValue Ofl = DAG.getSetCC(dl, N->getValueType(1), Temp2,
3770 ReplaceValueWith(SDValue(N, 1), Ofl);
3774 SDValue &Lo, SDValue &Hi) {
3777 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
3780 SDValue Res = DAG.getNode(ISD::UDIVREM, dl, DAG.getVTList(VT, VT), Ops);
3801 SDValue &Lo, SDValue &Hi) {
3804 SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
3807 SDValue Res = DAG.getNode(ISD::UDIVREM, dl, DAG.getVTList(VT, VT), Ops);
3828 SDValue &Lo, SDValue &Hi) {
3831 SDValue Op = N->getOperand(0);
3842 SDValue Res = GetPromotedInteger(Op);
3855 SDValue &Lo, SDValue &Hi) {
3859 SDValue Zero = DAG.getConstant(0, dl, VT);
3860 SDValue Swap = DAG.getAtomicCmpSwap(
3865 ReplaceValueWith(SDValue(N, 0), Swap.getValue(0));
3866 ReplaceValueWith(SDValue(N, 1), Swap.getValue(2));
3870 SDValue &Lo, SDValue &Hi) {
3873 SDValue Res = TLI.expandVecReduce(N, DAG);
3888 SDValue Res = SDValue();
3939 ReplaceValueWith(SDValue(N, 0), Res);
3945 void DAGTypeLegalizer::IntegerExpandSetCCOperands(SDValue &NewLHS,
3946 SDValue &NewRHS,
3949 SDValue LHSLo, LHSHi, RHSLo, RHSHi;
4005 SDValue LoCmp, HiCmp;
4035 NewRHS = SDValue();
4042 NewRHS = SDValue();
4073 SDValue LowCmp = DAG.getNode(ISD::USUBO, dl, VTList, LHSLo, RHSLo);
4074 SDValue Res = DAG.getNode(ISD::SETCCCARRY, dl, getSetCCResultType(HiVT),
4078 NewRHS = SDValue();
4088 NewRHS = SDValue();
4091 SDValue DAGTypeLegalizer::ExpandIntOp_BR_CC(SDNode *N) {
4092 SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
4104 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
4109 SDValue DAGTypeLegalizer::ExpandIntOp_SELECT_CC(SDNode *N) {
4110 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
4122 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
4127 SDValue DAGTypeLegalizer::ExpandIntOp_SETCC(SDNode *N) {
4128 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
4140 return SDValue(
4144 SDValue DAGTypeLegalizer::ExpandIntOp_SETCCCARRY(SDNode *N) {
4145 SDValue LHS = N->getOperand(0);
4146 SDValue RHS = N->getOperand(1);
4147 SDValue Carry = N->getOperand(2);
4148 SDValue Cond = N->getOperand(3);
4151 SDValue LHSLo, LHSHi, RHSLo, RHSHi;
4157 SDValue LowCmp = DAG.getNode(ISD::SUBCARRY, dl, VTList, LHSLo, RHSLo, Carry);
4162 SDValue DAGTypeLegalizer::ExpandIntOp_Shift(SDNode *N) {
4166 SDValue Lo, Hi;
4168 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0), Lo), 0);
4171 SDValue DAGTypeLegalizer::ExpandIntOp_RETURNADDR(SDNode *N) {
4175 SDValue Lo, Hi;
4177 return SDValue(DAG.UpdateNodeOperands(N, Lo), 0);
4180 SDValue DAGTypeLegalizer::ExpandIntOp_SINT_TO_FP(SDNode *N) {
4182 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
4183 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
4190 std::pair<SDValue, SDValue> Tmp =
4196 ReplaceValueWith(SDValue(N, 1), Tmp.second);
4197 ReplaceValueWith(SDValue(N, 0), Tmp.first);
4198 return SDValue();
4201 SDValue DAGTypeLegalizer::ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo) {
4205 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
4220 SDValue Ch = N->getChain();
4221 SDValue Ptr = N->getBasePtr();
4225 SDValue Lo, Hi;
4293 SDValue DAGTypeLegalizer::ExpandIntOp_TRUNCATE(SDNode *N) {
4294 SDValue InL, InH;
4300 SDValue DAGTypeLegalizer::ExpandIntOp_UINT_TO_FP(SDNode *N) {
4302 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
4303 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
4310 std::pair<SDValue, SDValue> Tmp =
4316 ReplaceValueWith(SDValue(N, 1), Tmp.second);
4317 ReplaceValueWith(SDValue(N, 0), Tmp.first);
4318 return SDValue();
4321 SDValue DAGTypeLegalizer::ExpandIntOp_ATOMIC_STORE(SDNode *N) {
4323 SDValue Swap = DAG.getAtomic(ISD::ATOMIC_SWAP, dl,
4332 SDValue DAGTypeLegalizer::PromoteIntRes_EXTRACT_SUBVECTOR(SDNode *N) {
4340 SDValue BaseIdx = N->getOperand(1);
4345 SDValue InOp0 = N->getOperand(0);
4352 SDValue Ops[] = { GetPromotedInteger(InOp0), BaseIdx };
4359 SDValue Ext = DAG.getNode(ISD::EXTRACT_SUBVECTOR, SDLoc(N), ExtVT, Ops);
4367 SDValue InOp0 = N->getOperand(0);
4374 SmallVector<SDValue, 8> Ops;
4379 SDValue Index = DAG.getNode(ISD::ADD, dl, BaseIdx.getValueType(),
4381 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
4384 SDValue Op = DAG.getAnyExtOrTrunc(Ext, dl, NOutVTElem);
4393 SDValue DAGTypeLegalizer::PromoteIntRes_VECTOR_SHUFFLE(SDNode *N) {
4400 SDValue V0 = GetPromotedInteger(N->getOperand(0));
4401 SDValue V1 = GetPromotedInteger(N->getOperand(1));
4408 SDValue DAGTypeLegalizer::PromoteIntRes_BUILD_VECTOR(SDNode *N) {
4417 SmallVector<SDValue, 8> Ops;
4420 SDValue Op;
4435 SDValue DAGTypeLegalizer::PromoteIntRes_SCALAR_TO_VECTOR(SDNode *N) {
4447 SDValue Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutVTElem, N->getOperand(0));
4452 SDValue DAGTypeLegalizer::PromoteIntRes_SPLAT_VECTOR(SDNode *N) {
4455 SDValue SplatVal = N->getOperand(0);
4464 SDValue Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutElemVT, SplatVal);
4469 SDValue DAGTypeLegalizer::PromoteIntRes_CONCAT_VECTORS(SDNode *N) {
4485 SmallVector<SDValue, 8> Ops(NumOutElem);
4487 SDValue Op = N->getOperand(i);
4495 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SclrTy, Op,
4504 SDValue DAGTypeLegalizer::PromoteIntRes_EXTEND_VECTOR_INREG(SDNode *N) {
4517 SDValue Promoted;
4539 SDValue DAGTypeLegalizer::PromoteIntRes_INSERT_VECTOR_ELT(SDNode *N) {
4547 SDValue V0 = GetPromotedInteger(N->getOperand(0));
4549 SDValue ConvElem = DAG.getNode(ISD::ANY_EXTEND, dl,
4555 SDValue DAGTypeLegalizer::PromoteIntRes_VECREDUCE(SDNode *N) {
4563 SDValue DAGTypeLegalizer::PromoteIntOp_EXTRACT_VECTOR_ELT(SDNode *N) {
4565 SDValue V0 = GetPromotedInteger(N->getOperand(0));
4566 SDValue V1 = DAG.getZExtOrTrunc(N->getOperand(1), dl,
4568 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
4577 SDValue DAGTypeLegalizer::PromoteIntOp_EXTRACT_SUBVECTOR(SDNode *N) {
4579 SDValue V0 = GetPromotedInteger(N->getOperand(0));
4583 SDValue Ext = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OutVT, V0, N->getOperand(1));
4587 SDValue DAGTypeLegalizer::PromoteIntOp_CONCAT_VECTORS(SDNode *N) {
4593 SmallVector<SDValue, 8> NewOps;
4598 SDValue Incoming = GetPromotedInteger(N->getOperand(VecIdx));
4604 SDValue Ex = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SclrTy, Incoming,
4606 SDValue Tr = DAG.getNode(ISD::TRUNCATE, dl, RetSclrTy, Ex);