Lines Matching refs:SDValue
51 SDValue R = SDValue();
142 SetSoftenedFloat(SDValue(N, ResNo), R);
146 SDValue DAGTypeLegalizer::SoftenFloatRes_Unary(SDNode *N, RTLIB::Libcall LC) {
152 SDValue Op = GetSoftenedFloat(N->getOperand(0 + Offset));
153 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
157 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, NVT, Op,
161 ReplaceValueWith(SDValue(N, 1), Tmp.second);
165 SDValue DAGTypeLegalizer::SoftenFloatRes_Binary(SDNode *N, RTLIB::Libcall LC) {
171 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0 + Offset)),
173 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
178 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, NVT, Ops,
182 ReplaceValueWith(SDValue(N, 1), Tmp.second);
186 SDValue DAGTypeLegalizer::SoftenFloatRes_BITCAST(SDNode *N) {
190 SDValue DAGTypeLegalizer::SoftenFloatRes_FREEZE(SDNode *N) {
196 SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N,
198 SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
202 SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {
211 SDValue DAGTypeLegalizer::SoftenFloatRes_ConstantFP(SDNode *N) {
235 SDValue DAGTypeLegalizer::SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N, unsigned ResNo) {
236 SDValue NewOp = BitConvertVectorToIntegerVector(N->getOperand(0));
242 SDValue DAGTypeLegalizer::SoftenFloatRes_FABS(SDNode *N) {
249 SDValue Mask = DAG.getConstant(API, SDLoc(N), NVT);
250 SDValue Op = GetSoftenedFloat(N->getOperand(0));
254 SDValue DAGTypeLegalizer::SoftenFloatRes_FMINNUM(SDNode *N) {
263 SDValue DAGTypeLegalizer::SoftenFloatRes_FMAXNUM(SDNode *N) {
272 SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) {
281 SDValue DAGTypeLegalizer::SoftenFloatRes_FCBRT(SDNode *N) {
290 SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) {
299 SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) {
300 SDValue LHS = GetSoftenedFloat(N->getOperand(0));
301 SDValue RHS = BitConvertToInteger(N->getOperand(1));
311 SDValue SignBit = DAG.getNode(
336 SDValue Mask = DAG.getNode(
347 SDValue DAGTypeLegalizer::SoftenFloatRes_FCOS(SDNode *N) {
356 SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
365 SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) {
374 SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) {
383 SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) {
392 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) {
401 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) {
410 SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) {
419 SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) {
423 SDValue Ops[3] = { GetSoftenedFloat(N->getOperand(0 + Offset)),
426 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
432 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG,
441 ReplaceValueWith(SDValue(N, 1), Tmp.second);
445 SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
454 SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) {
463 SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) {
473 SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
476 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
478 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
506 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, NVT, Op,
510 ReplaceValueWith(SDValue(N, 1), Tmp.second);
516 SDValue DAGTypeLegalizer::SoftenFloatRes_FP16_TO_FP(SDNode *N) {
518 SDValue Op = N->getOperand(0);
522 SDValue Res32 = TLI.makeLibCall(DAG, RTLIB::FPEXT_F16_F32, MidVT, Op,
533 SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
536 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
537 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
543 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, NVT, Op,
547 ReplaceValueWith(SDValue(N, 1), Tmp.second);
551 SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
560 SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
579 SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0 + Offset)),
581 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
586 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, NVT, Ops,
590 ReplaceValueWith(SDValue(N, 1), Tmp.second);
594 SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) {
603 SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) {
612 SDValue DAGTypeLegalizer::SoftenFloatRes_FROUND(SDNode *N) {
621 SDValue DAGTypeLegalizer::SoftenFloatRes_FROUNDEVEN(SDNode *N) {
630 SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
639 SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) {
648 SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
657 SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) {
666 SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) {
675 SDValue NewL;
683 ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
694 ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
699 SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT(SDNode *N) {
700 SDValue LHS = GetSoftenedFloat(N->getOperand(1));
701 SDValue RHS = GetSoftenedFloat(N->getOperand(2));
706 SDValue DAGTypeLegalizer::SoftenFloatRes_SELECT_CC(SDNode *N) {
707 SDValue LHS = GetSoftenedFloat(N->getOperand(2));
708 SDValue RHS = GetSoftenedFloat(N->getOperand(3));
714 SDValue DAGTypeLegalizer::SoftenFloatRes_UNDEF(SDNode *N) {
719 SDValue DAGTypeLegalizer::SoftenFloatRes_VAARG(SDNode *N) {
720 SDValue Chain = N->getOperand(0); // Get the chain.
721 SDValue Ptr = N->getOperand(1); // Get the pointer.
726 SDValue NewVAARG;
733 ReplaceValueWith(SDValue(N, 1), NewVAARG.getValue(1));
737 SDValue DAGTypeLegalizer::SoftenFloatRes_XINT_TO_FP(SDNode *N) {
759 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
761 SDValue Op = DAG.getNode(Signed ? ISD::SIGN_EXTEND : ISD::ZERO_EXTEND, dl,
766 std::pair<SDValue, SDValue> Tmp =
771 ReplaceValueWith(SDValue(N, 1), Tmp.second);
783 SDValue Res = SDValue();
829 ReplaceValueWith(SDValue(N, 0), Res);
833 SDValue DAGTypeLegalizer::SoftenFloatOp_BITCAST(SDNode *N) {
834 SDValue Op0 = GetSoftenedFloat(N->getOperand(0));
839 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_ROUND(SDNode *N) {
846 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
854 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
858 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, RVT, Op,
862 ReplaceValueWith(SDValue(N, 1), Tmp.second);
863 ReplaceValueWith(SDValue(N, 0), Tmp.first);
864 return SDValue();
869 SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) {
870 SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
887 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
893 SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_XINT(SDNode *N) {
898 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
920 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
923 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, NVT, Op,
927 SDValue Res = DAG.getNode(ISD::TRUNCATE, dl, RVT, Tmp.first);
932 ReplaceValueWith(SDValue(N, 1), Tmp.second);
933 ReplaceValueWith(SDValue(N, 0), Res);
934 return SDValue();
937 SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) {
938 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
955 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
961 SDValue DAGTypeLegalizer::SoftenFloatOp_SETCC(SDNode *N) {
963 SDValue Op0 = N->getOperand(IsStrict ? 1 : 0);
964 SDValue Op1 = N->getOperand(IsStrict ? 2 : 1);
965 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
970 SDValue NewLHS = GetSoftenedFloat(Op0);
971 SDValue NewRHS = GetSoftenedFloat(Op1);
981 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
990 ReplaceValueWith(SDValue(N, 0), NewLHS);
991 ReplaceValueWith(SDValue(N, 1), Chain);
992 return SDValue();
997 SDValue DAGTypeLegalizer::SoftenFloatOp_STORE(SDNode *N, unsigned OpNo) {
1001 SDValue Val = ST->getValue();
1015 SDValue DAGTypeLegalizer::SoftenFloatOp_FCOPYSIGN(SDNode *N) {
1016 SDValue LHS = N->getOperand(0);
1017 SDValue RHS = BitConvertToInteger(N->getOperand(1));
1049 SDValue DAGTypeLegalizer::SoftenFloatOp_Unary(SDNode *N, RTLIB::Libcall LC) {
1053 SDValue Op = GetSoftenedFloat(N->getOperand(0 + Offset));
1054 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
1058 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, NVT, Op,
1062 ReplaceValueWith(SDValue(N, 1), Tmp.second);
1063 ReplaceValueWith(SDValue(N, 0), Tmp.first);
1064 return SDValue();
1070 SDValue DAGTypeLegalizer::SoftenFloatOp_LROUND(SDNode *N) {
1080 SDValue DAGTypeLegalizer::SoftenFloatOp_LLROUND(SDNode *N) {
1090 SDValue DAGTypeLegalizer::SoftenFloatOp_LRINT(SDNode *N) {
1100 SDValue DAGTypeLegalizer::SoftenFloatOp_LLRINT(SDNode *N) {
1120 SDValue Lo, Hi;
1121 Lo = Hi = SDValue();
1211 SetExpandedFloat(SDValue(N, ResNo), Lo, Hi);
1214 void DAGTypeLegalizer::ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo,
1215 SDValue &Hi) {
1230 SDValue &Lo, SDValue &Hi) {
1233 SDValue Op = N->getOperand(0 + Offset);
1234 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
1236 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, N->getValueType(0),
1240 ReplaceValueWith(SDValue(N, 1), Tmp.second);
1245 SDValue &Lo, SDValue &Hi) {
1248 SDValue Ops[] = { N->getOperand(0 + Offset), N->getOperand(1 + Offset) };
1249 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
1251 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, N->getValueType(0),
1255 ReplaceValueWith(SDValue(N, 1), Tmp.second);
1259 void DAGTypeLegalizer::ExpandFloatRes_FABS(SDNode *N, SDValue &Lo,
1260 SDValue &Hi) {
1264 SDValue Tmp;
1273 void DAGTypeLegalizer::ExpandFloatRes_FMINNUM(SDNode *N, SDValue &Lo,
1274 SDValue &Hi) {
1281 void DAGTypeLegalizer::ExpandFloatRes_FMAXNUM(SDNode *N, SDValue &Lo,
1282 SDValue &Hi) {
1289 void DAGTypeLegalizer::ExpandFloatRes_FADD(SDNode *N, SDValue &Lo,
1290 SDValue &Hi) {
1297 void DAGTypeLegalizer::ExpandFloatRes_FCBRT(SDNode *N, SDValue &Lo,
1298 SDValue &Hi) {
1306 SDValue &Lo, SDValue &Hi) {
1314 SDValue &Lo, SDValue &Hi) {
1324 SDValue &Lo, SDValue &Hi) {
1331 void DAGTypeLegalizer::ExpandFloatRes_FDIV(SDNode *N, SDValue &Lo,
1332 SDValue &Hi) {
1342 SDValue &Lo, SDValue &Hi) {
1350 SDValue &Lo, SDValue &Hi) {
1358 SDValue &Lo, SDValue &Hi) {
1366 SDValue &Lo, SDValue &Hi) {
1374 SDValue &Lo, SDValue &Hi) {
1382 SDValue &Lo, SDValue &Hi) {
1389 void DAGTypeLegalizer::ExpandFloatRes_FMA(SDNode *N, SDValue &Lo,
1390 SDValue &Hi) {
1393 SDValue Ops[3] = { N->getOperand(0 + Offset), N->getOperand(1 + Offset),
1395 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
1397 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
1406 ReplaceValueWith(SDValue(N, 1), Tmp.second);
1410 void DAGTypeLegalizer::ExpandFloatRes_FMUL(SDNode *N, SDValue &Lo,
1411 SDValue &Hi) {
1421 SDValue &Lo, SDValue &Hi) {
1430 void DAGTypeLegalizer::ExpandFloatRes_FNEG(SDNode *N, SDValue &Lo,
1431 SDValue &Hi) {
1438 void DAGTypeLegalizer::ExpandFloatRes_FP_EXTEND(SDNode *N, SDValue &Lo,
1439 SDValue &Hi) {
1444 SDValue Chain;
1464 ReplaceValueWith(SDValue(N, 1), Chain);
1468 SDValue &Lo, SDValue &Hi) {
1476 SDValue &Lo, SDValue &Hi) {
1484 SDValue &Lo, SDValue &Hi) {
1495 SDValue &Lo, SDValue &Hi) {
1503 SDValue &Lo, SDValue &Hi) {
1511 SDValue &Lo, SDValue &Hi) {
1521 SDValue &Lo, SDValue &Hi) {
1531 SDValue &Lo, SDValue &Hi) {
1539 SDValue &Lo, SDValue &Hi) {
1546 void DAGTypeLegalizer::ExpandFloatRes_FSUB(SDNode *N, SDValue &Lo,
1547 SDValue &Hi) {
1557 SDValue &Lo, SDValue &Hi) {
1564 void DAGTypeLegalizer::ExpandFloatRes_LOAD(SDNode *N, SDValue &Lo,
1565 SDValue &Hi) {
1573 SDValue Chain = LD->getChain();
1574 SDValue Ptr = LD->getBasePtr();
1593 ReplaceValueWith(SDValue(LD, 1), Chain);
1596 void DAGTypeLegalizer::ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo,
1597 SDValue &Hi) {
1601 SDValue Src = N->getOperand(0);
1682 SDValue Res = SDValue();
1729 ReplaceValueWith(SDValue(N, 0), Res);
1735 void DAGTypeLegalizer::FloatExpandSetCCOperands(SDValue &NewLHS,
1736 SDValue &NewRHS,
1739 SDValue LHSLo, LHSHi, RHSLo, RHSHi;
1750 SDValue Tmp1, Tmp2, Tmp3;
1762 NewRHS = SDValue(); // LHS is the result, not a compare.
1765 SDValue DAGTypeLegalizer::ExpandFloatOp_BR_CC(SDNode *N) {
1766 SDValue NewLHS = N->getOperand(2), NewRHS = N->getOperand(3);
1778 return SDValue(DAG.UpdateNodeOperands(N, N->getOperand(0),
1783 SDValue DAGTypeLegalizer::ExpandFloatOp_FCOPYSIGN(SDNode *N) {
1786 SDValue Lo, Hi;
1794 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_ROUND(SDNode *N) {
1798 SDValue Lo, Hi;
1810 ReplaceValueWith(SDValue(N, 1), N->getOperand(0));
1811 ReplaceValueWith(SDValue(N, 0), Hi);
1812 return SDValue();
1815 SDValue Expansion = DAG.getNode(ISD::STRICT_FP_ROUND, SDLoc(N),
1818 ReplaceValueWith(SDValue(N, 1), Expansion.getValue(1));
1819 ReplaceValueWith(SDValue(N, 0), Expansion);
1820 return SDValue();
1823 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) {
1828 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
1829 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
1833 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, RVT, Op,
1838 ReplaceValueWith(SDValue(N, 1), Tmp.second);
1839 ReplaceValueWith(SDValue(N, 0), Tmp.first);
1840 return SDValue();
1843 SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
1848 SDValue Op = N->getOperand(IsStrict ? 1 : 0);
1849 SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
1853 std::pair<SDValue, SDValue> Tmp = TLI.makeLibCall(DAG, LC, RVT, Op,
1858 ReplaceValueWith(SDValue(N, 1), Tmp.second);
1859 ReplaceValueWith(SDValue(N, 0), Tmp.first);
1860 return SDValue();
1863 SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) {
1864 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
1876 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
1881 SDValue DAGTypeLegalizer::ExpandFloatOp_SETCC(SDNode *N) {
1882 SDValue NewLHS = N->getOperand(0), NewRHS = N->getOperand(1);
1894 return SDValue(DAG.UpdateNodeOperands(N, NewLHS, NewRHS,
1898 SDValue DAGTypeLegalizer::ExpandFloatOp_STORE(SDNode *N, unsigned OpNo) {
1906 SDValue Chain = ST->getChain();
1907 SDValue Ptr = ST->getBasePtr();
1915 SDValue Lo, Hi;
1922 SDValue DAGTypeLegalizer::ExpandFloatOp_LROUND(SDNode *N) {
1935 SDValue DAGTypeLegalizer::ExpandFloatOp_LLROUND(SDNode *N) {
1948 SDValue DAGTypeLegalizer::ExpandFloatOp_LRINT(SDNode *N) {
1961 SDValue DAGTypeLegalizer::ExpandFloatOp_LLRINT(SDNode *N) {
1992 SDValue R = SDValue();
2023 ReplaceValueWith(SDValue(N, 0), R);
2027 SDValue DAGTypeLegalizer::PromoteFloatOp_BITCAST(SDNode *N, unsigned OpNo) {
2028 SDValue Op = N->getOperand(0);
2031 SDValue Promoted = GetPromotedFloat(N->getOperand(0));
2036 SDValue Convert = DAG.getNode(GetPromotionOpcode(PromotedVT, OpVT), SDLoc(N),
2045 SDValue DAGTypeLegalizer::PromoteFloatOp_FCOPYSIGN(SDNode *N, unsigned OpNo) {
2047 SDValue Op1 = GetPromotedFloat(N->getOperand(1));
2054 SDValue DAGTypeLegalizer::PromoteFloatOp_FP_TO_XINT(SDNode *N, unsigned OpNo) {
2055 SDValue Op = GetPromotedFloat(N->getOperand(0));
2059 SDValue DAGTypeLegalizer::PromoteFloatOp_FP_EXTEND(SDNode *N, unsigned OpNo) {
2060 SDValue Op = GetPromotedFloat(N->getOperand(0));
2074 SDValue DAGTypeLegalizer::PromoteFloatOp_SELECT_CC(SDNode *N, unsigned OpNo) {
2075 SDValue LHS = GetPromotedFloat(N->getOperand(0));
2076 SDValue RHS = GetPromotedFloat(N->getOperand(1));
2085 SDValue DAGTypeLegalizer::PromoteFloatOp_SETCC(SDNode *N, unsigned OpNo) {
2087 SDValue Op0 = GetPromotedFloat(N->getOperand(0));
2088 SDValue Op1 = GetPromotedFloat(N->getOperand(1));
2097 SDValue DAGTypeLegalizer::PromoteFloatOp_STORE(SDNode *N, unsigned OpNo) {
2099 SDValue Val = ST->getValue();
2102 SDValue Promoted = GetPromotedFloat(Val);
2106 SDValue NewVal;
2121 SDValue R = SDValue();
2197 SetPromotedFloat(SDValue(N, ResNo), R);
2205 SDValue DAGTypeLegalizer::PromoteFloatRes_BITCAST(SDNode *N) {
2212 SDValue Cast = DAG.getBitcast(IVT, N->getOperand(0));
2216 SDValue DAGTypeLegalizer::PromoteFloatRes_ConstantFP(SDNode *N) {
2223 SDValue C = DAG.getConstant(CFPNode->getValueAPF().bitcastToAPInt(), DL,
2237 SDValue DAGTypeLegalizer::PromoteFloatRes_EXTRACT_VECTOR_ELT(SDNode *N) {
2243 SDValue Vec = N->getOperand(0);
2244 SDValue Idx = N->getOperand(1);
2253 SDValue Res = GetScalarizedVector(N->getOperand(0));
2254 ReplaceValueWith(SDValue(N, 0), Res);
2255 return SDValue();
2259 SDValue Res = DAG.getNode(N->getOpcode(), DL, EltVT, Vec, Idx);
2260 ReplaceValueWith(SDValue(N, 0), Res);
2261 return SDValue();
2264 SDValue Lo, Hi;
2268 SDValue Res;
2275 ReplaceValueWith(SDValue(N, 0), Res);
2276 return SDValue();
2283 SDValue NewOp = BitConvertVectorToIntegerVector(N->getOperand(0));
2287 SDValue NewVal = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, DL, IVT,
2299 SDValue DAGTypeLegalizer::PromoteFloatRes_FCOPYSIGN(SDNode *N) {
2302 SDValue Op0 = GetPromotedFloat(N->getOperand(0));
2304 SDValue Op1 = N->getOperand(1);
2312 SDValue DAGTypeLegalizer::PromoteFloatRes_UnaryOp(SDNode *N) {
2315 SDValue Op = GetPromotedFloat(N->getOperand(0));
2323 SDValue DAGTypeLegalizer::PromoteFloatRes_BinOp(SDNode *N) {
2326 SDValue Op0 = GetPromotedFloat(N->getOperand(0));
2327 SDValue Op1 = GetPromotedFloat(N->getOperand(1));
2331 SDValue DAGTypeLegalizer::PromoteFloatRes_FMAD(SDNode *N) {
2334 SDValue Op0 = GetPromotedFloat(N->getOperand(0));
2335 SDValue Op1 = GetPromotedFloat(N->getOperand(1));
2336 SDValue Op2 = GetPromotedFloat(N->getOperand(2));
2342 SDValue DAGTypeLegalizer::PromoteFloatRes_FPOWI(SDNode *N) {
2345 SDValue Op0 = GetPromotedFloat(N->getOperand(0));
2346 SDValue Op1 = N->getOperand(1);
2353 SDValue DAGTypeLegalizer::PromoteFloatRes_FP_ROUND(SDNode *N) {
2356 SDValue Op = N->getOperand(0);
2363 SDValue Round = DAG.getNode(GetPromotionOpcode(OpVT, VT), DL, IVT, Op);
2368 SDValue DAGTypeLegalizer::PromoteFloatRes_LOAD(SDNode *N) {
2374 SDValue newL = DAG.getLoad(
2380 ReplaceValueWith(SDValue(N, 1), newL.getValue(1));
2388 SDValue DAGTypeLegalizer::PromoteFloatRes_SELECT(SDNode *N) {
2389 SDValue TrueVal = GetPromotedFloat(N->getOperand(1));
2390 SDValue FalseVal = GetPromotedFloat(N->getOperand(2));
2398 SDValue DAGTypeLegalizer::PromoteFloatRes_SELECT_CC(SDNode *N) {
2399 SDValue TrueVal = GetPromotedFloat(N->getOperand(2));
2400 SDValue FalseVal = GetPromotedFloat(N->getOperand(3));
2409 SDValue DAGTypeLegalizer::PromoteFloatRes_XINT_TO_FP(SDNode *N) {
2413 SDValue NV = DAG.getNode(N->getOpcode(), DL, NVT, N->getOperand(0));
2420 SDValue DAGTypeLegalizer::PromoteFloatRes_UNDEF(SDNode *N) {
2425 SDValue DAGTypeLegalizer::BitcastToInt_ATOMIC_SWAP(SDNode *N) {
2431 SDValue CastVal = BitConvertToInteger(AM->getVal());
2434 SDValue NewAtomic
2440 SDValue Result = NewAtomic;
2450 ReplaceValueWith(SDValue(N, 1), NewAtomic.getValue(1));
2463 SDValue R = SDValue();
2536 SetSoftPromotedHalf(SDValue(N, ResNo), R);
2539 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_BITCAST(SDNode *N) {
2543 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_ConstantFP(SDNode *N) {
2551 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_EXTRACT_VECTOR_ELT(SDNode *N) {
2552 SDValue NewOp = BitConvertVectorToIntegerVector(N->getOperand(0));
2558 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FCOPYSIGN(SDNode *N) {
2559 SDValue LHS = GetSoftPromotedHalf(N->getOperand(0));
2560 SDValue RHS = BitConvertToInteger(N->getOperand(1));
2570 SDValue SignBit = DAG.getNode(
2595 SDValue Mask = DAG.getNode(
2606 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FMAD(SDNode *N) {
2608 SDValue Op0 = GetSoftPromotedHalf(N->getOperand(0));
2609 SDValue Op1 = GetSoftPromotedHalf(N->getOperand(1));
2610 SDValue Op2 = GetSoftPromotedHalf(N->getOperand(2));
2618 SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, Op0, Op1, Op2);
2624 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FPOWI(SDNode *N) {
2626 SDValue Op0 = GetSoftPromotedHalf(N->getOperand(0));
2627 SDValue Op1 = N->getOperand(1);
2632 SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, Op0, Op1);
2638 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FP_ROUND(SDNode *N) {
2640 SDValue Res =
2643 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
2650 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_LOAD(SDNode *N) {
2655 SDValue NewL =
2662 ReplaceValueWith(SDValue(N, 1), NewL.getValue(1));
2666 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_SELECT(SDNode *N) {
2667 SDValue Op1 = GetSoftPromotedHalf(N->getOperand(1));
2668 SDValue Op2 = GetSoftPromotedHalf(N->getOperand(2));
2673 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_SELECT_CC(SDNode *N) {
2674 SDValue Op2 = GetSoftPromotedHalf(N->getOperand(2));
2675 SDValue Op3 = GetSoftPromotedHalf(N->getOperand(3));
2681 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_XINT_TO_FP(SDNode *N) {
2685 SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
2691 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_UNDEF(SDNode *N) {
2695 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_UnaryOp(SDNode *N) {
2697 SDValue Op = GetSoftPromotedHalf(N->getOperand(0));
2703 SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, Op);
2709 SDValue DAGTypeLegalizer::SoftPromoteHalfRes_BinOp(SDNode *N) {
2711 SDValue Op0 = GetSoftPromotedHalf(N->getOperand(0));
2712 SDValue Op1 = GetSoftPromotedHalf(N->getOperand(1));
2719 SDValue Res = DAG.getNode(N->getOpcode(), dl, NVT, Op0, Op1);
2732 SDValue Res = SDValue();
2771 ReplaceValueWith(SDValue(N, 0), Res);
2775 SDValue DAGTypeLegalizer::SoftPromoteHalfOp_BITCAST(SDNode *N) {
2776 SDValue Op0 = GetSoftPromotedHalf(N->getOperand(0));
2781 SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FCOPYSIGN(SDNode *N,
2784 SDValue Op1 = N->getOperand(1);
2796 SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FP_EXTEND(SDNode *N) {
2798 SDValue Op = GetSoftPromotedHalf(N->getOperand(IsStrict ? 1 : 0));
2801 SDValue Res =
2804 ReplaceValueWith(SDValue(N, 1), Res.getValue(1));
2805 ReplaceValueWith(SDValue(N, 0), Res);
2806 return SDValue();
2812 SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FP_TO_XINT(SDNode *N) {
2813 SDValue Op = N->getOperand(0);
2820 SDValue Res = DAG.getNode(ISD::FP16_TO_FP, dl, NVT, Op);
2825 SDValue DAGTypeLegalizer::SoftPromoteHalfOp_SELECT_CC(SDNode *N,
2828 SDValue Op0 = N->getOperand(0);
2829 SDValue Op1 = N->getOperand(1);
2845 SDValue DAGTypeLegalizer::SoftPromoteHalfOp_SETCC(SDNode *N) {
2846 SDValue Op0 = N->getOperand(0);
2847 SDValue Op1 = N->getOperand(1);
2863 SDValue DAGTypeLegalizer::SoftPromoteHalfOp_STORE(SDNode *N, unsigned OpNo) {
2866 SDValue Val = ST->getValue();
2870 SDValue Promoted = GetSoftPromotedHalf(Val);