Lines Matching refs:Lo
239 SDValue Lo, Hi;
240 GetSplitVector(N->getOperand(0), Lo, Hi);
241 Lo = BitConvertToInteger(Lo);
245 std::swap(Lo, Hi);
250 JoinIntegers(Lo, Hi));
884 SDValue Lo = ZExtPromotedInteger(N->getOperand(0));
886 assert(Lo.getValueType() == N->getValueType(0) && "Operand over promoted?");
891 return DAG.getNode(ISD::OR, dl, N->getValueType(0), Lo, Hi);
1070 SDValue Lo, Hi;
1071 Lo = Hi = SDValue();
1085 case ISD::MERGE_VALUES: SplitRes_MERGE_VALUES(N, ResNo, Lo, Hi); break;
1086 case ISD::SELECT: SplitRes_SELECT(N, Lo, Hi); break;
1087 case ISD::SELECT_CC: SplitRes_SELECT_CC(N, Lo, Hi); break;
1088 case ISD::UNDEF: SplitRes_UNDEF(N, Lo, Hi); break;
1090 case ISD::BITCAST: ExpandRes_BITCAST(N, Lo, Hi); break;
1091 case ISD::BUILD_PAIR: ExpandRes_BUILD_PAIR(N, Lo, Hi); break;
1092 case ISD::EXTRACT_ELEMENT: ExpandRes_EXTRACT_ELEMENT(N, Lo, Hi); break;
1093 case ISD::EXTRACT_VECTOR_ELT: ExpandRes_EXTRACT_VECTOR_ELT(N, Lo, Hi); break;
1094 case ISD::VAARG: ExpandRes_VAARG(N, Lo, Hi); break;
1096 case ISD::ANY_EXTEND: ExpandIntRes_ANY_EXTEND(N, Lo, Hi); break;
1097 case ISD::AssertSext: ExpandIntRes_AssertSext(N, Lo, Hi); break;
1098 case ISD::AssertZext: ExpandIntRes_AssertZext(N, Lo, Hi); break;
1099 case ISD::BSWAP: ExpandIntRes_BSWAP(N, Lo, Hi); break;
1100 case ISD::Constant: ExpandIntRes_Constant(N, Lo, Hi); break;
1101 case ISD::CTLZ: ExpandIntRes_CTLZ(N, Lo, Hi); break;
1102 case ISD::CTPOP: ExpandIntRes_CTPOP(N, Lo, Hi); break;
1103 case ISD::CTTZ: ExpandIntRes_CTTZ(N, Lo, Hi); break;
1104 case ISD::FP_TO_SINT: ExpandIntRes_FP_TO_SINT(N, Lo, Hi); break;
1105 case ISD::FP_TO_UINT: ExpandIntRes_FP_TO_UINT(N, Lo, Hi); break;
1106 case ISD::LOAD: ExpandIntRes_LOAD(cast<LoadSDNode>(N), Lo, Hi); break;
1107 case ISD::MUL: ExpandIntRes_MUL(N, Lo, Hi); break;
1108 case ISD::SDIV: ExpandIntRes_SDIV(N, Lo, Hi); break;
1109 case ISD::SIGN_EXTEND: ExpandIntRes_SIGN_EXTEND(N, Lo, Hi); break;
1110 case ISD::SIGN_EXTEND_INREG: ExpandIntRes_SIGN_EXTEND_INREG(N, Lo, Hi); break;
1111 case ISD::SREM: ExpandIntRes_SREM(N, Lo, Hi); break;
1112 case ISD::TRUNCATE: ExpandIntRes_TRUNCATE(N, Lo, Hi); break;
1113 case ISD::UDIV: ExpandIntRes_UDIV(N, Lo, Hi); break;
1114 case ISD::UREM: ExpandIntRes_UREM(N, Lo, Hi); break;
1115 case ISD::ZERO_EXTEND: ExpandIntRes_ZERO_EXTEND(N, Lo, Hi); break;
1116 case ISD::ATOMIC_LOAD: ExpandIntRes_ATOMIC_LOAD(N, Lo, Hi); break;
1130 SplitInteger(Tmp.first, Lo, Hi);
1137 case ISD::XOR: ExpandIntRes_Logical(N, Lo, Hi); break;
1140 case ISD::SUB: ExpandIntRes_ADDSUB(N, Lo, Hi); break;
1143 case ISD::SUBC: ExpandIntRes_ADDSUBC(N, Lo, Hi); break;
1146 case ISD::SUBE: ExpandIntRes_ADDSUBE(N, Lo, Hi); break;
1150 case ISD::SRL: ExpandIntRes_Shift(N, Lo, Hi); break;
1153 case ISD::SSUBO: ExpandIntRes_SADDSUBO(N, Lo, Hi); break;
1155 case ISD::USUBO: ExpandIntRes_UADDSUBO(N, Lo, Hi); break;
1157 case ISD::SMULO: ExpandIntRes_XMULO(N, Lo, Hi); break;
1160 // If Lo/Hi is null, the sub-method took care of registering results etc.
1161 if (Lo.getNode())
1162 SetExpandedInteger(SDValue(N, ResNo), Lo, Hi);
1255 SDValue &Lo, SDValue &Hi) {
1268 Lo = Hi = DAG.getConstant(0, NVT);
1270 Lo = DAG.getConstant(0, NVT);
1274 Lo = DAG.getConstant(0, NVT);
1282 Lo = DAG.getNode(ISD::ADDC, DL, VTList, LoOps, 2);
1283 SDValue HiOps[3] = { InH, InH, Lo.getValue(1) };
1286 Lo = DAG.getNode(ISD::SHL, DL, NVT, InL, DAG.getConstant(Amt, ShTy));
1298 Lo = DAG.getConstant(0, NVT);
1301 Lo = DAG.getNode(ISD::SRL, DL,
1305 Lo = InH;
1308 Lo = DAG.getNode(ISD::OR, DL, NVT,
1320 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1323 Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1328 Lo = InH;
1332 Lo = DAG.getNode(ISD::OR, DL, NVT,
1346 ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
1378 Lo = DAG.getConstant(0, NVT); // Low part is zero.
1379 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1383 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1388 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1410 Lo = DAG.getNode(N->getOpcode(), NVT, InL, Amt);
1424 ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
1456 LoL = DAG.getConstant(0, NVT); // Lo part is zero.
1457 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1459 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1473 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1475 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1490 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1492 Lo = DAG.getNode(ISD::SELECT, dl, NVT, isShort, LoS, LoL);
1501 SDValue &Lo, SDValue &Hi) {
1525 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps, 2);
1526 HiOps[2] = Lo.getValue(1);
1529 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps, 2);
1530 HiOps[2] = Lo.getValue(1);
1537 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps, 2);
1539 SDValue Cmp1 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo, LoOps[0],
1544 SDValue Cmp2 = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo, LoOps[1],
1550 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps, 2);
1563 SDValue &Lo, SDValue &Hi) {
1574 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps, 2);
1575 HiOps[2] = Lo.getValue(1);
1578 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps, 2);
1579 HiOps[2] = Lo.getValue(1);
1589 SDValue &Lo, SDValue &Hi) {
1599 Lo = DAG.getNode(N->getOpcode(), dl, VTList, LoOps, 3);
1600 HiOps[2] = Lo.getValue(1);
1609 SDValue &Lo, SDValue &Hi) {
1611 SplitInteger(Res, Lo, Hi);
1615 SDValue &Lo, SDValue &Hi) {
1621 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
1633 SplitInteger(Res, Lo, Hi);
1638 SDValue &Lo, SDValue &Hi) {
1640 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1641 EVT NVT = Lo.getValueType();
1651 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
1652 // The high part replicates the sign bit of Lo, make it explicit.
1653 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1659 SDValue &Lo, SDValue &Hi) {
1661 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1662 EVT NVT = Lo.getValueType();
1672 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
1679 SDValue &Lo, SDValue &Hi) {
1681 GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands.
1682 Lo = DAG.getNode(ISD::BSWAP, dl, Lo.getValueType(), Lo);
1687 SDValue &Lo, SDValue &Hi) {
1691 Lo = DAG.getConstant(Cst.trunc(NBitWidth), NVT);
1696 SDValue &Lo, SDValue &Hi) {
1698 // ctlz (HiLo) -> Hi != 0 ? ctlz(Hi) : (ctlz(Lo)+32)
1699 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1700 EVT NVT = Lo.getValueType();
1705 SDValue LoLZ = DAG.getNode(ISD::CTLZ, dl, NVT, Lo);
1708 Lo = DAG.getNode(ISD::SELECT, dl, NVT, HiNotZero, HiLZ,
1715 SDValue &Lo, SDValue &Hi) {
1717 // ctpop(HiLo) -> ctpop(Hi)+ctpop(Lo)
1718 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1719 EVT NVT = Lo.getValueType();
1720 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
1726 SDValue &Lo, SDValue &Hi) {
1728 // cttz (HiLo) -> Lo != 0 ? cttz(Lo) : (cttz(Hi)+32)
1729 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1730 EVT NVT = Lo.getValueType();
1732 SDValue LoNotZero = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Lo,
1735 SDValue LoLZ = DAG.getNode(ISD::CTTZ, dl, NVT, Lo);
1738 Lo = DAG.getNode(ISD::SELECT, dl, NVT, LoNotZero, LoLZ,
1744 void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDValue &Lo,
1751 SplitInteger(MakeLibCall(LC, VT, &Op, 1, true/*irrelevant*/, dl), Lo, Hi);
1754 void DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDValue &Lo,
1761 SplitInteger(MakeLibCall(LC, VT, &Op, 1, false/*irrelevant*/, dl), Lo, Hi);
1765 SDValue &Lo, SDValue &Hi) {
1767 ExpandRes_NormalLoad(N, Lo, Hi);
1788 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1792 Ch = Lo.getValue(1);
1797 unsigned LoSize = Lo.getValueType().getSizeInBits();
1798 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1810 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
1828 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1848 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
1856 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
1860 // Transfer low bits from the bottom of Hi to the top of Lo.
1861 Lo = DAG.getNode(ISD::OR, dl, NVT, Lo,
1879 SDValue &Lo, SDValue &Hi) {
1884 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), LL, RL);
1889 SDValue &Lo, SDValue &Hi) {
1913 Lo = DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1914 Hi = SDValue(Lo.getNode(), 1);
1919 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1928 Lo = DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(NVT, NVT), LL, RL);
1929 Hi = SDValue(Lo.getNode(), 1);
1934 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1940 // Lo,Hi = umul LHS, RHS.
1943 Lo = UMulLOHI;
1952 Lo = DAG.getNode(ISD::MUL, dl, NVT, LL, RL);
1975 SplitInteger(MakeLibCall(LC, VT, Ops, 2, true/*irrelevant*/, dl), Lo, Hi);
1979 SDValue &Lo, SDValue &Hi) {
1989 SplitInteger(Sum, Lo, Hi);
2021 SDValue &Lo, SDValue &Hi) {
2037 SplitInteger(MakeLibCall(LC, VT, Ops, 2, true, dl), Lo, Hi);
2041 SDValue &Lo, SDValue &Hi) {
2048 return ExpandShiftByConstant(N, CN->getZExtValue(), Lo, Hi);
2052 if (ExpandShiftWithKnownAmountBit(N, Lo, Hi))
2078 Lo = DAG.getNode(PartsOpc, dl, DAG.getVTList(VT, VT), Ops, 3);
2079 Hi = Lo.getValue(1);
2121 SplitInteger(MakeLibCall(LC, VT, Ops, 2, isSigned, dl), Lo, Hi);
2125 if (!ExpandShiftWithUnknownAmountBit(N, Lo, Hi))
2130 SDValue &Lo, SDValue &Hi) {
2136 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
2139 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2151 SplitInteger(Res, Lo, Hi);
2161 ExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi) {
2163 GetExpandedInteger(N->getOperand(0), Lo, Hi);
2166 if (EVT.bitsLE(Lo.getValueType())) {
2168 Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Lo.getValueType(), Lo,
2173 Hi = DAG.getNode(ISD::SRA, dl, Hi.getValueType(), Lo,
2180 EVT.getSizeInBits() - Lo.getValueType().getSizeInBits();
2188 SDValue &Lo, SDValue &Hi) {
2204 SplitInteger(MakeLibCall(LC, VT, Ops, 2, true, dl), Lo, Hi);
2208 SDValue &Lo, SDValue &Hi) {
2211 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
2219 SDValue &Lo, SDValue &Hi) {
2229 SplitInteger(Sum, Lo, Hi);
2242 SDValue &Lo, SDValue &Hi) {
2255 SplitInteger(MUL, Lo, Hi);
2311 SplitInteger(CallInfo.first, Lo, Hi);
2322 SDValue &Lo, SDValue &Hi) {
2338 SplitInteger(MakeLibCall(LC, VT, Ops, 2, false, dl), Lo, Hi);
2342 SDValue &Lo, SDValue &Hi) {
2358 SplitInteger(MakeLibCall(LC, VT, Ops, 2, false, dl), Lo, Hi);
2362 SDValue &Lo, SDValue &Hi) {
2368 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
2380 SplitInteger(Res, Lo, Hi);
2390 SDValue &Lo, SDValue &Hi) {
2625 SDValue Lo, Hi;
2626 GetExpandedInteger(N->getOperand(1), Lo, Hi);
2627 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0), Lo), 0);
2634 SDValue Lo, Hi;
2635 GetExpandedInteger(N->getOperand(0), Lo, Hi);
2636 return SDValue(DAG.UpdateNodeOperands(N, Lo), 0);
2663 SDValue Lo, Hi;
2668 GetExpandedInteger(N->getValue(), Lo, Hi);
2669 return DAG.getTruncStore(Ch, dl, Lo, Ptr, N->getPointerInfo(),
2676 GetExpandedInteger(N->getValue(), Lo, Hi);
2678 Lo = DAG.getStore(Ch, dl, Lo, Ptr, N->getPointerInfo(),
2693 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
2698 GetExpandedInteger(N->getValue(), Lo, Hi);
2708 // Transfer high bits from the top of Lo to the bottom of Hi.
2713 DAG.getNode(ISD::SRL, dl, NVT, Lo,
2726 Lo = DAG.getTruncStore(Ch, dl, Lo, Ptr,
2731 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
2787 SDValue Lo, Hi;
2788 GetExpandedInteger(Op, Lo, Hi);