Lines Matching defs:Builder
57 IRBuilder<> Builder(BB);
63 V = Builder.CreateLoad(GV->getValueType(), GV);
64 I = cast<Instruction>(Builder.CreateFAdd(V, V));
68 Result = Builder.CreateMinNum(V, V);
72 Result = Builder.CreateMaxNum(V, V);
76 Result = Builder.CreateMinimum(V, V);
80 Result = Builder.CreateMaximum(V, V);
84 Result = Builder.CreateIntrinsic(Intrinsic::readcyclecounter, {}, {});
88 Result = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, V);
94 Result = Builder.CreateUnaryIntrinsic(Intrinsic::fabs, V, I);
100 Result = Builder.CreateBinaryIntrinsic(Intrinsic::pow, V, V);
106 Result = Builder.CreateBinaryIntrinsic(Intrinsic::pow, V, V, I);
112 Result = Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V});
119 Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
126 Builder.CreateIntrinsic(Intrinsic::fma, {V->getType()}, {V, V, V}, I);
132 Result = Builder.CreateUnaryIntrinsic(Intrinsic::roundeven, V);
138 Result = Builder.CreateIntrinsic(
140 {Builder.getInt32(static_cast<uint32_t>(RoundingMode::TowardZero))});
146 IRBuilder<> Builder(BB);
147 Type *VoidTy = Builder.getVoidTy();
148 Type *Int64Ty = Builder.getInt64Ty();
149 Value *Int64Val = Builder.getInt64(0);
150 Value *DoubleVal = PoisonValue::get(Builder.getDoubleTy());
154 Call = Builder.CreateIntrinsic(Int64Ty, Intrinsic::coro_size, {});
159 Builder.CreateIntrinsic(VoidTy, Intrinsic::set_loop_iterations, Int64Val);
164 Call = Builder.CreateIntrinsic(Int64Ty, Intrinsic::lround, DoubleVal);
169 IRBuilder<> Builder(BB);
175 Type *SrcVecTy = VectorType::get(Builder.getHalfTy(), 8, true);
176 Type *DstVecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
177 Type *PredTy = VectorType::get(Builder.getInt1Ty(), 4, true);
184 Call = Builder.CreateIntrinsic(Intrinsic::aarch64_sve_fcvtzs_i32f16, {},
194 Type *VecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
195 Type *PtrToVecTy = Builder.getPtrTy();
196 PredTy = VectorType::get(Builder.getInt1Ty(), 4, true);
200 ArgTys.push_back(UndefValue::get(Builder.getInt32Ty()));
204 Call = Builder.CreateIntrinsic(Intrinsic::masked_load,
214 IRBuilder<> Builder(BB);
216 Constant *Zero = Builder.getInt32(0);
217 Value *VScale = Builder.CreateVScale(Zero);
222 IRBuilder<> Builder(BB);
225 Type *DstVecTy = VectorType::get(Builder.getInt32Ty(), 4, false);
226 Value *StepVec = Builder.CreateStepVector(DstVecTy);
238 DstVecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
239 StepVec = Builder.CreateStepVector(DstVecTy);
248 IRBuilder<> Builder(BB);
252 Type *VecI8Ty = VectorType::get(Builder.getInt8Ty(), 2, true);
253 Value *StepVec = Builder.CreateStepVector(DstVecTy);
267 IRBuilder<> Builder(BB);
276 V = Builder.CreateLoad(GV->getValueType(), GV);
277 VDouble = Builder.CreateLoad(GVDouble->getValueType(), GVDouble);
281 Builder.setIsFPConstrained(true);
285 V = Builder.CreateFAdd(V, V);
290 V = Builder.CreateFSub(V, V);
295 V = Builder.CreateFMul(V, V);
300 V = Builder.CreateFDiv(V, V);
305 V = Builder.CreateFRem(V, V);
310 VInt = Builder.CreateFPToUI(VDouble, Builder.getInt32Ty());
315 VInt = Builder.CreateFPToSI(VDouble, Builder.getInt32Ty());
320 VDouble = Builder.CreateUIToFP(VInt, Builder.getDoubleTy());
325 VDouble = Builder.CreateSIToFP(VInt, Builder.getDoubleTy());
330 V = Builder.CreateFPTrunc(VDouble, Type::getFloatTy(Ctx));
335 VDouble = Builder.CreateFPExt(V, Type::getDoubleTy(Ctx));
345 Builder.setConstrainedFPFunctionAttr();
351 V = Builder.CreateFAdd(V, V);
357 Builder.setDefaultConstrainedExcept(fp::ebIgnore);
358 Builder.setDefaultConstrainedRounding(RoundingMode::TowardPositive);
359 V = Builder.CreateFAdd(V, V);
364 Builder.setDefaultConstrainedExcept(fp::ebIgnore);
365 Builder.setDefaultConstrainedRounding(RoundingMode::NearestTiesToEven);
366 V = Builder.CreateFAdd(V, V);
371 Builder.setDefaultConstrainedExcept(fp::ebMayTrap);
372 Builder.setDefaultConstrainedRounding(RoundingMode::TowardNegative);
373 V = Builder.CreateFAdd(V, V);
378 Builder.setDefaultConstrainedExcept(fp::ebStrict);
379 Builder.setDefaultConstrainedRounding(RoundingMode::TowardZero);
380 V = Builder.CreateFAdd(V, V);
385 Builder.setDefaultConstrainedExcept(fp::ebIgnore);
386 Builder.setDefaultConstrainedRounding(RoundingMode::Dynamic);
387 V = Builder.CreateFAdd(V, V);
393 Call = Builder.CreateConstrainedFPBinOp(
401 Builder.CreateRetVoid();
406 IRBuilder<> Builder(BB);
412 VDouble = Builder.CreateLoad(GVDouble->getValueType(), GVDouble);
414 Builder.setDefaultConstrainedExcept(fp::ebStrict);
415 Builder.setDefaultConstrainedRounding(RoundingMode::TowardZero);
419 V = Builder.CreateConstrainedFPCall(Fn, { VDouble });
426 IRBuilder<> Builder(BB);
440 Builder.setIsFPConstrained(true);
441 Builder.setConstrainedFPFunctionAttr();
442 CallInst *FCall = Builder.CreateCall(Callee, {});
448 Builder.CreateRetVoid();
453 IRBuilder<> Builder(BB);
454 AllocaInst *Var1 = Builder.CreateAlloca(Builder.getInt8Ty());
455 AllocaInst *Var2 = Builder.CreateAlloca(Builder.getInt32Ty());
456 AllocaInst *Var3 = Builder.CreateAlloca(Builder.getInt8Ty(),
457 Builder.getInt32(123));
459 CallInst *Start1 = Builder.CreateLifetimeStart(Var1);
460 CallInst *Start2 = Builder.CreateLifetimeStart(Var2);
461 CallInst *Start3 = Builder.CreateLifetimeStart(Var3, Builder.getInt64(100));
463 EXPECT_EQ(Start1->getArgOperand(0), Builder.getInt64(-1));
464 EXPECT_EQ(Start2->getArgOperand(0), Builder.getInt64(-1));
465 EXPECT_EQ(Start3->getArgOperand(0), Builder.getInt64(100));
471 Value *End1 = Builder.CreateLifetimeEnd(Var1);
472 Builder.CreateLifetimeEnd(Var2);
473 Builder.CreateLifetimeEnd(Var3);
484 IRBuilder<> Builder(BB);
488 BranchInst *BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
497 BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB, Weights);
507 IRBuilder<> Builder(BB);
508 LandingPadInst *LP = Builder.CreateLandingPad(Builder.getInt32Ty(), 0, "LP");
521 IRBuilder<> Builder(BB);
522 IntegerType *Ty1 = Builder.getInt1Ty();
526 IntegerType *IntPtrTy = Builder.getIntPtrTy(DL);
532 IRBuilder<NoFolder> Builder(BB);
533 Value *V = Builder.CreateLoad(GV->getValueType(), GV);
536 Value *U = Builder.CreateUnOp(Instruction::FNeg, V);
546 Value *VFMF = Builder.CreateFNegFMF(V, I);
554 IRBuilder<> Builder(BB);
558 F = Builder.CreateLoad(GV->getValueType(), GV);
559 F = Builder.CreateFAdd(F, F);
561 EXPECT_FALSE(Builder.getFastMathFlags().any());
567 Builder.setFastMathFlags(FMF);
570 F = Builder.CreateFAdd(F, F);
571 EXPECT_FALSE(Builder.getFastMathFlags().any());
594 Builder.setFastMathFlags(FMF);
596 F = Builder.CreateFAdd(F, F);
597 EXPECT_TRUE(Builder.getFastMathFlags().any());
598 EXPECT_TRUE(Builder.getFastMathFlags().all());
605 F = Builder.CreateBinOp(Instruction::FAdd, F, F);
606 EXPECT_TRUE(Builder.getFastMathFlags().any());
612 F = Builder.CreateFDiv(F, F);
613 EXPECT_TRUE(Builder.getFastMathFlags().all());
619 Builder.clearFastMathFlags();
621 F = Builder.CreateFDiv(F, F);
629 Builder.setFastMathFlags(FMF);
631 F = Builder.CreateFDiv(F, F);
632 EXPECT_TRUE(Builder.getFastMathFlags().any());
633 EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
638 Builder.clearFastMathFlags();
640 FC = Builder.CreateFCmpOEQ(F, F);
647 Builder.setFastMathFlags(FMF);
649 FC = Builder.CreateFCmpOEQ(F, F);
650 EXPECT_TRUE(Builder.getFastMathFlags().any());
651 EXPECT_TRUE(Builder.getFastMathFlags().AllowReciprocal);
656 Builder.clearFastMathFlags();
659 FC = Builder.CreateFAdd(F, F);
666 Builder.setFastMathFlags(FMF);
668 FC = Builder.CreateFAdd(F, F);
669 EXPECT_TRUE(Builder.getFastMathFlags().any());
670 EXPECT_TRUE(Builder.getFastMathFlags().AllowContract);
676 Builder.clearFastMathFlags();
677 Builder.setFastMathFlags(FMF);
679 F = Builder.CreateFMul(F, F);
686 Builder.clearFastMathFlags();
687 Builder.setFastMathFlags(FMF);
689 F = Builder.CreateFMul(F, F);
701 FCall = Builder.CreateCall(Callee, {});
706 FCall = Builder.CreateCall(V, {});
711 Builder.setFastMathFlags(FMF);
713 FCall = Builder.CreateCall(Callee, {});
714 EXPECT_TRUE(Builder.getFastMathFlags().any());
715 EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
718 FCall = Builder.CreateCall(V, {});
719 EXPECT_TRUE(Builder.getFastMathFlags().any());
720 EXPECT_TRUE(Builder.getFastMathFlags().NoNaNs);
723 Builder.clearFastMathFlags();
726 F = Builder.CreateFDiv(F, F);
740 EXPECT_FALSE(Builder.getFastMathFlags().noNaNs());
743 F = Builder.CreateFNegFMF(F, FMFSource);
747 F = Builder.CreateFAddFMF(F, F, FMFSource);
751 F = Builder.CreateFSubFMF(F, F, FMFSource);
755 F = Builder.CreateFMulFMF(F, F, FMFSource);
759 F = Builder.CreateFDivFMF(F, F, FMFSource);
763 F = Builder.CreateFRemFMF(F, F, FMFSource);
770 IRBuilder<NoFolder> Builder(BB);
773 GlobalVariable *G = new GlobalVariable(*M, Builder.getInt32Ty(), true,
775 Value *V = Builder.CreateLoad(G->getValueType(), G);
777 cast<BinaryOperator>(Builder.CreateNSWAdd(V, V))->hasNoSignedWrap());
779 cast<BinaryOperator>(Builder.CreateNSWMul(V, V))->hasNoSignedWrap());
781 cast<BinaryOperator>(Builder.CreateNSWSub(V, V))->hasNoSignedWrap());
783 Builder.CreateShl(V, V, "", /* NUW */ false, /* NSW */ true))
787 cast<BinaryOperator>(Builder.CreateNUWAdd(V, V))->hasNoUnsignedWrap());
789 cast<BinaryOperator>(Builder.CreateNUWMul(V, V))->hasNoUnsignedWrap());
791 cast<BinaryOperator>(Builder.CreateNUWSub(V, V))->hasNoUnsignedWrap());
793 Builder.CreateShl(V, V, "", /* NUW */ true, /* NSW */ false))
797 Constant *C = Builder.getInt32(42);
798 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWAdd(C, C))
800 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWSub(C, C))
802 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNSWMul(C, C))
805 Builder.CreateShl(C, C, "", /* NUW */ false, /* NSW */ true))
808 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWAdd(C, C))
810 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWSub(C, C))
812 EXPECT_TRUE(cast<OverflowingBinaryOperator>(Builder.CreateNUWMul(C, C))
815 Builder.CreateShl(C, C, "", /* NUW */ true, /* NSW */ false))
820 IRBuilder<> Builder(BB);
821 EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
827 Builder.setDefaultFPMathTag(FPMathA);
830 IRBuilder<>::FastMathFlagGuard Guard(Builder);
833 Builder.setFastMathFlags(FMF);
834 Builder.setDefaultFPMathTag(FPMathB);
835 EXPECT_TRUE(Builder.getFastMathFlags().allowReciprocal());
836 EXPECT_EQ(FPMathB, Builder.getDefaultFPMathTag());
839 EXPECT_FALSE(Builder.getFastMathFlags().allowReciprocal());
840 EXPECT_EQ(FPMathA, Builder.getDefaultFPMathTag());
842 Value *F = Builder.CreateLoad(GV->getValueType(), GV);
845 IRBuilder<>::InsertPointGuard Guard(Builder);
846 Builder.SetInsertPoint(cast<Instruction>(F));
847 EXPECT_EQ(F, &*Builder.GetInsertPoint());
850 EXPECT_EQ(BB->end(), Builder.GetInsertPoint());
851 EXPECT_EQ(BB, Builder.GetInsertBlock());
855 IRBuilder<> Builder(BB);
894 IRBuilder<> Builder(BB);
905 AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
914 I = Builder.CreateAlloca(Builder.getInt1Ty());
934 I = Builder.CreateAlloca(Builder.getInt32Ty());
953 I = Builder.CreateAlloca(Builder.getInt32Ty());
963 I = Builder.CreateAlloca(Builder.getInt32Ty());
968 I = Builder.CreateAlloca(Builder.getInt32Ty());
976 I = Builder.CreateAlloca(Builder.getInt32Ty());
981 Builder.CreateRet(nullptr);
1011 IRBuilder<> Builder(BB);
1025 AllocaInst *I = Builder.CreateAlloca(Builder.getInt8Ty());
1026 ReturnInst *R = Builder.CreateRetVoid();
1035 Builder.SetInsertPoint(GBB);
1037 Builder.Insert(I);
1038 Builder.CreateRetVoid();
1069 IRBuilder<> Builder(BB);
1070 Builder.CreateRetVoid();
1133 IRBuilder<> Builder(BB);
1135 auto VecTy = FixedVectorType::get(Builder.getInt64Ty(), 4);
1136 auto Elt1 = Builder.getInt64(-1);
1137 auto Elt2 = Builder.getInt64(-2);
1138 Value *Vec = Builder.CreateInsertElement(VecTy, Elt1, Builder.getInt8(1));
1139 Vec = Builder.CreateInsertElement(Vec, Elt2, 2);
1140 auto X1 = Builder.CreateExtractElement(Vec, 1);
1141 auto X2 = Builder.CreateExtractElement(Vec, Builder.getInt32(2));
1147 IRBuilder<> Builder(BB);
1149 auto String1a = Builder.CreateGlobalString("TestString", "String1a");
1150 auto String1b = Builder.CreateGlobalString("TestString", "String1b", 0);
1151 auto String2 = Builder.CreateGlobalString("TestString", "String2", 1);
1152 auto String3 = Builder.CreateGlobalString("TestString", "String3", 2);
1182 IRBuilder<> Builder(Ctx);
1183 Builder.SetInsertPoint(Br);
1184 EXPECT_EQ(DL1, Builder.getCurrentDebugLocation());
1185 auto Call1 = Builder.CreateCall(Callee, {});
1189 Builder.SetInsertPoint(Call1->getParent(), Call1->getIterator());
1190 EXPECT_EQ(DL2, Builder.getCurrentDebugLocation());
1191 auto Call2 = Builder.CreateCall(Callee, {});
1198 IRBuilder<> Builder(BB);
1224 IRBuilder<> Builder(BB);
1287 IRBuilder<NoFolder> Builder(BB);
1289 Builder.CreateAdd(Builder.getInt32(1), Builder.getInt32(2), "add");