Lines Matching refs:Hi
237 SDValue Lo, Hi;
238 GetSplitVector(N->getOperand(0), Lo, Hi);
240 Hi = BitConvertToInteger(Hi);
243 std::swap(Lo, Hi);
248 JoinIntegers(Lo, Hi));
668 SDValue Hi = DAG.getNode(ISD::SRL, DL, Mul.getValueType(), Mul,
670 Overflow = DAG.getSetCC(DL, N->getValueType(1), Hi,
671 DAG.getConstant(0, Hi.getValueType()), ISD::SETNE);
896 SDValue Hi = GetPromotedInteger(N->getOperand(1));
900 Hi = DAG.getNode(ISD::SHL, dl, N->getValueType(0), Hi,
902 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;
1102 case ISD::CTLZ: ExpandIntRes_CTLZ(N, Lo, Hi); break;
1103 case ISD::CTPOP: ExpandIntRes_CTPOP(N, Lo, Hi); break;
1105 case ISD::CTTZ: ExpandIntRes_CTTZ(N, Lo, Hi); break;
1106 case ISD::FP_TO_SINT: ExpandIntRes_FP_TO_SINT(N, Lo, Hi); break;
1107 case ISD::FP_TO_UINT: ExpandIntRes_FP_TO_UINT(N, Lo, Hi); break;
1108 case ISD::LOAD: ExpandIntRes_LOAD(cast<LoadSDNode>(N), Lo, Hi); break;
1109 case ISD::MUL: ExpandIntRes_MUL(N, Lo, Hi); break;
1110 case ISD::SDIV: ExpandIntRes_SDIV(N, Lo, Hi); break;
1111 case ISD::SIGN_EXTEND: ExpandIntRes_SIGN_EXTEND(N, Lo, Hi); break;
1112 case ISD::SIGN_EXTEND_INREG: ExpandIntRes_SIGN_EXTEND_INREG(N, Lo, Hi); break;
1113 case ISD::SREM: ExpandIntRes_SREM(N, Lo, Hi); break;
1114 case ISD::TRUNCATE: ExpandIntRes_TRUNCATE(N, Lo, Hi); break;
1115 case ISD::UDIV: ExpandIntRes_UDIV(N, Lo, Hi); break;
1116 case ISD::UREM: ExpandIntRes_UREM(N, Lo, Hi); break;
1117 case ISD::ZERO_EXTEND: ExpandIntRes_ZERO_EXTEND(N, Lo, Hi); break;
1118 case ISD::ATOMIC_LOAD: ExpandIntRes_ATOMIC_LOAD(N, Lo, Hi); break;
1132 SplitInteger(Tmp.first, Lo, Hi);
1139 case ISD::XOR: ExpandIntRes_Logical(N, Lo, Hi); break;
1142 case ISD::SUB: ExpandIntRes_ADDSUB(N, Lo, Hi); break;
1145 case ISD::SUBC: ExpandIntRes_ADDSUBC(N, Lo, Hi); break;
1148 case ISD::SUBE: ExpandIntRes_ADDSUBE(N, Lo, Hi); break;
1152 case ISD::SRL: ExpandIntRes_Shift(N, Lo, Hi); break;
1155 case ISD::SSUBO: ExpandIntRes_SADDSUBO(N, Lo, Hi); break;
1157 case ISD::USUBO: ExpandIntRes_UADDSUBO(N, Lo, Hi); break;
1159 case ISD::SMULO: ExpandIntRes_XMULO(N, Lo, Hi); break;
1162 // If Lo/Hi is null, the sub-method took care of registering results etc.
1164 SetExpandedInteger(SDValue(N, ResNo), Lo, Hi);
1256 SDValue &Lo, SDValue &Hi) {
1269 Lo = Hi = DAG.getConstant(0, NVT);
1272 Hi = DAG.getNode(ISD::SHL, DL,
1276 Hi = InL;
1285 Hi = DAG.getNode(ISD::ADDE, DL, VTList, HiOps, 3);
1288 Hi = DAG.getNode(ISD::OR, DL, NVT,
1300 Hi = DAG.getConstant(0, NVT);
1304 Hi = DAG.getConstant(0, NVT);
1307 Hi = DAG.getConstant(0, NVT);
1314 Hi = DAG.getNode(ISD::SRL, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1321 Hi = Lo = DAG.getNode(ISD::SRA, DL, NVT, InH,
1326 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1330 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH,
1338 Hi = DAG.getNode(ISD::SRA, DL, NVT, InH, DAG.getConstant(Amt, ShTy));
1347 ExpandShiftWithKnownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
1380 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
1383 Hi = DAG.getConstant(0, NVT); // Hi part is zero.
1384 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
1387 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
1389 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
1411 // When shifting right the arithmetic for Lo and Hi is swapped.
1415 // Use a little trick to get the bits that move from Lo to Hi. First
1422 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
1425 std::swap(Hi, Lo);
1435 ExpandShiftWithUnknownAmountBit(SDNode *N, SDValue &Lo, SDValue &Hi) {
1468 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
1471 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1483 HiL = DAG.getConstant(0, NVT); // Hi part is zero.
1484 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1487 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1499 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
1501 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
1504 Hi = DAG.getNode(ISD::SELECT, dl, NVT, isShort, HiS, HiL);
1510 SDValue &Lo, SDValue &Hi) {
1536 Hi = DAG.getNode(ISD::ADDE, dl, VTList, HiOps, 3);
1540 Hi = DAG.getNode(ISD::SUBE, dl, VTList, HiOps, 3);
1547 Hi = DAG.getNode(ISD::ADD, dl, NVT, HiOps, 2);
1557 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry2);
1560 Hi = DAG.getNode(ISD::SUB, dl, NVT, HiOps, 2);
1567 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
1572 SDValue &Lo, SDValue &Hi) {
1585 Hi = DAG.getNode(ISD::ADDE, dl, VTList, HiOps, 3);
1589 Hi = DAG.getNode(ISD::SUBE, dl, VTList, HiOps, 3);
1594 ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
1598 SDValue &Lo, SDValue &Hi) {
1610 Hi = DAG.getNode(N->getOpcode(), dl, VTList, HiOps, 3);
1614 ReplaceValueWith(SDValue(N, 1), Hi.getValue(1));
1618 SDValue &Lo, SDValue &Hi) {
1620 SplitInteger(Res, Lo, Hi);
1624 SDValue &Lo, SDValue &Hi) {
1631 Hi = DAG.getUNDEF(NVT); // The high part is undefined.
1642 SplitInteger(Res, Lo, Hi);
1647 SDValue &Lo, SDValue &Hi) {
1649 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1656 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
1662 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1668 SDValue &Lo, SDValue &Hi) {
1670 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1677 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
1683 Hi = DAG.getConstant(0, NVT);
1688 SDValue &Lo, SDValue &Hi) {
1690 GetExpandedInteger(N->getOperand(0), Hi, Lo); // Note swapped operands.
1692 Hi = DAG.getNode(ISD::BSWAP, dl, Hi.getValueType(), Hi);
1696 SDValue &Lo, SDValue &Hi) {
1701 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), NVT);
1705 SDValue &Lo, SDValue &Hi) {
1707 // ctlz (HiLo) -> Hi != 0 ? ctlz(Hi) : (ctlz(Lo)+32)
1708 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1711 SDValue HiNotZero = DAG.getSetCC(dl, TLI.getSetCCResultType(NVT), Hi,
1715 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
1720 Hi = DAG.getConstant(0, NVT);
1724 SDValue &Lo, SDValue &Hi) {
1726 // ctpop(HiLo) -> ctpop(Hi)+ctpop(Lo)
1727 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1730 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
1731 Hi = DAG.getConstant(0, NVT);
1735 SDValue &Lo, SDValue &Hi) {
1737 // cttz (HiLo) -> Lo != 0 ? cttz(Lo) : (cttz(Hi)+32)
1738 GetExpandedInteger(N->getOperand(0), Lo, Hi);
1745 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
1750 Hi = DAG.getConstant(0, NVT);
1754 SDValue &Hi) {
1761 Lo, Hi);
1765 SDValue &Hi) {
1772 Lo, Hi);
1776 SDValue &Lo, SDValue &Hi) {
1778 ExpandRes_NormalLoad(N, Lo, Hi);
1810 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
1814 Hi = DAG.getConstant(0, NVT);
1818 Hi = DAG.getUNDEF(NVT);
1833 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
1841 Hi.getValue(1));
1851 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
1869 Hi.getValue(1));
1872 // Transfer low bits from the bottom of Hi to the top of Lo.
1874 DAG.getNode(ISD::SHL, dl, NVT, Hi,
1877 // Move high bits to the right position in Hi.
1878 Hi = DAG.getNode(ExtType == ISD::SEXTLOAD ? ISD::SRA : ISD::SRL, dl,
1879 NVT, Hi,
1891 SDValue &Lo, SDValue &Hi) {
1897 Hi = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), LH, RH);
1901 SDValue &Lo, SDValue &Hi) {
1926 Hi = SDValue(Lo.getNode(), 1);
1932 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1941 Hi = SDValue(Lo.getNode(), 1);
1947 Hi = DAG.getNode(ISD::MULHS, dl, NVT, LL, RL);
1952 // Lo,Hi = umul LHS, RHS.
1956 Hi = UMulLOHI.getValue(1);
1959 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1960 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
1965 Hi = DAG.getNode(ISD::MULHU, dl, NVT, LL, RL);
1968 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, RH);
1969 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, LH);
1988 Lo, Hi);
1992 SDValue &Lo, SDValue &Hi) {
2002 SplitInteger(Sum, Lo, Hi);
2034 SDValue &Lo, SDValue &Hi) {
2050 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true, dl), Lo, Hi);
2054 SDValue &Lo, SDValue &Hi) {
2061 return ExpandShiftByConstant(N, CN->getZExtValue(), Lo, Hi);
2065 if (ExpandShiftWithKnownAmountBit(N, Lo, Hi))
2103 Hi = Lo.getValue(1);
2145 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, isSigned, dl), Lo, Hi);
2149 if (!ExpandShiftWithUnknownAmountBit(N, Lo, Hi))
2154 SDValue &Lo, SDValue &Hi) {
2163 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
2175 SplitInteger(Res, Lo, Hi);
2178 Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Hi.getValueType(), Hi,
2185 ExpandIntRes_SIGN_EXTEND_INREG(SDNode *N, SDValue &Lo, SDValue &Hi) {
2187 GetExpandedInteger(N->getOperand(0), Lo, Hi);
2197 Hi = DAG.getNode(ISD::SRA, dl, Hi.getValueType(), Lo,
2198 DAG.getConstant(Hi.getValueType().getSizeInBits()-1,
2205 Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Hi.getValueType(), Hi,
2212 SDValue &Lo, SDValue &Hi) {
2228 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true, dl), Lo, Hi);
2232 SDValue &Lo, SDValue &Hi) {
2236 Hi = DAG.getNode(ISD::SRL, dl,
2239 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
2243 SDValue &Lo, SDValue &Hi) {
2253 SplitInteger(Sum, Lo, Hi);
2266 SDValue &Lo, SDValue &Hi) {
2275 SplitInteger(MUL, Lo, Hi);
2341 SplitInteger(CallInfo.first, Lo, Hi);
2352 SDValue &Lo, SDValue &Hi) {
2368 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, false, dl), Lo, Hi);
2372 SDValue &Lo, SDValue &Hi) {
2388 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, false, dl), Lo, Hi);
2392 SDValue &Lo, SDValue &Hi) {
2399 Hi = DAG.getConstant(0, NVT); // The high part is just a zero.
2410 SplitInteger(Res, Lo, Hi);
2413 Hi = DAG.getZeroExtendInReg(Hi, dl,
2420 SDValue &Lo, SDValue &Hi) {
2655 SDValue Lo, Hi;
2656 GetExpandedInteger(N->getOperand(1), Lo, Hi);
2664 SDValue Lo, Hi;
2665 GetExpandedInteger(N->getOperand(0), Lo, Hi);
2693 SDValue Lo, Hi;
2698 GetExpandedInteger(N->getValue(), Lo, Hi);
2706 GetExpandedInteger(N->getValue(), Lo, Hi);
2719 Hi = DAG.getTruncStore(Ch, dl, Hi, Ptr,
2723 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
2728 GetExpandedInteger(N->getValue(), Lo, Hi);
2738 // Transfer high bits from the top of Lo to the bottom of Hi.
2739 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
2742 Hi = DAG.getNode(ISD::OR, dl, NVT, Hi,
2749 Hi = DAG.getTruncStore(Ch, dl, Hi, Ptr, N->getPointerInfo(),
2761 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
2806 SDValue Lo, Hi;
2807 GetExpandedInteger(Op, Lo, Hi);
2809 TLI.getSetCCResultType(Hi.getValueType()),
2810 Hi, DAG.getConstant(0, Hi.getValueType()),