Lines Matching refs:Lo
286 SDValue Lo, Hi;
287 GetSplitVector(N->getOperand(0), Lo, Hi);
288 Lo = BitConvertToInteger(Lo);
292 std::swap(Lo, Hi);
297 JoinIntegers(Lo, Hi));
1036 SDValue Lo = ZExtPromotedInteger(N->getOperand(0));
1038 assert(Lo.getValueType() == N->getValueType(0) && "Operand over promoted?");
1044 return DAG.getNode(ISD::OR, dl, N->getValueType(0), Lo, Hi);
1285 SDValue Lo, Hi;
1286 Lo = Hi = SDValue();
1300 case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
1301 case ISD::SELECT: SplitRes_SELECT(N, Lo, Hi); break;
1302 case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break;
1303 case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break;
1305 case ISD::BITCAST: ExpandRes_BITCAST(N, Lo, Hi); break;
1306 case ISD::BUILD_PAIR: ExpandRes_BUILD_PAIR(N, Lo, Hi); break;
1307 case ISD::EXTRACT_ELEMENT: ExpandRes_EXTRACT_ELEMENT(N, Lo, Hi); break;
1308 case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break;
1309 case ISD::VAARG: ExpandRes_VAARG(N, Lo, Hi); break;
1311 case ISD::ANY_EXTEND: ExpandIntRes_ANY_EXTEND(N, Lo, Hi); break;
1312 case ISD::AssertSext: ExpandIntRes_AssertSext(N, Lo, Hi); break;
1313 case ISD::AssertZext: ExpandIntRes_AssertZext(N, Lo, Hi); break;
1314 case ISD::BITREVERSE: ExpandIntRes_BITREVERSE(N, Lo, Hi); break;
1315 case ISD::BSWAP: ExpandIntRes_BSWAP(N, Lo, Hi); break;
1316 case ISD::Constant: ExpandIntRes_Constant(N, Lo, Hi); break;
1318 case ISD::CTLZ: ExpandIntRes_CTLZ(N, Lo, Hi); break;
1319 case ISD::CTPOP: ExpandIntRes_CTPOP(N, Lo, Hi); break;
1321 case ISD::CTTZ: ExpandIntRes_CTTZ(N, Lo, Hi); break;
1322 case ISD::FP_TO_SINT: ExpandIntRes_FP_TO_SINT(N, Lo, Hi); break;
1323 case ISD::FP_TO_UINT: ExpandIntRes_FP_TO_UINT(N, Lo, Hi); break;
1324 case ISD::LOAD: ExpandIntRes_LOAD(cast<LoadSDNode>(N), Lo, Hi); break;
1325 case ISD::MUL: ExpandIntRes_MUL(N, Lo, Hi); break;
1326 case ISD::READCYCLECOUNTER: ExpandIntRes_READCYCLECOUNTER(N, Lo, Hi); break;
1327 case ISD::SDIV: ExpandIntRes_SDIV(N, Lo, Hi); break;
1328 case ISD::SIGN_EXTEND: ExpandIntRes_SIGN_EXTEND(N, Lo, Hi); break;
1329 case ISD::SIGN_EXTEND_INREG: ExpandIntRes_SIGN_EXTEND_INREG(N, Lo, Hi); break;
1330 case ISD::SREM: ExpandIntRes_SREM(N, Lo, Hi); break;
1331 case ISD::TRUNCATE: ExpandIntRes_TRUNCATE(N, Lo, Hi); break;
1332 case ISD::UDIV: ExpandIntRes_UDIV(N, Lo, Hi); break;
1333 case ISD::UREM: ExpandIntRes_UREM(N, Lo, Hi); break;
1334 case ISD::ZERO_EXTEND: ExpandIntRes_ZERO_EXTEND(N, Lo, Hi); break;
1335 case ISD::ATOMIC_LOAD: ExpandIntRes_ATOMIC_LOAD(N, Lo, Hi); break;
1350 SplitInteger(Tmp.first, Lo, Hi);
1369 SplitInteger(Tmp, Lo, Hi);
1377 case ISD::XOR: ExpandIntRes_Logical(N, Lo, Hi); break;
1382 case ISD::SMIN: ExpandIntRes_MINMAX(N, Lo, Hi); break;
1385 case ISD::SUB: ExpandIntRes_ADDSUB(N, Lo, Hi); break;
1388 case ISD::SUBC: ExpandIntRes_ADDSUBC(N, Lo, Hi); break;
1391 case ISD::SUBE: ExpandIntRes_ADDSUBE(N, Lo, Hi); break;
1395 case ISD::SRL: ExpandIntRes_Shift(N, Lo, Hi); break;
1398 case ISD::SSUBO: ExpandIntRes_SADDSUBO(N, Lo, Hi); break;
1400 case ISD::USUBO: ExpandIntRes_UADDSUBO(N, Lo, Hi); break;
1402 case ISD::SMULO: ExpandIntRes_XMULO(N, Lo, Hi); break;
1405 // If Lo/Hi is null, the sub-method took care of registering results etc.
1406 if (Lo.getNode())
1407 SetExpandedInteger(SDValue(N, ResNo), Lo, Hi);
1423 SDValue &Lo, SDValue &Hi) {
1432 Lo = InL;
1444 Lo = Hi = DAG.getConstant(0, DL, NVT);
1446 Lo = DAG.getConstant(0, DL, NVT);
1450 Lo = DAG.getConstant(0, DL, NVT);
1453 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, DL, ShTy));
1465 Lo = Hi = DAG.getConstant(0, DL, NVT);
1467 Lo = DAG.getNode(ISD::SRL, DL,
1471 Lo = InH;
1474 Lo = DAG.getNode(ISD::OR, DL, NVT,
1486 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1489 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1494 Lo = InH;
1498 Lo = DAG.getNode(ISD::OR, DL, NVT,
1512 ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
1544 Lo = DAG.getConstant(0, dl, NVT); // Low part is zero.
1545 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1549 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1554 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1576 // When shifting right the arithmetic for Lo and Hi is swapped.
1580 // Use a little trick to get the bits that move from Lo to Hi. First
1586 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1590 std::swap(Hi, Lo);
1600 ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
1633 LoL = DAG.getConstant(0, dl, NVT); // Lo part is zero.
1634 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1636 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1651 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1653 Lo = DAG.getSelect(dl, NVT, isZero, InL,
1667 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1669 Lo = DAG.getSelect(dl, NVT, isZero, InL,
1692 SDValue &Lo, SDValue &Hi) {
1710 // We need to know whether to select Lo part that corresponds to 'winning'
1715 // Lo part corresponding to the 'winning' Hi part
1718 // Recursed Lo part if Hi parts are equal, this uses unsigned version
1721 Lo = DAG.getSelect(DL, NVT, IsHiEq, LoMinMax, LoCmp);
1725 SDValue &Lo, SDValue &Hi) {
1749 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps);
1750 HiOps[2] = Lo.getValue(1);
1753 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps);
1754 HiOps[2] = Lo.getValue(1);
1770 Lo = DAG.getNode(ISD::UADDO, dl, VTList, LoOps);
1774 Lo = DAG.getNode(ISD::USUBO, dl, VTList, LoOps);
1777 SDValue OVF = Lo.getValue(1);
1793 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps);
1795 SDValue Cmp1 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
1800 SDValue Cmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[1],
1806 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps);
1819 SDValue &Lo, SDValue &Hi) {
1830 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps);
1831 HiOps[2] = Lo.getValue(1);
1834 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps);
1835 HiOps[2] = Lo.getValue(1);
1845 SDValue &Lo, SDValue &Hi) {
1855 Lo = DAG.getNode(N->getOpcode(), dl, VTList, LoOps);
1856 HiOps[2] = Lo.getValue(1);
1865 SDValue &Lo, SDValue &Hi) {
1871 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1883 SplitInteger(Res, Lo, Hi);
1888 SDValue &Lo, SDValue &Hi) {
1890 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1891 EVT NVT = Lo.getValueType();
1901 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1902 // The high part replicates the sign bit of Lo, make it explicit.
1903 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1910 SDValue &Lo, SDValue &Hi) {
1912 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1913 EVT NVT = Lo.getValueType();
1923 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1930 SDValue &Lo, SDValue &Hi) {
1932 GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands.
1933 Lo = DAG.getNode(ISD::BITREVERSE, dl, Lo.getValueType(), Lo);
1938 SDValue &Lo, SDValue &Hi) {
1940 GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands.
1941 Lo = DAG.getNode(ISD::BSWAP, dl, Lo.getValueType(), Lo);
1946 SDValue &Lo, SDValue &Hi) {
1954 Lo = DAG.getConstant(Cst.trunc(NBitWidth), dl, NVT, IsTarget, IsOpaque);
1960 SDValue &Lo, SDValue &Hi) {
1962 // ctlz (HiLo) -> Hi != 0 ? ctlz(Hi) : (ctlz(Lo)+32)
1963 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1964 EVT NVT = Lo.getValueType();
1969 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1972 Lo = DAG.getSelect(dl, NVT, HiNotZero, HiLZ,
1980 SDValue &Lo, SDValue &Hi) {
1982 // ctpop(HiLo) -> ctpop(Hi)+ctpop(Lo)
1983 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1984 EVT NVT = Lo.getValueType();
1985 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1991 SDValue &Lo, SDValue &Hi) {
1993 // cttz (HiLo) -> Lo != 0 ? cttz(Lo) : (cttz(Hi)+32)
1994 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1995 EVT NVT = Lo.getValueType();
1997 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
2000 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
2003 Lo = DAG.getSelect(dl, NVT, LoNotZero, LoLZ,
2010 void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDValue &Lo,
2022 Lo, Hi);
2025 void DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDValue &Lo,
2037 Lo, Hi);
2041 SDValue &Lo, SDValue &Hi) {
2043 ExpandRes_NormalLoad(N, Lo, Hi);
2066 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
2071 Ch = Lo.getValue(1);
2076 unsigned LoSize = Lo.getValueType().getSizeInBits();
2077 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2090 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
2109 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
2130 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
2138 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
2142 // Transfer low bits from the bottom of Hi to the top of Lo.
2143 Lo = DAG.getNode(
2144 ISD::OR, dl, NVT, Lo,
2162 SDValue &Lo, SDValue &Hi) {
2167 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), LL, RL);
2172 SDValue &Lo, SDValue &Hi) {
2181 if (TLI.expandMUL(N, Lo, Hi, NVT, DAG, LL, LH, RL, RH))
2228 Lo = DAG.getNode(ISD::ADD, dl, NVT, TH,
2240 Lo, Hi);
2243 void DAGTypeLegalizer::ExpandIntRes_READCYCLECOUNTER(SDNode *N, SDValue &Lo,
2249 Lo = R.getValue(0);
2255 SDValue &Lo, SDValue &Hi) {
2265 SplitInteger(Sum, Lo, Hi);
2297 SDValue &Lo, SDValue &Hi) {
2304 SplitInteger(Res.getValue(0), Lo, Hi);
2319 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, true, dl).first, Lo, Hi);
2323 SDValue &Lo, SDValue &Hi) {
2330 return ExpandShiftByConstant(N, CN->getAPIntValue(), Lo, Hi);
2334 if (ExpandShiftWithKnownAmountBit(N, Lo, Hi))
2371 Lo = DAG.getNode(PartsOpc, dl, DAG.getVTList(VT, VT), Ops);
2372 Hi = Lo.getValue(1);
2414 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, isSigned, dl).first, Lo, Hi);
2418 if (!ExpandShiftWithUnknownAmountBit(N, Lo, Hi))
2423 SDValue &Lo, SDValue &Hi) {
2429 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2433 ISD::SRA, dl, NVT, Lo,
2445 SplitInteger(Res, Lo, Hi);
2455 ExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi) {
2457 GetExpandedInteger(N->getOperand(0), Lo, Hi);
2460 if (EVT.bitsLE(Lo.getValueType())) {
2462 Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Lo.getValueType(), Lo,
2467 Hi = DAG.getNode(ISD::SRA, dl, Hi.getValueType(), Lo,
2474 EVT.getSizeInBits() - Lo.getValueType().getSizeInBits();
2482 SDValue &Lo, SDValue &Hi) {
2489 SplitInteger(Res.getValue(1), Lo, Hi);
2504 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, true, dl).first, Lo, Hi);
2508 SDValue &Lo, SDValue &Hi) {
2511 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2520 SDValue &Lo, SDValue &Hi) {
2530 SplitInteger(Sum, Lo, Hi);
2543 SDValue &Lo, SDValue &Hi) {
2552 SplitInteger(MUL, Lo, Hi);
2618 SplitInteger(CallInfo.first, Lo, Hi);
2629 SDValue &Lo, SDValue &Hi) {
2636 SplitInteger(Res.getValue(0), Lo, Hi);
2651 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, false, dl).first, Lo, Hi);
2655 SDValue &Lo, SDValue &Hi) {
2662 SplitInteger(Res.getValue(1), Lo, Hi);
2677 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, false, dl).first, Lo, Hi);
2681 SDValue &Lo, SDValue &Hi) {
2687 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2699 SplitInteger(Res, Lo, Hi);
2709 SDValue &Lo, SDValue &Hi) {
3012 SDValue Lo, Hi;
3013 GetExpandedInteger(N->getOperand(1), Lo, Hi);
3014 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0), Lo), 0);
3021 SDValue Lo, Hi;
3022 GetExpandedInteger(N->getOperand(0), Lo, Hi);
3023 return SDValue(DAG.UpdateNodeOperands(N, Lo), 0);
3051 SDValue Lo, Hi;
3056 GetExpandedInteger(N->getValue(), Lo, Hi);
3057 return DAG.getTruncStore(Ch, dl, Lo, Ptr, N->getPointerInfo(),
3064 GetExpandedInteger(N->getValue(), Lo, Hi);
3066 Lo = DAG.getStore(Ch, dl, Lo, Ptr, N->getPointerInfo(),
3081 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
3086 GetExpandedInteger(N->getValue(), Lo, Hi);
3096 // Transfer high bits from the top of Lo to the bottom of Hi.
3102 DAG.getNode(ISD::SRL, dl, NVT, Lo,
3115 Lo = DAG.getTruncStore(Ch, dl, Lo, Ptr,
3120 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
3165 SDValue Lo, Hi;
3166 GetExpandedInteger(Op, Lo, Hi);