Lines Matching refs:dl
418 SDLoc dl(N);
426 return DAG.getNode(ISD::BITCAST, dl, NOutVT, GetPromotedInteger(InOp));
430 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, GetSoftenedFloat(InOp));
433 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, GetSoftPromotedHalf(InOp));
437 return DAG.getNode(ISD::FP_TO_FP16, dl, NOutVT, GetPromotedFloat(InOp));
446 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT,
463 InOp = DAG.getNode(ISD::ANY_EXTEND, dl,
467 return DAG.getNode(ISD::BITCAST, dl, NOutVT, InOp);
477 DAG.getNode(ISD::BITCAST, dl, NOutVT, GetWidenedVector(InOp));
484 Res = DAG.getNode(ISD::SRL, dl, NOutVT, Res,
485 DAG.getShiftAmountConstant(ShiftAmt, NOutVT, dl));
502 InOp = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OutVT, InOp,
503 DAG.getVectorIdxConstant(0, dl));
504 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, InOp);
510 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT,
524 SDLoc dl(N);
533 return DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Res);
537 SDValue ShAmt = DAG.getShiftAmountConstant(DiffBits, NVT, dl);
539 return DAG.getNode(ISD::SRL, dl, NVT, DAG.getNode(ISD::BSWAP, dl, NVT, Op),
543 return DAG.getNode(ISD::VP_LSHR, dl, NVT,
544 DAG.getNode(ISD::VP_BSWAP, dl, NVT, Op, Mask, EVL), ShAmt,
552 SDLoc dl(N);
561 return DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Res);
565 SDValue ShAmt = DAG.getShiftAmountConstant(DiffBits, NVT, dl);
567 return DAG.getNode(ISD::SRL, dl, NVT,
568 DAG.getNode(ISD::BITREVERSE, dl, NVT, Op), ShAmt);
571 return DAG.getNode(ISD::VP_LSHR, dl, NVT,
572 DAG.getNode(ISD::VP_BITREVERSE, dl, NVT, Op, Mask, EVL),
588 SDLoc dl(N);
592 SDValue Result = DAG.getNode(Opc, dl,
602 SDLoc dl(N);
611 Result = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Result);
621 NVT.getScalarSizeInBits() - OVT.getScalarSizeInBits(), dl, NVT);
623 return DAG.getNode(ISD::SUB, dl, NVT,
624 DAG.getNode(N->getOpcode(), dl, NVT, Op),
628 return DAG.getNode(ISD::VP_SUB, dl, NVT,
629 DAG.getNode(N->getOpcode(), dl, NVT, Op, Mask, EVL),
662 SDLoc dl(N);
674 Result = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Result);
686 Op = DAG.getNode(ISD::OR, dl, NVT, Op, DAG.getConstant(TopBit, dl, NVT));
689 DAG.getNode(ISD::VP_OR, dl, NVT, Op, DAG.getConstant(TopBit, dl, NVT),
693 return DAG.getNode(N->getOpcode(), dl, NVT, Op);
694 return DAG.getNode(N->getOpcode(), dl, NVT, Op, N->getOperand(1),
699 SDLoc dl(N);
715 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SVT, In, Op1);
716 return DAG.getAnyExtOrTrunc(Ext, dl, NVT);
720 return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, NVT, Op0, Op1);
726 SDLoc dl(N);
749 Res = DAG.getNode(NewOpc, dl, {NVT, MVT::Other},
755 Res = DAG.getNode(NewOpc, dl, NVT, {N->getOperand(0), N->getOperand(1),
758 Res = DAG.getNode(NewOpc, dl, NVT, N->getOperand(0));
773 dl, NVT, Res,
780 SDLoc dl(N);
781 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0),
787 SDLoc dl(N);
789 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
794 SDLoc dl(N);
796 SDValue Res = DAG.getNode(N->getOpcode(), dl, DAG.getVTList(NVT, MVT::Other),
804 SDLoc dl(N);
805 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
810 SDLoc dl(N);
813 DAG.getNode(N->getOpcode(), dl, {NVT, MVT::Other}, N->getOperand(0));
823 SDLoc dl(N);
835 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
838 return DAG.getZeroExtendInReg(Res, dl, N->getOperand(0).getValueType());
848 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0),
851 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
859 SDLoc dl(N);
860 SDValue Res = DAG.getExtLoad(ExtType, dl, NVT, N->getChain(), N->getBasePtr(),
877 SDLoc dl(N);
878 SDValue Res = DAG.getMaskedLoad(NVT, dl, N->getChain(), N->getBasePtr(),
899 SDLoc dl(N);
903 N->getMemoryVT(), dl, Ops,
925 SDLoc dl(N);
926 SDValue Res = DAG.getNode(N->getOpcode(), dl, DAG.getVTList(VT, SVT),
934 return DAG.getBoolExtOrTrunc(Res.getValue(1), dl, NVT, VT);
945 SDLoc dl(N);
969 SDValue SatMax = DAG.getConstant(MaxVal, dl, PromotedType);
971 DAG.getNode(ISD::ADD, dl, PromotedType, Op1Promoted, Op2Promoted);
972 return DAG.getNode(ISD::UMIN, dl, PromotedType, Add, SatMax);
977 return DAG.getNode(ISD::USUBSAT, dl, PromotedType, Op1Promoted,
1000 DAG.getShiftAmountConstant(SHLAmount, PromotedType, dl);
1002 DAG.getNode(ISD::SHL, dl, PromotedType, Op1Promoted, ShiftAmount);
1005 DAG.getNode(ISD::SHL, dl, PromotedType, Op2Promoted, ShiftAmount);
1008 DAG.getNode(Opcode, dl, PromotedType, Op1Promoted, Op2Promoted);
1009 return DAG.getNode(ShiftOp, dl, PromotedType, Result, ShiftAmount);
1015 SDValue SatMin = DAG.getConstant(MinVal, dl, PromotedType);
1016 SDValue SatMax = DAG.getConstant(MaxVal, dl, PromotedType);
1018 DAG.getNode(AddOp, dl, PromotedType, Op1Promoted, Op2Promoted);
1019 Result = DAG.getNode(ISD::SMIN, dl, PromotedType, Result, SatMax);
1020 Result = DAG.getNode(ISD::SMAX, dl, PromotedType, Result, SatMin);
1026 SDLoc dl(N);
1050 DAG.getNode(ISD::SHL, dl, PromotedType, Op1Promoted,
1051 DAG.getShiftAmountConstant(DiffSize, PromotedType, dl));
1052 SDValue Result = DAG.getNode(N->getOpcode(), dl, PromotedType, Op1Promoted,
1055 return DAG.getNode(ShiftOp, dl, PromotedType, Result,
1056 DAG.getShiftAmountConstant(DiffSize, PromotedType, dl));
1058 return DAG.getNode(N->getOpcode(), dl, PromotedType, Op1Promoted, Op2Promoted,
1062 static SDValue SaturateWidenedDIVFIX(SDValue V, SDLoc &dl,
1072 return DAG.getNode(ISD::UMIN, dl, VT, V,
1074 dl, VT));
1079 V = DAG.getNode(ISD::SMIN, dl, VT, V,
1081 dl, VT));
1084 V = DAG.getNode(ISD::SMAX, dl, VT, V,
1086 dl, VT));
1100 SDLoc dl(N);
1107 LHS = DAG.getExtOrTrunc(Signed, LHS, dl, WideVT);
1108 RHS = DAG.getExtOrTrunc(Signed, RHS, dl, WideVT);
1109 SDValue Res = TLI.expandFixedPointDiv(N->getOpcode(), dl, LHS, RHS, Scale,
1118 Res = SaturateWidenedDIVFIX(Res, dl, SatW == 0 ? VTSize : SatW, Signed,
1121 return DAG.getZExtOrTrunc(Res, dl, VT);
1125 SDLoc dl(N);
1151 DAG.getNode(ISD::SHL, dl, PromotedType, Op1Promoted,
1152 DAG.getShiftAmountConstant(Diff, PromotedType, dl));
1153 SDValue Res = DAG.getNode(N->getOpcode(), dl, PromotedType, Op1Promoted,
1156 Res = DAG.getNode(Signed ? ISD::SRA : ISD::SRL, dl, PromotedType, Res,
1157 DAG.getShiftAmountConstant(Diff, PromotedType, dl));
1163 if (SDValue Res = TLI.expandFixedPointDiv(N->getOpcode(), dl, Op1Promoted,
1166 Res = SaturateWidenedDIVFIX(Res, dl,
1188 SDLoc dl(N);
1192 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
1196 SDValue Ofl = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, NVT, Res,
1199 Ofl = DAG.getSetCC(dl, N->getValueType(1), Ofl, Res, ISD::SETNE);
1248 SDLoc dl(N);
1258 SetCC = DAG.getNode(N->getOpcode(), dl, VTs, Opers, N->getFlags());
1263 SetCC = DAG.getNode(N->getOpcode(), dl, SVT, N->getOperand(0),
1267 return DAG.getSExtOrTrunc(SetCC, dl, NVT);
1282 SDLoc dl(N);
1284 DAG.getNode(N->getOpcode(), dl, DAG.getVTList(VT, NVT), N->getOperand(0));
1492 SDLoc dl(N);
1518 EOp1 = DAG.getNode(ISD::TRUNCATE, dl, HalfNVT, EOp1);
1519 EOp2 = DAG.getNode(ISD::TRUNCATE, dl, HalfNVT, EOp2);
1526 DAG.SplitEVL(N->getOperand(2), N->getValueType(0), dl);
1527 EOp1 = DAG.getNode(ISD::VP_TRUNCATE, dl, HalfNVT, EOp1, MaskLo, EVLLo);
1528 EOp2 = DAG.getNode(ISD::VP_TRUNCATE, dl, HalfNVT, EOp2, MaskHi, EVLHi);
1530 return DAG.getNode(ISD::CONCAT_VECTORS, dl, NVT, EOp1, EOp2);
1541 SDValue WideTrunc = DAG.getNode(ISD::TRUNCATE, dl, TruncVT, WideInOp);
1546 SDValue WideExt = DAG.getNode(ISD::ZERO_EXTEND, dl, ExtVT, WideTrunc);
1549 SDValue ZeroIdx = DAG.getVectorIdxConstant(0, dl);
1550 return DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NVT, WideExt, ZeroIdx);
1556 return DAG.getNode(ISD::VP_TRUNCATE, dl, NVT, Res, N->getOperand(1),
1558 return DAG.getNode(ISD::TRUNCATE, dl, NVT, Res);
1571 SDLoc dl(N);
1575 SDValue Res = DAG.getNode(Opcode, dl, NVT, LHS, RHS);
1579 SDValue Ofl = DAG.getZeroExtendInReg(Res, dl, OVT);
1581 Ofl = DAG.getSetCC(dl, N->getValueType(1), Ofl, Res, ISD::SETNE);
1715 SDLoc dl(N);
1723 Parts[i] = DAG.getVAArg(RegVT, dl, Chain, Ptr, N->getOperand(2),
1734 SDValue Res = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[0]);
1736 SDValue Part = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, Parts[i]);
1738 Part = DAG.getNode(ISD::SHL, dl, NVT, Part,
1739 DAG.getConstant(i * RegVT.getSizeInBits(), dl,
1741 Res = DAG.getNode(ISD::OR, dl, NVT, Res, Part);
2024 SDLoc dl(N);
2026 Hi = DAG.getNode(ISD::SHL, dl, N->getValueType(0), Hi,
2027 DAG.getConstant(OVT.getSizeInBits(), dl,
2029 return DAG.getNode(ISD::OR, dl, N->getValueType(0), Lo, Hi);
2147 SDLoc dl(N);
2148 Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
2149 return DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Op.getValueType(),
2154 SDLoc dl(N);
2158 Op = DAG.getNode(ISD::VP_ZERO_EXTEND, dl, VT, Op, N->getOperand(1),
2162 SDValue ShAmt = DAG.getShiftAmountConstant(Diff, VT, dl);
2164 SDValue Shl = DAG.getNode(ISD::VP_SHL, dl, VT, Op, ShAmt, N->getOperand(1),
2166 return DAG.getNode(ISD::VP_ASHR, dl, VT, Shl, ShAmt, N->getOperand(1),
2188 SDLoc dl(N);
2193 return DAG.getTruncStore(Ch, dl, Val, Ptr,
2315 SDLoc dl(N);
2317 Op = DAG.getNode(ISD::ANY_EXTEND, dl, N->getValueType(0), Op);
2318 return DAG.getZeroExtendInReg(Op, dl, N->getOperand(0).getValueType());
2322 SDLoc dl(N);
2326 Op = DAG.getNode(ISD::VP_ZERO_EXTEND, dl, VT, Op, N->getOperand(1),
2330 return DAG.getNode(ISD::VP_AND, dl, VT, Op, DAG.getConstant(Imm, dl, VT),
2440 SDLoc dl(N);
2499 SDValue Reduce = DAG.getNode(Opcode, dl, EltVT, Op);
2500 return DAG.getNode(ISD::TRUNCATE, dl, ResVT, Reduce);
2907 SDLoc dl(N);
2924 Amt = DAG.getNode(ISD::AND, dl, ShTy, Amt,
2925 DAG.getConstant(~HighBitMask, dl, ShTy));
2930 Lo = DAG.getConstant(0, dl, NVT); // Low part is zero.
2931 Hi = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt); // High part from Lo part.
2934 Hi = DAG.getConstant(0, dl, NVT); // Hi part is zero.
2935 Lo = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt); // Lo part from Hi part.
2938 Hi = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign extend high part.
2939 DAG.getConstant(NVTBits - 1, dl, ShTy));
2940 Lo = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt); // Lo part from Hi part.
2951 SDValue Amt2 = DAG.getNode(ISD::XOR, dl, ShTy, Amt,
2952 DAG.getConstant(NVTBits - 1, dl, ShTy));
2968 SDValue Sh1 = DAG.getNode(Op2, dl, NVT, InL, DAG.getConstant(1, dl, ShTy));
2970 SDValue Sh2 = DAG.getNode(Op2, dl, NVT, Sh1, Amt2);
2972 Lo = DAG.getNode(N->getOpcode(), dl, NVT, InL, Amt);
2973 Hi = DAG.getNode(ISD::OR, dl, NVT, DAG.getNode(Op1, dl, NVT, InH, Amt),Sh2);
2993 SDLoc dl(N);
2999 SDValue NVBitsNode = DAG.getConstant(NVTBits, dl, ShTy);
3000 SDValue AmtExcess = DAG.getNode(ISD::SUB, dl, ShTy, Amt, NVBitsNode);
3001 SDValue AmtLack = DAG.getNode(ISD::SUB, dl, ShTy, NVBitsNode, Amt);
3002 SDValue isShort = DAG.getSetCC(dl, getSetCCResultType(ShTy),
3004 SDValue isZero = DAG.getSetCC(dl, getSetCCResultType(ShTy),
3005 Amt, DAG.getConstant(0, dl, ShTy),
3013 LoS = DAG.getNode(ISD::SHL, dl, NVT, InL, Amt);
3014 HiS = DAG.getNode(ISD::OR, dl, NVT,
3015 DAG.getNode(ISD::SHL, dl, NVT, InH, Amt),
3016 DAG.getNode(ISD::SRL, dl, NVT, InL, AmtLack));
3019 LoL = DAG.getConstant(0, dl, NVT); // Lo part is zero.
3020 HiL = DAG.getNode(ISD::SHL, dl, NVT, InL, AmtExcess); // Hi from Lo part.
3022 Lo = DAG.getSelect(dl, NVT, isShort, LoS, LoL);
3023 Hi = DAG.getSelect(dl, NVT, isZero, InH,
3024 DAG.getSelect(dl, NVT, isShort, HiS, HiL));
3028 HiS = DAG.getNode(ISD::SRL, dl, NVT, InH, Amt);
3029 LoS = DAG.getNode(ISD::OR, dl, NVT,
3030 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
3033 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
3036 HiL = DAG.getConstant(0, dl, NVT); // Hi part is zero.
3037 LoL = DAG.getNode(ISD::SRL, dl, NVT, InH, AmtExcess); // Lo from Hi part.
3039 Lo = DAG.getSelect(dl, NVT, isZero, InL,
3040 DAG.getSelect(dl, NVT, isShort, LoS, LoL));
3041 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
3045 HiS = DAG.getNode(ISD::SRA, dl, NVT, InH, Amt);
3046 LoS = DAG.getNode(ISD::OR, dl, NVT,
3047 DAG.getNode(ISD::SRL, dl, NVT, InL, Amt),
3048 DAG.getNode(ISD::SHL, dl, NVT, InH, AmtLack));
3051 HiL = DAG.getNode(ISD::SRA, dl, NVT, InH, // Sign of Hi part.
3052 DAG.getConstant(NVTBits - 1, dl, ShTy));
3053 LoL = DAG.getNode(ISD::SRA, dl, NVT, InH, AmtExcess); // Lo from Hi part.
3055 Lo = DAG.getSelect(dl, NVT, isZero, InL,
3056 DAG.getSelect(dl, NVT, isShort, LoS, LoL));
3057 Hi = DAG.getSelect(dl, NVT, isShort, HiS, HiL);
3196 SDLoc dl(N);
3212 Lo = DAG.getNode(ISD::UADDO, dl, VTList, LoOps);
3215 ? DAG.getNode(ISD::UADDO, dl, VTList, ArrayRef(HiOps, 2))
3216 : DAG.getNode(ISD::UADDO_CARRY, dl, VTList, HiOps);
3218 Lo = DAG.getNode(ISD::USUBO, dl, VTList, LoOps);
3221 ? DAG.getNode(ISD::USUBO, dl, VTList, ArrayRef(HiOps, 2))
3222 : DAG.getNode(ISD::USUBO_CARRY, dl, VTList, HiOps);
3240 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps);
3242 Hi = DAG.getNode(ISD::ADDE, dl, VTList, HiOps);
3244 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps);
3246 Hi = DAG.getNode(ISD::SUBE, dl, VTList, HiOps);
3263 Lo = DAG.getNode(ISD::UADDO, dl, VTList, LoOps);
3264 Hi = DAG.getNode(ISD::ADD, dl, NVT, ArrayRef(HiOps, 2));
3267 Lo = DAG.getNode(ISD::USUBO, dl, VTList, LoOps);
3268 Hi = DAG.getNode(ISD::SUB, dl, NVT, ArrayRef(HiOps, 2));
3274 OVF = DAG.getNode(ISD::AND, dl, OvfVT, DAG.getConstant(1, dl, OvfVT), OVF);
3277 OVF = DAG.getZExtOrTrunc(OVF, dl, NVT);
3278 Hi = DAG.getNode(N->getOpcode(), dl, NVT, Hi, OVF);
3281 OVF = DAG.getSExtOrTrunc(OVF, dl, NVT);
3282 Hi = DAG.getNode(RevOpc, dl, NVT, Hi, OVF);
3288 Lo = DAG.getNode(ISD::ADD, dl, NVT, LoOps);
3289 Hi = DAG.getNode(ISD::ADD, dl, NVT, ArrayRef(HiOps, 2));
3294 Cmp = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
3295 DAG.getConstant(0, dl, NVT), ISD::SETEQ);
3298 Cmp = DAG.getSetCC(dl, getSetCCResultType(NVT), LoOps[0],
3299 DAG.getConstant(0, dl, NVT), ISD::SETEQ);
3301 Cmp = DAG.getSetCC(dl, getSetCCResultType(NVT), LoOps[0],
3302 DAG.getConstant(0, dl, NVT), ISD::SETNE);
3304 Cmp = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo, LoOps[0],
3309 Carry = DAG.getZExtOrTrunc(Cmp, dl, NVT);
3311 Carry = DAG.getSelect(dl, NVT, Cmp, DAG.getConstant(1, dl, NVT),
3312 DAG.getConstant(0, dl, NVT));
3315 Hi = DAG.getNode(ISD::SUB, dl, NVT, HiOps[0], Carry);
3317 Hi = DAG.getNode(ISD::ADD, dl, NVT, Hi, Carry);
3319 Lo = DAG.getNode(ISD::SUB, dl, NVT, LoOps);
3320 Hi = DAG.getNode(ISD::SUB, dl, NVT, ArrayRef(HiOps, 2));
3322 DAG.getSetCC(dl, getSetCCResultType(LoOps[0].getValueType()),
3327 Borrow = DAG.getZExtOrTrunc(Cmp, dl, NVT);
3329 Borrow = DAG.getSelect(dl, NVT, Cmp, DAG.getConstant(1, dl, NVT),
3330 DAG.getConstant(0, dl, NVT));
3332 Hi = DAG.getNode(ISD::SUB, dl, NVT, Hi, Borrow);
3340 SDLoc dl(N);
3348 Lo = DAG.getNode(ISD::ADDC, dl, VTList, LoOps);
3350 Hi = DAG.getNode(ISD::ADDE, dl, VTList, HiOps);
3352 Lo = DAG.getNode(ISD::SUBC, dl, VTList, LoOps);
3354 Hi = DAG.getNode(ISD::SUBE, dl, VTList, HiOps);
3366 SDLoc dl(N);
3373 Lo = DAG.getNode(N->getOpcode(), dl, VTList, LoOps);
3375 Hi = DAG.getNode(N->getOpcode(), dl, VTList, HiOps);
3386 SDLoc dl(N);
3419 Lo = DAG.getNode(N->getOpcode(), dl, VTList, LoOps);
3421 Hi = DAG.getNode(CarryOp, dl, VTList, HiOps);
3427 SDValue Sum = DAG.getNode(NoCarryOp, dl, LHS.getValueType(), LHS, RHS);
3433 SDValue Or = DAG.getNode(ISD::OR, dl, Lo.getValueType(), Lo, Hi);
3434 Ovf = DAG.getSetCC(dl, N->getValueType(1), Or,
3435 DAG.getConstant(0, dl, Lo.getValueType()), ISD::SETEQ);
3439 DAG.getSetCC(dl, N->getValueType(1), LHS,
3440 DAG.getConstant(0, dl, LHS.getValueType()), ISD::SETNE);
3444 Ovf = DAG.getSetCC(dl, N->getValueType(1), Sum, LHS, Cond);
3457 SDLoc dl(N);
3464 Lo = DAG.getNode(N->getOpcode(), dl, VTList, LoOps);
3466 Hi = DAG.getNode(N->getOpcode(), dl, VTList, HiOps);
3477 SDLoc dl(N);
3485 Lo = DAG.getNode(CarryOp, dl, VTList, { LHSL, RHSL, N->getOperand(2) });
3486 Hi = DAG.getNode(N->getOpcode(), dl, VTList, { LHSH, RHSH, Lo.getValue(1) });
3496 SDLoc dl(N);
3500 Lo = DAG.getNode(ISD::ANY_EXTEND, dl, NVT, Op);
3518 SDLoc dl(N);
3526 Hi = DAG.getNode(ISD::AssertSext, dl, NVT, Hi,
3530 Lo = DAG.getNode(ISD::AssertSext, dl, NVT, Lo, DAG.getValueType(EVT));
3532 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
3533 DAG.getConstant(NVTBits - 1, dl,
3540 SDLoc dl(N);
3548 Hi = DAG.getNode(ISD::AssertZext, dl, NVT, Hi,
3552 Lo = DAG.getNode(ISD::AssertZext, dl, NVT, Lo, DAG.getValueType(EVT));
3554 Hi = DAG.getConstant(0, dl, NVT);
3560 SDLoc dl(N);
3562 Lo = DAG.getNode(ISD::BITREVERSE, dl, Lo.getValueType(), Lo);
3563 Hi = DAG.getNode(ISD::BITREVERSE, dl, Hi.getValueType(), Hi);
3568 SDLoc dl(N);
3570 Lo = DAG.getNode(ISD::BSWAP, dl, Lo.getValueType(), Lo);
3571 Hi = DAG.getNode(ISD::BSWAP, dl, Hi.getValueType(), Hi);
3576 SDLoc dl(N);
3581 DAG.getNode(ISD::PARITY, dl, NVT, DAG.getNode(ISD::XOR, dl, NVT, Lo, Hi));
3582 Hi = DAG.getConstant(0, dl, NVT);
3593 SDLoc dl(N);
3594 Lo = DAG.getConstant(Cst.trunc(NBitWidth), dl, NVT, IsTarget, IsOpaque);
3595 Hi = DAG.getConstant(Cst.lshr(NBitWidth).trunc(NBitWidth), dl, NVT, IsTarget,
3600 SDLoc dl(N);
3609 Lo = DAG.getNode(ISD::ABS, dl, NVT, Lo);
3610 Hi = DAG.getConstant(0, dl, NVT);
3624 ISD::SRA, dl, NVT, Hi,
3625 DAG.getShiftAmountConstant(NVT.getSizeInBits() - 1, NVT, dl));
3627 Lo = DAG.getNode(ISD::XOR, dl, NVT, Lo, Sign);
3628 Hi = DAG.getNode(ISD::XOR, dl, NVT, Hi, Sign);
3629 Lo = DAG.getNode(ISD::USUBO, dl, VTList, Lo, Sign);
3630 Hi = DAG.getNode(ISD::USUBO_CARRY, dl, VTList, Hi, Sign, Lo.getValue(1));
3636 SDValue Neg = DAG.getNode(ISD::SUB, dl, VT,
3637 DAG.getConstant(0, dl, VT), N0);
3641 SDValue HiIsNeg = DAG.getSetCC(dl, getSetCCResultType(NVT), Hi,
3642 DAG.getConstant(0, dl, NVT), ISD::SETLT);
3643 Lo = DAG.getSelect(dl, NVT, HiIsNeg, NegLo, Lo);
3644 Hi = DAG.getSelect(dl, NVT, HiIsNeg, NegHi, Hi);
3649 SDLoc dl(N);
3654 SDValue HiNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Hi,
3655 DAG.getConstant(0, dl, NVT), ISD::SETNE);
3657 SDValue LoLZ = DAG.getNode(N->getOpcode(), dl, NVT, Lo);
3658 SDValue HiLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, NVT, Hi);
3660 Lo = DAG.getSelect(dl, NVT, HiNotZero, HiLZ,
3661 DAG.getNode(ISD::ADD, dl, NVT, LoLZ,
3662 DAG.getConstant(NVT.getSizeInBits(), dl,
3664 Hi = DAG.getConstant(0, dl, NVT);
3669 SDLoc dl(N);
3673 Lo = DAG.getNode(ISD::ADD, dl, NVT, DAG.getNode(ISD::CTPOP, dl, NVT, Lo),
3674 DAG.getNode(ISD::CTPOP, dl, NVT, Hi));
3675 Hi = DAG.getConstant(0, dl, NVT);
3680 SDLoc dl(N);
3685 SDValue LoNotZero = DAG.getSetCC(dl, getSetCCResultType(NVT), Lo,
3686 DAG.getConstant(0, dl, NVT), ISD::SETNE);
3688 SDValue LoLZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, NVT, Lo);
3689 SDValue HiLZ = DAG.getNode(N->getOpcode(), dl, NVT, Hi);
3691 Lo = DAG.getSelect(dl, NVT, LoNotZero, LoLZ,
3692 DAG.getNode(ISD::ADD, dl, NVT, HiLZ,
3693 DAG.getConstant(NVT.getSizeInBits(), dl,
3695 Hi = DAG.getConstant(0, dl, NVT);
3700 SDLoc dl(N);
3704 Lo = DAG.getNode(ISD::GET_ROUNDING, dl, {NVT, MVT::Other}, N->getOperand(0));
3707 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
3708 DAG.getShiftAmountConstant(NBitWidth - 1, NVT, dl));
3728 SDLoc dl(N);
3743 Op = DAG.getNode(OFPVT == MVT::f16 ? ISD::FP16_TO_FP : ISD::BF16_TO_FP, dl,
3745 Op = DAG.getNode(IsSigned ? ISD::FP_TO_SINT : ISD::FP_TO_UINT, dl, VT, Op);
3752 Op = fpExtendHelper(Op, Chain, IsStrict, MVT::f32, dl, DAG);
3761 CallOptions, dl, Chain);
3776 SDLoc dl(N);
3789 Op = fpExtendHelper(Op, Chain, IsStrict, VT, dl, DAG);
3853 Op, CallOptions, dl,
3879 SDLoc dl(N);
3886 Lo = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(), MemVT,
3896 Hi = DAG.getNode(ISD::SRA, dl, NVT, Lo,
3897 DAG.getConstant(LoSize - 1, dl,
3901 Hi = DAG.getConstant(0, dl, NVT);
3909 Lo = DAG.getLoad(NVT, dl, Ch, Ptr, N->getPointerInfo(),
3918 Ptr = DAG.getMemBasePlusOffset(Ptr, TypeSize::getFixed(IncrementSize), dl);
3919 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr,
3925 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
3936 Hi = DAG.getExtLoad(ExtType, dl, NVT, Ch, Ptr, N->getPointerInfo(),
3942 Ptr = DAG.getMemBasePlusOffset(Ptr, TypeSize::getFixed(IncrementSize), dl);
3944 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, NVT, Ch, Ptr,
3951 Ch = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
3957 ISD::OR, dl, NVT, Lo,
3958 DAG.getNode(ISD::SHL, dl, NVT, Hi,
3959 DAG.getConstant(ExcessBits, dl,
3962 Hi = DAG.getNode(ExtType == ISD::SEXTLOAD ? ISD::SRA : ISD::SRL, dl, NVT,
3964 DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
3976 SDLoc dl(N);
3980 Lo = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), LL, RL);
3981 Hi = DAG.getNode(N->getOpcode(), dl, LL.getValueType(), LH, RH);
3988 SDLoc dl(N);
4017 SDValue Mask = DAG.getConstant(APInt::getLowBitsSet(Bits, HalfBits), dl,
4019 SDValue LLL = DAG.getNode(ISD::AND, dl, NVT, LL, Mask);
4020 SDValue RLL = DAG.getNode(ISD::AND, dl, NVT, RL, Mask);
4022 SDValue T = DAG.getNode(ISD::MUL, dl, NVT, LLL, RLL);
4023 SDValue TL = DAG.getNode(ISD::AND, dl, NVT, T, Mask);
4025 SDValue Shift = DAG.getShiftAmountConstant(HalfBits, NVT, dl);
4026 SDValue TH = DAG.getNode(ISD::SRL, dl, NVT, T, Shift);
4027 SDValue LLH = DAG.getNode(ISD::SRL, dl, NVT, LL, Shift);
4028 SDValue RLH = DAG.getNode(ISD::SRL, dl, NVT, RL, Shift);
4030 SDValue U = DAG.getNode(ISD::ADD, dl, NVT,
4031 DAG.getNode(ISD::MUL, dl, NVT, LLH, RLL), TH);
4032 SDValue UL = DAG.getNode(ISD::AND, dl, NVT, U, Mask);
4033 SDValue UH = DAG.getNode(ISD::SRL, dl, NVT, U, Shift);
4035 SDValue V = DAG.getNode(ISD::ADD, dl, NVT,
4036 DAG.getNode(ISD::MUL, dl, NVT, LLL, RLH), UL);
4037 SDValue VH = DAG.getNode(ISD::SRL, dl, NVT, V, Shift);
4039 SDValue W = DAG.getNode(ISD::ADD, dl, NVT,
4040 DAG.getNode(ISD::MUL, dl, NVT, LLH, RLH),
4041 DAG.getNode(ISD::ADD, dl, NVT, UH, VH));
4042 Lo = DAG.getNode(ISD::ADD, dl, NVT, TL,
4043 DAG.getNode(ISD::SHL, dl, NVT, V, Shift));
4045 Hi = DAG.getNode(ISD::ADD, dl, NVT, W,
4046 DAG.getNode(ISD::ADD, dl, NVT,
4047 DAG.getNode(ISD::MUL, dl, NVT, RH, LL),
4048 DAG.getNode(ISD::MUL, dl, NVT, RL, LH)));
4055 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, CallOptions, dl).first,
4089 SDLoc dl(N);
4104 Result = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
4108 Result = DAG.getNode(MulOp, dl, DAG.getVTList(VT, BoolVT), LHS, RHS);
4114 SDValue SatMin = DAG.getConstant(MinVal, dl, VT);
4115 SDValue SatMax = DAG.getConstant(MaxVal, dl, VT);
4116 SDValue Zero = DAG.getConstant(0, dl, VT);
4119 SDValue Xor = DAG.getNode(ISD::XOR, dl, VT, LHS, RHS);
4120 SDValue ProdNeg = DAG.getSetCC(dl, BoolVT, Xor, Zero, ISD::SETLT);
4121 Result = DAG.getSelect(dl, VT, ProdNeg, SatMin, SatMax);
4122 Result = DAG.getSelect(dl, VT, Overflow, Result, Product);
4127 SDValue SatMax = DAG.getConstant(MaxVal, dl, VT);
4128 Result = DAG.getSelect(dl, VT, Overflow, SatMax, Product);
4146 if (!TLI.expandMUL_LOHI(LoHiOp, VT, dl, LHS, RHS, Result, NVT, DAG,
4178 SDValue ShiftAmount = DAG.getShiftAmountConstant(Scale % NVTSize, NVT, dl);
4179 Lo = DAG.getNode(ISD::FSHR, dl, NVT, Result[Part0 + 1], Result[Part0],
4181 Hi = DAG.getNode(ISD::FSHR, dl, NVT, Result[Part0 + 2], Result[Part0 + 1],
4212 SDValue NVTZero = DAG.getConstant(0, dl, NVT);
4213 SDValue NVTNeg1 = DAG.getConstant(-1, dl, NVT);
4220 DAG.getNode(ISD::SRL, dl, NVT, ResultHL,
4221 DAG.getShiftAmountConstant(Scale, NVT, dl));
4222 SDValue Tmp = DAG.getNode(ISD::OR, dl, NVT, HLAdjusted, ResultHH);
4223 SatMax = DAG.getSetCC(dl, BoolNVT, Tmp, NVTZero, ISD::SETNE);
4226 SatMax = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETNE);
4230 DAG.getNode(ISD::SRL, dl, NVT, ResultHL,
4231 DAG.getShiftAmountConstant(Scale - NVTSize, NVT, dl));
4232 SatMax = DAG.getSetCC(dl, BoolNVT, HLAdjusted, NVTZero, ISD::SETNE);
4237 Hi = DAG.getSelect(dl, NVT, SatMax, NVTNeg1, Hi);
4238 Lo = DAG.getSelect(dl, NVT, SatMax, NVTNeg1, Lo);
4251 APInt::getHighBitsSet(NVTSize, OverflowBits - NVTSize), dl, NVT);
4253 APInt::getLowBitsSet(NVTSize, VTSize - OverflowBits), dl, NVT);
4255 SDValue HHGT0 = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETGT);
4256 SDValue HHEQ0 = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETEQ);
4257 SDValue HLUGT = DAG.getSetCC(dl, BoolNVT, ResultHL, HLLoMask, ISD::SETUGT);
4258 SatMax = DAG.getNode(ISD::OR, dl, BoolNVT, HHGT0,
4259 DAG.getNode(ISD::AND, dl, BoolNVT, HHEQ0, HLUGT));
4261 SDValue HHLT = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTNeg1, ISD::SETLT);
4262 SDValue HHEQ = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTNeg1, ISD::SETEQ);
4263 SDValue HLULT = DAG.getSetCC(dl, BoolNVT, ResultHL, HLHiMask, ISD::SETULT);
4264 SatMin = DAG.getNode(ISD::OR, dl, BoolNVT, HHLT,
4265 DAG.getNode(ISD::AND, dl, BoolNVT, HHEQ, HLULT));
4268 SDValue HHGT0 = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETGT);
4269 SDValue HHEQ0 = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTZero, ISD::SETEQ);
4270 SDValue HLNeg = DAG.getSetCC(dl, BoolNVT, ResultHL, NVTZero, ISD::SETLT);
4271 SatMax = DAG.getNode(ISD::OR, dl, BoolNVT, HHGT0,
4272 DAG.getNode(ISD::AND, dl, BoolNVT, HHEQ0, HLNeg));
4274 SDValue HHLT = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTNeg1, ISD::SETLT);
4275 SDValue HHEQ = DAG.getSetCC(dl, BoolNVT, ResultHH, NVTNeg1, ISD::SETEQ);
4276 SDValue HLPos = DAG.getSetCC(dl, BoolNVT, ResultHL, NVTZero, ISD::SETGE);
4277 SatMin = DAG.getNode(ISD::OR, dl, BoolNVT, HHLT,
4278 DAG.getNode(ISD::AND, dl, BoolNVT, HHEQ, HLPos));
4284 APInt::getHighBitsSet(NVTSize, OverflowBits), dl, NVT);
4286 APInt::getLowBitsSet(NVTSize, NVTSize - OverflowBits), dl, NVT);
4287 SatMax = DAG.getSetCC(dl, BoolNVT, ResultHH, HHLoMask, ISD::SETGT);
4288 SatMin = DAG.getSetCC(dl, BoolNVT, ResultHH, HHHiMask, ISD::SETLT);
4295 Hi = DAG.getSelect(dl, NVT, SatMax, DAG.getConstant(MaxHi, dl, NVT), Hi);
4296 Lo = DAG.getSelect(dl, NVT, SatMax, DAG.getConstant(MaxLo, dl, NVT), Lo);
4299 Hi = DAG.getSelect(dl, NVT, SatMin, DAG.getConstant(MinHi, dl, NVT), Hi);
4300 Lo = DAG.getSelect(dl, NVT, SatMin, NVTZero, Lo);
4305 SDLoc dl(N);
4307 SDValue Res = TLI.expandFixedPointDiv(N->getOpcode(), dl, N->getOperand(0),
4323 SDLoc dl(Node);
4340 Lo = DAG.getNode(IsAdd ? ISD::UADDO : ISD::USUBO, dl, VTList, {LHSL, RHSL});
4341 Hi = DAG.getNode(CarryOp, dl, VTList, { LHSH, RHSH, Lo.getValue(1) });
4348 ISD::ADD : ISD::SUB, dl, LHS.getValueType(),
4376 SDValue SignsMatch = DAG.getNode(ISD::XOR, dl, VT, LHS, RHS);
4378 SignsMatch = DAG.getNOT(dl, SignsMatch, VT);
4380 SDValue SumSignNE = DAG.getNode(ISD::XOR, dl, VT, LHS, Sum);
4381 Ovf = DAG.getNode(ISD::AND, dl, VT, SignsMatch, SumSignNE);
4383 Ovf = DAG.getSetCC(dl, OType, Ovf, DAG.getConstant(0, dl, VT), ISD::SETLT);
4393 SDLoc dl(N);
4397 SDValue Res = DAG.getNode(ISD::SDIVREM, dl, DAG.getVTList(VT, VT), Ops);
4415 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, CallOptions, dl).first, Lo, Hi);
4420 SDLoc dl(N);
4463 Init = DAG.getNode(WideningOpc, dl, StackSlotVT, Shiftee);
4466 SDValue AllZeros = DAG.getConstant(0, dl, VT);
4467 Init = DAG.getNode(ISD::BUILD_PAIR, dl, StackSlotVT, AllZeros, Shiftee);
4470 Ch = DAG.getStore(Ch, dl, Init, StackPtr, StackPtrInfo, StackSlotAlignment);
4478 SDValue ByteOffset = DAG.getNode(ISD::SRL, dl, ShAmtVT, ShAmt,
4479 DAG.getConstant(3, dl, ShAmtVT), Flags);
4482 ByteOffset = DAG.getNode(ISD::AND, dl, ShAmtVT, ByteOffset,
4483 DAG.getConstant(VTByteWidth - 1, dl, ShAmtVT));
4498 StackPtr, DAG.getConstant(VTByteWidth, dl, PtrTy), dl);
4499 ByteOffset = DAG.getNegative(ByteOffset, dl, ShAmtVT);
4503 ByteOffset = DAG.getSExtOrTrunc(ByteOffset, dl, PtrTy);
4504 AdjStackPtr = DAG.getMemBasePlusOffset(AdjStackPtr, ByteOffset, dl);
4508 VT, dl, Ch, AdjStackPtr,
4514 SDValue ShAmtRem = DAG.getNode(ISD::AND, dl, ShAmtVT, ShAmt,
4515 DAG.getConstant(7, dl, ShAmtVT));
4516 Res = DAG.getNode(N->getOpcode(), dl, VT, Res, ShAmtRem);
4526 SDLoc dl(N);
4587 ShiftOp = DAG.getZExtOrTrunc(ShiftOp, dl, ShiftTy);
4590 Lo = DAG.getNode(PartsOpc, dl, DAG.getVTList(VT, VT), Ops);
4634 SDValue ShAmt = DAG.getZExtOrTrunc(N->getOperand(1), dl, ShAmtTy);
4638 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, CallOptions, dl).first, Lo, Hi);
4649 SDLoc dl(N);
4653 Lo = DAG.getNode(ISD::SIGN_EXTEND, dl, NVT, N->getOperand(0));
4657 ISD::SRA, dl, NVT, Lo,
4658 DAG.getConstant(LoSize - 1, dl, TLI.getPointerTy(DAG.getDataLayout())));
4671 Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Hi.getValueType(), Hi,
4679 SDLoc dl(N);
4685 Lo = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Lo.getValueType(), Lo,
4690 Hi = DAG.getNode(ISD::SRA, dl, Hi.getValueType(), Lo,
4691 DAG.getConstant(Hi.getValueSizeInBits() - 1, dl,
4697 Hi = DAG.getNode(ISD::SIGN_EXTEND_INREG, dl, Hi.getValueType(), Hi,
4706 SDLoc dl(N);
4710 SDValue Res = DAG.getNode(ISD::SDIVREM, dl, DAG.getVTList(VT, VT), Ops);
4728 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, CallOptions, dl).first, Lo, Hi);
4734 SDLoc dl(N);
4735 Lo = DAG.getNode(ISD::TRUNCATE, dl, NVT, N->getOperand(0));
4736 Hi = DAG.getNode(ISD::SRL, dl, N->getOperand(0).getValueType(),
4738 DAG.getConstant(NVT.getSizeInBits(), dl,
4740 Hi = DAG.getNode(ISD::TRUNCATE, dl, NVT, Hi);
4746 SDLoc dl(N);
4771 SDValue HalfZero = DAG.getConstant(0, dl, HalfVT);
4772 SDValue Overflow = DAG.getNode(ISD::AND, dl, BitVT,
4773 DAG.getSetCC(dl, BitVT, LHSHigh, HalfZero, ISD::SETNE),
4774 DAG.getSetCC(dl, BitVT, RHSHigh, HalfZero, ISD::SETNE));
4776 SDValue One = DAG.getNode(ISD::UMULO, dl, VTHalfWithO, LHSHigh, RHSLow);
4777 Overflow = DAG.getNode(ISD::OR, dl, BitVT, Overflow, One.getValue(1));
4779 SDValue Two = DAG.getNode(ISD::UMULO, dl, VTHalfWithO, RHSHigh, LHSLow);
4780 Overflow = DAG.getNode(ISD::OR, dl, BitVT, Overflow, Two.getValue(1));
4782 SDValue HighSum = DAG.getNode(ISD::ADD, dl, HalfVT, One, Two);
4790 SDValue Three = DAG.getNode(ISD::MUL, dl, VT,
4791 DAG.getNode(ISD::ZERO_EXTEND, dl, VT, LHSLow),
4792 DAG.getNode(ISD::ZERO_EXTEND, dl, VT, RHSLow));
4795 Hi = DAG.getNode(ISD::UADDO, dl, VTHalfWithO, Hi, HighSum);
4796 Overflow = DAG.getNode(ISD::OR, dl, BitVT, Overflow, Hi.getValue(1));
4821 SDValue LHS = DAG.getNode(ISD::SIGN_EXTEND, dl, WideVT, N->getOperand(0));
4822 SDValue RHS = DAG.getNode(ISD::SIGN_EXTEND, dl, WideVT, N->getOperand(1));
4823 SDValue Mul = DAG.getNode(ISD::MUL, dl, WideVT, LHS, RHS);
4827 DAG.getNode(ISD::SRA, dl, VT, MulLo,
4828 DAG.getConstant(VT.getScalarSizeInBits() - 1, dl, VT));
4830 DAG.getSetCC(dl, N->getValueType(1), MulHi, SRA, ISD::SETNE);
4839 DAG.getStore(DAG.getEntryNode(), dl, DAG.getConstant(0, dl, PtrVT), Temp,
4864 CLI.setDebugLoc(dl)
4873 DAG.getLoad(PtrVT, dl, CallInfo.second, Temp, MachinePointerInfo());
4874 SDValue Ofl = DAG.getSetCC(dl, N->getValueType(1), Temp2,
4875 DAG.getConstant(0, dl, PtrVT),
4884 SDLoc dl(N);
4888 SDValue Res = DAG.getNode(ISD::UDIVREM, dl, DAG.getVTList(VT, VT), Ops);
4921 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, CallOptions, dl).first, Lo, Hi);
4927 SDLoc dl(N);
4931 SDValue Res = DAG.getNode(ISD::UDIVREM, dl, DAG.getVTList(VT, VT), Ops);
4964 SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, CallOptions, dl).first, Lo, Hi);
4970 SDLoc dl(N);
4974 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, NVT, N->getOperand(0));
4975 Hi = DAG.getConstant(0, dl, NVT); // The high part is just a zero.
4988 Hi = DAG.getZeroExtendInReg(Hi, dl,
4996 SDLoc dl(N);
4999 SDValue Zero = DAG.getConstant(0, dl, VT);
5001 ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, dl,
5065 SDLoc dl(N);
5069 SDValue VScaleBase = DAG.getVScale(dl, HalfVT, One);
5070 VScaleBase = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, VScaleBase);
5071 SDValue Res = DAG.getNode(ISD::MUL, dl, VT, VScaleBase, N->getOperand(0));
5156 const SDLoc &dl) {
5164 NewLHS = DAG.getNode(ISD::AND, dl, LHSLo.getValueType(), LHSLo, LHSHi);
5169 NewLHS = DAG.getNode(ISD::XOR, dl, LHSLo.getValueType(), LHSLo, RHSLo);
5170 NewRHS = DAG.getNode(ISD::XOR, dl, LHSLo.getValueType(), LHSHi, RHSHi);
5171 NewLHS = DAG.getNode(ISD::OR, dl, NewLHS.getValueType(), NewLHS, NewRHS);
5172 NewRHS = DAG.getConstant(0, dl, NewLHS.getValueType());
5212 RHSLo, LowCC, false, DagCombineInfo, dl);
5214 LoCmp = DAG.getSetCC(dl, getSetCCResultType(LHSLo.getValueType()), LHSLo,
5219 RHSHi, CCCode, false, DagCombineInfo, dl);
5222 DAG.getNode(ISD::SETCC, dl, getSetCCResultType(LHSHi.getValueType()),
5277 SDValue LowCmp = DAG.getNode(ISD::USUBO, dl, VTList, LHSLo, RHSLo);
5278 SDValue Res = DAG.getNode(ISD::SETCCCARRY, dl, getSetCCResultType(HiVT),
5287 false, DagCombineInfo, dl);
5290 DAG.getSetCC(dl, getSetCCResultType(HiVT), LHSHi, RHSHi, ISD::SETEQ);
5291 NewLHS = DAG.getSelect(dl, LoCmp.getValueType(), NewLHS, LoCmp, HiCmp);
5353 SDLoc dl = SDLoc(N);
5362 DAG.getNode(ISD::USUBO_CARRY, dl, VTList, LHSLo, RHSLo, Carry);
5363 return DAG.getNode(ISD::SETCCCARRY, dl, N->getValueType(0), LHSHi, RHSHi,
5432 SDLoc dl(N);
5439 return DAG.getTruncStore(Ch, dl, Lo, Ptr, N->getPointerInfo(),
5448 Lo = DAG.getStore(Ch, dl, Lo, Ptr, N->getPointerInfo(),
5457 Ptr = DAG.getObjectPtrOffset(dl, Ptr, TypeSize::getFixed(IncrementSize));
5458 Hi = DAG.getTruncStore(Ch, dl, Hi, Ptr,
5461 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
5477 Hi = DAG.getNode(ISD::SHL, dl, NVT, Hi,
5478 DAG.getConstant(NVT.getSizeInBits() - ExcessBits, dl,
5481 ISD::OR, dl, NVT, Hi,
5482 DAG.getNode(ISD::SRL, dl, NVT, Lo,
5483 DAG.getConstant(ExcessBits, dl,
5488 Hi = DAG.getTruncStore(Ch, dl, Hi, Ptr, N->getPointerInfo(), HiVT,
5492 Ptr = DAG.getObjectPtrOffset(dl, Ptr, TypeSize::getFixed(IncrementSize));
5494 Lo = DAG.getTruncStore(Ch, dl, Lo, Ptr,
5498 return DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo, Hi);
5509 SDLoc dl(N);
5511 DAG.getAtomic(ISD::ATOMIC_SWAP, dl, cast<AtomicSDNode>(N)->getMemoryVT(),
5529 SDLoc dl(N);
5535 return DAG.getNode(ISD::VECTOR_SPLICE, dl, OutVT, V0, V1, N->getOperand(2));
5539 SDLoc dl(N);
5544 SDValue Res = DAG.getNode(N->getOpcode(), dl,
5558 SDLoc dl(N);
5575 SDValue Step1 = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, NInVT, InOp0,
5576 DAG.getConstant(alignDown(IdxVal, NElts), dl,
5579 ISD::EXTRACT_SUBVECTOR, dl, OutVT, Step1,
5580 DAG.getConstant(IdxVal % NElts, dl, BaseIdx.getValueType()));
5581 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, Step2);
5588 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, Ext);
5603 return DAG.getNode(ISD::ANY_EXTEND, dl, NOutVT, Ext);
5622 SDValue Index = DAG.getNode(ISD::ADD, dl, BaseIdx.getValueType(),
5623 BaseIdx, DAG.getConstant(i, dl, BaseIdx.getValueType()));
5624 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
5627 SDValue Op = DAG.getAnyExtOrTrunc(Ext, dl, NOutVTElem);
5632 return DAG.getBuildVector(NOutVT, dl, Ops);
5640 SDLoc dl(N);
5651 SubVec = DAG.getNode(ISD::ANY_EXTEND, dl, NSubVT, SubVec);
5653 return DAG.getNode(ISD::INSERT_SUBVECTOR, dl, NOutVT, Vec, SubVec, Idx);
5657 SDLoc dl(N);
5662 return DAG.getNode(ISD::VECTOR_REVERSE, dl, OutVT, V0);
5668 SDLoc dl(N);
5676 return DAG.getVectorShuffle(OutVT, dl, V0, V1, NewMask);
5687 SDLoc dl(N);
5705 Op = DAG.getNode(ExtOpc, dl, NOutVTElem, Op);
5710 return DAG.getBuildVector(NOutVT, dl, Ops);
5715 SDLoc dl(N);
5725 SDValue Op = DAG.getNode(ISD::ANY_EXTEND, dl, NOutElemVT, N->getOperand(0));
5727 return DAG.getNode(N->getOpcode(), dl, NOutVT, Op);
5731 SDLoc dl(N);
5737 return DAG.getStepVector(dl, NOutVT,
5742 SDLoc dl(N);
5774 Op = DAG.getAnyExtOrTrunc(Op, dl,
5782 DAG.getNode(ISD::CONCAT_VECTORS, dl,
5784 dl, NOutVT);
5802 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SclrTy, Op,
5803 DAG.getVectorIdxConstant(j, dl));
5804 Ops[i * NumElem + j] = DAG.getAnyExtOrTrunc(Ext, dl, OutElemTy);
5808 return DAG.getBuildVector(NOutVT, dl, Ops);
5816 SDLoc dl(N);
5839 return DAG.getNode(N->getOpcode(), dl, NVT, Promoted);
5843 return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
5853 SDLoc dl(N);
5856 SDValue ConvElem = DAG.getNode(ISD::ANY_EXTEND, dl,
5858 return DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, NOutVT,
5865 SDLoc dl(N);
5867 return DAG.getNode(N->getOpcode(), dl, NVT, N->ops());
5881 SDLoc dl(N);
5883 SDValue V1 = DAG.getZExtOrTrunc(N->getOperand(1), dl,
5885 SDValue Ext = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
5891 return DAG.getAnyExtOrTrunc(Ext, dl, N->getValueType(0));
5895 SDLoc dl(N);
5904 V0 = DAG.getAnyExtOrTrunc(V0, dl, PromVT);
5905 SDValue Ext = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, PromVT, V0, V1, Idx);
5906 return DAG.getAnyExtOrTrunc(Ext, dl, N->getValueType(0));
5910 SDLoc dl(N);
5915 SDValue Ext = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OutVT, V0, N->getOperand(1));
5916 return DAG.getNode(ISD::TRUNCATE, dl, N->getValueType(0), Ext);
5920 SDLoc dl(N);
5931 ResVec = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResVT, ResVec, Op,
5932 DAG.getIntPtrConstant(OpIdx * OpNumElts, dl));
5951 SDValue Ex = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, SclrTy, Incoming,
5952 DAG.getVectorIdxConstant(i, dl));
5953 SDValue Tr = DAG.getNode(ISD::TRUNCATE, dl, RetSclrTy, Ex);
5958 return DAG.getBuildVector(N->getValueType(0), dl, NewOps);