Lines Matching full:builder
61 CGBuilderTy &Builder;
67 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
117 return Builder.CreateFCmpUNE(V, Zero, "tobool");
124 return Builder.CreateICmpNE(V, Zero, "tobool");
132 if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
143 return Builder.CreateIsNotNull(V, "tobool");
172 return Builder.getInt(E->getValue());
196 return Builder.CreateBitCast(V, ConvertType(E->getType()));
353 return Builder.getInt1(E->getValue());
361 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
365 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
388 return Builder.getInt1(E->getValue());
396 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
398 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
405 return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
406 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
417 Builder.SetInsertPoint(overflowBB);
419 Builder.CreateCall(Trap);
420 Builder.CreateUnreachable();
432 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
435 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
438 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
555 Src = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16), Src);
576 return Builder.CreateBitCast(Src, DstTy, "conv");
584 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
586 return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
592 return Builder.CreatePtrToInt(Src, DstTy, "conv");
603 llvm::Value *Idx = Builder.getInt32(0);
604 UnV = Builder.CreateInsertElement(UnV, Elt, Idx);
609 Builder.getInt32(0));
610 llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat");
617 return Builder.CreateBitCast(Src, DstTy, "conv");
630 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
632 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
634 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
638 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
640 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
645 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
647 Res = Builder.CreateFPExt(Src, DstTy, "conv");
652 Res = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16), Res);
672 return Builder.CreateOr(Src.first, Src.second, "tobool");
717 concat.push_back(Builder.getInt32(2*i));
718 concat.push_back(Builder.getInt32(2*i+1));
722 LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat");
745 Mask = Builder.CreateAnd(Mask, MaskBits, "mask");
757 Value *IIndx = Builder.getInt32(i);
758 Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx");
759 Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext");
764 cmpIndx = Builder.CreateICmpUGT(Indx, Builder.getInt32(3),
766 newIndx = Builder.CreateSub(Indx, Builder.getInt32(1), "shuf_idx_adj");
767 Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx");
769 Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt");
770 NewV = Builder.CreateInsertElement(NewV, VExt, IIndx, "shuf_ins");
785 indices.push_back(Builder.getInt32(Idx));
789 return Builder.CreateShuffleVector(V1, V2, SV, "shuffle");
798 return Builder.getInt(Value);
829 Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast");
830 return Builder.CreateExtractElement(Base, Idx, "vecext");
902 Args.push_back(Builder.getInt32(ResElts + C->getZExtValue()));
911 V = Builder.CreateShuffleVector(LHS, RHS, Mask);
917 V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
943 Args.push_back(Builder.getInt32(j));
961 Args.push_back(Builder.getInt32(j));
964 Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT),
969 Args.push_back(Builder.getInt32(j));
971 Args.push_back(Builder.getInt32(j+Offset));
980 V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit");
991 Value *Idx = Builder.getInt32(CurIdx);
993 V = Builder.CreateInsertElement(V, Init, Idx, "vecinit");
1038 V = Builder.CreateBitCast(V,
1048 return Builder.CreateBitCast(Src, ConvertType(DestTy));
1094 V = Builder.CreateStructGEP(V, 0, "arraydecay");
1099 return CGF.Builder.CreateBitCast(V, ConvertType(CE->getType()));
1171 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
1173 return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy));
1177 return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy));
1191 llvm::Value *Idx = Builder.getInt32(0);
1192 UnV = Builder.CreateInsertElement(UnV, Elt, Idx);
1196 llvm::Constant *Zero = Builder.getInt32(0);
1198 llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat");
1252 return Builder.CreateNSWAdd(InVal, NextVal, IsInc ? "inc" : "dec");
1254 return Builder.CreateAdd(InVal, NextVal, IsInc ? "inc" : "dec");
1279 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
1281 Builder.CreateBr(opBB);
1282 Builder.SetInsertPoint(opBB);
1283 atomicPHI = Builder.CreatePHI(value->getType(), 2);
1297 value = Builder.getTrue();
1311 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
1321 if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
1323 value = Builder.CreateGEP(value, numElts, "vla.inc");
1325 value = Builder.CreateInBoundsGEP(value, numElts, "vla.inc");
1329 llvm::Value *amt = Builder.getInt32(amount);
1333 value = Builder.CreateGEP(value, amt, "incdec.funcptr");
1335 value = Builder.CreateInBoundsGEP(value, amt, "incdec.funcptr");
1336 value = Builder.CreateBitCast(value, input->getType());
1340 llvm::Value *amt = Builder.getInt32(amount);
1342 value = Builder.CreateGEP(value, amt, "incdec.ptr");
1344 value = Builder.CreateInBoundsGEP(value, amt, "incdec.ptr");
1352 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
1354 value = Builder.CreateFAdd(
1368 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16),
1385 value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
1389 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16),
1403 value = Builder.CreateGEP(value, sizeValue, "incdec.objptr");
1405 value = Builder.CreateInBoundsGEP(value, sizeValue, "incdec.objptr");
1406 value = Builder.CreateBitCast(value, input->getType());
1410 llvm::BasicBlock *opBB = Builder.GetInsertBlock();
1412 llvm::Value *old = Builder.CreateAtomicCmpXchg(LV.getAddress(), atomicPHI,
1415 llvm::Value *success = Builder.CreateICmpEQ(old, atomicPHI);
1416 Builder.CreateCondBr(success, contBB, opBB);
1417 Builder.SetInsertPoint(contBB);
1453 return Builder.CreateNot(Op, "neg");
1462 Value *Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp");
1463 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
1472 BoolVal = Builder.CreateNot(BoolVal, "lnot");
1475 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
1482 return Builder.getInt(Value);
1498 Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv");
1509 Offset = Builder.CreateMul(Idx, ElemSize);
1563 Result = Builder.CreateAdd(Result, Offset);
1595 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts);
1603 return Builder.getInt(E->EvaluateKnownConstInt(CGF.getContext()));
1692 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
1694 Builder.CreateBr(opBB);
1695 Builder.SetInsertPoint(opBB);
1696 atomicPHI = Builder.CreatePHI(OpInfo.LHS->getType(), 2);
1709 llvm::BasicBlock *opBB = Builder.GetInsertBlock();
1711 llvm::Value *old = Builder.CreateAtomicCmpXchg(LHSLV.getAddress(), atomicPHI,
1714 llvm::Value *success = Builder.CreateICmpEQ(old, atomicPHI);
1715 Builder.CreateCondBr(success, contBB, opBB);
1716 Builder.SetInsertPoint(contBB);
1757 llvm::Function::iterator insertPt = Builder.GetInsertBlock();
1767 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
1770 llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero);
1771 llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin);
1772 llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne);
1773 llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and");
1774 Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"),
1777 CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero),
1781 Builder.SetInsertPoint(contBB);
1791 llvm::Function::iterator insertPt = Builder.GetInsertBlock();
1796 CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero),
1799 Builder.SetInsertPoint(DivCont);
1803 llvm::Value *Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
1815 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
1817 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
1830 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
1832 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
1865 Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS);
1866 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
1867 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
1870 llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
1876 Builder.CreateCondBr(overflow, overflowBB, continueBB);
1883 Builder.SetInsertPoint(continueBB);
1889 Builder.SetInsertPoint(overflowBB);
1900 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
1901 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
1905 llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs,
1906 Builder.getInt8(OpID),
1907 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth()));
1910 handlerResult = Builder.CreateTrunc(handlerResult, opTy);
1911 Builder.CreateBr(continueBB);
1913 Builder.SetInsertPoint(continueBB);
1914 llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
1945 index = CGF.Builder.CreateIntCast(index, CGF.PtrDiffTy, isSigned,
1951 index = CGF.Builder.CreateNeg(index, "idx.neg");
1962 index = CGF.Builder.CreateMul(index, objectSize);
1964 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
1965 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
1966 return CGF.Builder.CreateBitCast(result, pointer->getType());
1980 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
1981 pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
1983 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
1984 pointer = CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
1993 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
1994 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
1995 return CGF.Builder.CreateBitCast(result, pointer->getType());
1999 return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
2001 return CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
2012 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
2014 return Builder.CreateAdd(op.LHS, op.RHS, "add");
2021 return Builder.CreateFAdd(op.LHS, op.RHS, "add");
2023 return Builder.CreateAdd(op.LHS, op.RHS, "add");
2032 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
2034 return Builder.CreateSub(op.LHS, op.RHS, "sub");
2041 return Builder.CreateFSub(op.LHS, op.RHS, "sub");
2043 return Builder.CreateSub(op.LHS, op.RHS, "sub");
2055 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
2057 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
2058 Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
2077 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2101 return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div");
2109 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
2115 CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS,
2121 return Builder.CreateShl(Ops.LHS, RHS, "shl");
2129 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
2135 CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS,
2142 return Builder.CreateLShr(Ops.LHS, RHS, "shr");
2143 return Builder.CreateAShr(Ops.LHS, RHS, "shr");
2255 Value *CR6Param = Builder.getInt32(CR6);
2257 Result = Builder.CreateCall3(F, CR6Param, FirstVecArg, SecondVecArg, "");
2262 Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc,
2265 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc,
2269 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2276 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
2287 ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
2289 ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
2294 ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2296 ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2301 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
2305 Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
2374 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
2375 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
2376 Value *And = Builder.CreateAnd(LHS, RHS);
2377 return Builder.CreateSExt(And, Zero->getType(), "sext");
2389 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
2420 RHSBlock = Builder.GetInsertBlock();
2426 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
2431 return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
2441 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
2442 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
2443 Value *Or = Builder.CreateOr(LHS, RHS);
2444 return Builder.CreateSExt(Or, Zero->getType(), "sext");
2456 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
2490 RHSBlock = Builder.GetInsertBlock();
2498 return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
2583 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
2584 llvm::Value *tmp = Builder.CreateSExt(TestMSB,
2588 llvm::Value *tmp2 = Builder.CreateNot(tmp);
2596 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
2597 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
2601 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
2602 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
2603 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
2605 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
2623 return Builder.CreateSelect(CondV, LHS, RHS, "cond");
2638 LHSBlock = Builder.GetInsertBlock();
2639 Builder.CreateBr(ContBlock);
2646 RHSBlock = Builder.GetInsertBlock();
2656 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
2672 return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType()));
2675 return Builder.CreateLoad(ArgPtr);
2709 Src = Builder.CreateBitCast(Src, newSrcTy, "astypeCast");
2715 Args.push_back(Builder.getInt32(0));
2716 Args.push_back(Builder.getInt32(1));
2717 Args.push_back(Builder.getInt32(2));
2724 return Builder.CreateShuffleVector(Src, UnV, Mask, "astype");
2728 return Builder.CreateBitCast(Src, DstTy, "astype");
2793 Builder.CreateStore(Src, V);
2805 V = Builder.CreateBitCast(V, ClassPtrTy);
