Lines Matching refs:Builder
63 CGBuilderTy &Builder;
69 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
170 return Builder.CreateFCmpUNE(V, Zero, "tobool");
177 return Builder.CreateICmpNE(V, Zero, "tobool");
185 if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
196 return Builder.CreateIsNotNull(V, "tobool");
226 return Builder.getInt(E->getValue());
250 return Builder.CreateBitCast(V, ConvertType(E->getType()));
419 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
423 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
446 return Builder.getInt1(E->getValue());
454 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
457 return Builder
469 return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
470 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
488 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
491 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
494 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
626 Check = Builder.CreateICmpULE(Src, Max);
629 llvm::Value *GE = Builder.CreateICmpSGE(Src, Min);
630 llvm::Value *LE = Builder.CreateICmpSLE(Src, Max);
631 Check = Builder.CreateAnd(GE, LE);
678 Builder.CreateFCmpOGT(Src, llvm::ConstantFP::get(VMContext, MinSrc));
680 Builder.CreateFCmpOLT(Src, llvm::ConstantFP::get(VMContext, MaxSrc));
681 Check = Builder.CreateAnd(GE, LE);
716 Builder.CreateFCmpOGT(AbsSrc, llvm::ConstantFP::get(VMContext, MinBad));
718 Builder.CreateFCmpOLT(AbsSrc, llvm::ConstantFP::get(VMContext, MaxBad));
719 Check = Builder.CreateNot(Builder.CreateAnd(GE, LE));
763 return Builder.CreateCall(
771 Src = Builder.CreateCall(
776 Src = Builder.CreateFPExt(Src, CGF.CGM.FloatTy, "conv");
793 return Builder.CreateBitCast(Src, DstTy, "conv");
801 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
803 return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
809 return Builder.CreatePtrToInt(Src, DstTy, "conv");
821 return Builder.CreateVectorSplat(NumElements, Elt, "splat");
827 return Builder.CreateBitCast(Src, DstTy, "conv");
847 return Builder.CreateCall(
850 return Builder.CreateFPTrunc(Src, DstTy);
861 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
863 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
865 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
869 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
871 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
876 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
878 Res = Builder.CreateFPExt(Src, DstTy, "conv");
884 Res = Builder.CreateCall(
888 Res = Builder.CreateFPTrunc(Res, ResTy, "conv");
908 return Builder.CreateOr(Src.first, Src.second, "tobool");
1001 concat.push_back(Builder.getInt32(2*i));
1002 concat.push_back(Builder.getInt32(2*i+1));
1006 LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat");
1017 Mask = Builder.CreateAnd(Mask, MaskBits, "mask");
1030 Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx");
1032 Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt");
1033 NewV = Builder.CreateInsertElement(NewV, VExt, IIndx, "shuf_ins");
1048 indices.push_back(Builder.getInt32(Idx.getZExtValue()));
1052 return Builder.CreateShuffleVector(V1, V2, SV, "shuffle");
1094 return Builder.CreateFCmpUNE(Src, Zero, "tobool");
1096 return Builder.CreateICmpNE(Src, Zero, "tobool");
1106 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
1108 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
1110 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
1114 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
1116 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
1121 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
1123 Res = Builder.CreateFPExt(Src, DstTy, "conv");
1136 return Builder.getInt(Value);
1161 return Builder.CreateExtractElement(Base, Idx, "vecext");
1244 Args.push_back(Builder.getInt32(ResElts + C->getZExtValue()));
1253 V = Builder.CreateShuffleVector(LHS, RHS, Mask);
1259 V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
1285 Args.push_back(Builder.getInt32(j));
1303 Args.push_back(Builder.getInt32(j));
1306 Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT),
1311 Args.push_back(Builder.getInt32(j));
1313 Args.push_back(Builder.getInt32(j+Offset));
1322 V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit");
1333 Value *Idx = Builder.getInt32(CurIdx);
1335 V = Builder.CreateInsertElement(V, Init, Idx, "vecinit");
1382 Addr = Builder.CreateElementBitCast(Addr, CGF.ConvertTypeForMem(DestTy));
1408 return Builder.CreateBitCast(Src, DstTy);
1412 return Builder.CreateAddrSpaceCast(Src, ConvertType(DestTy));
1530 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
1532 return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy));
1536 return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy));
1555 return Builder.CreateVectorSplat(NumElements, Elt, "splat");
1632 return Builder.CreateAdd(InVal, Amount, Name);
1635 return Builder.CreateNSWAdd(InVal, Amount, Name);
1657 llvm::Value *True = CGF.EmitToMemory(Builder.getTrue(), type);
1659 Builder.CreateStore(True, LV.getAddress(), LV.isVolatileQualified())
1661 return Builder.getTrue();
1665 return Builder.CreateAtomicRMW(llvm::AtomicRMWInst::Xchg,
1682 llvm::Value *old = Builder.CreateAtomicRMW(aop,
1684 return isPre ? Builder.CreateBinOp(op, old, amt) : old;
1689 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
1692 Builder.CreateBr(opBB);
1693 Builder
1694 atomicPHI = Builder.CreatePHI(value->getType(), 2);
1710 value = Builder.getTrue();
1726 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
1737 if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
1739 value = Builder.CreateGEP(value, numElts, "vla.inc");
1741 value = Builder.CreateInBoundsGEP(value, numElts, "vla.inc");
1745 llvm::Value *amt = Builder.getInt32(amount);
1749 value = Builder.CreateGEP(value, amt, "incdec.funcptr");
1751 value = Builder.CreateInBoundsGEP(value, amt, "incdec.funcptr");
1752 value = Builder.CreateBitCast(value, input->getType());
1756 llvm::Value *amt = Builder.getInt32(amount);
1758 value = Builder.CreateGEP(value, amt, "incdec.ptr");
1760 value = Builder.CreateInBoundsGEP(value, amt, "incdec.ptr");
1768 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
1770 value = Builder.CreateFAdd(
1784 value = Builder.CreateCall(
1789 value = Builder.CreateFPExt(input, CGF.CGM.FloatTy, "incdec.conv");
1811 value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
1815 value = Builder.CreateCall(
1820 value = Builder.CreateFPTrunc(value, input->getType(), "incdec.conv");
1835 value = Builder.CreateGEP(value, sizeValue, "incdec.objptr");
1837 value = Builder.CreateInBoundsGEP(value, sizeValue, "incdec.objptr");
1838 value = Builder.CreateBitCast(value, input->getType());
1842 llvm::BasicBlock *opBB = Builder.GetInsertBlock();
1849 Builder.CreateCondBr(success, contBB, opBB);
1850 Builder.SetInsertPoint(contBB);
1887 return Builder.CreateNot(Op, "neg");
1897 Result = Builder.CreateFCmp(llvm::CmpInst::FCMP_OEQ, Oper, Zero, "cmp");
1899 Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp");
1900 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
1909 BoolVal = Builder.CreateNot(BoolVal, "lnot");
1912 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
1919 return Builder.getInt(Value);
1935 Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv");
1946 Offset = Builder.CreateMul(Idx, ElemSize);
1999 Result = Builder.CreateAdd(Result, Offset);
2031 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts);
2046 return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
2164 Builder.CreateAtomicRMW(aop, LHSLV.getPointer(), amt,
2171 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
2175 Builder.CreateBr(opBB);
2176 Builder.SetInsertPoint(opBB);
2177 atomicPHI = Builder.CreatePHI(OpInfo.LHS->getType(), 2);
2196 llvm::BasicBlock *opBB = Builder.GetInsertBlock();
2203 Builder.CreateCondBr(success, contBB, opBB);
2204 Builder.SetInsertPoint(contBB);
2247 Checks.push_back(std::make_pair(Builder.CreateICmpNE(Ops.RHS, Zero),
2256 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
2259 llvm::Value *LHSCmp = Builder.CreateICmpNE(Ops.LHS, IntMin);
2260 llvm::Value *RHSCmp = Builder.CreateICmpNE(Ops.RHS, NegOne);
2261 llvm::Value *NotOverflow = Builder.CreateOr(LHSCmp, RHSCmp, "or");
2281 llvm::Value *NonZero = Builder.CreateFCmpUNE(Ops.RHS, Zero);
2288 llvm::Value *Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
2300 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
2302 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
2316 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
2318 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
2356 Value *resultAndOverflow = Builder.CreateCall(intrinsic, {Ops.LHS, Ops.RHS});
2357 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
2358 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
2368 llvm::Value *NotOverflow = Builder.CreateNot(overflow);
2373 CGF.EmitTrapCheck(Builder.CreateNot(overflow));
2378 llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
2384 Builder.CreateCondBr(overflow, overflowBB, continueBB);
2388 Builder.SetInsertPoint(overflowBB);
2399 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
2400 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
2407 Builder.getInt8(OpID),
2408 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())
2414 handlerResult = Builder.CreateTrunc(handlerResult, opTy);
2415 Builder.CreateBr(continueBB);
2417 Builder.SetInsertPoint(continueBB);
2418 llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
2449 index = CGF.Builder.CreateIntCast(index, CGF.PtrDiffTy, isSigned,
2455 index = CGF.Builder.CreateNeg(index, "idx.neg");
2470 index = CGF.Builder.CreateMul(index, objectSize);
2472 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
2473 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
2474 return CGF.Builder.CreateBitCast(result, pointer->getType());
2488 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
2489 pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
2491 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
2492 pointer = CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
2501 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
2502 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
2503 return CGF.Builder.CreateBitCast(result, pointer->getType());
2507 return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
2509 return CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
2518 const CodeGenFunction &CGF, CGBuilderTy &Builder,
2526 Builder.CreateFSub(
2531 Builder.CreateFSub(
2536 Value *FMulAdd = Builder.CreateCall(
2551 const CodeGenFunction &CGF, CGBuilderTy &Builder,
2573 return buildFMulAdd(LHSBinOp, op.RHS, CGF, Builder, false, isSub);
2578 return buildFMulAdd(RHSBinOp, op.LHS, CGF, Builder, isSub, false);
2592 return Builder.CreateAdd(op.LHS, op.RHS, "add");
2595 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
2608 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder))
2611 return Builder.CreateFAdd(op.LHS, op.RHS, "add");
2614 return Builder.CreateAdd(op.LHS, op.RHS, "add");
2623 return Builder.CreateSub(op.LHS, op.RHS, "sub");
2626 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
2639 if (Value *FMulAdd = tryEmitFMulAdd(op, CGF, Builder, true))
2641 return Builder.CreateFSub(op.LHS, op.RHS, "sub");
2644 return Builder.CreateSub(op.LHS, op.RHS, "sub");
2656 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
2658 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
2659 Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
2678 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2702 return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div");
2719 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
2727 Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shl.mask");
2733 llvm::Value *ValidExponent = Builder.CreateICmpULE(RHS, WidthMinusOne);
2744 llvm::BasicBlock *Orig = Builder.GetInsertBlock();
2747 Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);
2750 Builder.CreateLShr(Ops.LHS,
2751 Builder.CreateSub(WidthMinusOne, RHS, "shl.zeros",
2760 BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
2763 llvm::Value *ValidBase = Builder.CreateICmpEQ(BitsShiftedOff, Zero);
2765 llvm::PHINode *BaseCheck = Builder.CreatePHI(ValidBase->getType(), 2);
2766 BaseCheck->addIncoming(Builder.getTrue(), Orig);
2775 return Builder.CreateShl(Ops.LHS, RHS, "shl");
2783 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
2788 Builder.CreateAnd(RHS, GetWidthMinusOneValue(Ops.LHS, RHS), "shr.mask");
2793 Builder.CreateICmpULE(RHS, GetWidthMinusOneValue(Ops.LHS, RHS));
2798 return Builder.CreateLShr(Ops.LHS, RHS, "shr");
2799 return Builder.CreateAShr(Ops.LHS, RHS, "shr");
2914 Value *CR6Param = Builder.getInt32(CR6);
2916 Result = Builder.CreateCall(F, {CR6Param, FirstVecArg, SecondVecArg});
2922 Result = Builder.CreateFCmp(FCmpOpc, LHS, RHS, "cmp");
2924 Result = Builder.CreateICmp(SICmpOpc, LHS, RHS, "cmp");
2927 Result = Builder.CreateICmp(UICmpOpc, LHS, RHS, "cmp");
2933 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
2962 ResultR = Builder.CreateFCmp(FCmpOpc, LHS.first, RHS.first, "cmp.r");
2963 ResultI = Builder.CreateFCmp(FCmpOpc, LHS.second, RHS.second, "cmp.i");
2967 ResultR = Builder.CreateICmp(UICmpOpc, LHS.first, RHS.first, "cmp.r");
2968 ResultI = Builder.CreateICmp(UICmpOpc, LHS.second, RHS.second, "cmp.i");
2972 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
2976 Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
3048 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
3049 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
3051 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
3052 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
3054 Value *And = Builder.CreateAnd(LHS, RHS);
3055 return Builder.CreateSExt(And, ConvertType(E->getType()), "sext");
3069 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
3102 RHSBlock = Builder.GetInsertBlock();
3114 return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
3126 LHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, LHS, Zero, "cmp");
3127 RHS = Builder.CreateFCmp(llvm::CmpInst::FCMP_UNE, RHS, Zero, "cmp");
3129 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
3130 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
3132 Value *Or = Builder.CreateOr(LHS, RHS);
3133 return Builder.CreateSExt(Or, ConvertType(E->getType()), "sext");
3147 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
3184 RHSBlock = Builder.GetInsertBlock();
3192 return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
3274 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
3275 llvm::Value *tmp = Builder.CreateSExt(TestMSB,
3279 llvm::Value *tmp2 = Builder.CreateNot(tmp);
3287 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
3288 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
3292 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
3293 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
3294 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
3296 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
3316 return Builder.CreateSelect(CondV, LHS, RHS, "cond");
3333 LHSBlock = Builder.GetInsertBlock();
3334 Builder.CreateBr(ContBlock);
3341 RHSBlock = Builder.GetInsertBlock();
3351 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
3374 return Builder.CreateVAArg(ArgValue.getPointer(), ArgTy);
3377 llvm::Value *Val = Builder.CreateLoad(ArgPtr);
3382 Val = Builder.CreateIntToPtr(Val, ArgTy);
3384 Val = Builder.CreateTrunc(Val, ArgTy);
3421 Src = Builder.CreateBitCast(Src, newSrcTy, "astypeCast");
3427 Args.push_back(Builder.getInt32(0));
3428 Args.push_back(Builder.getInt32(1));
3429 Args.push_back(Builder.getInt32(2));
3436 return Builder.CreateShuffleVector(Src, UnV, Mask, "astype");
3440 return Builder.CreateBitCast(Src, DstTy, "astype");
3503 Addr = Builder.CreateElementBitCast(Addr, ConvertType(E->getType()));
