Lines Matching defs:Lo
237 SDValue Lo, Hi;
238 GetSplitVector(N->getOperand(0), Lo, Hi);
239 Lo = BitConvertToInteger(Lo);
243 std::swap(Lo, Hi);
248 JoinIntegers(Lo, Hi));
906 SDValue Lo = ZExtPromotedInteger(N->getOperand(0));
908 assert(Lo.getValueType() == N->getValueType(0) && "Operand over promoted?");
913 return DAG.getNode(ISD::OR, dl, N->getValueType(0), Lo, Hi);
1082 SDValue Lo, Hi;
1083 Lo = Hi = SDValue();
1097 case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
1098 case ISD::SELECT: SplitRes_SELECT(N, Lo, Hi); break;
1099 case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break;
1100 case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break;
1102 case ISD::BITCAST: ExpandRes_BITCAST(N, Lo, Hi); break;
1103 case ISD::BUILD_PAIR: ExpandRes_BUILD_PAIR(N, Lo, Hi); break;
1104 case ISD::EXTRACT_ELEMENT: ExpandRes_EXTRACT_ELEMENT(N, Lo, Hi); break;
1105 case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break;
1106 case ISD::VAARG: ExpandRes_VAARG(N, Lo, Hi); break;
1108 case ISD::ANY_EXTEND: ExpandIntRes_ANY_EXTEND(N, Lo, Hi); break;
1109 case ISD::AssertSext: ExpandIntRes_AssertSext(N, Lo, Hi); break;
1110 case ISD::AssertZext: ExpandIntRes_AssertZext(N, Lo, Hi); break;
1111 case ISD::BSWAP: ExpandIntRes_BSWAP(N, Lo, Hi); break;
1112 case ISD::Constant: ExpandIntRes_Constant(N, Lo, Hi); break;
1114 case ISD::CTLZ: ExpandIntRes_CTLZ(N, Lo, Hi); break;
1115 case ISD::CTPOP: ExpandIntRes_CTPOP(N, Lo, Hi); break;
1117 case ISD::CTTZ: ExpandIntRes_CTTZ(N, Lo, Hi); break;
1118 case ISD::FP_TO_SINT: ExpandIntRes_FP_TO_SINT(N, Lo, Hi); break;
1119 case ISD::FP_TO_UINT: ExpandIntRes_FP_TO_UINT(N, Lo, Hi); break;
1120 case ISD::LOAD: ExpandIntRes_LOAD(cast<LoadSDNode>(N), Lo, Hi); break;
1121 case ISD::MUL: ExpandIntRes_MUL(N, Lo, Hi); break;
1122 case ISD::SDIV: ExpandIntRes_SDIV(N, Lo, Hi); break;
1123 case ISD::SIGN_EXTEND: ExpandIntRes_SIGN_EXTEND(N, Lo, Hi); break;
1124 case ISD::SIGN_EXTEND_INREG: ExpandIntRes_SIGN_EXTEND_INREG(N, Lo, Hi); break;
1125 case ISD::SREM: ExpandIntRes_SREM(N, Lo, Hi); break;
1126 case ISD::TRUNCATE: ExpandIntRes_TRUNCATE(N, Lo, Hi); break;
1127 case ISD::UDIV: ExpandIntRes_UDIV(N, Lo, Hi); break;
1128 case ISD::UREM: ExpandIntRes_UREM(N, Lo, Hi); break;
1129 case ISD::ZERO_EXTEND: ExpandIntRes_ZERO_EXTEND(N, Lo, Hi); break;
1130 case ISD::ATOMIC_LOAD: ExpandIntRes_ATOMIC_LOAD(N, Lo, Hi); break;
1145 SplitInteger(Tmp.first, Lo, Hi);
1152 case ISD::XOR: ExpandIntRes_Logical(N, Lo, Hi); break;
1155 case ISD::SUB: ExpandIntRes_ADDSUB(N, Lo, Hi); break;
1158 case ISD::SUBC: ExpandIntRes_ADDSUBC(N, Lo, Hi); break;
1161 case ISD::SUBE: ExpandIntRes_ADDSUBE(N, Lo, Hi); break;
1165 case ISD::SRL: ExpandIntRes_Shift(N, Lo, Hi); break;
1168 case ISD::SSUBO: ExpandIntRes_SADDSUBO(N, Lo, Hi); break;
1170 case ISD::USUBO: ExpandIntRes_UADDSUBO(N, Lo, Hi); break;
1172 case ISD::SMULO: ExpandIntRes_XMULO(N, Lo, Hi); break;
1175 // If Lo/Hi is null, the sub-method took care of registering results etc.
1176 if (Lo.getNode())
1177 SetExpandedInteger(SDValue(N, ResNo), Lo, Hi);
1269 SDValue &Lo, SDValue &Hi) {
1282 Lo = Hi = DAG.getConstant(0, NVT);
1284 Lo = DAG.getConstant(0, NVT);
1288 Lo = DAG.getConstant(0, NVT);
1296 Lo = DAG.getNode(ISD::ADDC, DL, VTList, LoOps, 2);
1297 SDValue HiOps[3] = { InH, InH, Lo.getValue(1) };
1300 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, ShTy));
1312 Lo = DAG.getConstant(0, NVT);
1315 Lo = DAG.getNode(ISD::SRL, DL,
1319 Lo = InH;
1322 Lo = DAG.getNode(ISD::OR, DL, NVT,
1334 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1337 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1342 Lo = InH;
1346 Lo = DAG.getNode(ISD::OR, DL, NVT,
1360 ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
1392 Lo = DAG.getConstant(0, NVT); // Low part is zero.
1393 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1397 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1402 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1424 // When shifting right the arithmetic for Lo and Hi is swapped.
1428 // Use a little trick to get the bits that move from Lo to Hi. First
1434 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
1438 std::swap(Hi, Lo);
1448 ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
1480 LoL = DAG.getConstant(0, NVT); // Lo part is zero.
1481 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1483 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1497 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1499 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1514 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1516 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
1523 SDValue &Lo, SDValue &Hi) {
1547 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps, 2);
1548 HiOps[2] = Lo.getValue(1);
1551 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps, 2);
1552 HiOps[2] = Lo.getValue(1);
1559 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps, 2);
1561 SDValue Cmp1 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
1566 SDValue Cmp2 = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[1],
1572 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps, 2);
1585 SDValue &Lo, SDValue &Hi) {
1596 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps, 2);
1597 HiOps[2] = Lo.getValue(1);
1600 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps, 2);
1601 HiOps[2] = Lo.getValue(1);
1611 SDValue &Lo, SDValue &Hi) {
1621 Lo = DAG.getNode(N->getOpcode(), dl, VTList, LoOps, 3);
1622 HiOps[2] = Lo.getValue(1);
1631 SDValue &Lo, SDValue &Hi) {
1633 SplitInteger(Res, Lo, Hi);
1637 SDValue &Lo, SDValue &Hi) {
1643 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1655 SplitInteger(Res, Lo, Hi);
1660 SDValue &Lo, SDValue &Hi) {
1662 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1663 EVT NVT = Lo.getValueType();
1673 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1674 // The high part replicates the sign bit of Lo, make it explicit.
1675 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1681 SDValue &Lo, SDValue &Hi) {
1683 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1684 EVT NVT = Lo.getValueType();
1694 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1701 SDValue &Lo, SDValue &Hi) {
1703 GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands.
1704 Lo = DAG.getNode(ISD::BSWAP, dl, Lo.getValueType(), Lo);
1709 SDValue &Lo, SDValue &Hi) {
1713 Lo = DAG.getConstant(Cst.trunc(NBitWidth), NVT);
1718 SDValue &Lo, SDValue &Hi) {
1720 // ctlz (HiLo) -> Hi != 0 ? ctlz(Hi) : (ctlz(Lo)+32)
1721 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1722 EVT NVT = Lo.getValueType();
1727 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
1730 Lo = DAG.getSelect(dl, NVT, HiNotZero, HiLZ,
1737 SDValue &Lo, SDValue &Hi) {
1739 // ctpop(HiLo) -> ctpop(Hi)+ctpop(Lo)
1740 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1741 EVT NVT = Lo.getValueType();
1742 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1748 SDValue &Lo, SDValue &Hi) {
1750 // cttz (HiLo) -> Lo != 0 ? cttz(Lo) : (cttz(Hi)+32)
1751 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1752 EVT NVT = Lo.getValueType();
1754 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
1757 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
1760 Lo = DAG.getSelect(dl, NVT, LoNotZero, LoLZ,
1766 void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDValue &Lo,
1774 Lo, Hi);
1777 void DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDValue &Lo,
1785 Lo, Hi);
1789 SDValue &Lo, SDValue &Hi) {
1791 ExpandRes_NormalLoad(N, Lo, Hi);
1813 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1817 Ch = Lo.getValue(1);
1821 // lo part.
1822 unsigned LoSize = Lo.getValueType().getSizeInBits();
1823 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1835 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
1853 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1873 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
1881 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1885 // Transfer low bits from the bottom of Hi to the top of Lo.
1886 Lo = DAG.getNode(ISD::OR, dl, NVT, Lo,
1904 SDValue &Lo, SDValue &Hi) {
1909 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), LL, RL);
1914 SDValue &Lo, SDValue &Hi) {
1938 Lo = DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1939 Hi = SDValue(Lo.getNode(), 1);
1944 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1953 Lo = DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1954 Hi = SDValue(Lo.getNode(), 1);
1959 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1965 // Lo,Hi = umul LHS, RHS.
1968 Lo = UMulLOHI;
1977 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
2001 Lo, Hi);
2005 SDValue &Lo, SDValue &Hi) {
2015 SplitInteger(Sum, Lo, Hi);
2047 SDValue &Lo, SDValue &Hi) {
2063 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true, dl), Lo, Hi);
2067 SDValue &Lo, SDValue &Hi) {
2074 return ExpandShiftByConstant(N, CN->getZExtValue(), Lo, Hi);
2078 if (ExpandShiftWithKnownAmountBit(N, Lo, Hi))
2115 Lo = DAG.getNode(PartsOpc, dl, DAG.getVTList(VT, VT), Ops, 3);
2116 Hi = Lo.getValue(1);
2158 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, isSigned, dl), Lo, Hi);
2162 if (!ExpandShiftWithUnknownAmountBit(N, Lo, Hi))
2167 SDValue &Lo, SDValue &Hi) {
2173 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2176 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2188 SplitInteger(Res, Lo, Hi);
2198 ExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi) {
2200 GetExpandedInteger(N->getOperand(0), Lo, Hi);
2203 if (EVT.bitsLE(Lo.getValueType())) {
2205 Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Lo.getValueType(), Lo,
2208 // The high part gets the sign extension from the lo-part. This handles
2210 Hi = DAG.getNode(ISD::SRA, dl, Hi.getValueType(), Lo,
2217 EVT.getSizeInBits() - Lo.getValueType().getSizeInBits();
2225 SDValue &Lo, SDValue &Hi) {
2241 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true, dl), Lo, Hi);
2245 SDValue &Lo, SDValue &Hi) {
2248 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2256 SDValue &Lo, SDValue &Hi) {
2266 SplitInteger(Sum, Lo, Hi);
2279 SDValue &Lo, SDValue &Hi) {
2288 SplitInteger(MUL, Lo, Hi);
2354 SplitInteger(CallInfo.first, Lo, Hi);
2365 SDValue &Lo, SDValue &Hi) {
2381 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, false, dl), Lo, Hi);
2385 SDValue &Lo, SDValue &Hi) {
2401 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, false, dl), Lo, Hi);
2405 SDValue &Lo, SDValue &Hi) {
2411 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2423 SplitInteger(Res, Lo, Hi);
2433 SDValue &Lo, SDValue &Hi) {
2563 // Tmp1 = lo(op1) < lo(op2) // Always unsigned comparison
2668 SDValue Lo, Hi;
2669 GetExpandedInteger(N->getOperand(1), Lo, Hi);
2670 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0), Lo), 0);
2677 SDValue Lo, Hi;
2678 GetExpandedInteger(N->getOperand(0), Lo, Hi);
2679 return SDValue(DAG.UpdateNodeOperands(N, Lo), 0);
2706 SDValue Lo, Hi;
2711 GetExpandedInteger(N->getValue(), Lo, Hi);
2712 return DAG.getTruncStore(Ch, dl, Lo, Ptr, N->getPointerInfo(),
2719 GetExpandedInteger(N->getValue(), Lo, Hi);
2721 Lo = DAG.getStore(Ch, dl, Lo, Ptr, N->getPointerInfo(),
2736 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
2741 GetExpandedInteger(N->getValue(), Lo, Hi);
2751 // Transfer high bits from the top of Lo to the bottom of Hi.
2756 DAG.getNode(ISD::SRL, dl, NVT, Lo,
2769 Lo = DAG.getTruncStore(Ch, dl, Lo, Ptr,
2774 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
2819 SDValue Lo, Hi;
2820 GetExpandedInteger(Op, Lo, Hi);
2826 // Build a 64 bit pair (0, FF) in the constant pool, with FF in the lo bits.
