Lines Matching refs:Builder
61 CGBuilderTy &Builder;
67 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira),
119 return Builder.CreateFCmpUNE(V, Zero, "tobool");
126 return Builder.CreateICmpNE(V, Zero, "tobool");
134 if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) {
145 return Builder.CreateIsNotNull(V, "tobool");
174 return Builder.getInt(E->getValue());
198 return Builder.CreateBitCast(V, ConvertType(E->getType()));
355 return Builder.getInt1(E->getValue());
363 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
367 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
390 return Builder.getInt1(E->getValue());
398 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
401 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul");
409 return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul");
410 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
430 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
433 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
436 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
553 Src = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16), Src);
574 return Builder.CreateBitCast(Src, DstTy, "conv");
582 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
584 return Builder.CreateIntToPtr(IntResult, DstTy, "conv");
590 return Builder.CreatePtrToInt(Src, DstTy, "conv");
601 llvm::Value *Idx = Builder.getInt32(0);
602 UnV = Builder.CreateInsertElement(UnV, Elt, Idx);
607 Builder.getInt32(0));
608 llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat");
615 return Builder.CreateBitCast(Src, DstTy, "conv");
628 Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
630 Res = Builder.CreateSIToFP(Src, DstTy, "conv");
632 Res = Builder.CreateUIToFP(Src, DstTy, "conv");
636 Res = Builder.CreateFPToSI(Src, DstTy, "conv");
638 Res = Builder.CreateFPToUI(Src, DstTy, "conv");
643 Res = Builder.CreateFPTrunc(Src, DstTy, "conv");
645 Res = Builder.CreateFPExt(Src, DstTy, "conv");
650 Res = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16), Res);
670 return Builder.CreateOr(Src.first, Src.second, "tobool");
715 concat.push_back(Builder.getInt32(2*i));
716 concat.push_back(Builder.getInt32(2*i+1));
720 LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat");
743 Mask = Builder.CreateAnd(Mask, MaskBits, "mask");
755 Value *IIndx = Builder.getInt32(i);
756 Value *Indx = Builder.CreateExtractElement(Mask, IIndx, "shuf_idx");
757 Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext");
762 cmpIndx = Builder.CreateICmpUGT(Indx, Builder.getInt32(3),
764 newIndx = Builder.CreateSub(Indx, Builder.getInt32(1), "shuf_idx_adj");
765 Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx");
767 Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt");
768 NewV = Builder.CreateInsertElement(NewV, VExt, IIndx, "shuf_ins");
783 indices.push_back(Builder.getInt32(Idx));
787 return Builder.CreateShuffleVector(V1, V2, SV, "shuffle");
796 return Builder.getInt(Value);
828 Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast");
829 return Builder.CreateExtractElement(Base, Idx, "vecext");
901 Args.push_back(Builder.getInt32(ResElts + C->getZExtValue()));
910 V = Builder.CreateShuffleVector(LHS, RHS, Mask);
916 V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx),
942 Args.push_back(Builder.getInt32(j));
960 Args.push_back(Builder.getInt32(j));
963 Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT),
968 Args.push_back(Builder.getInt32(j));
970 Args.push_back(Builder.getInt32(j+Offset));
979 V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit");
990 Value *Idx = Builder.getInt32(CurIdx);
992 V = Builder.CreateInsertElement(V, Init, Idx, "vecinit");
1039 V = Builder.CreateBitCast(V,
1049 return Builder.CreateBitCast(Src, ConvertType(DestTy));
1095 V = Builder.CreateStructGEP(V, 0, "arraydecay");
1100 return CGF.Builder.CreateBitCast(V, ConvertType(CE->getType()));
1172 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv");
1174 return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy));
1178 return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy));
1192 llvm::Value *Idx = Builder.getInt32(0);
1193 UnV = Builder.CreateInsertElement(UnV, Elt, Idx);
1197 llvm::Constant *Zero = Builder.getInt32(0);
1199 llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat");
1253 return Builder.CreateAdd(InVal, NextVal, IsInc ? "inc" : "dec");
1256 return Builder.CreateNSWAdd(InVal, NextVal, IsInc ? "inc" : "dec");
1282 llvm::BasicBlock *startBB = Builder.GetInsertBlock();
1284 Builder.CreateBr(opBB);
1285 Builder.SetInsertPoint(opBB);
1286 atomicPHI = Builder.CreatePHI(value->getType(), 2);
1300 value = Builder.getTrue();
1314 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
1324 if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize");
1326 value = Builder.CreateGEP(value, numElts, "vla.inc");
1328 value = Builder.CreateInBoundsGEP(value, numElts, "vla.inc");
1332 llvm::Value *amt = Builder.getInt32(amount);
1336 value = Builder.CreateGEP(value, amt, "incdec.funcptr");
1338 value = Builder.CreateInBoundsGEP(value, amt, "incdec.funcptr");
1339 value = Builder.CreateBitCast(value, input->getType());
1343 llvm::Value *amt = Builder.getInt32(amount);
1345 value = Builder.CreateGEP(value, amt, "incdec.ptr");
1347 value = Builder.CreateInBoundsGEP(value, amt, "incdec.ptr");
1355 value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec");
1357 value = Builder.CreateFAdd(
1371 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16),
1388 value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
1392 Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16),
1406 value = Builder.CreateGEP(value, sizeValue, "incdec.objptr");
1408 value = Builder.CreateInBoundsGEP(value, sizeValue, "incdec.objptr");
1409 value = Builder.CreateBitCast(value, input->getType());
1413 llvm::BasicBlock *opBB = Builder.GetInsertBlock();
1415 llvm::Value *old = Builder.CreateAtomicCmpXchg(LV.getAddress(), atomicPHI,
1418 llvm::Value *success = Builder.CreateICmpEQ(old, atomicPHI);
1419 Builder.CreateCondBr(success, contBB, opBB);
1420 Builder.SetInsertPoint(contBB);
1456 return Builder.CreateNot(Op, "neg");
1465 Value *Result = Builder.CreateICmp(llvm::CmpInst::ICMP_EQ, Oper, Zero, "cmp");
1466 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
1475 BoolVal = Builder.CreateNot(BoolVal, "lnot");
1478 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext");
1485 return Builder.getInt(Value);
1501 Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv");
1512 Offset = Builder.CreateMul(Idx, ElemSize);
1565 Result = Builder.CreateAdd(Result, Offset);
1597 size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts);
1605 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);
1711 llvm::BasicBlock *opBB = Builder.GetInsertBlock();
1713 llvm::Value *old = Builder.CreateAtomicCmpXchg(LHSLV.getAddress(), atomicPHI,
1716 llvm::Value *success = Builder.CreateICmpEQ(old, atomicPHI);
1717 Builder.CreateCondBr(success, contBB, opBB);
1718 Builder.SetInsertPoint(contBB);
1762 Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth()));
1765 llvm::Value *Cond1 = Builder.CreateICmpNE(Ops.RHS, Zero);
1766 llvm::Value *LHSCmp = Builder.CreateICmpNE(Ops.LHS, IntMin);
1767 llvm::Value *RHSCmp = Builder.CreateICmpNE(Ops.RHS, NegOne);
1768 llvm::Value *Cond2 = Builder.CreateOr(LHSCmp, RHSCmp, "or");
1769 CGF.EmitCheck(Builder.CreateAnd(Cond1, Cond2, "and"));
1771 CGF.EmitCheck(Builder.CreateICmpNE(Ops.RHS, Zero));
1782 CGF.EmitCheck(Builder.CreateFCmpUNE(Ops.RHS, Zero));
1785 llvm::Value *Val = Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
1797 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
1799 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
1812 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
1814 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
1847 Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS);
1848 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0);
1849 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1);
1855 CGF.EmitCheck(Builder.CreateNot(overflow));
1860 llvm::BasicBlock *initialBB = Builder.GetInsertBlock();
1866 Builder.CreateCondBr(overflow, overflowBB, continueBB);
1870 Builder.SetInsertPoint(overflowBB);
1881 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty);
1882 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty);
1886 llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs,
1887 Builder.getInt8(OpID),
1888 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth()));
1891 handlerResult = Builder.CreateTrunc(handlerResult, opTy);
1892 Builder.CreateBr(continueBB);
1894 Builder.SetInsertPoint(continueBB);
1895 llvm::PHINode *phi = Builder.CreatePHI(opTy, 2);
1926 index = CGF.Builder.CreateIntCast(index, CGF.PtrDiffTy, isSigned,
1932 index = CGF.Builder.CreateNeg(index, "idx.neg");
1943 index = CGF.Builder.CreateMul(index, objectSize);
1945 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
1946 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
1947 return CGF.Builder.CreateBitCast(result, pointer->getType());
1961 index = CGF.Builder.CreateMul(index, numElements, "vla.index");
1962 pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr");
1964 index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index");
1965 pointer = CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
1974 Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy);
1975 result = CGF.Builder.CreateGEP(result, index, "add.ptr");
1976 return CGF.Builder.CreateBitCast(result, pointer->getType());
1980 return CGF.Builder.CreateGEP(pointer, index, "add.ptr");
1982 return CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr");
1993 return Builder.CreateAdd(op.LHS, op.RHS, "add");
1996 return Builder.CreateNSWAdd(op.LHS, op.RHS, "add");
2004 return Builder.CreateFAdd(op.LHS, op.RHS, "add");
2006 return Builder.CreateAdd(op.LHS, op.RHS, "add");
2015 return Builder.CreateSub(op.LHS, op.RHS, "sub");
2018 return Builder.CreateNSWSub(op.LHS, op.RHS, "sub");
2026 return Builder.CreateFSub(op.LHS, op.RHS, "sub");
2028 return Builder.CreateSub(op.LHS, op.RHS, "sub");
2040 = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast");
2042 = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast");
2043 Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
2062 divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor);
2086 return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div");
2094 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
2100 CGF.EmitCheck(Builder.CreateICmpULE(RHS, WidthMinusOne));
2106 Builder.CreateLShr(Ops.LHS,
2107 Builder.CreateSub(WidthMinusOne, RHS, "shl.zeros",
2116 BitsShiftedOff = Builder.CreateLShr(BitsShiftedOff, One);
2119 CGF.EmitCheck(Builder.CreateICmpEQ(BitsShiftedOff, Zero));
2123 return Builder.CreateShl(Ops.LHS, RHS, "shl");
2131 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
2136 CGF.EmitCheck(Builder.CreateICmpULT(RHS, WidthVal));
2140 return Builder.CreateLShr(Ops.LHS, RHS, "shr");
2141 return Builder.CreateAShr(Ops.LHS, RHS, "shr");
2253 Value *CR6Param = Builder.getInt32(CR6);
2255 Result = Builder.CreateCall3(F, CR6Param, FirstVecArg, SecondVecArg, "");
2260 Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc,
2263 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc,
2267 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2274 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext");
2285 ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
2287 ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
2292 ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2294 ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
2299 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
2303 Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
2372 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
2373 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
2374 Value *And = Builder.CreateAnd(LHS, RHS);
2375 return Builder.CreateSExt(And, Zero->getType(), "sext");
2387 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext");
2418 RHSBlock = Builder.GetInsertBlock();
2424 Builder.SetCurrentDebugLocation(llvm::DebugLoc());
2429 return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext");
2439 LHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, LHS, Zero, "cmp");
2440 RHS = Builder.CreateICmp(llvm::CmpInst::ICMP_NE, RHS, Zero, "cmp");
2441 Value *Or = Builder.CreateOr(LHS, RHS);
2442 return Builder.CreateSExt(Or, Zero->getType(), "sext");
2454 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext");
2488 RHSBlock = Builder.GetInsertBlock();
2496 return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext");
2581 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec);
2582 llvm::Value *tmp = Builder.CreateSExt(TestMSB,
2586 llvm::Value *tmp2 = Builder.CreateNot(tmp);
2594 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType());
2595 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType());
2599 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2);
2600 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp);
2601 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond");
2603 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType());
2621 return Builder.CreateSelect(CondV, LHS, RHS, "cond");
2636 LHSBlock = Builder.GetInsertBlock();
2637 Builder.CreateBr(ContBlock);
2644 RHSBlock = Builder.GetInsertBlock();
2654 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond");
2670 return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType()));
2673 return Builder.CreateLoad(ArgPtr);
2707 Src = Builder.CreateBitCast(Src, newSrcTy, "astypeCast");
2713 Args.push_back(Builder.getInt32(0));
2714 Args.push_back(Builder.getInt32(1));
2715 Args.push_back(Builder.getInt32(2));
2722 return Builder.CreateShuffleVector(Src, UnV, Mask, "astype");
2726 return Builder.CreateBitCast(Src, DstTy, "astype");
2791 Builder.CreateStore(Src, V);
2803 V = Builder.CreateBitCast(V, ClassPtrTy);