Lines Matching refs:dl
119 static SDValue getCopyFromPartsVector(SelectionDAG &DAG, const SDLoc &DL,
128 static SDValue getCopyFromParts(SelectionDAG &DAG, const SDLoc &DL,
133 return getCopyFromPartsVector(DAG, DL, Parts, NumParts,
157 Lo = getCopyFromParts(DAG, DL, Parts, RoundParts / 2,
159 Hi = getCopyFromParts(DAG, DL, Parts + RoundParts / 2,
162 Lo = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[0]);
163 Hi = DAG.getNode(ISD::BITCAST, DL, HalfVT, Parts[1]);
169 Val = DAG.getNode(ISD::BUILD_PAIR, DL, RoundVT, Lo, Hi);
175 Hi = getCopyFromParts(DAG, DL,
183 Hi = DAG.getNode(ISD::ANY_EXTEND, DL, TotalVT, Hi);
185 DAG.getNode(ISD::SHL, DL, TotalVT, Hi,
186 DAG.getConstant(Lo.getValueType().getSizeInBits(), DL,
188 Lo = DAG.getNode(ISD::ZERO_EXTEND, DL, TotalVT, Lo);
189 Val = DAG.getNode(ISD::OR, DL, TotalVT, Lo, Hi);
196 Lo = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[0]);
197 Hi = DAG.getNode(ISD::BITCAST, DL, EVT(MVT::f64), Parts[1]);
200 Val = DAG.getNode(ISD::BUILD_PAIR, DL, ValueVT, Lo, Hi);
206 Val = getCopyFromParts(DAG, DL, Parts, NumParts, PartVT, IntVT, V);
223 Val = DAG.getNode(ISD::TRUNCATE, DL, PartEVT, Val);
228 return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
237 Val = DAG.getNode(*AssertOp, DL, PartEVT, Val,
239 return DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
241 return DAG.getNode(ISD::ANY_EXTEND, DL, ValueVT, Val);
248 ISD::FP_ROUND, DL, ValueVT, Val,
249 DAG.getTargetConstant(1, DL, TLI.getPointerTy(DAG.getDataLayout())));
251 return DAG.getNode(ISD::FP_EXTEND, DL, ValueVT, Val);
276 static SDValue getCopyFromPartsVector(SelectionDAG &DAG, const SDLoc &DL,
305 Ops[i] = getCopyFromParts(DAG, DL, &Parts[i], 1,
314 Ops[i] = getCopyFromParts(DAG, DL, &Parts[i * Factor], Factor,
322 DL, ValueVT, Ops);
340 ISD::EXTRACT_SUBVECTOR, DL, ValueVT, Val,
341 DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
346 return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
351 return DAG.getAnyExtOrTrunc(Val, DL, ValueVT);
359 return DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
370 Val = DAG.getAnyExtOrTrunc(Val, DL, ValueVT.getScalarType());
372 return DAG.getNode(ISD::BUILD_VECTOR, DL, ValueVT, Val);
375 static void getCopyToPartsVector(SelectionDAG &DAG, const SDLoc &dl,
382 static void getCopyToParts(SelectionDAG &DAG, const SDLoc &DL, SDValue Val,
390 return getCopyToPartsVector(DAG, DL, Val, Parts, NumParts, PartVT, V);
412 Val = DAG.getNode(ISD::FP_EXTEND, DL, PartVT, Val);
418 Val = DAG.getNode(ISD::BITCAST, DL, ValueVT, Val);
424 Val = DAG.getNode(ExtendKind, DL, ValueVT, Val);
426 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
431 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
438 Val = DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
440 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
452 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
467 SDValue OddVal = DAG.getNode(ISD::SRL, DL, ValueVT, Val,
468 DAG.getIntPtrConstant(RoundBits, DL));
469 getCopyToParts(DAG, DL, OddVal, Parts + RoundParts, OddParts, PartVT, V);
477 Val = DAG.getNode(ISD::TRUNCATE, DL, ValueVT, Val);
482 Parts[0] = DAG.getNode(ISD::BITCAST, DL,
494 Part1 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL,
495 ThisVT, Part0, DAG.getIntPtrConstant(1, DL));
496 Part0 = DAG.getNode(ISD::EXTRACT_ELEMENT, DL,
497 ThisVT, Part0, DAG.getIntPtrConstant(0, DL));
500 Part0 = DAG.getNode(ISD::BITCAST, DL, PartVT, Part0);
501 Part1 = DAG.getNode(ISD::BITCAST, DL, PartVT, Part1);
513 static void getCopyToPartsVector(SelectionDAG &DAG, const SDLoc &DL,
526 Val = DAG.getNode(ISD::BITCAST, DL, PartVT, Val);
536 ISD::EXTRACT_VECTOR_ELT, DL, ElementVT, Val,
537 DAG.getConstant(i, DL, TLI.getVectorIdxTy(DAG.getDataLayout()))));
543 Val = DAG.getNode(ISD::BUILD_VECTOR, DL, PartVT, Ops);
548 //Val = DAG.getNode(ISD::CONCAT_VECTORS, DL, PartVT, Val, UndefElts);
555 Val = DAG.getAnyExtOrTrunc(Val, DL, PartVT);
561 ISD::EXTRACT_VECTOR_ELT, DL, PartVT, Val,
562 DAG.getConstant(0, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
564 Val = DAG.getAnyExtOrTrunc(Val, DL, PartVT);
589 DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, IntermediateVT, Val,
590 DAG.getConstant(i * (NumElements / NumIntermediates), DL,
594 ISD::EXTRACT_VECTOR_ELT, DL, IntermediateVT, Val,
595 DAG.getConstant(i, DL, TLI.getVectorIdxTy(DAG.getDataLayout())));
603 getCopyToParts(DAG, DL, Ops[i], &Parts[i], 1, PartVT, V);
612 getCopyToParts(DAG, DL, Ops[i], &Parts[i*Factor], Factor, PartVT, V);
623 const DataLayout &DL, unsigned Reg, Type *Ty) {
624 ComputeValueVTs(TLI, DL, Ty, ValueVTs);
642 const SDLoc &dl, SDValue &Chain,
663 P = DAG.getCopyFromReg(Chain, dl, Regs[Part+i], RegisterVT);
665 P = DAG.getCopyFromReg(Chain, dl, Regs[Part+i], RegisterVT, *Flag);
691 Parts[i] = DAG.getConstant(0, dl, RegisterVT);
728 Parts[i] = DAG.getNode(isSExt ? ISD::AssertSext : ISD::AssertZext, dl,
732 Values[Value] = getCopyFromParts(DAG, dl, Parts.begin(),
738 return DAG.getNode(ISD::MERGE_VALUES, dl, DAG.getVTList(ValueVTs), Values);
746 const SDLoc &dl, SDValue &Chain, SDValue *Flag,
763 getCopyToParts(DAG, dl, Val.getValue(Val.getResNo() + Value),
773 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i]);
775 Part = DAG.getCopyToReg(Chain, dl, Regs[i], Parts[i], *Flag);
795 Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other, Chains);
802 unsigned MatchingIdx, const SDLoc &dl,
822 SDValue Res = DAG.getTargetConstant(Flag, dl, MVT::i32);
848 DL = &DAG.getDataLayout();
961 auto &DL = SDB.DAG.getDataLayout();
964 SDB.DAG.getRegister(MapReg, EVT(TLI.getPointerTy(DL))));
1013 DebugLoc dl = DDI.getdl();
1017 assert(Variable->isValidLocationForIntrinsic(dl) &&
1022 if (!EmitFuncArgumentDbgValue(V, Variable, Expr, dl, Offset, false,
1025 false, Offset, dl, DbgSDNodeOrder);
1377 auto &DL = DAG.getDataLayout();
1402 ComputeValueVTs(TLI, DL, PointerType::getUnqual(F->getReturnType()),
1411 ComputeValueVTs(TLI, DL, I.getOperand(0)->getType(), ValueVTs, &Offsets);
1437 ComputeValueVTs(TLI, DL, I.getOperand(0)->getType(), ValueVTs);
1497 Outs.push_back(ISD::OutputArg(Flags, EVT(TLI.getPointerTy(DL)) /*vt*/,
1498 EVT(TLI.getPointerTy(DL)) /*argvt*/,
1503 EVT(TLI.getPointerTy(DL))));
1876 SDLoc dl = getCurSDLoc();
1887 SDValue True = DAG.getConstant(1, dl, CondLHS.getValueType());
1888 Cond = DAG.getNode(ISD::XOR, dl, CondLHS.getValueType(), CondLHS, True);
1890 Cond = DAG.getSetCC(dl, MVT::i1, CondLHS, getValue(CB.CmpRHS), CB.CC);
1901 Cond = DAG.getSetCC(dl, MVT::i1, CmpOp, DAG.getConstant(High, dl, VT),
1904 SDValue SUB = DAG.getNode(ISD::SUB, dl,
1905 VT, CmpOp, DAG.getConstant(Low, dl, VT));
1906 Cond = DAG.getSetCC(dl, MVT::i1, SUB,
1907 DAG.getConstant(High-Low, dl, VT), ISD::SETULE);
1923 SDValue True = DAG.getConstant(1, dl, Cond.getValueType());
1924 Cond = DAG.getNode(ISD::XOR, dl, Cond.getValueType(), Cond, True);
1927 SDValue BrCond = DAG.getNode(ISD::BRCOND, dl,
1934 BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
1959 SDLoc dl = getCurSDLoc();
1966 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, SwitchOp,
1967 DAG.getConstant(JTH.First, dl, VT));
1975 SwitchOp = DAG.getZExtOrTrunc(Sub, dl, TLI.getPointerTy(DAG.getDataLayout()));
1979 SDValue CopyTo = DAG.getCopyToReg(getControlRoot(), dl,
1987 dl, TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(),
1989 Sub, DAG.getConstant(JTH.Last - JTH.First, dl, VT), ISD::SETUGT);
1991 SDValue BrCond = DAG.getNode(ISD::BRCOND, dl,
1997 BrCond = DAG.getNode(ISD::BR, dl, MVT::Other, BrCond,
2005 static SDValue getLoadStackGuard(SelectionDAG &DAG, const SDLoc &DL,
2012 DAG.getMachineNode(TargetOpcode::LOAD_STACK_GUARD, DL, PtrTy, Chain);
2041 SDLoc dl = getCurSDLoc();
2044 unsigned Align = DL->getPrefTypeAlignment(Type::getInt8PtrTy(M.getContext()));
2048 PtrTy, dl, DAG.getEntryNode(), StackSlotPtr,
2084 Guard = getLoadStackGuard(DAG, dl, Chain);
2090 DAG.getLoad(PtrTy, dl, Chain, GuardPtr, MachinePointerInfo(IRGuard, 0),
2096 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, Guard, StackSlot);
2098 SDValue Cmp = DAG.getSetCC(dl, TLI.getSetCCResultType(DAG.getDataLayout(),
2101 Sub, DAG.getConstant(0, dl, VT), ISD::SETNE);
2105 SDValue BrCond = DAG.getNode(ISD::BRCOND, dl,
2109 SDValue Br = DAG.getNode(ISD::BR, dl,
2137 SDLoc dl = getCurSDLoc();
2142 SDValue Sub = DAG.getNode(ISD::SUB, dl, VT, SwitchOp,
2143 DAG.getConstant(B.First, dl, VT));
2148 dl, TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(),
2150 Sub, DAG.getConstant(B.Range, dl, VT), ISD::SETUGT);
2167 Sub = DAG.getZExtOrTrunc(Sub, dl, VT);
2172 SDValue CopyTo = DAG.getCopyToReg(getControlRoot(), dl, B.Reg, Sub);
2180 SDValue BrRange = DAG.getNode(ISD::BRCOND, dl,
2186 BrRange = DAG.getNode(ISD::BR, dl, MVT::Other, BrRange,
2199 SDLoc dl = getCurSDLoc();
2201 SDValue ShiftOp = DAG.getCopyFromReg(getControlRoot(), dl, Reg, VT);
2209 dl, TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT),
2210 ShiftOp, DAG.getConstant(countTrailingZeros(B.Mask), dl, VT),
2215 dl, TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT),
2216 ShiftOp, DAG.getConstant(countTrailingOnes(B.Mask), dl, VT),
2220 SDValue SwitchVal = DAG.getNode(ISD::SHL, dl, VT,
2221 DAG.getConstant(1, dl, VT), ShiftOp);
2224 SDValue AndOp = DAG.getNode(ISD::AND, dl,
2225 VT, SwitchVal, DAG.getConstant(B.Mask, dl, VT));
2227 dl, TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), VT),
2228 AndOp, DAG.getConstant(0, dl, VT), ISD::SETNE);
2240 SDValue BrAnd = DAG.getNode(ISD::BRCOND, dl,
2246 BrAnd = DAG.getNode(ISD::BR, dl, MVT::Other, BrAnd,
2352 SDLoc dl = getCurSDLoc();
2361 DAG.getCopyFromReg(DAG.getEntryNode(), dl,
2364 dl, ValueVTs[0]);
2366 Ops[0] = DAG.getConstant(0, dl, TLI.getPointerTy(DAG.getDataLayout()));
2369 DAG.getCopyFromReg(DAG.getEntryNode(), dl,
2372 dl, ValueVTs[1]);
2375 SDValue Res = DAG.getNode(ISD::MERGE_VALUES, dl,
2644 SDLoc DL = getCurSDLoc();
2648 Op2 = DAG.getNode(ISD::ZERO_EXTEND, DL, ShiftTy, Op2);
2655 Op2 = DAG.getNode(ISD::TRUNCATE, DL, ShiftTy, Op2);
2659 Op2 = DAG.getZExtOrTrunc(Op2, DL, MVT::i32);
2875 SDLoc dl = getCurSDLoc();
2878 setValue(&I, DAG.getNode(ISD::FP_ROUND, dl, DestVT, N,
2880 0, dl, TLI.getPointerTy(DAG.getDataLayout()))));
2943 SDLoc dl = getCurSDLoc();
2950 setValue(&I, DAG.getNode(ISD::BITCAST, dl,
2957 setValue(&I, DAG.getConstant(C->getValue(), dl, DestVT, /*isTarget=*/false,
3145 SDLoc dl = getCurSDLoc();
3147 ISD::EXTRACT_SUBVECTOR, dl, VT, Src,
3148 DAG.getConstant(StartIdx[Input], dl,
3177 SDLoc dl = getCurSDLoc();
3189 Res = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl,
3190 EltVT, Src, DAG.getConstant(Idx, dl, IdxVT));
3196 setValue(&I, DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops));
3287 SDLoc dl = getCurSDLoc();
3298 N = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
3307 uint64_t Offset = DL->getStructLayout(StTy)->getElementOffset(Field);
3315 N = DAG.getNode(ISD::ADD, dl, N.getValueType(), N,
3316 DAG.getConstant(Offset, dl, N.getValueType()), &Flags);
3322 APInt ElementSize(PtrSize, DL->getTypeAllocSize(GTI.getIndexedType()));
3336 DAG.getConstant(Offs, dl, MVT::getVectorVT(PtrTy, VectorWidth)) :
3337 DAG.getConstant(Offs, dl, PtrTy);
3345 N = DAG.getNode(ISD::ADD, dl, N.getValueType(), N, OffsVal, &Flags);
3355 IdxN = DAG.getNode(ISD::BUILD_VECTOR, dl, VT, Ops);
3359 IdxN = DAG.getSExtOrTrunc(IdxN, dl, N.getValueType());
3366 IdxN = DAG.getNode(ISD::SHL, dl,
3368 DAG.getConstant(Amt, dl, IdxN.getValueType()));
3370 SDValue Scale = DAG.getConstant(ElementSize, dl, IdxN.getValueType());
3371 IdxN = DAG.getNode(ISD::MUL, dl,
3376 N = DAG.getNode(ISD::ADD, dl,
3390 SDLoc dl = getCurSDLoc();
3393 auto &DL = DAG.getDataLayout();
3394 uint64_t TySize = DL.getTypeAllocSize(Ty);
3396 std::max((unsigned)DL.getPrefTypeAlignment(Ty), I.getAlignment());
3402 AllocSize = DAG.getZExtOrTrunc(AllocSize, dl, IntPtr);
3404 AllocSize = DAG.getNode(ISD::MUL, dl, IntPtr,
3406 DAG.getConstant(TySize, dl, IntPtr));
3421 AllocSize = DAG.getNode(ISD::ADD, dl,
3423 DAG.getIntPtrConstant(StackAlign - 1, dl), &Flags);
3426 AllocSize = DAG.getNode(ISD::AND, dl,
3429 dl));
3431 SDValue Ops[] = { getRoot(), AllocSize, DAG.getIntPtrConstant(Align, dl) };
3433 SDValue DSA = DAG.getNode(ISD::DYNAMIC_STACKALLOC, dl, VTs, Ops);
3505 SDLoc dl = getCurSDLoc();
3508 Root = TLI.prepareVolatileOrAtomicLoad(Root, dl, DAG);
3528 SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3533 SDValue A = DAG.getNode(ISD::ADD, dl,
3535 DAG.getConstant(Offsets[i], dl, PtrVT),
3537 SDValue L = DAG.getLoad(ValueVTs[i], dl, Root,
3547 SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3555 setValue(&I, DAG.getNode(ISD::MERGE_VALUES, dl,
3574 auto &DL = DAG.getDataLayout();
3575 const TargetRegisterClass *RC = TLI.getRegClassFor(TLI.getPointerTy(DL));
3577 // Chain, DL, Reg, N or Chain, DL, Reg, N, Glue
3609 // Chain, DL, Reg, VT, Glue or Chain, DL, Reg, VT
3659 SDLoc dl = getCurSDLoc();
3673 SDValue Chain = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3678 SDValue Add = DAG.getNode(ISD::ADD, dl, PtrVT, Ptr,
3679 DAG.getConstant(Offsets[i], dl, PtrVT), &Flags);
3680 SDValue St = DAG.getStore(Root, dl,
3687 SDValue StoreNode = DAG.getNode(ISD::TokenFactor, dl, MVT::Other,
3908 SDLoc dl = getCurSDLoc();
3918 ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, dl, MemVT, VTs, InChain,
3930 SDLoc dl = getCurSDLoc();
3952 DAG.getAtomic(NT, dl,
3967 SDLoc dl = getCurSDLoc();
3971 Ops[1] = DAG.getConstant((unsigned)I.getOrdering(), dl,
3973 Ops[2] = DAG.getConstant(I.getSynchScope(), dl,
3975 DAG.setRoot(DAG.getNode(ISD::ATOMIC_FENCE, dl, MVT::Other, Ops));
3979 SDLoc dl = getCurSDLoc();
4000 InChain = TLI.prepareVolatileOrAtomicLoad(InChain, dl, DAG);
4002 DAG.getAtomic(ISD::ATOMIC_LOAD, dl, VT, VT, InChain,
4013 SDLoc dl = getCurSDLoc();
4028 DAG.getAtomic(ISD::ATOMIC_STORE, dl, VT,
4123 static SDValue GetSignificand(SelectionDAG &DAG, SDValue Op, const SDLoc &dl) {
4124 SDValue t1 = DAG.getNode(ISD::AND, dl, MVT::i32, Op,
4125 DAG.getConstant(0x007fffff, dl, MVT::i32));
4126 SDValue t2 = DAG.getNode(ISD::OR, dl, MVT::i32, t1,
4127 DAG.getConstant(0x3f800000, dl, MVT::i32));
4128 return DAG.getNode(ISD::BITCAST, dl, MVT::f32, t2);
4137 const TargetLowering &TLI, const SDLoc &dl) {
4138 SDValue t0 = DAG.getNode(ISD::AND, dl, MVT::i32, Op,
4139 DAG.getConstant(0x7f800000, dl, MVT::i32));
4141 ISD::SRL, dl, MVT::i32, t0,
4142 DAG.getConstant(23, dl, TLI.getPointerTy(DAG.getDataLayout())));
4143 SDValue t2 = DAG.getNode(ISD::SUB, dl, MVT::i32, t1,
4144 DAG.getConstant(127, dl, MVT::i32));
4145 return DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, t2);
4150 dl) {
4151 return DAG.getConstantFP(APFloat(APFloat::IEEEsingle, APInt(32, Flt)), dl,
4155 static SDValue getLimitedPrecisionExp2(SDValue t0, const SDLoc &dl,
4160 SDValue IntegerPartOfX = DAG.getNode(ISD::FP_TO_SINT, dl, MVT::i32, t0);
4163 SDValue t1 = DAG.getNode(ISD::SINT_TO_FP, dl, MVT::f32, IntegerPartOfX);
4164 SDValue X = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0, t1);
4168 ISD::SHL, dl, MVT::i32, IntegerPartOfX,
4169 DAG.getConstant(23, dl, DAG.getTargetLoweringInfo().getPointerTy(
4181 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4182 getF32Constant(DAG, 0x3e814304, dl));
4183 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
4184 getF32Constant(DAG, 0x3f3c50c8, dl));
4185 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4186 TwoToFractionalPartOfX = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4187 getF32Constant(DAG, 0x3f7f5e7e, dl));
4197 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4198 getF32Constant(DAG, 0x3da235e3, dl));
4199 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
4200 getF32Constant(DAG, 0x3e65b8f3, dl));
4201 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4202 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4203 getF32Constant(DAG, 0x3f324b07, dl));
4204 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4205 TwoToFractionalPartOfX = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
4206 getF32Constant(DAG, 0x3f7ff8fd, dl));
4218 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4219 getF32Constant(DAG, 0x3924b03e, dl));
4220 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
4221 getF32Constant(DAG, 0x3ab24b87, dl));
4222 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4223 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4224 getF32Constant(DAG, 0x3c1d8c17, dl));
4225 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4226 SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
4227 getF32Constant(DAG, 0x3d634a1d, dl));
4228 SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
4229 SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
4230 getF32Constant(DAG, 0x3e75fe14, dl));
4231 SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
4232 SDValue t11 = DAG.getNode(ISD::FADD, dl, MVT::f32, t10,
4233 getF32Constant(DAG, 0x3f317234, dl));
4234 SDValue t12 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t11, X);
4235 TwoToFractionalPartOfX = DAG.getNode(ISD::FADD, dl, MVT::f32, t12,
4236 getF32Constant(DAG, 0x3f800000, dl));
4240 SDValue t13 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, TwoToFractionalPartOfX);
4241 return DAG.getNode(ISD::BITCAST, dl, MVT::f32,
4242 DAG.getNode(ISD::ADD, dl, MVT::i32, t13, IntegerPartOfX));
4247 static SDValue expandExp(const SDLoc &dl, SDValue Op, SelectionDAG &DAG,
4259 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, Op,
4260 getF32Constant(DAG, 0x3fb8aa3b, dl));
4261 return getLimitedPrecisionExp2(t0, dl, DAG);
4265 return DAG.getNode(ISD::FEXP, dl, Op.getValueType(), Op);
4270 static SDValue expandLog(const SDLoc &dl, SDValue Op, SelectionDAG &DAG,
4277 SDValue Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op);
4280 SDValue Exp = GetExponent(DAG, Op1, TLI, dl);
4281 SDValue LogOfExponent = DAG.getNode(ISD::FMUL, dl, MVT::f32, Exp,
4282 getF32Constant(DAG, 0x3f317218, dl));
4286 SDValue X = GetSignificand(DAG, Op1, dl);
4297 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4298 getF32Constant(DAG, 0xbe74c456, dl));
4299 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
4300 getF32Constant(DAG, 0x3fb3a2b1, dl));
4301 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4302 LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
4303 getF32Constant(DAG, 0x3f949a29, dl));
4314 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4315 getF32Constant(DAG, 0xbd67b6d6, dl));
4316 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
4317 getF32Constant(DAG, 0x3ee4f4b8, dl));
4318 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4319 SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
4320 getF32Constant(DAG, 0x3fbc278b, dl));
4321 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4322 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4323 getF32Constant(DAG, 0x40348e95, dl));
4324 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4325 LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
4326 getF32Constant(DAG, 0x3fdef31a, dl));
4339 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4340 getF32Constant(DAG, 0xbc91e5ac, dl));
4341 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
4342 getF32Constant(DAG, 0x3e4350aa, dl));
4343 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4344 SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
4345 getF32Constant(DAG, 0x3f60d3e3, dl));
4346 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4347 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4348 getF32Constant(DAG, 0x4011cdf0, dl));
4349 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4350 SDValue t7 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
4351 getF32Constant(DAG, 0x406cfd1c, dl));
4352 SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
4353 SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
4354 getF32Constant(DAG, 0x408797cb, dl));
4355 SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
4356 LogOfMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t10,
4357 getF32Constant(DAG, 0x4006dcab, dl));
4360 return DAG.getNode(ISD::FADD, dl, MVT::f32, LogOfExponent, LogOfMantissa);
4364 return DAG.getNode(ISD::FLOG, dl, Op.getValueType(), Op);
4369 static SDValue expandLog2(const SDLoc &dl, SDValue Op, SelectionDAG &DAG,
4376 SDValue Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op);
4379 SDValue LogOfExponent = GetExponent(DAG, Op1, TLI, dl);
4383 SDValue X = GetSignificand(DAG, Op1, dl);
4394 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4395 getF32Constant(DAG, 0xbeb08fe0, dl));
4396 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
4397 getF32Constant(DAG, 0x40019463, dl));
4398 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4399 Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
4400 getF32Constant(DAG, 0x3fd6633d, dl));
4411 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4412 getF32Constant(DAG, 0xbda7262e, dl));
4413 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
4414 getF32Constant(DAG, 0x3f25280b, dl));
4415 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4416 SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
4417 getF32Constant(DAG, 0x4007b923, dl));
4418 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4419 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4420 getF32Constant(DAG, 0x40823e2f, dl));
4421 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4422 Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
4423 getF32Constant(DAG, 0x4020d29c, dl));
4437 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4438 getF32Constant(DAG, 0xbcd2769e, dl));
4439 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
4440 getF32Constant(DAG, 0x3e8ce0b9, dl));
4441 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4442 SDValue t3 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
4443 getF32Constant(DAG, 0x3fa22ae7, dl));
4444 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4445 SDValue t5 = DAG.getNode(ISD::FADD, dl, MVT::f32, t4,
4446 getF32Constant(DAG, 0x40525723, dl));
4447 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4448 SDValue t7 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t6,
4449 getF32Constant(DAG, 0x40aaf200, dl));
4450 SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
4451 SDValue t9 = DAG.getNode(ISD::FADD, dl, MVT::f32, t8,
4452 getF32Constant(DAG, 0x40c39dad, dl));
4453 SDValue t10 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t9, X);
4454 Log2ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t10,
4455 getF32Constant(DAG, 0x4042902c, dl));
4458 return DAG.getNode(ISD::FADD, dl, MVT::f32, LogOfExponent, Log2ofMantissa);
4462 return DAG.getNode(ISD::FLOG2, dl, Op.getValueType(), Op);
4467 static SDValue expandLog10(const SDLoc &dl, SDValue Op, SelectionDAG &DAG,
4474 SDValue Op1 = DAG.getNode(ISD::BITCAST, dl, MVT::i32, Op);
4477 SDValue Exp = GetExponent(DAG, Op1, TLI, dl);
4478 SDValue LogOfExponent = DAG.getNode(ISD::FMUL, dl, MVT::f32, Exp,
4479 getF32Constant(DAG, 0x3e9a209a, dl));
4483 SDValue X = GetSignificand(DAG, Op1, dl);
4494 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4495 getF32Constant(DAG, 0xbdd49a13, dl));
4496 SDValue t1 = DAG.getNode(ISD::FADD, dl, MVT::f32, t0,
4497 getF32Constant(DAG, 0x3f1c0789, dl));
4498 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4499 Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t2,
4500 getF32Constant(DAG, 0x3f011300, dl));
4510 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4511 getF32Constant(DAG, 0x3d431f31, dl));
4512 SDValue t1 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0,
4513 getF32Constant(DAG, 0x3ea21fb2, dl));
4514 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4515 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
4516 getF32Constant(DAG, 0x3f6ae232, dl));
4517 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4518 Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t4,
4519 getF32Constant(DAG, 0x3f25f7c3, dl));
4531 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, X,
4532 getF32Constant(DAG, 0x3c5d51ce, dl));
4533 SDValue t1 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t0,
4534 getF32Constant(DAG, 0x3e00685a, dl));
4535 SDValue t2 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t1, X);
4536 SDValue t3 = DAG.getNode(ISD::FADD, dl, MVT::f32, t2,
4537 getF32Constant(DAG, 0x3efb6798, dl));
4538 SDValue t4 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t3, X);
4539 SDValue t5 = DAG.getNode(ISD::FSUB, dl, MVT::f32, t4,
4540 getF32Constant(DAG, 0x3f88d192, dl));
4541 SDValue t6 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t5, X);
4542 SDValue t7 = DAG.getNode(ISD::FADD, dl, MVT::f32, t6,
4543 getF32Constant(DAG, 0x3fc4316c, dl));
4544 SDValue t8 = DAG.getNode(ISD::FMUL, dl, MVT::f32, t7, X);
4545 Log10ofMantissa = DAG.getNode(ISD::FSUB, dl, MVT::f32, t8,
4546 getF32Constant(DAG, 0x3f57ce70, dl));
4549 return DAG.getNode(ISD::FADD, dl, MVT::f32, LogOfExponent, Log10ofMantissa);
4553 return DAG.getNode(ISD::FLOG10, dl, Op.getValueType(), Op);
4558 static SDValue expandExp2(const SDLoc &dl, SDValue Op, SelectionDAG &DAG,
4562 return getLimitedPrecisionExp2(Op, dl, DAG);
4565 return DAG.getNode(ISD::FEXP2, dl, Op.getValueType(), Op);
4570 static SDValue expandPow(const SDLoc &dl, SDValue LHS, SDValue RHS,
4588 SDValue t0 = DAG.getNode(ISD::FMUL, dl, MVT::f32, RHS,
4589 getF32Constant(DAG, 0x40549a78, dl));
4590 return getLimitedPrecisionExp2(t0, dl, DAG);
4594 return DAG.getNode(ISD::FPOW, dl, LHS.getValueType(), LHS, RHS);
4599 static SDValue ExpandPowI(const SDLoc &DL, SDValue LHS, SDValue RHS,
4612 return DAG.getConstantFP(1.0, DL, LHS.getValueType());
4630 Res = DAG.getNode(ISD::FMUL, DL,Res.getValueType(), Res, CurSquare);
4635 CurSquare = DAG.getNode(ISD::FMUL, DL, CurSquare.getValueType(),
4642 Res = DAG.getNode(ISD::FDIV, DL, LHS.getValueType(),
4643 DAG.getConstantFP(1.0, DL, LHS.getValueType()), Res);
4649 return DAG.getNode(ISD::FPOWI, DL, LHS.getValueType(), LHS, RHS);
4673 DILocation *DL, int64_t Offset, bool IsIndirect, const SDValue &N) {
4683 // FIXME: Should we be checking DL->inlinedAt() to determine this?
4721 assert(Variable->isValidLocationForIntrinsic(DL) &&
4725 BuildMI(MF, DL, TII->get(TargetOpcode::DBG_VALUE), IsIndirect,
4729 BuildMI(MF, DL, TII->get(TargetOpcode::DBG_VALUE))
4753 DebugLoc dl = getCurDebugLoc();
4877 FINode->getIndex(), 0, dl, SDNodeOrder);
4881 EmitFuncArgumentDbgValue(Address, Variable, Expression, dl, 0, false,
4886 true, 0, dl, SDNodeOrder);
4892 if (!EmitFuncArgumentDbgValue(Address, Variable, Expression, dl, 0, false,
4902 0, dl, SDNodeOrder);
4926 SDV = DAG.getConstantDbgValue(Variable, Expression, V, Offset, dl,
4937 if (!EmitFuncArgumentDbgValue(V, Variable, Expression, dl, Offset,
4940 false, Offset, dl, SDNodeOrder);
4946 DanglingDebugInfo DDI(&DI, dl, SDNodeOrder);
5360 unsigned Align = DL->getPrefTypeAlignment(Global->getType());
5547 GetUnderlyingObjects(I.getArgOperand(1), Allocas, *DL);
5630 BuildMI(*FuncInfo.MBB, FuncInfo.InsertPt, dl,
5760 auto &DL = DAG.getDataLayout();
5791 EVT(TLI.getPointerTy(DL)));
5827 const TargetRegisterClass *RC = TLI.getRegClassFor(TLI.getPointerTy(DL));
5829 SDValue CopyNode = CLI.DAG.getCopyToReg(Result.second, CLI.DL, VReg, Src);
5863 const_cast<Constant *>(LoadInput), LoadTy, *Builder.DL))
6405 const DataLayout &DL) const {
6409 return TLI.getPointerTy(DL);
6431 unsigned BitSize = DL.getTypeSizeInBits(OpTy);
6445 return TLI.getValueType(DL, OpTy, true);
6462 const SDLoc &DL,
6488 OpInfo.CallOperand = DAG.getNode(ISD::BITCAST, DL,
6497 OpInfo.CallOperand = DAG.getNode(ISD::BITCAST, DL,
6716 auto &DL = DAG.getDataLayout();
6717 uint64_t TySize = DL.getTypeAllocSize(Ty);
6718 unsigned Align = DL.getPrefTypeAlignment(Ty);
6916 SDLoc dl = getCurSDLoc();
6918 MatchedRegs.getCopyToRegs(InOperandVal, DAG, dl,
6921 true, OpInfo.getMatchedOperand(), dl,
7005 SDLoc dl = getCurSDLoc();
7007 OpInfo.AssignedRegs.getCopyToRegs(InOperandVal, DAG, dl,
7011 dl, DAG, AsmNodeOperands);
7119 const DataLayout &DL = DAG.getDataLayout();
7123 DL.getABITypeAlignment(I.getType()));
7230 const SDLoc &DL, SmallVectorImpl<SDValue> &Ops,
7236 Builder.DAG.getTargetConstant(StackMaps::ConstantOp, DL, MVT::i64));
7238 Builder.DAG.getTargetConstant(C->getSExtValue(), DL, MVT::i64));
7258 SDLoc DL = getCurSDLoc();
7260 NullPtr = DAG.getIntPtrConstant(0, DL, true);
7272 Chain = DAG.getCALLSEQ_START(getRoot(), NullPtr, DL);
7278 cast<ConstantSDNode>(IDVal)->getZExtValue(), DL, MVT::i64));
7281 cast<ConstantSDNode>(NBytesVal)->getZExtValue(), DL,
7285 addStackMapLiveVars(&CI, 2, DL, Ops, *this);
7296 SDNode *SM = DAG.getMachineNode(TargetOpcode::STACKMAP, DL, NodeTys, Ops);
7300 Chain = DAG.getCALLSEQ_END(Chain, NullPtr, NullPtr, InFlag, DL);
7324 SDLoc dl = getCurSDLoc();
7329 Callee = DAG.getIntPtrConstant(ConstCallee->getZExtValue(), dl,
7373 cast<ConstantSDNode>(IDVal)->getZExtValue(), dl, MVT::i64));
7376 cast<ConstantSDNode>(NBytesVal)->getZExtValue(), dl,
7387 Ops.push_back(DAG.getTargetConstant(NumCallRegArgs, dl, MVT::i32));
7390 Ops.push_back(DAG.getTargetConstant((unsigned)CC, dl, MVT::i32));
7403 addStackMapLiveVars(CS, NumMetaOpers + NumArgs, dl, Ops, *this);
7436 dl, NodeTys, Ops);
7488 auto &DL = CLI.DAG.getDataLayout();
7489 ComputeValueVTs(*this, DL, CLI.RetTy, RetTys, &Offsets);
7492 GetReturnInfo(CLI.RetTy, getReturnAttrs(CLI), Outs, *this, DL);
7504 uint64_t TySize = DL.getTypeAllocSize(CLI.RetTy);
7505 unsigned Align = DL.getPrefTypeAlignment(CLI.RetTy);
7510 DemoteStackSlot = CLI.DAG.getFrameIndex(DemoteStackIdx, getPointerTy(DL));
7557 MyFlags.VT = getPointerTy(DL);
7558 MyFlags.ArgVT = EVT(getPointerTy(DL));
7570 ComputeValueVTs(*this, DL, Args[i].Ty, ValueVTs);
7583 unsigned OriginalAlignment = DL.getABITypeAlignment(ArgTy);
7611 Flags.setByValSize(DL.getTypeAllocSize(ElementTy));
7618 FrameAlign = getByValTypeAlignment(ElementTy, DL);
7657 getCopyToParts(CLI.DAG, CLI.DL, Op, &Parts[0], NumParts, PartVT,
7720 ComputeValueVTs(*this, DL, PtrRetTy, PVTs);
7734 SDValue Add = CLI.DAG.getNode(ISD::ADD, CLI.DL, PtrVT, DemoteStackSlot,
7735 CLI.DAG.getConstant(Offsets[i], CLI.DL,
7738 RetTys[i], CLI.DL, CLI.Chain, Add,
7746 CLI.Chain = CLI.DAG.getNode(ISD::TokenFactor, CLI.DL, MVT::Other, Chains);
7761 ReturnValues.push_back(getCopyFromParts(CLI.DAG, CLI.DL, &InVals[CurReg],
7774 SDValue Res = CLI.DAG.getNode(ISD::MERGE_VALUES, CLI.DL,
7832 SDLoc dl = SDB->getCurSDLoc();
7833 const DataLayout &DL = DAG.getDataLayout();
7870 unsigned OriginalAlignment = DL.getABITypeAlignment(ArgTy);
7903 Flags.setByValSize(DL.getTypeAllocSize(ElementTy));
7910 FrameAlign = TLI->getByValTypeAlignment(ElementTy, DL);
7943 DAG.getRoot(), F.getCallingConv(), F.isVarArg(), Ins, dl, DAG, InVals);
7974 SDValue ArgValue = getCopyFromParts(DAG, dl, &InVals[0], 1,
8020 ArgValues.push_back(getCopyFromParts(DAG, dl, &InVals[i],
8697 SDLoc DL = getCurSDLoc();
8699 SDValue Or = DAG.getNode(ISD::OR, DL, VT, CondLHS,
8700 DAG.getConstant(CommonBit, DL, VT));
8702 DL, MVT::i1, Or, DAG.getConstant(BigValue | SmallValue, DL, VT),
8719 DAG.getNode(ISD::BRCOND, DL, MVT::Other, getControlRoot(), Cond,
8722 BrCond = DAG.getNode(ISD::BR, DL, MVT::Other, BrCond,
