Lines Matching refs:Builder
221 CGBuilderTy &Builder;
227 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
377 return Builder.CreateFCmpUNE(V, Zero, "tobool");
384 return Builder.CreateICmpNE(V, Zero, "tobool");
392 if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
403 return Builder.CreateIsNotNull(V, "tobool");
424 return CGF.Builder.CreateLoad(Address(
451 return Builder.getInt(E->getValue());
454 return Builder.getInt(E->getValue());
478 return Builder.CreateBitCast(V, ConvertType(E->getType()));
533 return llvm::ConstantInt::get(Builder.getInt1Ty(), 1);
678 return Builder.getInt1(E->isSatisfied());
682 return Builder.getInt1(E->isSatisfied());
686 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
690 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
713 return Builder.getInt1(E->getValue());
721 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
724 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
728 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
734 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
757 return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
761 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
784 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
787 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
790 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
956 Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
958 Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
959 Check = Builder.CreateAnd(GE, LE);
973 QualType DstType, CGBuilderTy &Builder) {
1001 Check = Builder.CreateIntCast(Dst, SrcTy, DstSigned, "anyext");
1003 Check = Builder.CreateICmpEQ(Check, Src, "truncheck");
1047 EmitIntegerTruncationCheckHelper(Src, SrcType, Dst, DstType, Builder);
1057 llvm::ConstantInt::get(Builder.getInt8Ty(), Check.first)};
1067 QualType DstType, CGBuilderTy &Builder) {
1087 auto EmitIsNegativeTest = [&Builder](Value *V, QualType VType,
1101 return Builder.CreateICmp(llvm::ICmpInst::ICMP_SLT, V, Zero,
1115 Check = Builder.CreateICmpEQ(SrcIsNegative, DstIsNegative, "signchangecheck");
1179 Check = EmitIntegerSignChangeCheckHelper(Src, SrcType, Dst, DstType, Builder);
1189 EmitIntegerTruncationCheckHelper(Src, SrcType, Dst, DstType, Builder);
1198 llvm::ConstantInt::get(Builder.getInt8Ty(), CheckKind)};
1224 return Builder.CreateIsNotNull(Src, "tobool");
1263 return Builder.CreateCall(
1271 Src = Builder.CreateCall(
1276 Src = Builder.CreateFPExt(Src, CGF.CGM.FloatTy, "conv");
1298 return Builder.CreateBitCast(Src, DstTy, "conv");
1306 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
1308 return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
1314 return Builder.CreatePtrToInt(Src, DstTy, "conv");
1327 return Builder.CreateVectorSplat(NumElements, Src, "splat");
1335 return Builder.CreateBitCast(Src, DstTy, "conv");
1357 return Builder.CreateIntCast(Src, DstTy, false, "conv");
1361 return Builder.CreateFPTrunc(Src, DstTy, "conv");
1364 return Builder.CreateFPExt(Src, DstTy, "conv");
1388 return Builder.CreateCall(
1391 return Builder.CreateFPTrunc(Src, DstTy);
1402 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1404 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
1406 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
1410 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
1412 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
1417 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
1419 Res = Builder.CreateFPExt(Src, DstTy, "conv");
1425 Res = Builder.CreateCall(
1429 Res = Builder.CreateFPTrunc(Res, ResTy, "conv");
1469 llvm::Type *DstIntTy = Builder.getIntNTy(DstWidth);
1481 Value *IsNegative = Builder.CreateICmpSLT(Result, Zero);
1484 Value *Rounded = Builder.CreateAdd(Result, LowBits);
1485 Result = Builder.CreateSelect(IsNegative, Rounded, Result);
1489 ? Builder.CreateAShr(Result, SrcScale - DstScale, "downscale")
1490 : Builder.CreateLShr(Result, SrcScale - DstScale, "downscale");
1495 Result = Builder.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
1499 Result = Builder.CreateShl(Result, DstScale - SrcScale, "upscale");
1505 llvm::Type *UpscaledTy = Builder.getIntNTy(ResultWidth);
1506 Result = Builder.CreateIntCast(Result, UpscaledTy, SrcIsSigned, "resize");
1507 Result = Builder.CreateShl(Result, DstScale - SrcScale, "upscale");
1516 Value *TooHigh = SrcIsSigned ? Builder.CreateICmpSGT(Result, Max)
1517 : Builder.CreateICmpUGT(Result, Max);
1518 Result = Builder.CreateSelect(TooHigh, Max, Result, "satmax");
1526 Value *TooLow = Builder.CreateICmpSLT(Result, Min);
1527 Result = Builder.CreateSelect(TooLow, Min, Result, "satmin");
1532 Result = Builder.CreateIntCast(Result, DstIntTy, SrcIsSigned, "resize");
1550 return Builder.CreateOr(Src.first, Src.second, "tobool");
1643 Mask = Builder.CreateAnd(Mask, MaskBits, "mask");
1656 Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx");
1658 Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt");
1659 NewV = Builder.CreateInsertElement(NewV, VExt, IIndx, "shuf_ins");
1677 return Builder.CreateShuffleVector(V1, V2, Indices, "shuffle");
1719 return Builder.CreateFCmpUNE(Src, Zero, "tobool");
1721 return Builder.CreateICmpNE(Src, Zero, "tobool");
1731 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1733 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
1735 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
1739 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
1741 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
1746 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
1748 Res = Builder.CreateFPExt(Src, DstTy, "conv");
1763 return Builder.getInt(Value);
1789 return Builder.CreateExtractElement(Base, Idx, "vecext");
1802 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
1892 V = Builder.CreateShuffleVector(LHS, RHS, Args);
1898 V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
1943 Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), Args,
1958 V = Builder.CreateShuffleVector(V, Init, Args, "vecinit");
1969 Value *Idx = Builder.getInt32(CurIdx);
1971 V = Builder.CreateInsertElement(V, Init, Idx, "vecinit");
2019 Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
2026 Address Addr = Builder.CreateElementBitCast(SourceLVal.getAddress(CGF),
2060 Src = Builder.CreateLaunderInvariantGroup(Src);
2068 Src = Builder.CreateStripInvariantGroup(Src);
2082 return Builder.CreateBitCast(Src, DstTy);
2215 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
2217 auto *IntToPtr = Builder.CreateIntToPtr(IntResult, DestLLVMTy);
2223 IntToPtr = Builder.CreateLaunderInvariantGroup(IntToPtr);
2237 PtrExpr = Builder.CreateStripInvariantGroup(PtrExpr);
2240 return Builder.CreatePtrToInt(PtrExpr, ConvertType(DestTy));
2251 return Builder.CreateVectorSplat(NumElements, Elt, "splat");
2383 return Builder.CreateAdd(InVal, Amount, Name);
2386 return Builder.CreateNSWAdd(InVal, Amount, Name);
2390 return Builder.CreateNSWAdd(InVal, Amount, Name);
2431 llvm::Value *True = CGF.EmitToMemory(Builder.getTrue(), type);
2433 Builder.CreateStore(True, LV.getAddress(CGF), LV.isVolatileQualified())
2435 return Builder.getTrue();
2439 return Builder.CreateAtomicRMW(
2458 Builder.CreateAtomicRMW(aop, LV.getPointer(CGF), amt,
2460 return isPre ? Builder.CreateBinOp(op, old, amt) : old;
2465 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
2468 Builder.CreateBr(opBB);
2469 Builder.SetInsertPoint(opBB);
2470 atomicPHI = Builder.CreatePHI(value->getType(), 2);
2486 value = Builder.getTrue();
2525 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2542 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2553 if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
2555 value = Builder.CreateGEP(value, numElts, "vla.inc");
2563 llvm::Value *amt = Builder.getInt32(amount);
2567 value = Builder.CreateGEP(value, amt, "incdec.funcptr");
2572 value = Builder.CreateBitCast(value, input->getType());
2576 llvm::Value *amt = Builder.getInt32(amount);
2578 value = Builder.CreateGEP(value, amt, "incdec.ptr");
2590 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
2592 value = Builder.CreateFAdd(
2606 value = Builder.CreateCall(
2611 value = Builder.CreateFPExt(input, CGF.CGM.FloatTy, "incdec.conv");
2637 value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
2641 value = Builder.CreateCall(
2646 value = Builder.CreateFPTrunc(value, input->getType(), "incdec.conv");
2665 Info.RHS = Builder.CreateNeg(Info.RHS);
2691 value = Builder.CreateGEP(value, sizeValue, "incdec.objptr");
2696 value = Builder.CreateBitCast(value, input->getType());
2700 llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
2707 Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
2708 Builder.SetInsertPoint(contBB);
2731 return Builder.CreateFNeg(Op, "fneg");
2747 return Builder.CreateNot(Op, "neg");
2761 Result = Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero, "cmp");
2763 Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp");
2764 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
2773 BoolVal = Builder.CreateNot(BoolVal, "lnot");
2776 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
2784 return Builder.getInt(Value);
2801 Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv");
2812 Offset = Builder.CreateMul(Idx, ElemSize);
2865 Result = Builder.CreateAdd(Result, Offset);
2894 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), size);
2909 return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
3033 Value *OldVal = Builder.CreateAtomicRMW(
3039 Result = Builder.CreateBinOp(Op, OldVal, Amt);
3045 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
3049 Builder.CreateBr(opBB);
3050 Builder.SetInsertPoint(opBB);
3051 atomicPHI = Builder.CreatePHI(OpInfo.LHS->getType(), 2);
3071 llvm::BasicBlock *curBlock = Builder.GetInsertBlock();
3078 Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
3079 Builder.SetInsertPoint(contBB);
3125 Checks.push_back(std::make_pair(Builder.CreateICmpNE(Ops.RHS, Zero),
3137 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
3140 llvm::Value *LHSCmp = Builder.CreateICmpNE(Ops.LHS, IntMin);
3141 llvm::Value *RHSCmp = Builder.CreateICmpNE(Ops.RHS, NegOne);
3142 llvm::Value *NotOverflow = Builder.CreateOr(LHSCmp, RHSCmp, "or");
3164 llvm::Value *NonZero = Builder.CreateFCmpUNE(Ops.RHS, Zero);
3173 Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
3192 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
3194 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
3209 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
3211 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
3250 Value *resultAndOverflow = Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
3251 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
3252 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
3261 llvm::Value *NotOverflow = Builder.CreateNot(overflow);
3266 CGF.EmitTrapCheck(Builder.CreateNot(overflow));
3271 llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
3276 Builder.CreateCondBr(overflow, overflowBB, continueBB);
3280 Builder.SetInsertPoint(overflowBB);
3292 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
3293 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
3300 Builder.getInt8(OpID),
3301 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
3307 handlerResult = Builder.CreateTrunc(handlerResult, opTy);
3308 Builder.CreateBr(continueBB);
3310 Builder.SetInsertPoint(continueBB);
3311 llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
3364 return CGF.Builder.CreateIntToPtr(index, pointer->getType());
3369 index = CGF.Builder.CreateIntCast(index, DL.getIndexType(PtrTy), isSigned,
3375 index = CGF.Builder.CreateNeg(index, "idx.neg");
3390 index = CGF.Builder.CreateMul(index, objectSize);
3392 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
3393 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
3394 return CGF.Builder.CreateBitCast(result, pointer->getType());
3408 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
3409 pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
3411 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
3424 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
3425 return CGF.Builder.CreateBitCast(result, pointer->getType());
3429 return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
3441 const CodeGenFunction &CGF, CGBuilderTy &Builder,
3448 MulOp0 = Builder.CreateFNeg(MulOp0, "neg");
3450 Addend = Builder.CreateFNeg(Addend, "neg");
3453 if (Builder.getIsFPConstrained()) {
3455 "Only constrained operation should be created when Builder is in FP "
3457 FMulAdd = Builder.CreateConstrainedFPCall(
3462 FMulAdd = Builder.CreateCall(
3478 const CodeGenFunction &CGF, CGBuilderTy &Builder,
3495 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub);
3500 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false);
3507 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub);
3513 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false);
3527 return Builder.CreateAdd(op.LHS, op.RHS, "add");
3530 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
3534 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
3540 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
3552 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder))
3555 return Builder.CreateFAdd(op.LHS, op.RHS, "add");
3561 return Builder.CreateAdd(op.LHS, op.RHS, "add");
3615 Result = Builder.CreateBinaryIntrinsic(IID, FullLHS, FullRHS);
3617 Result = Builder.CreateAdd(FullLHS, FullRHS);
3627 Result = Builder.CreateBinaryIntrinsic(IID, FullLHS, FullRHS);
3629 Result = Builder.CreateSub(FullLHS, FullRHS);
3642 Result = Builder.CreateIntrinsic(IID, {FullLHS->getType()},
3643 {FullLHS, FullRHS, Builder.getInt32(CommonFixedSema.getScale())});
3655 Result = Builder.CreateIntrinsic(IID, {FullLHS->getType()},
3656 {FullLHS, FullRHS, Builder.getInt32(CommonFixedSema.getScale())});
3660 return CommonFixedSema.isSigned() ? Builder.CreateICmpSLT(FullLHS, FullRHS)
3661 : Builder.CreateICmpULT(FullLHS, FullRHS);
3663 return CommonFixedSema.isSigned() ? Builder.CreateICmpSGT(FullLHS, FullRHS)
3664 : Builder.CreateICmpUGT(FullLHS, FullRHS);
3666 return CommonFixedSema.isSigned() ? Builder.CreateICmpSLE(FullLHS, FullRHS)
3667 : Builder.CreateICmpULE(FullLHS, FullRHS);
3669 return CommonFixedSema.isSigned() ? Builder.CreateICmpSGE(FullLHS, FullRHS)
3670 : Builder.CreateICmpUGE(FullLHS, FullRHS);
3675 return Builder.CreateICmpEQ(FullLHS, FullRHS);
3677 return Builder.CreateICmpNE(FullLHS, FullRHS);
3712 return Builder.CreateSub(op.LHS, op.RHS, "sub");
3715 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
3719 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
3725 llvm::MatrixBuilder<CGBuilderTy> MB(Builder);
3737 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true))
3739 return Builder.CreateFSub(op.LHS, op.RHS, "sub");
3745 return Builder.CreateSub(op.LHS, op.RHS, "sub");
3757 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
3759 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
3760 Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
3778 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
3802 return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div");
3823 return Builder.CreateAnd(RHS, GetWidthMinusOneValue(LHS, RHS), Name);
3825 return Builder.CreateURem(
3834 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
3849 llvm::Value *ValidExponent = Builder.CreateICmpULE(Ops.RHS, WidthMinusOne);
3860 llvm::BasicBlock *Orig = Builder.GetInsertBlock();
3863 Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
3868 llvm::Value *BitsShiftedOff = Builder.CreateLShr(
3869 Ops.LHS, Builder.CreateSub(PromotedWidthMinusOne, RHS, "shl.zeros",
3878 BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
3881 llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero);
3883 llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2);
3884 BaseCheck->addIncoming(Builder.getTrue(), Orig);
3893 return Builder.CreateShl(Ops.LHS, RHS, "shl");
3901 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
3910 Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
3915 return Builder.CreateLShr(Ops.LHS, RHS, "shr");
3916 return Builder.CreateAShr(Ops.LHS, RHS, "shr");
4041 Value *CR6Param = Builder.getInt32(CR6);
4043 Result = Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});
4053 Result = Builder.CreateTrunc(Result, Builder.getInt1Ty());
4063 Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS, "cmp");
4065 Result = Builder.CreateFCmpS(FCmpOpc, LHS, RHS, "cmp");
4067 Result = Builder.CreateICmp(SICmpOpc, LHS, RHS, "cmp");
4082 LHS = Builder.CreateStripInvariantGroup(LHS);
4084 RHS = Builder.CreateStripInvariantGroup(RHS);
4087 Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp");
4093 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
4124 ResultR = Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first, "cmp.r");
4125 ResultI = Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second, "cmp.i");
4129 ResultR = Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first, "cmp.r");
4130 ResultI = Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second, "cmp.i");
4134 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
4138 Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
4216 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
4217 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
4219 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
4220 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
4222 Value *And = Builder.CreateAnd(LHS, RHS);
4223 return Builder.CreateSExt(And, ConvertType(E->getType()), "sext");
4237 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
4270 RHSBlock = Builder.GetInsertBlock();
4284 PN->setDebugLoc(Builder.getCurrentDebugLocation());
4288 return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
4302 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
4303 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
4305 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
4306 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
4308 Value *Or = Builder.CreateOr(LHS, RHS);
4309 return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext");
4323 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
4360 RHSBlock = Builder.GetInsertBlock();
4368 return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
4450 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
4451 llvm::Value *tmp = Builder.CreateSExt(
4453 llvm::Value *tmp2 = Builder.CreateNot(tmp);
4461 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
4462 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
4466 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
4467 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
4468 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
4470 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
4486 CondV = Builder.CreateICmpNE(CondV, ZeroVec, "vector_cond");
4487 return Builder.CreateSelect(CondV, LHS, RHS, "vector_select");
4496 llvm::Value *StepV = Builder.CreateZExtOrBitCast(CondV, CGF.Int64Ty);
4507 return Builder.CreateSelect(CondV, LHS, RHS, "cond");
4524 LHSBlock = Builder.GetInsertBlock();
4525 Builder.CreateBr(ContBlock);
4532 RHSBlock = Builder.GetInsertBlock();
4542 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
4570 llvm::Value *Val = Builder.CreateLoad(ArgPtr);
4575 Val = Builder.CreateIntToPtr(Val, ArgTy);
4577 Val = Builder.CreateTrunc(Val, ArgTy);
4588 static Value *ConvertVec3AndVec4(CGBuilderTy &Builder, CodeGenFunction &CGF,
4592 return Builder.CreateShuffleVector(Src, UnV,
4612 static Value *createCastsForTypeOfSameSize(CGBuilderTy &Builder,
4620 return Builder.CreateBitCast(Src, DstTy, Name);
4624 return Builder.CreatePointerBitCastOrAddrSpaceCast(Src, DstTy, Name);
4630 Src = Builder.CreatePtrToInt(Src, DL.getIntPtrType(SrcTy));
4632 return Builder.CreateBitOrPointerCast(Src, DstTy, Name);
4637 Src = Builder.CreateBitCast(Src, DL.getIntPtrType(DstTy));
4639 return Builder.CreateIntToPtr(Src, DstTy, Name);
4655 Src = ConvertVec3AndVec4(Builder, CGF, Src, 4);
4658 Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
4673 Src = createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(), Src,
4677 Src = ConvertVec3AndVec4(Builder, CGF, Src, 3);
4682 return createCastsForTypeOfSameSize(Builder, CGF.CGM.getDataLayout(),
4746 Addr = Builder.CreateElementBitCast(Addr, ConvertType(E->getType()));
4815 CGBuilderTy &Builder) {
4826 Builder.CreatePtrToInt(BasePtr, DL.getIntPtrType(BasePtr->getType()));
4828 Builder.CreatePtrToInt(GEPVal, DL.getIntPtrType(GEPVal->getType()));
4829 TotalOffset = Builder.CreateSub(GEPVal_int, BasePtr_int);
4830 return {TotalOffset, /*OffsetOverflows=*/Builder.getFalse()};
4848 llvm::Value *OffsetOverflows = Builder.getFalse();
4862 OffsetOverflows = Builder.getTrue();
4868 auto *ResultAndOverflow = Builder.CreateCall(
4870 OffsetOverflows = Builder.CreateOr(
4871 Builder.CreateExtractValue(ResultAndOverflow, 1), OffsetOverflows);
4872 return Builder.CreateExtractValue(ResultAndOverflow, 0);
4892 auto *IndexS = Builder.CreateIntCast(Index, IntPtrTy, /*isSigned=*/true);
4911 Value *GEPVal = Builder.CreateInBoundsGEP(Ptr, IdxList, Name);
4921 Builder.GetInsertBlock()->getParent(), PtrTy->getPointerAddressSpace());
4936 EmitGEPOffsetInBytes(Ptr, GEPVal, getLLVMContext(), CGM, Builder);
4939 EvaluatedGEP.OffsetOverflows == Builder.getFalse()) &&
4952 auto *IntPtr = Builder.CreatePtrToInt(Ptr, IntPtrTy);
4953 auto *ComputedGEP = Builder.CreateAdd(IntPtr, EvaluatedGEP.TotalOffset);
4969 auto *BaseIsNotNullptr = Builder.CreateIsNotNull(Ptr);
4970 auto *ResultIsNotNullptr = Builder.CreateIsNotNull(ComputedGEP);
4973 ? Builder.CreateICmpEQ(BaseIsNotNullptr, ResultIsNotNullptr)
4974 : Builder.CreateAnd(BaseIsNotNullptr, ResultIsNotNullptr);
4984 auto *NoOffsetOverflow = Builder.CreateNot(EvaluatedGEP.OffsetOverflows);
4991 auto *PosOrZeroValid = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
4993 Builder.CreateICmpSGE(EvaluatedGEP.TotalOffset, Zero);
4994 llvm::Value *NegValid = Builder.CreateICmpULT(ComputedGEP, IntPtr);
4996 Builder.CreateSelect(PosOrZeroOffset, PosOrZeroValid, NegValid);
5002 ValidGEP = Builder.CreateICmpUGE(ComputedGEP, IntPtr);
5008 ValidGEP = Builder.CreateICmpULE(ComputedGEP, IntPtr);
5010 ValidGEP = Builder.CreateAnd(ValidGEP, NoOffsetOverflow);