Lines Matching refs:dl
129 const SDLoc &dl,
168 CLI.setDebugLoc(dl)
286 const SDLoc &dl, const SDValue OldLHS,
289 return softenSetCCOperands(DAG, VT, NewLHS, NewRHS, CCCode, dl, OldLHS,
296 const SDLoc &dl, const SDValue OldLHS,
402 auto Call = makeLibCall(DAG, LC1, RetVT, Ops, CallOptions, dl, Chain);
404 NewRHS = DAG.getConstant(0, dl, RetVT);
418 SDValue Tmp = DAG.getSetCC(dl, SetCCVT, NewLHS, NewRHS, CCCode);
419 auto Call2 = makeLibCall(DAG, LC2, RetVT, Ops, CallOptions, dl, Chain);
423 NewLHS = DAG.getSetCC(dl, SetCCVT, Call2.first, NewRHS, CCCode);
425 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Call.second,
427 NewLHS = DAG.getNode(ShouldInvertCC ? ISD::AND : ISD::OR, dl,
545 SDLoc dl(Op);
569 Op.getOpcode(), dl, SmallVT,
570 DAG.getNode(ISD::TRUNCATE, dl, SmallVT, Op.getOperand(0)),
571 DAG.getNode(ISD::TRUNCATE, dl, SmallVT, Op.getOperand(1)));
573 SDValue Z = DAG.getNode(ISD::ANY_EXTEND, dl, Op.getValueType(), X);
815 SDLoc dl(Op);
1048 SDValue NewOp = TLO.DAG.getVectorShuffle(VT, dl, Op0, Op1, ShuffleMask);
1082 SDValue Xor = TLO.DAG.getNode(ISD::XOR, dl, VT, Op0.getOperand(0), Op1);
1105 SDValue NewOp = TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1);
1118 return TLO.CombineTo(Op, TLO.DAG.getConstant(0, dl, VT));
1154 SDValue NewOp = TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1);
1200 SDValue NewOp = TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1);
1219 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::OR, dl, VT, Op0, Op1));
1234 TLO.DAG.getConstant(~C->getAPIntValue() & DemandedBits, dl, VT);
1235 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::AND, dl, VT, Op0, ANDC));
1244 SDValue New = TLO.DAG.getNOT(dl, Op0, VT);
1350 SDValue NewSA = TLO.DAG.getConstant(Diff, dl, Op1.getValueType());
1352 Op, TLO.DAG.getNode(Opc, dl, VT, Op0.getOperand(0), NewSA));
1380 TLO.DAG.getNode(ISD::SHL, dl, InnerVT, InnerOp,
1381 TLO.DAG.getConstant(ShAmt, dl, ShTy));
1383 Op, TLO.DAG.getNode(ISD::ANY_EXTEND, dl, VT, NarrowShl));
1399 SDValue NewSA = TLO.DAG.getConstant(ShAmt - InnerShAmt, dl,
1401 SDValue NewExt = TLO.DAG.getNode(ISD::ANY_EXTEND, dl, VT,
1404 Op, TLO.DAG.getNode(ISD::SHL, dl, VT, NewExt, NewSA));
1456 SDValue NewSA = TLO.DAG.getConstant(Diff, dl, ShiftVT);
1458 Op, TLO.DAG.getNode(Opc, dl, VT, Op0.getOperand(0), NewSA));
1485 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::SRL, dl, VT, Op0, Op1));
1522 Op, TLO.DAG.getNode(ISD::SRL, dl, VT, Op0, Op1, Flags));
1529 TLO.DAG.getConstant(BitWidth - 1 - Log2, dl, Op1.getValueType());
1530 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::SRL, dl, VT, Op0, NewSA));
1617 TLO.DAG.getConstant(BitWidth - ExVTBits, dl, ShiftAmtTy);
1619 TLO.DAG.getNode(ISD::SHL, dl, VT, Op0, ShiftAmt));
1643 Op, TLO.DAG.getZeroExtendInReg(Op0, dl, ExVT.getScalarType()));
1697 return TLO.CombineTo(Op, TLO.DAG.getNode(Opc, dl, VT, Src));
1730 return TLO.CombineTo(Op, TLO.DAG.getNode(Opc, dl, VT, Src));
1754 return TLO.CombineTo(Op, TLO.DAG.getNode(Opc, dl, VT, Src));
1797 return TLO.CombineTo(Op, TLO.DAG.getNode(ISD::TRUNCATE, dl, VT, NewSrc));
1828 ShAmt = TLO.DAG.getConstant(ShVal, dl, getShiftAmountTy(VT, DL));
1830 TLO.DAG.getNode(ISD::TRUNCATE, dl, VT, Src.getOperand(0));
1832 Op, TLO.DAG.getNode(ISD::SRL, dl, VT, NewTrunc, ShAmt));
1882 TLO.DAG.getNode(Op.getOpcode(), dl, VT, DemandedSrc, Idx);
1910 SDValue Sign = TLO.DAG.getNode(ISD::FGETSIGN, dl, Ty, Src);
1913 Sign = TLO.DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Sign);
1915 SDValue ShAmt = TLO.DAG.getConstant(ShVal, dl, VT);
1917 TLO.DAG.getNode(ISD::SHL, dl, VT, Sign, ShAmt));
2005 TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1, Flags);
2023 TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Op1, Flags);
2037 SDValue Neg1 = TLO.DAG.getAllOnesConstant(dl, VT);
2042 SDValue NewOp = TLO.DAG.getNode(Op.getOpcode(), dl, VT, Op0, Neg1, Flags);
2076 return TLO.CombineTo(Op, TLO.DAG.getConstant(Known.One, dl, VT));
3121 const SDLoc &dl) const {
3127 if (SDValue Fold = DAG.FoldSetCC(VT, N0, N1, Cond, dl))
3136 return DAG.getSetCC(dl, VT, N1, N0, SwappedCC);
3147 return DAG.getSetCC(dl, VT, N1, N0, SwappedCC);
3170 SDValue Zero = DAG.getConstant(0, dl, N0.getValueType());
3171 return DAG.getSetCC(dl, VT, N0.getOperand(0).getOperand(0),
3190 SDValue NegOne = DAG.getAllOnesConstant(dl, CTVT);
3191 SDValue Add = DAG.getNode(ISD::ADD, dl, CTVT, CTOp, NegOne);
3192 SDValue And = DAG.getNode(ISD::AND, dl, CTVT, CTOp, Add);
3194 return DAG.getSetCC(dl, VT, And, DAG.getConstant(0, dl, CTVT), CC);
3202 SDValue Zero = DAG.getConstant(0, dl, CTVT);
3203 SDValue NegOne = DAG.getAllOnesConstant(dl, CTVT);
3206 SDValue Add = DAG.getNode(ISD::ADD, dl, CTVT, CTOp, NegOne);
3207 SDValue And = DAG.getNode(ISD::AND, dl, CTVT, CTOp, Add);
3208 SDValue LHS = DAG.getSetCC(dl, VT, CTOp, Zero, InvCond);
3209 SDValue RHS = DAG.getSetCC(dl, VT, And, Zero, Cond);
3211 return DAG.getNode(LogicOpcode, dl, VT, LHS, RHS);
3262 SDValue Trunc = DAG.getNode(ISD::TRUNCATE, dl, MinVT, PreExt);
3265 return DAG.getSetCC(dl, VT, Trunc, DAG.getConstant(0, dl, MVT::i1),
3267 SDValue C = DAG.getConstant(C1.trunc(MinBits), dl, MinVT);
3268 return DAG.getSetCC(dl, VT, Trunc, C, Cond);
3297 return DAG.getSetCC(dl, VT, TopSetCC.getOperand(0),
3347 Ptr = DAG.getMemBasePlusOffset(Ptr, bestOffset, dl);
3350 newVT, dl, Lod->getChain(), Ptr,
3352 return DAG.getSetCC(dl, VT,
3353 DAG.getNode(ISD::AND, dl, newVT, NewLoad,
3355 dl, newVT)),
3356 DAG.getConstant(0LL, dl, newVT), Cond);
3373 return DAG.getConstant(0, dl, VT);
3377 return DAG.getConstant(1, dl, VT);
3381 return DAG.getConstant(C1.isNegative(), dl, VT);
3385 return DAG.getConstant(C1.isNonNegative(), dl, VT);
3404 SDValue NewConst = DAG.getConstant(C1.trunc(InSize), dl, newVT);
3406 SDValue NewSetCC = DAG.getSetCC(dl, NewSetCCVT, N0.getOperand(0),
3408 return DAG.getBoolExtOrTrunc(NewSetCC, dl, VT, N0.getValueType());
3425 return DAG.getConstant(Cond == ISD::SETNE, dl, VT);
3433 ZextOp = DAG.getNode(ISD::AND, dl, Op0Ty, N0.getOperand(0),
3434 DAG.getConstant(Imm, dl, Op0Ty));
3439 return DAG.getSetCC(dl, VT, ZextOp,
3443 dl, ExtDstTy),
3455 return DAG.getNode(ISD::TRUNCATE, dl, VT, N0);
3461 return DAG.getSetCC(dl, VT, N0.getOperand(0), N0.getOperand(1), CC);
3484 Val = DAG.getNode(ISD::AND, dl, N0.getValueType(),
3489 return DAG.getSetCC(dl, VT, Val, N1,
3510 return DAG.getSetCC(dl, VT, XorLHS, XorRHS, Cond);
3518 Op0 = DAG.getNode(ISD::AND, dl, VT,
3519 DAG.getNode(ISD::TRUNCATE, dl, VT, Op0.getOperand(0)),
3520 DAG.getConstant(1, dl, VT));
3522 Op0 = DAG.getNode(ISD::AND, dl, VT,
3523 DAG.getNode(ISD::ANY_EXTEND, dl, VT, Op0.getOperand(0)),
3524 DAG.getConstant(1, dl, VT));
3526 return DAG.getSetCC(dl, VT, Op0,
3527 DAG.getConstant(0, dl, Op0.getValueType()),
3532 return DAG.getSetCC(dl, VT, Op0,
3533 DAG.getConstant(0, dl, Op0.getValueType()),
3547 return DAG.getSetCC(dl, VT, N0.getOperand(0), N1, Cond);
3551 optimizeSetCCOfSignedTruncationCheck(VT, N0, N1, Cond, DCI, dl))
3574 return DAG.getBoolConstant(true, dl, VT, OpVT);
3584 return DAG.getSetCC(dl, VT, N0,
3585 DAG.getConstant(C, dl, N1.getValueType()),
3594 return DAG.getBoolConstant(true, dl, VT, OpVT);
3604 return DAG.getSetCC(dl, VT, N0,
3605 DAG.getConstant(C, dl, N1.getValueType()),
3613 return DAG.getBoolConstant(false, dl, VT, OpVT); // X < MIN --> false
3619 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETNE);
3623 return DAG.getSetCC(dl, VT, N0,
3624 DAG.getConstant(MinVal, dl, N0.getValueType()),
3631 return DAG.getBoolConstant(false, dl, VT, OpVT); // X > MAX --> false
3637 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETNE);
3641 return DAG.getSetCC(dl, VT, N0,
3642 DAG.getConstant(MaxVal, dl, N0.getValueType()),
3651 VT, N0, N1, Cond, DCI, dl))
3662 return DAG.getSetCC(dl, VT, N0,
3663 DAG.getConstant(0, dl, N1.getValueType()),
3670 DAG.getConstant(APInt::getAllOnesValue(OperandBitSize), dl,
3672 return DAG.getSetCC(dl, VT, N0, ConstMinusOne, ISD::SETGT);
3696 return DAG.getNode(ISD::TRUNCATE, dl, VT,
3697 DAG.getNode(ISD::SRL, dl, ShValTy, N0,
3698 DAG.getConstant(ShCt, dl, ShiftTy)));
3706 return DAG.getNode(ISD::TRUNCATE, dl, VT,
3707 DAG.getNode(ISD::SRL, dl, ShValTy, N0,
3708 DAG.getConstant(ShCt, dl, ShiftTy)));
3726 DAG.getNode(ISD::SRL, dl, ShValTy, N0.getOperand(0),
3727 DAG.getConstant(ShiftBits, dl, ShiftTy));
3728 SDValue CmpRHS = DAG.getConstant(C1.lshr(ShiftBits), dl, ShValTy);
3729 return DAG.getSetCC(dl, VT, Shift, CmpRHS, Cond);
3754 SDValue Shift = DAG.getNode(ISD::SRL, dl, ShValTy, N0,
3755 DAG.getConstant(ShiftBits, dl, ShiftTy));
3756 SDValue CmpRHS = DAG.getConstant(NewC, dl, ShValTy);
3757 return DAG.getSetCC(dl, VT, Shift, CmpRHS, NewCond);
3772 return DAG.getSetCC(dl, VT, N0, N0, Cond);
3779 SDValue NegN1 = DAG.getNode(ISD::FNEG, dl, N0.getValueType(), N1);
3780 return DAG.getSetCC(dl, VT, N0.getOperand(0), NegN1, SwapCond);
3794 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETOLE);
3797 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETULE);
3800 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETUGT);
3803 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETOGT);
3807 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETOGE);
3810 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETUGE);
3813 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETULT);
3816 return DAG.getSetCC(dl, VT, N0, N1, ISD::SETOLT);
3831 return DAG.getBoolConstant(EqTrue, dl, VT, OpVT);
3833 return DAG.getBoolConstant(EqTrue, dl, VT, OpVT);
3840 return DAG.getSetCC(dl, VT, N0, N1, NewCond);
3850 return DAG.getSetCC(dl, VT, N0.getOperand(1), N1.getOperand(1), Cond);
3852 return DAG.getSetCC(dl, VT, N0.getOperand(0), N1.getOperand(0), Cond);
3856 return DAG.getSetCC(dl, VT, N0.getOperand(1), N1.getOperand(0),
3859 return DAG.getSetCC(dl, VT, N0.getOperand(0), N1.getOperand(1),
3872 return DAG.getSetCC(dl, VT, N0.getOperand(0),
3875 dl, N0.getValueType()), Cond);
3884 DAG.getSetCC(dl, VT, N0.getOperand(0),
3887 dl, N0.getValueType()),
3895 DAG.getSetCC(dl, VT, N0.getOperand(1),
3898 dl, N0.getValueType()),
3913 if (SDValue V = foldSetCCWithBinOp(VT, N0, N1, Cond, dl, DCI))
3919 if (SDValue V = foldSetCCWithBinOp(VT, N1, N0, Cond, dl, DCI))
3922 if (SDValue V = foldSetCCWithAnd(VT, N0, N1, Cond, dl, DCI))
3935 if (SDValue Folded = buildUREMEqFold(VT, N0, N1, Cond, DCI, dl))
3938 if (SDValue Folded = buildSREMEqFold(VT, N0, N1, Cond, DCI, dl))
3950 Temp = DAG.getNode(ISD::XOR, dl, OpVT, N0, N1);
3951 N0 = DAG.getNOT(dl, Temp, OpVT);
3956 N0 = DAG.getNode(ISD::XOR, dl, OpVT, N0, N1);
3960 Temp = DAG.getNOT(dl, N0, OpVT);
3961 N0 = DAG.getNode(ISD::AND, dl, OpVT, N1, Temp);
3967 Temp = DAG.getNOT(dl, N1, OpVT);
3968 N0 = DAG.getNode(ISD::AND, dl, OpVT, N0, Temp);
3974 Temp = DAG.getNOT(dl, N0, OpVT);
3975 N0 = DAG.getNode(ISD::OR, dl, OpVT, N1, Temp);
3981 Temp = DAG.getNOT(dl, N1, OpVT);
3982 N0 = DAG.getNode(ISD::OR, dl, OpVT, N0, Temp);
3990 N0 = DAG.getNode(ExtendCode, dl, VT, N0);
4636 const SDLoc &dl, SelectionDAG &DAG,
4662 Shifts.push_back(DAG.getConstant(Shift, dl, ShSVT));
4663 Factors.push_back(DAG.getConstant(Factor, dl, SVT));
4673 Shift = DAG.getBuildVector(ShVT, dl, Shifts);
4674 Factor = DAG.getBuildVector(VT, dl, Factors);
4687 Res = DAG.getNode(ISD::SRA, dl, VT, Res, Shift, Flags);
4691 return DAG.getNode(ISD::MUL, dl, VT, Res, Factor);
4711 SDLoc dl(N);
4725 return BuildExactSDIV(*this, N, dl, DAG, Created);
4752 MagicFactors.push_back(DAG.getConstant(magics.m, dl, SVT));
4753 Factors.push_back(DAG.getConstant(NumeratorFactor, dl, SVT));
4754 Shifts.push_back(DAG.getConstant(magics.s, dl, ShSVT));
4755 ShiftMasks.push_back(DAG.getConstant(ShiftMask, dl, SVT));
4768 MagicFactor = DAG.getBuildVector(VT, dl, MagicFactors);
4769 Factor = DAG.getBuildVector(VT, dl, Factors);
4770 Shift = DAG.getBuildVector(ShVT, dl, Shifts);
4771 ShiftMask = DAG.getBuildVector(VT, dl, ShiftMasks);
4784 Q = DAG.getNode(ISD::MULHS, dl, VT, N0, MagicFactor);
4788 DAG.getNode(ISD::SMUL_LOHI, dl, DAG.getVTList(VT, VT), N0, MagicFactor);
4795 Factor = DAG.getNode(ISD::MUL, dl, VT, N0, Factor);
4797 Q = DAG.getNode(ISD::ADD, dl, VT, Q, Factor);
4801 Q = DAG.getNode(ISD::SRA, dl, VT, Q, Shift);
4805 SDValue SignShift = DAG.getConstant(EltBits - 1, dl, ShVT);
4806 SDValue T = DAG.getNode(ISD::SRL, dl, VT, Q, SignShift);
4808 T = DAG.getNode(ISD::AND, dl, VT, T, ShiftMask);
4810 return DAG.getNode(ISD::ADD, dl, VT, Q, T);
4820 SDLoc dl(N);
4866 PreShifts.push_back(DAG.getConstant(PreShift, dl, ShSVT));
4867 MagicFactors.push_back(DAG.getConstant(Magic, dl, SVT));
4871 dl, SVT));
4872 PostShifts.push_back(DAG.getConstant(PostShift, dl, ShSVT));
4886 PreShift = DAG.getBuildVector(ShVT, dl, PreShifts);
4887 MagicFactor = DAG.getBuildVector(VT, dl, MagicFactors);
4888 NPQFactor = DAG.getBuildVector(VT, dl, NPQFactors);
4889 PostShift = DAG.getBuildVector(ShVT, dl, PostShifts);
4897 Q = DAG.getNode(ISD::SRL, dl, VT, Q, PreShift);
4904 return DAG.getNode(ISD::MULHU, dl, VT, X, Y);
4908 DAG.getNode(ISD::UMUL_LOHI, dl, DAG.getVTList(VT, VT), X, Y);
4922 SDValue NPQ = DAG.getNode(ISD::SUB, dl, VT, N0, Q);
4930 NPQ = DAG.getNode(ISD::SRL, dl, VT, NPQ, DAG.getConstant(1, dl, ShVT));
4934 Q = DAG.getNode(ISD::ADD, dl, VT, NPQ, Q);
4938 Q = DAG.getNode(ISD::SRL, dl, VT, Q, PostShift);
4941 SDValue One = DAG.getConstant(1, dl, VT);
4942 SDValue IsOne = DAG.getSetCC(dl, VT, N1, One, ISD::SETEQ);
4943 return DAG.getSelect(dl, VT, IsOne, N0, Q);
5737 bool TargetLowering::expandMUL_LOHI(unsigned Opcode, EVT VT, SDLoc dl,
5771 Lo = DAG.getNode(Signed ? ISD::SMUL_LOHI : ISD::UMUL_LOHI, dl, VTs, L, R);
5776 Lo = DAG.getNode(ISD::MUL, dl, HiLoVT, L, R);
5777 Hi = DAG.getNode(Signed ? ISD::MULHS : ISD::MULHU, dl, HiLoVT, L, R);
5787 LL = DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, LHS);
5788 RL = DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, RHS);
5802 SDValue Zero = DAG.getConstant(0, dl, HiLoVT);
5829 SDValue Shift = DAG.getConstant(ShiftAmount, dl, ShiftAmountTy);
5834 LH = DAG.getNode(ISD::SRL, dl, VT, LHS, Shift);
5835 LH = DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, LH);
5836 RH = DAG.getNode(ISD::SRL, dl, VT, RHS, Shift);
5837 RH = DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, RH);
5849 RH = DAG.getNode(ISD::MUL, dl, HiLoVT, LL, RH);
5850 LH = DAG.getNode(ISD::MUL, dl, HiLoVT, LH, RL);
5851 Hi = DAG.getNode(ISD::ADD, dl, HiLoVT, Hi, RH);
5852 Hi = DAG.getNode(ISD::ADD, dl, HiLoVT, Hi, LH);
5859 Lo = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Lo);
5860 Hi = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Hi);
5861 Hi = DAG.getNode(ISD::SHL, dl, VT, Hi, Shift);
5862 return DAG.getNode(ISD::OR, dl, VT, Lo, Hi);
5865 SDValue Next = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Hi);
5871 Next = DAG.getNode(ISD::ADD, dl, VT, Next, Merge(Lo, Hi));
5876 SDValue Zero = DAG.getConstant(0, dl, HiLoVT);
5882 Next = DAG.getNode(ISD::ADDC, dl, DAG.getVTList(VT, MVT::Glue), Next,
5885 Next = DAG.getNode(ISD::ADDCARRY, dl, DAG.getVTList(VT, BoolType), Next,
5886 Merge(Lo, Hi), DAG.getConstant(0, dl, BoolType));
5889 Result.push_back(DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, Next));
5890 Next = DAG.getNode(ISD::SRL, dl, VT, Next, Shift);
5896 Hi = DAG.getNode(ISD::ADDE, dl, DAG.getVTList(HiLoVT, MVT::Glue), Hi, Zero,
5899 Hi = DAG.getNode(ISD::ADDCARRY, dl, DAG.getVTList(HiLoVT, BoolType), Hi,
5902 Next = DAG.getNode(ISD::ADD, dl, VT, Next, Merge(Lo, Hi));
5905 SDValue NextSub = DAG.getNode(ISD::SUB, dl, VT, Next,
5906 DAG.getNode(ISD::ZERO_EXTEND, dl, VT, RL));
5907 Next = DAG.getSelectCC(dl, LH, Zero, NextSub, Next, ISD::SETLT);
5909 NextSub = DAG.getNode(ISD::SUB, dl, VT, Next,
5910 DAG.getNode(ISD::ZERO_EXTEND, dl, VT, LL));
5911 Next = DAG.getSelectCC(dl, RH, Zero, NextSub, Next, ISD::SETLT);
5914 Result.push_back(DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, Next));
5915 Next = DAG.getNode(ISD::SRL, dl, VT, Next, Shift);
5916 Result.push_back(DAG.getNode(ISD::TRUNCATE, dl, HiLoVT, Next));
6035 SDLoc dl(SDValue(Node, 0));
6055 SDValue ExponentMask = DAG.getConstant(0x7F800000, dl, IntVT);
6056 SDValue ExponentLoBit = DAG.getConstant(23, dl, IntVT);
6057 SDValue Bias = DAG.getConstant(127, dl, IntVT);
6058 SDValue SignMask = DAG.getConstant(APInt::getSignMask(SrcEltBits), dl, IntVT);
6059 SDValue SignLowBit = DAG.getConstant(SrcEltBits - 1, dl, IntVT);
6060 SDValue MantissaMask = DAG.getConstant(0x007FFFFF, dl, IntVT);
6062 SDValue Bits = DAG.getNode(ISD::BITCAST, dl, IntVT, Src);
6065 ISD::SRL, dl, IntVT, DAG.getNode(ISD::AND, dl, IntVT, Bits, ExponentMask),
6066 DAG.getZExtOrTrunc(ExponentLoBit, dl, IntShVT));
6067 SDValue Exponent = DAG.getNode(ISD::SUB, dl, IntVT, ExponentBits, Bias);
6069 SDValue Sign = DAG.getNode(ISD::SRA, dl, IntVT,
6070 DAG.getNode(ISD::AND, dl, IntVT, Bits, SignMask),
6071 DAG.getZExtOrTrunc(SignLowBit, dl, IntShVT));
6072 Sign = DAG.getSExtOrTrunc(Sign, dl, DstVT);
6074 SDValue R = DAG.getNode(ISD::OR, dl, IntVT,
6075 DAG.getNode(ISD::AND, dl, IntVT, Bits, MantissaMask),
6076 DAG.getConstant(0x00800000, dl, IntVT));
6078 R = DAG.getZExtOrTrunc(R, dl, DstVT);
6081 dl, Exponent, ExponentLoBit,
6082 DAG.getNode(ISD::SHL, dl, DstVT, R,
6084 DAG.getNode(ISD::SUB, dl, IntVT, Exponent, ExponentLoBit),
6085 dl, IntShVT)),
6086 DAG.getNode(ISD::SRL, dl, DstVT, R,
6088 DAG.getNode(ISD::SUB, dl, IntVT, ExponentLoBit, Exponent),
6089 dl, IntShVT)),
6092 SDValue Ret = DAG.getNode(ISD::SUB, dl, DstVT,
6093 DAG.getNode(ISD::XOR, dl, DstVT, R, Sign), Sign);
6095 Result = DAG.getSelectCC(dl, Exponent, DAG.getConstant(0, dl, IntVT),
6096 DAG.getConstant(0, dl, DstVT), Ret, ISD::SETLT);
6103 SDLoc dl(SDValue(Node, 0));
6130 Result = DAG.getNode(ISD::STRICT_FP_TO_SINT, dl, { DstVT, MVT::Other },
6134 Result = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT, Src);
6138 SDValue Cst = DAG.getConstantFP(APF, dl, SrcVT);
6142 Sel = DAG.getSetCC(dl, SetCCVT, Src, Cst, ISD::SETLT,
6146 Sel = DAG.getSetCC(dl, SetCCVT, Src, Cst, ISD::SETLT);
6161 SDValue FltOfs = DAG.getSelect(dl, SrcVT, Sel,
6162 DAG.getConstantFP(0.0, dl, SrcVT), Cst);
6163 Sel = DAG.getBoolExtOrTrunc(Sel, dl, DstSetCCVT, DstVT);
6164 SDValue IntOfs = DAG.getSelect(dl, DstVT, Sel,
6165 DAG.getConstant(0, dl, DstVT),
6166 DAG.getConstant(SignMask, dl, DstVT));
6169 SDValue Val = DAG.getNode(ISD::STRICT_FSUB, dl, { SrcVT, MVT::Other },
6171 SInt = DAG.getNode(ISD::STRICT_FP_TO_SINT, dl, { DstVT, MVT::Other },
6175 SDValue Val = DAG.getNode(ISD::FSUB, dl, SrcVT, Src, FltOfs);
6176 SInt = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT, Val);
6178 Result = DAG.getNode(ISD::XOR, dl, DstVT, SInt, IntOfs);
6185 SDValue True = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT, Src);
6187 SDValue False = DAG.getNode(ISD::FP_TO_SINT, dl, DstVT,
6188 DAG.getNode(ISD::FSUB, dl, SrcVT, Src, Cst));
6189 False = DAG.getNode(ISD::XOR, dl, DstVT, False,
6190 DAG.getConstant(SignMask, dl, DstVT));
6191 Sel = DAG.getBoolExtOrTrunc(Sel, dl, DstSetCCVT, DstVT);
6192 Result = DAG.getSelect(dl, DstVT, Sel, True, False);
6208 SDLoc dl(SDValue(Node, 0));
6233 dl, SetCCVT, Src, DAG.getConstant(0, dl, SrcVT), ISD::SETLT);
6235 SDValue ShiftConst = DAG.getConstant(1, dl, ShiftVT);
6236 SDValue Shr = DAG.getNode(ISD::SRL, dl, SrcVT, Src, ShiftConst);
6237 SDValue AndConst = DAG.getConstant(1, dl, SrcVT);
6238 SDValue And = DAG.getNode(ISD::AND, dl, SrcVT, Src, AndConst);
6239 SDValue Or = DAG.getNode(ISD::OR, dl, SrcVT, And, Shr);
6245 SDValue InCvt = DAG.getSelect(dl, SrcVT, SignBitTest, Or, Src);
6246 Fast = DAG.getNode(ISD::STRICT_SINT_TO_FP, dl, { DstVT, MVT::Other },
6248 Slow = DAG.getNode(ISD::STRICT_FADD, dl, { DstVT, MVT::Other },
6260 SDValue SignCvt = DAG.getNode(ISD::SINT_TO_FP, dl, DstVT, Or);
6261 Slow = DAG.getNode(ISD::FADD, dl, DstVT, SignCvt, SignCvt);
6262 Fast = DAG.getNode(ISD::SINT_TO_FP, dl, DstVT, Src);
6265 Result = DAG.getSelect(dl, DstVT, SignBitTest, Slow, Fast);
6284 SDValue TwoP52 = DAG.getConstant(UINT64_C(0x4330000000000000), dl, SrcVT);
6286 BitsToDouble(UINT64_C(0x4530000000100000)), dl, DstVT);
6287 SDValue TwoP84 = DAG.getConstant(UINT64_C(0x4530000000000000), dl, SrcVT);
6288 SDValue LoMask = DAG.getConstant(UINT64_C(0x00000000FFFFFFFF), dl, SrcVT);
6289 SDValue HiShift = DAG.getConstant(32, dl, ShiftVT);
6291 SDValue Lo = DAG.getNode(ISD::AND, dl, SrcVT, Src, LoMask);
6292 SDValue Hi = DAG.getNode(ISD::SRL, dl, SrcVT, Src, HiShift);
6293 SDValue LoOr = DAG.getNode(ISD::OR, dl, SrcVT, Lo, TwoP52);
6294 SDValue HiOr = DAG.getNode(ISD::OR, dl, SrcVT, Hi, TwoP84);
6299 DAG.getNode(ISD::STRICT_FSUB, dl, {DstVT, MVT::Other},
6301 Result = DAG.getNode(ISD::STRICT_FADD, dl, {DstVT, MVT::Other},
6306 DAG.getNode(ISD::FSUB, dl, DstVT, HiFlt, TwoP84PlusTwoP52);
6307 Result = DAG.getNode(ISD::FADD, dl, DstVT, LoFlt, HiSub);
6317 SDLoc dl(Node);
6329 Quiet0 = DAG.getNode(ISD::FCANONICALIZE, dl, VT, Quiet0,
6333 Quiet1 = DAG.getNode(ISD::FCANONICALIZE, dl, VT, Quiet1,
6338 return DAG.getNode(NewOp, dl, VT, Quiet0, Quiet1, Node->getFlags());
6347 return DAG.getNode(IEEE2018Op, dl, VT, Node->getOperand(0),
6363 SDValue SelCC = DAG.getSelectCC(dl, Op1, Op2, Op1, Op2, Pred);
6377 SDLoc dl(Node);
6399 DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x55)), dl, VT);
6401 DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x33)), dl, VT);
6403 DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x0F)), dl, VT);
6405 DAG.getConstant(APInt::getSplat(Len, APInt(8, 0x01)), dl, VT);
6408 Op = DAG.getNode(ISD::SUB, dl, VT, Op,
6409 DAG.getNode(ISD::AND, dl, VT,
6410 DAG.getNode(ISD::SRL, dl, VT, Op,
6411 DAG.getConstant(1, dl, ShVT)),
6414 Op = DAG.getNode(ISD::ADD, dl, VT, DAG.getNode(ISD::AND, dl, VT, Op, Mask33),
6415 DAG.getNode(ISD::AND, dl, VT,
6416 DAG.getNode(ISD::SRL, dl, VT, Op,
6417 DAG.getConstant(2, dl, ShVT)),
6420 Op = DAG.getNode(ISD::AND, dl, VT,
6421 DAG.getNode(ISD::ADD, dl, VT, Op,
6422 DAG.getNode(ISD::SRL, dl, VT, Op,
6423 DAG.getConstant(4, dl, ShVT))),
6428 DAG.getNode(ISD::SRL, dl, VT, DAG.getNode(ISD::MUL, dl, VT, Op, Mask01),
6429 DAG.getConstant(Len - 8, dl, ShVT));
6437 SDLoc dl(Node);
6446 Result = DAG.getNode(ISD::CTLZ, dl, VT, Op);
6454 SDValue CTLZ = DAG.getNode(ISD::CTLZ_ZERO_UNDEF, dl, VT, Op);
6455 SDValue Zero = DAG.getConstant(0, dl, VT);
6456 SDValue SrcIsZero = DAG.getSetCC(dl, SetCCVT, Op, Zero, ISD::SETEQ);
6457 Result = DAG.getNode(ISD::SELECT, dl, VT, SrcIsZero,
6458 DAG.getConstant(NumBitsPerElt, dl, VT), CTLZ);
6479 SDValue Tmp = DAG.getConstant(1ULL << i, dl, ShVT);
6480 Op = DAG.getNode(ISD::OR, dl, VT, Op,
6481 DAG.getNode(ISD::SRL, dl, VT, Op, Tmp));
6483 Op = DAG.getNOT(dl, Op, VT);
6484 Result = DAG.getNode(ISD::CTPOP, dl, VT, Op);
6490 SDLoc dl(Node);
6498 Result = DAG.getNode(ISD::CTTZ, dl, VT, Op);
6506 SDValue CTTZ = DAG.getNode(ISD::CTTZ_ZERO_UNDEF, dl, VT, Op);
6507 SDValue Zero = DAG.getConstant(0, dl, VT);
6508 SDValue SrcIsZero = DAG.getSetCC(dl, SetCCVT, Op, Zero, ISD::SETEQ);
6509 Result = DAG.getNode(ISD::SELECT, dl, VT, SrcIsZero,
6510 DAG.getConstant(NumBitsPerElt, dl, VT), CTTZ);
6528 ISD::AND, dl, VT, DAG.getNOT(dl, Op, VT),
6529 DAG.getNode(ISD::SUB, dl, VT, Op, DAG.getConstant(1, dl, VT)));
6534 DAG.getNode(ISD::SUB, dl, VT, DAG.getConstant(NumBitsPerElt, dl, VT),
6535 DAG.getNode(ISD::CTLZ, dl, VT, Tmp));
6539 Result = DAG.getNode(ISD::CTPOP, dl, VT, Tmp);
6545 SDLoc dl(N);
6557 DAG.getNode(ISD::SRA, dl, VT, Op,
6558 DAG.getConstant(VT.getScalarSizeInBits() - 1, dl, ShVT));
6559 SDValue Add = DAG.getNode(ISD::ADD, dl, VT, Op, Shift);
6560 Result = DAG.getNode(ISD::XOR, dl, VT, Add, Shift);
6685 SDLoc dl(LD);
6699 SDValue newLoad = DAG.getLoad(intVT, dl, Chain, Ptr,
6701 SDValue Result = DAG.getNode(ISD::BITCAST, dl, LoadedVT, newLoad);
6704 ISD::ANY_EXTEND, dl, VT, Result);
6726 SDValue PtrIncrement = DAG.getConstant(RegBytes, dl, PtrVT);
6727 SDValue StackPtrIncrement = DAG.getConstant(RegBytes, dl, StackPtrVT);
6733 RegVT, dl, Chain, Ptr, LD->getPointerInfo().getWithOffset(Offset),
6738 Load.getValue(1), dl, Load, StackPtr,
6743 Ptr = DAG.getObjectPtrOffset(dl, Ptr, PtrIncrement);
6744 StackPtr = DAG.getObjectPtrOffset(dl, StackPtr, StackPtrIncrement);
6751 DAG.getExtLoad(ISD::EXTLOAD, dl, RegVT, Chain, Ptr,
6759 Load.getValue(1), dl, Load, StackPtr,
6763 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
6766 Load = DAG.getExtLoad(LD->getExtensionType(), dl, VT, TF, StackBase,
6795 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr, LD->getPointerInfo(),
6799 Ptr = DAG.getObjectPtrOffset(dl, Ptr, IncrementSize);
6800 Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr,
6805 Hi = DAG.getExtLoad(HiExtType, dl, VT, Chain, Ptr, LD->getPointerInfo(),
6809 Ptr = DAG.getObjectPtrOffset(dl, Ptr, IncrementSize);
6810 Lo = DAG.getExtLoad(ISD::ZEXTLOAD, dl, VT, Chain, Ptr,
6818 DAG.getConstant(NumBits, dl, getShiftAmountTy(Hi.getValueType(),
6820 SDValue Result = DAG.getNode(ISD::SHL, dl, VT, Hi, ShiftAmount);
6821 Result = DAG.getNode(ISD::OR, dl, VT, Result, Lo);
6823 SDValue TF = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Lo.getValue(1),
6841 SDLoc dl(ST);
6854 SDValue Result = DAG.getNode(ISD::BITCAST, dl, intVT, Val);
6855 Result = DAG.getStore(Chain, dl, Result, Ptr, ST->getPointerInfo(),
6875 Chain, dl, Val, StackPtr,
6880 SDValue PtrIncrement = DAG.getConstant(RegBytes, dl, PtrVT);
6881 SDValue StackPtrIncrement = DAG.getConstant(RegBytes, dl, StackPtrVT);
6889 RegVT, dl, Store, StackPtr,
6892 Stores.push_back(DAG.getStore(Load.getValue(1), dl, Load, Ptr,
6898 StackPtr = DAG.getObjectPtrOffset(dl, StackPtr, StackPtrIncrement);
6899 Ptr = DAG.getObjectPtrOffset(dl, Ptr, PtrIncrement);
6910 ISD::EXTLOAD, dl, RegVT, Store, StackPtr,
6914 DAG.getTruncStore(Load.getValue(1), dl, Load, Ptr,
6919 SDValue Result = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Stores);
6932 NumBits, dl, getShiftAmountTy(Val.getValueType(), DAG.getDataLayout()));
6934 SDValue Hi = DAG.getNode(ISD::SRL, dl, VT, Val, ShiftAmount);
6938 Store1 = DAG.getTruncStore(Chain, dl,
6943 Ptr = DAG.getObjectPtrOffset(dl, Ptr, IncrementSize);
6946 Chain, dl, DAG.getDataLayout().isLittleEndian() ? Hi : Lo, Ptr,
6951 DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Store1, Store2);
6990 const SDLoc &dl) {
6999 return DAG.getNode(ISD::AND, dl, IdxVT, Idx,
7000 DAG.getConstant(Imm, dl, IdxVT));
7003 return DAG.getNode(ISD::UMIN, dl, IdxVT, Idx,
7004 DAG.getConstant(NElts - 1, dl, IdxVT));
7010 SDLoc dl(Index);
7012 Index = DAG.getZExtOrTrunc(Index, dl, VecPtr.getValueType());
7021 Index = clampDynamicVectorIndex(DAG, Index, VecVT, dl);
7025 Index = DAG.getNode(ISD::MUL, dl, IdxVT, Index,
7026 DAG.getConstant(EltSize, dl, IdxVT));
7027 return DAG.getMemBasePlusOffset(VecPtr, Index, dl);
7040 SDLoc dl(GA);
7049 Entry.Node = DAG.getGlobalAddress(EmuTlsVar, dl, PtrVT);
7056 CLI.setDebugLoc(dl).setChain(DAG.getEntryNode());
7077 SDLoc dl(Op);
7084 Zext = DAG.getNode(ISD::ZERO_EXTEND, dl, VT, Op.getOperand(0));
7087 SDValue Clz = DAG.getNode(ISD::CTLZ, dl, VT, Zext);
7088 SDValue Scc = DAG.getNode(ISD::SRL, dl, VT, Clz,
7089 DAG.getConstant(Log2b, dl, MVT::i32));
7090 return DAG.getNode(ISD::TRUNCATE, dl, MVT::i32, Scc);
7101 SDLoc dl(Node);
7108 SDValue Max = DAG.getNode(ISD::UMAX, dl, VT, LHS, RHS);
7109 return DAG.getNode(ISD::SUB, dl, VT, Max, RHS);
7113 SDValue InvRHS = DAG.getNOT(dl, RHS, VT);
7114 SDValue Min = DAG.getNode(ISD::UMIN, dl, VT, LHS, InvRHS);
7115 return DAG.getNode(ISD::ADD, dl, VT, Min, RHS);
7139 SDValue Result = DAG.getNode(OverflowOp, dl, DAG.getVTList(VT, BoolVT),
7143 SDValue Zero = DAG.getConstant(0, dl, VT);
7144 SDValue AllOnes = DAG.getAllOnesConstant(dl, VT);
7149 SDValue OverflowMask = DAG.getSExtOrTrunc(Overflow, dl, VT);
7150 return DAG.getNode(ISD::OR, dl, VT, SumDiff, OverflowMask);
7153 return DAG.getSelect(dl, VT, Overflow, AllOnes, SumDiff);
7157 SDValue OverflowMask = DAG.getSExtOrTrunc(Overflow, dl, VT);
7158 SDValue Not = DAG.getNOT(dl, OverflowMask, VT);
7159 return DAG.getNode(ISD::AND, dl, VT, SumDiff, Not);
7162 return DAG.getSelect(dl, VT, Overflow, Zero, SumDiff);
7168 SDValue SatMin = DAG.getConstant(MinVal, dl, VT);
7169 SDValue SatMax = DAG.getConstant(MaxVal, dl, VT);
7170 SDValue SumNeg = DAG.getSetCC(dl, BoolVT, SumDiff, Zero, ISD::SETLT);
7171 Result = DAG.getSelect(dl, VT, SumNeg, SatMax, SatMin);
7172 return DAG.getSelect(dl, VT, Overflow, Result, SumDiff);
7184 SDLoc dl(Node);
7200 return DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
7203 DAG.getNode(ISD::SMULO, dl, DAG.getVTList(VT, BoolVT), LHS, RHS);
7206 SDValue Zero = DAG.getConstant(0, dl, VT);
7210 SDValue SatMin = DAG.getConstant(MinVal, dl, VT);
7211 SDValue SatMax = DAG.getConstant(MaxVal, dl, VT);
7212 SDValue ProdNeg = DAG.getSetCC(dl, BoolVT, Product, Zero, ISD::SETLT);
7213 Result = DAG.getSelect(dl, VT, ProdNeg, SatMax, SatMin);
7214 return DAG.getSelect(dl, VT, Overflow, Result, Product);
7217 DAG.getNode(ISD::UMULO, dl, DAG.getVTList(VT, BoolVT), LHS, RHS);
7222 SDValue SatMax = DAG.getConstant(MaxVal, dl, VT);
7223 return DAG.getSelect(dl, VT, Overflow, SatMax, Product);
7238 SDValue Result = DAG.getNode(LoHiOp, dl, DAG.getVTList(VT, VT), LHS, RHS);
7242 Lo = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
7243 Hi = DAG.getNode(HiOp, dl, VT, LHS, RHS);
7260 SDValue Result = DAG.getNode(ISD::FSHR, dl, VT, Hi, Lo,
7261 DAG.getConstant(Scale, dl, ShiftTy));
7273 dl, VT);
7274 Result = DAG.getSelectCC(dl, Hi, LowMask,
7275 DAG.getConstant(MaxVal, dl, VT), Result,
7284 SDValue SatMin = DAG.getConstant(APInt::getSignedMinValue(VTSize), dl, VT);
7285 SDValue SatMax = DAG.getConstant(APInt::getSignedMaxValue(VTSize), dl, VT);
7288 SDValue Sign = DAG.getNode(ISD::SRA, dl, VT, Lo,
7289 DAG.getConstant(VTSize - 1, dl, ShiftTy));
7290 SDValue Overflow = DAG.getSetCC(dl, BoolVT, Hi, Sign, ISD::SETNE);
7293 SDValue Zero = DAG.getConstant(0, dl, VT);
7294 SDValue ResultIfOverflow = DAG.getSelectCC(dl, Hi, Zero, SatMin, SatMax,
7297 return DAG.getSelect(dl, VT, Overflow, ResultIfOverflow, Result);
7305 dl, VT);
7306 Result = DAG.getSelectCC(dl, Hi, LowMask, SatMax, Result, ISD::SETGT);
7311 dl, VT);
7312 Result = DAG.getSelectCC(dl, Hi, HighMask, SatMin, Result, ISD::SETLT);
7317 TargetLowering::expandFixedPointDiv(unsigned Opcode, const SDLoc &dl,
7349 LHS = DAG.getNode(ISD::SHL, dl, VT, LHS,
7350 DAG.getConstant(LHSShift, dl, ShiftTy));
7352 RHS = DAG.getNode(Signed ? ISD::SRA : ISD::SRL, dl, VT, RHS,
7353 DAG.getConstant(RHSShift, dl, ShiftTy));
7366 Quot = DAG.getNode(ISD::SDIVREM, dl,
7372 Quot = DAG.getNode(ISD::SDIV, dl, VT,
7374 Rem = DAG.getNode(ISD::SREM, dl, VT,
7377 SDValue Zero = DAG.getConstant(0, dl, VT);
7378 SDValue RemNonZero = DAG.getSetCC(dl, BoolVT, Rem, Zero, ISD::SETNE);
7379 SDValue LHSNeg = DAG.getSetCC(dl, BoolVT, LHS, Zero, ISD::SETLT);
7380 SDValue RHSNeg = DAG.getSetCC(dl, BoolVT, RHS, Zero, ISD::SETLT);
7381 SDValue QuotNeg = DAG.getNode(ISD::XOR, dl, BoolVT, LHSNeg, RHSNeg);
7382 SDValue Sub1 = DAG.getNode(ISD::SUB, dl, VT, Quot,
7383 DAG.getConstant(1, dl, VT));
7384 Quot = DAG.getSelect(dl, VT,
7385 DAG.getNode(ISD::AND, dl, BoolVT, RemNonZero, QuotNeg),
7388 Quot = DAG.getNode(ISD::UDIV, dl, VT,
7398 SDLoc dl(Node);
7406 SDValue CarryIn = DAG.getConstant(0, dl, Node->getValueType(1));
7407 SDValue NodeCarry = DAG.getNode(OpcCarry, dl, Node->getVTList(),
7414 Result = DAG.getNode(IsAdd ? ISD::ADD : ISD::SUB, dl,
7421 SDValue SetCC = DAG.getSetCC(dl, SetCCType, Result, LHS, CC);
7422 Overflow = DAG.getBoolExtOrTrunc(SetCC, dl, ResultType, ResultType);
7427 SDLoc dl(Node);
7432 Result = DAG.getNode(IsAdd ? ISD::ADD : ISD::SUB, dl,
7442 SDValue Sat = DAG.getNode(OpcSat, dl, LHS.getValueType(), LHS, RHS);
7443 SDValue SetCC = DAG.getSetCC(dl, OType, Result, Sat, ISD::SETNE);
7444 Overflow = DAG.getBoolExtOrTrunc(SetCC, dl, ResultType, ResultType);
7448 SDValue Zero = DAG.getConstant(0, dl, LHS.getValueType());
7456 SDValue ResultLowerThanLHS = DAG.getSetCC(dl, OType, Result, LHS, ISD::SETLT);
7458 DAG.getSetCC(dl, OType, RHS, Zero, IsAdd ? ISD::SETLT : ISD::SETGT);
7461 DAG.getNode(ISD::XOR, dl, OType, ConditionRHS, ResultLowerThanLHS), dl,
7467 SDLoc dl(Node);
7482 SDValue ShiftAmt = DAG.getConstant(C.logBase2(), dl, ShiftAmtTy);
7483 Result = DAG.getNode(ISD::SHL, dl, VT, LHS, ShiftAmt);
7484 Overflow = DAG.getSetCC(dl, SetCCVT,
7486 dl, VT, Result, ShiftAmt),
7503 BottomHalf = DAG.getNode(ISD::MUL, dl, VT, LHS, RHS);
7504 TopHalf = DAG.getNode(Ops[isSigned][0], dl, VT, LHS, RHS);
7506 BottomHalf = DAG.getNode(Ops[isSigned][1], dl, DAG.getVTList(VT, VT), LHS,
7510 LHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, LHS);
7511 RHS = DAG.getNode(Ops[isSigned][2], dl, WideVT, RHS);
7512 SDValue Mul = DAG.getNode(ISD::MUL, dl, WideVT, LHS, RHS);
7513 BottomHalf = DAG.getNode(ISD::TRUNCATE, dl, VT, Mul);
7514 SDValue ShiftAmt = DAG.getConstant(VT.getScalarSizeInBits(), dl,
7516 TopHalf = DAG.getNode(ISD::TRUNCATE, dl, VT,
7517 DAG.getNode(ISD::SRL, dl, WideVT, Mul, ShiftAmt));
7544 DAG.getNode(ISD::SRA, dl, VT, LHS,
7545 DAG.getConstant(LoSize - 1, dl,
7548 DAG.getNode(ISD::SRA, dl, VT, RHS,
7549 DAG.getConstant(LoSize - 1, dl,
7552 HiLHS = DAG.getConstant(0, dl, VT);
7553 HiRHS = DAG.getConstant(0, dl, VT);
7570 Ret = makeLibCall(DAG, LC, WideVT, Args, CallOptions, dl).first;
7573 Ret = makeLibCall(DAG, LC, WideVT, Args, CallOptions, dl).first;
7590 VT.getScalarSizeInBits() - 1, dl,
7592 SDValue Sign = DAG.getNode(ISD::SRA, dl, VT, BottomHalf, ShiftAmt);
7593 Overflow = DAG.getSetCC(dl, SetCCVT, TopHalf, Sign, ISD::SETNE);
7595 Overflow = DAG.getSetCC(dl, SetCCVT, TopHalf,
7596 DAG.getConstant(0, dl, VT), ISD::SETNE);
7602 Overflow = DAG.getNode(ISD::TRUNCATE, dl, RType, Overflow);
7610 SDLoc dl(Node);
7645 std::tie(Lo, Hi) = DAG.SplitVector(Op, dl);
7646 Op = DAG.getNode(BaseOpcode, dl, HalfVT, Lo, Hi);
7659 Res = DAG.getNode(BaseOpcode, dl, EltVT, Res, Ops[i], Node->getFlags());
7663 Res = DAG.getNode(ISD::ANY_EXTEND, dl, Node->getValueType(0), Res);