|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
examples/BrainF/BrainF.cpp 88 builder = new IRBuilder<>(BasicBlock::Create(C, label, brainf_func));
examples/BrainF/BrainF.h 90 IRBuilder<> *builder;
examples/HowToUseJIT/HowToUseJIT.cpp 82 IRBuilder<> builder(BB);
examples/HowToUseLLJIT/HowToUseLLJIT.cpp 39 IRBuilder<> builder(BB);
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp 701 static std::unique_ptr<IRBuilder<>> Builder;
731 IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
1110 Builder = std::make_unique<IRBuilder<>>(*TheContext);
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp 701 static std::unique_ptr<IRBuilder<>> Builder;
731 IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
1110 Builder = std::make_unique<IRBuilder<>>(*TheContext);
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp 700 static IRBuilder<> Builder(TheContext);
730 IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp 685 static IRBuilder<> Builder(TheContext);
716 IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp 709 static IRBuilder<> Builder(TheContext);
740 IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
examples/Kaleidoscope/Chapter3/toy.cpp 403 static IRBuilder<> Builder(TheContext);
examples/Kaleidoscope/Chapter4/toy.cpp 413 static IRBuilder<> Builder(TheContext);
examples/Kaleidoscope/Chapter5/toy.cpp 540 static IRBuilder<> Builder(TheContext);
examples/Kaleidoscope/Chapter6/toy.cpp 632 static IRBuilder<> Builder(TheContext);
examples/Kaleidoscope/Chapter7/toy.cpp 705 static IRBuilder<> Builder(TheContext);
736 IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
examples/Kaleidoscope/Chapter8/toy.cpp 706 static IRBuilder<> Builder(TheContext);
735 IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
examples/Kaleidoscope/Chapter9/toy.cpp 91 static IRBuilder<> Builder(TheContext);
888 IRBuilder<> TmpB(&TheFunction->getEntryBlock(),
include/llvm/Analysis/MemoryBuiltins.h 286 using BuilderTy = IRBuilder<TargetFolder, IRBuilderCallbackInserter>;
include/llvm/Analysis/ScalarEvolutionExpander.h 94 typedef IRBuilder<TargetFolder> BuilderType;
include/llvm/Analysis/VectorUtils.h 272 Constant *createBitMaskForGaps(IRBuilder<> &Builder, unsigned VF,
287 Constant *createReplicatedMask(IRBuilder<> &Builder, unsigned ReplicationFactor,
301 Constant *createInterleaveMask(IRBuilder<> &Builder, unsigned VF,
316 Constant *createStrideMask(IRBuilder<> &Builder, unsigned Start,
330 Constant *createSequentialMask(IRBuilder<> &Builder, unsigned Start,
340 Value *concatenateVectors(IRBuilder<> &Builder, ArrayRef<Value *> Vecs);
include/llvm/CodeGen/AtomicExpandUtils.h 25 function_ref<void(IRBuilder<> &, Value *, Value *, Value *, AtomicOrdering,
include/llvm/CodeGen/TargetLowering.h 1630 virtual Value *getIRStackGuard(IRBuilder<> &IRB) const;
1654 Value *getDefaultSafeStackPointerLocation(IRBuilder<> &IRB,
1659 virtual Value *getSafeStackPointerLocation(IRBuilder<> &IRB) const;
1736 virtual Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
1743 virtual Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
1751 virtual Value *emitMaskedAtomicRMWIntrinsic(IRBuilder<> &Builder,
1763 IRBuilder<> &Builder, AtomicCmpXchgInst *CI, Value *AlignedAddr,
1801 virtual Instruction *emitLeadingFence(IRBuilder<> &Builder, Instruction *Inst,
1809 virtual Instruction *emitTrailingFence(IRBuilder<> &Builder,
1825 virtual void emitAtomicCmpXchgNoStoreLLBalance(IRBuilder<> &Builder) const {}
include/llvm/Transforms/Scalar/Reassociate.h 117 Value *buildMinimalMultiplyDAG(IRBuilder<> &Builder,
include/llvm/Transforms/Utils/BuildLibCalls.h 45 Value *castToCStr(Value *V, IRBuilder<> &B);
50 Value *emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
56 Value *emitStrDup(Value *Ptr, IRBuilder<> &B, const TargetLibraryInfo *TLI);
61 Value *emitStrNLen(Value *Ptr, Value *MaxLen, IRBuilder<> &B,
67 Value *emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
71 Value *emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
76 Value *emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
81 Value *emitStpCpy(Value *Dst, Value *Src, IRBuilder<> &B,
86 Value *emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
91 Value *emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
97 IRBuilder<> &B, const DataLayout &DL,
102 Value *emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
106 Value *emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
110 Value *emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
115 IRBuilder<> &B, const TargetLibraryInfo *TLI);
119 ArrayRef<Value *> Args, IRBuilder<> &B,
124 IRBuilder<> &B, const TargetLibraryInfo *TLI);
127 Value *emitStrCat(Value *Dest, Value *Src, IRBuilder<> &B,
131 Value *emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
135 Value *emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
139 Value *emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
144 IRBuilder<> &B, const TargetLibraryInfo *TLI);
147 Value *emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilder<> &B,
154 Value *emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
161 LibFunc LongDoubleFn, IRBuilder<> &B,
169 IRBuilder<> &B, const AttributeList &Attrs);
176 IRBuilder<> &B, const AttributeList &Attrs);
179 Value *emitPutChar(Value *Char, IRBuilder<> &B, const TargetLibraryInfo *TLI);
182 Value *emitPutS(Value *Str, IRBuilder<> &B, const TargetLibraryInfo *TLI);
186 Value *emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
191 Value *emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B,
196 Value *emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
201 Value *emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B,
206 Value *emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
210 Value *emitMalloc(Value *Num, IRBuilder<> &B, const DataLayout &DL,
215 IRBuilder<> &B, const TargetLibraryInfo &TLI);
220 IRBuilder<> &B, const DataLayout &DL,
224 Value *emitFGetCUnlocked(Value *File, IRBuilder<> &B,
229 Value *emitFGetSUnlocked(Value *Str, Value *Size, Value *File, IRBuilder<> &B,
235 IRBuilder<> &B, const DataLayout &DL,
include/llvm/Transforms/Utils/EscapeEnumerator.h 32 IRBuilder<> Builder;
43 IRBuilder<> *Next();
include/llvm/Transforms/Utils/LoopUtils.h 296 Value *createMinMaxOp(IRBuilder<> &Builder,
302 getOrderedReduction(IRBuilder<> &Builder, Value *Acc, Value *Src, unsigned Op,
309 Value *getShuffleReduction(IRBuilder<> &Builder, Value *Src, unsigned Op,
320 Value *createSimpleTargetReduction(IRBuilder<> &B,
331 Value *createTargetReduction(IRBuilder<> &B, const TargetTransformInfo *TTI,
include/llvm/Transforms/Utils/SanitizerStats.h 37 void create(IRBuilder<> &B, SanitizerStatKind SK);
include/llvm/Transforms/Utils/SimplifyLibCalls.h 56 Value *optimizeMemCpyChk(CallInst *CI, IRBuilder<> &B);
57 Value *optimizeMemMoveChk(CallInst *CI, IRBuilder<> &B);
58 Value *optimizeMemSetChk(CallInst *CI, IRBuilder<> &B);
61 Value *optimizeStrpCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
62 Value *optimizeStrpNCpyChk(CallInst *CI, IRBuilder<> &B, LibFunc Func);
63 Value *optimizeMemCCpyChk(CallInst *CI, IRBuilder<> &B);
64 Value *optimizeSNPrintfChk(CallInst *CI, IRBuilder<> &B);
65 Value *optimizeSPrintfChk(CallInst *CI,IRBuilder<> &B);
66 Value *optimizeStrCatChk(CallInst *CI, IRBuilder<> &B);
67 Value *optimizeStrLCat(CallInst *CI, IRBuilder<> &B);
68 Value *optimizeStrNCatChk(CallInst *CI, IRBuilder<> &B);
69 Value *optimizeStrLCpyChk(CallInst *CI, IRBuilder<> &B);
70 Value *optimizeVSNPrintfChk(CallInst *CI, IRBuilder<> &B);
71 Value *optimizeVSPrintfChk(CallInst *CI, IRBuilder<> &B);
135 Value *foldMallocMemset(CallInst *Memset, IRBuilder<> &B);
157 Value *optimizeStrCat(CallInst *CI, IRBuilder<> &B);
158 Value *optimizeStrNCat(CallInst *CI, IRBuilder<> &B);
159 Value *optimizeStrChr(CallInst *CI, IRBuilder<> &B);
160 Value *optimizeStrRChr(CallInst *CI, IRBuilder<> &B);
161 Value *optimizeStrCmp(CallInst *CI, IRBuilder<> &B);
162 Value *optimizeStrNCmp(CallInst *CI, IRBuilder<> &B);
163 Value *optimizeStrNDup(CallInst *CI, IRBuilder<> &B);
164 Value *optimizeStrCpy(CallInst *CI, IRBuilder<> &B);
165 Value *optimizeStpCpy(CallInst *CI, IRBuilder<> &B);
166 Value *optimizeStrNCpy(CallInst *CI, IRBuilder<> &B);
167 Value *optimizeStrLen(CallInst *CI, IRBuilder<> &B);
168 Value *optimizeStrPBrk(CallInst *CI, IRBuilder<> &B);
169 Value *optimizeStrTo(CallInst *CI, IRBuilder<> &B);
170 Value *optimizeStrSpn(CallInst *CI, IRBuilder<> &B);
171 Value *optimizeStrCSpn(CallInst *CI, IRBuilder<> &B);
172 Value *optimizeStrStr(CallInst *CI, IRBuilder<> &B);
173 Value *optimizeMemChr(CallInst *CI, IRBuilder<> &B);
174 Value *optimizeMemRChr(CallInst *CI, IRBuilder<> &B);
175 Value *optimizeMemCmp(CallInst *CI, IRBuilder<> &B);
176 Value *optimizeBCmp(CallInst *CI, IRBuilder<> &B);
177 Value *optimizeMemCmpBCmpCommon(CallInst *CI, IRBuilder<> &B);
178 Value *optimizeMemPCpy(CallInst *CI, IRBuilder<> &B);
179 Value *optimizeMemCpy(CallInst *CI, IRBuilder<> &B);
180 Value *optimizeMemMove(CallInst *CI, IRBuilder<> &B);
181 Value *optimizeMemSet(CallInst *CI, IRBuilder<> &B);
182 Value *optimizeRealloc(CallInst *CI, IRBuilder<> &B);
183 Value *optimizeWcslen(CallInst *CI, IRBuilder<> &B);
184 Value *optimizeBCopy(CallInst *CI, IRBuilder<> &B);
186 Value *optimizeStringMemoryLibCall(CallInst *CI, IRBuilder<> &B);
189 Value *optimizeCAbs(CallInst *CI, IRBuilder<> &B);
190 Value *optimizePow(CallInst *CI, IRBuilder<> &B);
191 Value *replacePowWithExp(CallInst *Pow, IRBuilder<> &B);
192 Value *replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B);
193 Value *optimizeExp2(CallInst *CI, IRBuilder<> &B);
194 Value *optimizeFMinFMax(CallInst *CI, IRBuilder<> &B);
195 Value *optimizeLog(CallInst *CI, IRBuilder<> &B);
196 Value *optimizeSqrt(CallInst *CI, IRBuilder<> &B);
197 Value *optimizeSinCosPi(CallInst *CI, IRBuilder<> &B);
198 Value *optimizeTan(CallInst *CI, IRBuilder<> &B);
201 IRBuilder<> &B);
204 Value *optimizeFFS(CallInst *CI, IRBuilder<> &B);
205 Value *optimizeFls(CallInst *CI, IRBuilder<> &B);
206 Value *optimizeAbs(CallInst *CI, IRBuilder<> &B);
207 Value *optimizeIsDigit(CallInst *CI, IRBuilder<> &B);
208 Value *optimizeIsAscii(CallInst *CI, IRBuilder<> &B);
209 Value *optimizeToAscii(CallInst *CI, IRBuilder<> &B);
210 Value *optimizeAtoi(CallInst *CI, IRBuilder<> &B);
211 Value *optimizeStrtol(CallInst *CI, IRBuilder<> &B);
214 Value *optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
216 Value *optimizePrintF(CallInst *CI, IRBuilder<> &B);
217 Value *optimizeSPrintF(CallInst *CI, IRBuilder<> &B);
218 Value *optimizeSnPrintF(CallInst *CI, IRBuilder<> &B);
219 Value *optimizeFPrintF(CallInst *CI, IRBuilder<> &B);
220 Value *optimizeFWrite(CallInst *CI, IRBuilder<> &B);
221 Value *optimizeFRead(CallInst *CI, IRBuilder<> &B);
222 Value *optimizeFPuts(CallInst *CI, IRBuilder<> &B);
223 Value *optimizeFGets(CallInst *CI, IRBuilder<> &B);
224 Value *optimizeFPutc(CallInst *CI, IRBuilder<> &B);
225 Value *optimizeFGetc(CallInst *CI, IRBuilder<> &B);
226 Value *optimizePuts(CallInst *CI, IRBuilder<> &B);
229 Value *emitStrLenMemCpy(Value *Src, Value *Dst, uint64_t Len, IRBuilder<> &B);
234 Value *optimizePrintFString(CallInst *CI, IRBuilder<> &B);
235 Value *optimizeSPrintFString(CallInst *CI, IRBuilder<> &B);
236 Value *optimizeSnPrintFString(CallInst *CI, IRBuilder<> &B);
237 Value *optimizeFPrintFString(CallInst *CI, IRBuilder<> &B);
244 Value *optimizeStringLength(CallInst *CI, IRBuilder<> &B, unsigned CharSize);
include/llvm/Transforms/Utils/VNCoercion.h 47 IRBuilder<> &IRB, const DataLayout &DL);
lib/Analysis/LoopAccessAnalysis.cpp 2215 IRBuilder<> ChkBuilder(Loc);
lib/Analysis/MemoryBuiltins.cpp 538 IRBuilder<TargetFolder> Builder(Ctx, TargetFolder(DL));
lib/Analysis/ScalarEvolutionExpander.cpp 2059 IRBuilder<> Builder(IP);
2074 IRBuilder<> Builder(&*L->getHeader()->getFirstInsertionPt());
lib/Analysis/VectorUtils.cpp 638 llvm::createBitMaskForGaps(IRBuilder<> &Builder, unsigned VF,
657 Constant *llvm::createReplicatedMask(IRBuilder<> &Builder,
667 Constant *llvm::createInterleaveMask(IRBuilder<> &Builder, unsigned VF,
677 Constant *llvm::createStrideMask(IRBuilder<> &Builder, unsigned Start,
686 Constant *llvm::createSequentialMask(IRBuilder<> &Builder, unsigned Start,
702 static Value *concatenateTwoVectors(IRBuilder<> &Builder, Value *V1,
725 Value *llvm::concatenateVectors(IRBuilder<> &Builder, ArrayRef<Value *> Vecs) {
lib/CodeGen/AtomicExpandPass.cpp 81 insertRMWLLSCLoop(IRBuilder<> &Builder, Type *ResultTy, Value *Addr,
83 function_ref<Value *(IRBuilder<> &, Value *)> PerformOp);
86 function_ref<Value *(IRBuilder<> &, Value *)> PerformOp);
97 IRBuilder<> &Builder, Type *ResultType, Value *Addr,
99 function_ref<Value *(IRBuilder<> &, Value *)> PerformOp,
347 IRBuilder<> Builder(I);
377 IRBuilder<> Builder(LI);
415 IRBuilder<> Builder(LI);
431 IRBuilder<> Builder(LI);
460 IRBuilder<> Builder(SI);
487 IRBuilder<> Builder(SI);
497 static void createCmpXchgInstFun(IRBuilder<> &Builder, Value *Addr,
525 static Value *performAtomicOp(AtomicRMWInst::BinOp Op, IRBuilder<> &Builder,
638 static PartwordMaskValues createMaskInstrs(IRBuilder<> &Builder, Instruction *I,
688 IRBuilder<> &Builder, Value *Loaded,
748 IRBuilder<> Builder(AI);
776 IRBuilder<> Builder(AI);
851 IRBuilder<> Builder(CI);
937 function_ref<Value *(IRBuilder<> &, Value *)> PerformOp) {
938 IRBuilder<> Builder(I);
947 IRBuilder<> Builder(AI);
974 IRBuilder<> Builder(CI);
1003 IRBuilder<> &Builder, Type *ResultTy, Value *Addr,
1005 function_ref<Value *(IRBuilder<> &, Value *)> PerformOp) {
1058 IRBuilder<> Builder(CI);
1180 IRBuilder<> Builder(CI);
1345 IRBuilder<> &Builder, Type *ResultTy, Value *Addr,
1347 function_ref<Value *(IRBuilder<> &, Value *)> PerformOp,
1432 IRBuilder<> Builder(AI);
1618 IRBuilder<> Builder(I);
1619 IRBuilder<> AllocaBuilder(&I->getFunction()->getEntryBlock().front());
lib/CodeGen/CodeGenPrepare.cpp 979 IRBuilder<> Builder(RelocatedBase->getNextNode());
1215 IRBuilder<> Builder(InsertPt);
1746 IRBuilder<> Builder(CountZeros->getContext());
2415 IRBuilder<> Builder(Opnd);
2441 IRBuilder<> Builder(InsertPt);
2467 IRBuilder<> Builder(InsertPt);
4761 IRBuilder<> Builder(MemoryInst);
5359 IRBuilder<> NewBaseBuilder(NewBaseInsertBB, NewBaseInsertPt);
5370 IRBuilder<> Builder(GEP);
5799 IRBuilder<> Builder(Load->getNextNode());
5921 IRBuilder<> Builder(Shift);
6725 IRBuilder<> Builder(SI.getContext());
lib/CodeGen/ExpandMemCmp.cpp 72 IRBuilder<> Builder;
lib/CodeGen/ExpandReductions.cpp 95 IRBuilder<> Builder(II);
96 IRBuilder<>::FastMathFlagGuard FMFGuard(Builder);
lib/CodeGen/HardwareLoops.cpp 371 IRBuilder<> Builder(BeginBB->getTerminator());
393 IRBuilder<> CondBuilder(ExitBranch);
415 IRBuilder<> CondBuilder(ExitBranch);
433 IRBuilder<> Builder(Header->getFirstNonPHI());
442 IRBuilder<> CondBuilder(ExitBranch);
lib/CodeGen/InterleavedAccessPass.cpp 404 IRBuilder<> Builder(Extracts[0]->getContext());
lib/CodeGen/InterleavedLoadCombinePass.cpp 1199 IRBuilder<> Builder(InsertionPoint);
lib/CodeGen/IntrinsicLowering.cpp 44 IRBuilder<> Builder(CI->getParent(), CI->getIterator());
67 IRBuilder<> Builder(IP);
166 IRBuilder<> Builder(IP);
198 IRBuilder<> Builder(IP);
235 IRBuilder<> Builder(CI);
lib/CodeGen/MachineOutliner.cpp 1126 IRBuilder<> Builder(EntryBB);
lib/CodeGen/PreISelIntrinsicLowering.cpp 43 IRBuilder<> B(CI);
83 IRBuilder<> Builder(CI->getParent(), CI->getIterator());
lib/CodeGen/SafeStack.cpp 146 Value *getStackGuard(IRBuilder<> &IRB, Function &F);
149 void checkStackGuard(IRBuilder<> &IRB, Function &F, ReturnInst &RI,
171 Value *moveStaticAllocasToUnsafeStack(IRBuilder<> &IRB, Function &F,
184 createStackRestorePoints(IRBuilder<> &IRB, Function &F,
369 Value *SafeStack::getStackGuard(IRBuilder<> &IRB, Function &F) {
427 SafeStack::createStackRestorePoints(IRBuilder<> &IRB, Function &F,
463 void SafeStack::checkStackGuard(IRBuilder<> &IRB, Function &F, ReturnInst &RI,
476 IRBuilder<> IRBFail(CheckTerm);
487 IRBuilder<> &IRB, Function &F, ArrayRef<AllocaInst *> StaticAllocas,
607 IRBuilder<> IRBUser(InsertBefore);
644 IRBuilder<> IRB(AI);
692 IRBuilder<> IRB(II);
698 IRBuilder<> IRB(II);
772 IRBuilder<> IRB(&F.front(), F.begin()->getFirstInsertionPt());
801 IRBuilder<> IRBRet(RI);
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp 137 IRBuilder<> Builder(CI->getContext());
275 IRBuilder<> Builder(CI->getContext());
398 IRBuilder<> Builder(CI->getContext());
525 IRBuilder<> Builder(CI->getContext());
607 IRBuilder<> Builder(CI->getContext());
718 IRBuilder<> Builder(CI->getContext());
lib/CodeGen/ShadowStackGCLowering.cpp 77 static GetElementPtrInst *CreateGEP(LLVMContext &Context, IRBuilder<> &B,
80 static GetElementPtrInst *CreateGEP(LLVMContext &Context, IRBuilder<> &B,
256 IRBuilder<> &B, Type *Ty,
271 IRBuilder<> &B, Type *Ty, Value *BasePtr,
305 IRBuilder<> AtEntry(IP->getParent(), IP);
351 while (IRBuilder<> *AtExit = EE.Next()) {
lib/CodeGen/SjLjEHPrepare.cpp 103 IRBuilder<> Builder(I);
161 IRBuilder<> Builder(SelI->getParent(), std::next(SelI->getIterator()));
184 IRBuilder<> Builder(LPI->getParent(),
207 IRBuilder<> Builder(EntryBB->getTerminator());
386 IRBuilder<> Builder(EntryBB->getTerminator());
lib/CodeGen/StackProtector.cpp 350 IRBuilder<> &B,
385 IRBuilder<> B(&F->getEntryBlock().front());
447 IRBuilder<> B(RI);
501 IRBuilder<> B(BB);
526 IRBuilder<> B(FailBB);
lib/CodeGen/TargetLoweringBase.cpp 1677 Value *TargetLoweringBase::getDefaultSafeStackPointerLocation(IRBuilder<> &IRB,
1709 Value *TargetLoweringBase::getSafeStackPointerLocation(IRBuilder<> &IRB) const {
1769 Value *TargetLoweringBase::getIRStackGuard(IRBuilder<> &IRB) const {
lib/CodeGen/WasmEHPrepare.cpp 143 IRBuilder<> IRB(M.getContext());
174 IRBuilder<> IRB(F.getContext());
203 IRBuilder<> IRB(F.getContext());
277 IRBuilder<> IRB(BB->getContext());
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 242 IRBuilder<> Builder(EntryBlock);
lib/ExecutionEngine/Orc/Speculation.cpp 82 IRBuilder<> Mutator(MContext);
lib/IR/AutoUpgrade.cpp 850 IRBuilder<> IRB(C);
870 static Value *UpgradeX86PSLLDQIntrinsics(IRBuilder<> &Builder,
904 static Value *UpgradeX86PSRLDQIntrinsics(IRBuilder<> &Builder, Value *Op,
936 static Value *getX86MaskVec(IRBuilder<> &Builder, Value *Mask,
956 static Value *EmitX86Select(IRBuilder<> &Builder, Value *Mask,
967 static Value *EmitX86ScalarSelect(IRBuilder<> &Builder, Value *Mask,
985 static Value *UpgradeX86ALIGNIntrinsics(IRBuilder<> &Builder, Value *Op0,
1031 static Value *UpgradeX86VPERMT2Intrinsics(IRBuilder<> &Builder, CallInst &CI,
1092 static Value *UpgradeX86AddSubSatIntrinsics(IRBuilder<> &Builder, CallInst &CI,
1112 static Value *upgradeX86Rotate(IRBuilder<> &Builder, CallInst &CI,
1139 static Value *upgradeX86vpcom(IRBuilder<> &Builder, CallInst &CI, unsigned Imm,
1178 static Value *upgradeX86ConcatShift(IRBuilder<> &Builder, CallInst &CI,
1212 static Value *UpgradeMaskedStore(IRBuilder<> &Builder,
1232 static Value *UpgradeMaskedLoad(IRBuilder<> &Builder,
1252 static Value *upgradeAbs(IRBuilder<> &Builder, CallInst &CI) {
1266 static Value *upgradeIntMinMax(IRBuilder<> &Builder, CallInst &CI,
1279 static Value *upgradePMULDQ(IRBuilder<> &Builder, CallInst &CI, bool IsSigned) {
1309 static Value *ApplyX86MaskOn1BitsVec(IRBuilder<> &Builder, Value *Vec,
1331 static Value *upgradeMaskedCompare(IRBuilder<> &Builder, CallInst &CI,
1361 static Value *UpgradeX86MaskedShift(IRBuilder<> &Builder, CallInst &CI,
1369 static Value* upgradeMaskedMove(IRBuilder<> &Builder, CallInst &CI) {
1384 static Value* UpgradeMaskToInt(IRBuilder<> &Builder, CallInst &CI) {
1393 static bool upgradeAVX512MaskToSelect(StringRef Name, IRBuilder<> &Builder,
1649 IRBuilder<> Builder(C);
3876 IRBuilder<> Builder(CI->getParent(), CI->getIterator());
lib/IR/Core.cpp 2988 return wrap(new IRBuilder<>(*unwrap(C)));
lib/IR/DIBuilder.cpp 897 static IRBuilder<> getIRBForDbgInsertion(const DILocation *DL,
900 IRBuilder<> B(DL->getContext());
936 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
958 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
976 IRBuilder<> B = getIRBForDbgInsertion(DL, InsertBB, InsertBefore);
lib/Target/AArch64/AArch64ISelLowering.cpp 8811 IRBuilder<> Builder(LI);
8937 IRBuilder<> Builder(SI);
12169 Value *AArch64TargetLowering::emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
12209 IRBuilder<> &Builder) const {
12214 Value *AArch64TargetLowering::emitStoreConditional(IRBuilder<> &Builder,
12260 static Value *UseTlsOffset(IRBuilder<> &IRB, unsigned Offset) {
12270 Value *AArch64TargetLowering::getIRStackGuard(IRBuilder<> &IRB) const {
12319 Value *AArch64TargetLowering::getSafeStackPointerLocation(IRBuilder<> &IRB) const {
lib/Target/AArch64/AArch64ISelLowering.h 417 Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
419 Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
422 void emitAtomicCmpXchgNoStoreLLBalance(IRBuilder<> &Builder) const override;
439 Value *getIRStackGuard(IRBuilder<> &IRB) const override;
447 Value *getSafeStackPointerLocation(IRBuilder<> &IRB) const override;
lib/Target/AArch64/AArch64PromoteConstant.cpp 495 IRBuilder<> Builder(IPI.first);
lib/Target/AArch64/AArch64StackTagging.cpp 111 IRBuilder<> IRB(SI);
120 IRBuilder<> IRB(MSI);
126 void applyMemSet(IRBuilder<> &IRB, int64_t Start, int64_t End,
155 Value *sliceValue(IRBuilder<> &IRB, Value *V, int64_t Offset) {
168 void applyStore(IRBuilder<> &IRB, int64_t Start, int64_t End,
182 void generate(IRBuilder<> &IRB) {
221 void emitZeroes(IRBuilder<> &IRB, uint64_t Offset, uint64_t Size) {
231 void emitUndef(IRBuilder<> &IRB, uint64_t Offset, uint64_t Size) {
240 void emitPair(IRBuilder<> &IRB, uint64_t Offset, Value *A, Value *B) {
249 Value *flatten(IRBuilder<> &IRB, Value *V) {
423 IRBuilder<> IRB(InsertBefore);
429 IRBuilder<> IRB(InsertBefore);
452 IRBuilder<> IRB(&PrologueBB->front());
620 IRBuilder<> IRB(Info.AI->getNextNode());
lib/Target/AArch64/AArch64TargetTransformInfo.cpp 807 IRBuilder<> Builder(Inst);
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp 49 Value *buildScan(IRBuilder<> &B, AtomicRMWInst::BinOp Op, Value *V,
51 Value *buildShiftRight(IRBuilder<> &B, Value *V, Value *const Identity) const;
245 static Value *buildNonAtomicBinOp(IRBuilder<> &B, AtomicRMWInst::BinOp Op,
282 Value *AMDGPUAtomicOptimizer::buildScan(IRBuilder<> &B, AtomicRMWInst::BinOp Op,
341 Value *AMDGPUAtomicOptimizer::buildShiftRight(IRBuilder<> &B, Value *V,
411 IRBuilder<> B(&I);
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp 83 Type *getI32Ty(IRBuilder<> &B, const Type *T) const;
154 Value* expandDivRem24(IRBuilder<> &Builder, BinaryOperator &I,
159 Value* expandDivRem32(IRBuilder<> &Builder, BinaryOperator &I,
210 Type *AMDGPUCodeGenPrepare::getI32Ty(IRBuilder<> &B, const Type *T) const {
293 IRBuilder<> Builder(&I);
334 IRBuilder<> Builder(&I);
361 IRBuilder<> Builder(&I);
393 IRBuilder<> Builder(&I);
435 static void extractValues(IRBuilder<> &Builder,
447 static Value *insertValues(IRBuilder<> &Builder,
475 IRBuilder<> Builder(&I);
566 IRBuilder<> Builder(FDiv.getParent(), std::next(FDiv.getIterator()), FPMath);
615 static std::pair<Value*, Value*> getMul64(IRBuilder<> &Builder,
629 static Value* getMulHu(IRBuilder<> &Builder, Value *LHS, Value *RHS) {
635 Value* AMDGPUCodeGenPrepare::expandDivRem24(IRBuilder<> &Builder,
739 Value* AMDGPUCodeGenPrepare::expandDivRem32(IRBuilder<> &Builder,
902 IRBuilder<> Builder(&I);
937 IRBuilder<> Builder(&I);
lib/Target/AMDGPU/AMDGPULibCalls.cpp 86 bool fold_recip(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
89 bool fold_divide(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
92 bool fold_pow(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
95 bool fold_rootn(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
98 bool fold_fma_mad(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
109 bool fold_exp(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
112 bool fold_exp2(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
115 bool fold_exp10(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
118 bool fold_log(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
121 bool fold_log2(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
124 bool fold_log10(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
127 bool fold_sqrt(CallInst *CI, IRBuilder<> &B, const FuncInfo &FInfo);
130 bool fold_sincos(CallInst * CI, IRBuilder<> &B, AliasAnalysis * AA);
133 bool fold_read_write_pipe(CallInst *CI, IRBuilder<> &B, FuncInfo &FInfo);
136 bool fold_wavefrontsize(CallInst *CI, IRBuilder<> &B);
141 AllocaInst* insertAlloca(CallInst * UI, IRBuilder<> &B, const char *prefix);
578 bool AMDGPULibCalls::fold_read_write_pipe(CallInst *CI, IRBuilder<> &B,
648 IRBuilder<> B(Context);
821 bool AMDGPULibCalls::fold_recip(CallInst *CI, IRBuilder<> &B,
839 bool AMDGPULibCalls::fold_divide(CallInst *CI, IRBuilder<> &B,
869 bool AMDGPULibCalls::fold_pow(CallInst *CI, IRBuilder<> &B,
1154 bool AMDGPULibCalls::fold_rootn(CallInst *CI, IRBuilder<> &B,
1208 bool AMDGPULibCalls::fold_fma_mad(CallInst *CI, IRBuilder<> &B,
1263 bool AMDGPULibCalls::fold_sqrt(CallInst *CI, IRBuilder<> &B,
1281 bool AMDGPULibCalls::fold_sincos(CallInst *CI, IRBuilder<> &B,
1381 bool AMDGPULibCalls::fold_wavefrontsize(CallInst *CI, IRBuilder<> &B) {
1414 AllocaInst* AMDGPULibCalls::insertAlloca(CallInst *UI, IRBuilder<> &B,
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp 73 IRBuilder<> Builder(&*EntryBlock.begin());
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp 151 IRBuilder<> Builder(Ctx);
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp 91 std::pair<Value *, Value *> getLocalSizeYZ(IRBuilder<> &Builder);
92 Value *getWorkitemID(IRBuilder<> &Builder, unsigned N);
181 AMDGPUPromoteAlloca::getLocalSizeYZ(IRBuilder<> &Builder) {
268 Value *AMDGPUPromoteAlloca::getWorkitemID(IRBuilder<> &Builder, unsigned N) {
422 IRBuilder<> Builder(Inst);
723 IRBuilder<> Builder(&I);
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp 386 IRBuilder<> B(RI);
444 IRBuilder<> B(StubBB);
lib/Target/ARM/ARMCodeGenPrepare.cpp 472 IRBuilder<> Builder{Ctx};
504 IRBuilder<> Builder{Ctx};
544 IRBuilder<> Builder{Ctx};
606 IRBuilder<> Builder{Ctx};
711 IRBuilder<> Builder{Ctx};
lib/Target/ARM/ARMISelLowering.cpp16401 Instruction* ARMTargetLowering::makeDMB(IRBuilder<> &Builder,
16431 Instruction *ARMTargetLowering::emitLeadingFence(IRBuilder<> &Builder,
16456 Instruction *ARMTargetLowering::emitTrailingFence(IRBuilder<> &Builder,
16606 Value *ARMTargetLowering::emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
16643 IRBuilder<> &Builder) const {
16650 Value *ARMTargetLowering::emitStoreConditional(IRBuilder<> &Builder, Value *Val,
16766 IRBuilder<> Builder(LI);
16898 IRBuilder<> Builder(SI);
lib/Target/ARM/ARMISelLowering.h 538 Instruction *makeDMB(IRBuilder<> &Builder, ARM_MB::MemBOpt Domain) const;
539 Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
541 Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
544 void emitAtomicCmpXchgNoStoreLLBalance(IRBuilder<> &Builder) const override;
546 Instruction *emitLeadingFence(IRBuilder<> &Builder, Instruction *Inst,
548 Instruction *emitTrailingFence(IRBuilder<> &Builder, Instruction *Inst,
lib/Target/ARM/ARMParallelDSP.cpp 643 IRBuilder<NoFolder> Builder(InsertAfter->getParent(),
670 IRBuilder<NoFolder> Builder(R.getRoot()->getParent());
765 IRBuilder<NoFolder> IRB(DomLoad->getParent(),
lib/Target/ARM/MVETailPredication.cpp 476 IRBuilder<> Builder(L->getHeader()->getFirstNonPHI());
lib/Target/Hexagon/HexagonGenExtract.cpp 209 IRBuilder<> IRB(In);
lib/Target/Hexagon/HexagonISelLowering.cpp 899 IRBuilder<> IRB(Ctx);
3239 Value *HexagonTargetLowering::emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
3262 Value *HexagonTargetLowering::emitStoreConditional(IRBuilder<> &Builder,
lib/Target/Hexagon/HexagonISelLowering.h 319 Value *emitLoadLinked(IRBuilder<> &Builder, Value *Addr,
321 Value *emitStoreConditional(IRBuilder<> &Builder, Value *Val,
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp 1374 IRBuilder<> IRB(LoopB);
1524 IRBuilder<> B(&*At);
1602 IRBuilder<> B(Ctx);
1621 IRBuilder<> B(Ctx);
1634 IRBuilder<> B(Ctx);
1642 IRBuilder<> B(Ctx);
1658 IRBuilder<> B(Ctx);
1698 IRBuilder<> B(Ctx);
1726 IRBuilder<> B(Ctx);
1756 IRBuilder<> B(Ctx);
2031 IRBuilder<> Builder(ExpPt);
2247 IRBuilder<> CondBuilder(MemmoveB);
lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp 634 IRBuilder<> IRB(BB);
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp 48 IRBuilder<> &Builder);
51 IRBuilder<> &Builder);
53 IRBuilder<> &Builder);
106 IRBuilder<> Builder(I->getEntryBlock().getFirstNonPHIOrDbg());
157 IRBuilder<> &Builder) {
196 Module *M, Function *F, Constant *C, IRBuilder<> &Builder) {
235 IRBuilder<> &Builder) {
lib/Target/PowerPC/PPCISelLowering.cpp10260 static Instruction* callIntrinsic(IRBuilder<> &Builder, Intrinsic::ID Id) {
10268 Instruction *PPCTargetLowering::emitLeadingFence(IRBuilder<> &Builder,
10278 Instruction *PPCTargetLowering::emitTrailingFence(IRBuilder<> &Builder,
lib/Target/PowerPC/PPCISelLowering.h 754 Instruction *emitLeadingFence(IRBuilder<> &Builder, Instruction *Inst,
756 Instruction *emitTrailingFence(IRBuilder<> &Builder, Instruction *Inst,
lib/Target/RISCV/RISCVISelLowering.cpp 2721 Instruction *RISCVTargetLowering::emitLeadingFence(IRBuilder<> &Builder,
2731 Instruction *RISCVTargetLowering::emitTrailingFence(IRBuilder<> &Builder,
2805 IRBuilder<> &Builder, AtomicRMWInst *AI, Value *AlignedAddr, Value *Incr,
2857 IRBuilder<> &Builder, AtomicCmpXchgInst *CI, Value *AlignedAddr,
lib/Target/RISCV/RISCVISelLowering.h 121 Instruction *emitLeadingFence(IRBuilder<> &Builder, Instruction *Inst,
123 Instruction *emitTrailingFence(IRBuilder<> &Builder, Instruction *Inst,
204 IRBuilder<> &Builder, AtomicRMWInst *AI, Value *AlignedAddr, Value *Incr,
209 emitMaskedAtomicCmpXchgIntrinsic(IRBuilder<> &Builder, AtomicCmpXchgInst *CI,
lib/Target/SystemZ/SystemZTDC.cpp 360 IRBuilder<> IRB(I);
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp 314 static GlobalVariable *getGlobalVariableI32(Module &M, IRBuilder<> &IRB,
386 IRBuilder<> IRB(C);
545 IRBuilder<> IRB(C);
628 IRBuilder<> IRB(C);
742 IRBuilder<> IRB(C);
876 IRBuilder<> IRB(C);
lib/Target/X86/X86ISelLowering.cpp 2291 static Constant* SegmentOffset(IRBuilder<> &IRB,
2298 Value *X86TargetLowering::getIRStackGuard(IRBuilder<> &IRB) const {
2359 Value *X86TargetLowering::getSafeStackPointerLocation(IRBuilder<> &IRB) const {
lib/Target/X86/X86ISelLowering.h 1190 Value *getIRStackGuard(IRBuilder<> &IRB) const override;
1204 Value *getSafeStackPointerLocation(IRBuilder<> &IRB) const override;
lib/Target/X86/X86InterleavedAccess.cpp 68 IRBuilder<> &Builder;
113 IRBuilder<> &B)
287 IRBuilder<> Builder) {
522 unsigned VecElems, IRBuilder<> Builder) {
816 IRBuilder<> Builder(LI);
842 IRBuilder<> Builder(SI);
lib/Target/X86/X86RetpolineThunks.cpp 215 IRBuilder<> Builder(Entry);
lib/Target/X86/X86WinEHState.cpp 60 void linkExceptionRegistration(IRBuilder<> &Builder, Function *Handler);
61 void unlinkExceptionRegistration(IRBuilder<> &Builder);
65 Value *emitEHLSDA(IRBuilder<> &Builder, Function *F);
70 void rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F, CallSite CS,
280 IRBuilder<> Builder(&F->getEntryBlock(), F->getEntryBlock().begin());
376 Value *WinEHStatePass::emitEHLSDA(IRBuilder<> &Builder, Function *F) {
409 IRBuilder<> Builder(EntryBB);
424 void WinEHStatePass::linkExceptionRegistration(IRBuilder<> &Builder,
442 void WinEHStatePass::unlinkExceptionRegistration(IRBuilder<> &Builder) {
462 void WinEHStatePass::rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F,
640 IRBuilder<> Builder(RegNode->getNextNode());
647 IRBuilder<> Builder(EHGuardNode->getNextNode());
782 IRBuilder<> Builder(CS.getInstruction());
796 IRBuilder<> Builder(IP);
lib/Target/XCore/XCoreLowerThreadLocal.cpp 78 IRBuilder<NoFolder> Builder(Instr);
207 IRBuilder<> Builder(Inst);
lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp 147 IRBuilder<> Builder(PhiBB, PhiBB->getFirstInsertionPt());
243 IRBuilder<> Builder(&I);
306 IRBuilder<> Builder(&I);
lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp 307 IRBuilder<> Builder(I);
366 IRBuilder<> Builder(CurrentTruncInst);
lib/Transforms/CFGuard/CFGuard.cpp 165 IRBuilder<> B(CB);
189 IRBuilder<> B(CB);
lib/Transforms/Coroutines/CoroCleanup.cpp 25 IRBuilder<> Builder;
40 static void lowerSubFn(IRBuilder<> &Builder, CoroSubFnInst *SubFn) {
lib/Transforms/Coroutines/CoroEarly.cpp 27 IRBuilder<> Builder;
lib/Transforms/Coroutines/CoroFrame.cpp 589 IRBuilder<> Builder(CB->getNextNode());
955 static void rewriteMaterializableInstructions(IRBuilder<> &IRB,
1098 IRBuilder<> Builder(AI);
1141 IRBuilder<> Builder(AI);
1163 static Value *emitGetSwiftErrorValue(IRBuilder<> &Builder, Type *ValueTy,
1178 static Value *emitSetSwiftErrorValue(IRBuilder<> &Builder, Value *V,
1200 IRBuilder<> Builder(Call);
1260 IRBuilder<> Builder(F.getEntryBlock().getFirstNonPHIOrDbg());
1357 IRBuilder<> Builder(F.getContext());
lib/Transforms/Coroutines/CoroInternal.h 226 Value *emitAlloc(IRBuilder<> &Builder, Value *Size, CallGraph *CG) const;
231 void emitDealloc(IRBuilder<> &Builder, Value *Ptr, CallGraph *CG) const;
lib/Transforms/Coroutines/CoroSplit.cpp 99 IRBuilder<> Builder;
160 static void maybeFreeRetconStorage(IRBuilder<> &Builder, coro::Shape &Shape,
175 IRBuilder<> Builder(End);
223 IRBuilder<> Builder(End);
280 IRBuilder<> Builder(NewEntry);
518 IRBuilder<> Builder(F.getEntryBlock().getFirstNonPHIOrDbg());
528 IRBuilder<> Builder(MappedOp);
846 IRBuilder<> Builder(Shape.FramePtr->getNextNode());
981 IRBuilder<> Builder(AllocInst);
1206 IRBuilder<> Builder(Id);
1262 IRBuilder<> Builder(ReturnBB);
lib/Transforms/Coroutines/Coroutines.cpp 498 Value *coro::Shape::emitAlloc(IRBuilder<> &Builder, Value *Size,
519 void coro::Shape::emitDealloc(IRBuilder<> &Builder, Value *Ptr,
lib/Transforms/IPO/ArgumentPromotion.cpp 247 IRBuilder<NoFolder> IRB(Call);
lib/Transforms/IPO/CrossDSOCFI.cpp 130 IRBuilder<> IRBFail(TrapBB);
137 IRBuilder<> IRBExit(ExitBB);
140 IRBuilder<> IRB(BB);
145 IRBuilder<> IRBTest(TestBB);
lib/Transforms/IPO/LowerTypeTests.cpp 454 Value *createBitSetTest(IRBuilder<> &B, const TypeIdLowering &TIL,
576 static Value *createMaskedBitTest(IRBuilder<> &B, Value *Bits,
660 Value *LowerTypeTestsModule::createBitSetTest(IRBuilder<> &B,
740 IRBuilder<> B(CI);
793 IRBuilder<> ThenB(CI);
797 IRBuilder<> ThenB(SplitBlockAndInsertIfThen(OffsetInRange, CI, false));
1269 IRBuilder<> IRB(WeakInitializerFn->getEntryBlock().getTerminator());
1385 IRBuilder<> IRB(BB);
lib/Transforms/IPO/MergeFunctions.cpp 483 static Value *createCast(IRBuilder<> &Builder, Value *V, Type *DestTy) {
703 IRBuilder<> Builder(BB);
lib/Transforms/IPO/WholeProgramDevirt.cpp 1117 IRBuilder<> IRB(CS.getInstruction());
1302 IRBuilder<> B(Call.CS.getInstruction());
1371 IRBuilder<> B(Call.CS.getInstruction());
1628 IRBuilder<> LoadB(
1640 IRBuilder<> CallB((Preds.size() == 1 && !HasNonCallUses) ? Preds[0] : CI);
1654 IRBuilder<> B(CI);
lib/Transforms/InstCombine/InstCombineCompares.cpp 618 static void setInsertionPoint(IRBuilder<> &Builder, Value *V,
669 IRBuilder<> Builder(Base->getContext());
lib/Transforms/InstCombine/InstCombineInternal.h 309 using BuilderTy = IRBuilder<TargetFolder, IRBuilderCallbackInserter>;
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp 153 IRBuilder<>::FastMathFlagGuard FMFGuard(Builder);
163 IRBuilder<>::FastMathFlagGuard FMFGuard(Builder);
1256 IRBuilder<> B(&I);
1257 IRBuilder<>::FastMathFlagGuard FMFGuard(B);
lib/Transforms/InstCombine/InstCombineSelect.cpp 2314 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
2332 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
2453 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
lib/Transforms/InstCombine/InstructionCombining.cpp 3517 IRBuilder<TargetFolder, IRBuilderCallbackInserter> Builder(
lib/Transforms/Instrumentation/AddressSanitizer.cpp 634 Value *createSlowPathCmp(IRBuilder<> &IRB, Value *AddrLong,
640 Value *memToShadow(Value *Shadow, IRBuilder<> &IRB);
769 bool InstrumentGlobals(IRBuilder<> &IRB, Module &M, bool *CtorComdat);
770 void InstrumentGlobalsCOFF(IRBuilder<> &IRB, Module &M,
773 void InstrumentGlobalsELF(IRBuilder<> &IRB, Module &M,
777 void InstrumentGlobalsMachO(IRBuilder<> &IRB, Module &M,
781 InstrumentGlobalsWithMetadataArray(IRBuilder<> &IRB, Module &M,
789 IRBuilder<> CreateAsanModuleDtor(Module &M);
975 IRBuilder<> IRB(InstBefore);
1095 IRBuilder<> &IRB, Value *ShadowBase);
1097 size_t Begin, size_t End, IRBuilder<> &IRB,
1101 size_t End, IRBuilder<> &IRB, Value *ShadowBase);
1103 void poisonAlloca(Value *V, uint64_t Size, IRBuilder<> &IRB, bool DoPoison);
1105 Value *createAllocaForLayout(IRBuilder<> &IRB, const ASanStackFrameLayout &L,
1107 PHINode *createPHI(IRBuilder<> &IRB, Value *Cond, Value *ValueIfTrue,
1284 Value *AddressSanitizer::memToShadow(Value *Shadow, IRBuilder<> &IRB) {
1302 IRBuilder<> IRB(MI);
1481 IRBuilder<> IRB(I);
1532 IRBuilder<> IRB(I);
1538 IRBuilder<> IRB(InsertBefore);
1612 IRBuilder<> IRB(InsertBefore);
1638 Value *AddressSanitizer::createSlowPathCmp(IRBuilder<> &IRB, Value *AddrLong,
1663 IRBuilder<> IRB(InsertBefore);
1741 IRBuilder<> IRB(InsertBefore);
1763 IRBuilder<> IRB(&GlobalInit.front(),
1949 IRBuilder<> IRB(*C);
2030 IRBuilder<> ModuleAddressSanitizer::CreateAsanModuleDtor(Module &M) {
2040 IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
2064 IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
2115 IRBuilder<> IRB_Dtor = CreateAsanModuleDtor(M);
2123 IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
2174 IRBuilder<> IRB_Dtor = CreateAsanModuleDtor(M);
2180 IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
2202 IRBuilder<> IRB_Dtor = CreateAsanModuleDtor(M);
2213 bool ModuleAddressSanitizer::InstrumentGlobals(IRBuilder<> &IRB, Module &M,
2444 IRBuilder<> IRB(AsanCtorFunction->getEntryBlock().getTerminator());
2470 IRBuilder<> IRB(*C);
2549 IRBuilder<> IRB(&F.front(), F.front().begin());
2561 IRBuilder<> IRB(&F.front().front());
2729 IRBuilder<> IRB(CI);
2760 IRBuilder<> IRB(*C);
2793 IRBuilder<> &IRB,
2844 IRBuilder<> &IRB, Value *ShadowBase) {
2851 IRBuilder<> &IRB, Value *ShadowBase) {
2896 IRBuilder<> IRB(CopyInsertPoint);
2918 PHINode *FunctionStackPoisoner::createPHI(IRBuilder<> &IRB, Value *Cond,
2931 IRBuilder<> &IRB, const ASanStackFrameLayout &L, bool Dynamic) {
2950 IRBuilder<> IRB(dyn_cast<Instruction>(FirstBB.begin()));
2969 IRBuilder<> IRB(APC.InsBefore);
2995 IRBuilder<> IRB(InsBefore);
3090 IRBuilder<> IRBIf(Term);
3176 IRBuilder<> IRB(APC.InsBefore);
3188 IRBuilder<> IRBRet(Ret);
3209 IRBuilder<> IRBPoison(ThenTerm);
3231 IRBuilder<> IRBElse(ElseTerm);
3243 IRBuilder<> &IRB, bool DoPoison) {
3261 IRBuilder<> IRB(AI);
lib/Transforms/Instrumentation/BoundsChecking.cpp 47 using BuilderTy = IRBuilder<TargetFolder>;
184 IRBuilder<>::InsertPointGuard Guard(IRB);
lib/Transforms/Instrumentation/ControlHeightReduction.cpp 390 IRBuilder<> &IRB,
394 IRBuilder<> &IRB,
399 IRBuilder<> &IRB,
1848 IRBuilder<> IRB(PreEntryBlock->getTerminator());
1883 IRBuilder<> &IRB,
1927 IRBuilder<> &IRB,
1954 IRBuilder<> &IRB,
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 983 IRBuilder<> IRB(Pos);
987 IRBuilder<> ThenIRB(BI);
1002 IRBuilder<> IRB(&F->getEntryBlock().front());
1012 IRBuilder<> IRB(&F->getEntryBlock().front());
1018 IRBuilder<> IRB(Pos);
1037 IRBuilder<> IRB(ArgTLSPos);
1068 IRBuilder<> IRB(Pos);
1117 IRBuilder<> IRB(Pos);
1131 IRBuilder<> ThenIRB(BI);
1188 IRBuilder<> IRB(Pos);
1219 IRBuilder<> IRB(Pos);
1232 IRBuilder<> FallbackIRB(FallbackBB);
1240 IRBuilder<> IRB(Pos);
1274 IRBuilder<> NextIRB(NextBB);
1292 IRBuilder<> IRB(Pos);
1315 IRBuilder<> IRB(&LI);
1332 IRBuilder<> IRB(Pos);
1339 IRBuilder<> IRB(Pos);
1453 IRBuilder<> IRB(&I);
1482 IRBuilder<> IRB(&I);
1491 IRBuilder<> IRB(&I);
1517 IRBuilder<> IRB(&RI);
1522 IRBuilder<> IRB(&RI);
1547 IRBuilder<> IRB(CS.getInstruction());
1697 IRBuilder<> NextIRB(Next);
lib/Transforms/Instrumentation/GCOVProfiling.cpp 656 IRBuilder<> Builder(I);
815 IRBuilder<> BuilderForPhi(&*BB.begin());
828 IRBuilder<> Builder(&*BB.getFirstInsertionPt());
864 IRBuilder<> Builder(BB);
953 IRBuilder<> Builder(BB);
1209 IRBuilder<> Builder(Entry);
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 203 Value *getDynamicShadowIfunc(IRBuilder<> &IRB);
204 Value *getDynamicShadowNonTls(IRBuilder<> &IRB);
208 Value *memToShadow(Value *Shadow, IRBuilder<> &IRB);
219 bool tagAlloca(IRBuilder<> &IRB, AllocaInst *AI, Value *Tag, size_t Size);
220 Value *tagPointer(IRBuilder<> &IRB, Type *Ty, Value *PtrLong, Value *Tag);
221 Value *untagPointer(IRBuilder<> &IRB, Value *PtrLong);
226 Value *readRegister(IRBuilder<> &IRB, StringRef Name);
228 Value *getNextTagWithCall(IRBuilder<> &IRB);
229 Value *getStackBaseTag(IRBuilder<> &IRB);
230 Value *getAllocaTag(IRBuilder<> &IRB, Value *StackTag, AllocaInst *AI,
232 Value *getUARTag(IRBuilder<> &IRB, Value *StackTag);
234 Value *getHwasanThreadSlotPtr(IRBuilder<> &IRB, Type *Ty);
235 void emitPrologue(IRBuilder<> &IRB, bool WithFrameRecord);
372 IRBuilder<> IRB(*C);
435 IRBuilder<> IRB(*C);
481 Value *HWAddressSanitizer::getDynamicShadowIfunc(IRBuilder<> &IRB) {
491 Value *HWAddressSanitizer::getDynamicShadowNonTls(IRBuilder<> &IRB) {
587 IRBuilder<> IRB(I);
601 Value *HWAddressSanitizer::memToShadow(Value *Mem, IRBuilder<> &IRB) {
614 IRBuilder<> IRB(InsertBefore);
702 IRBuilder<> IRB(MI);
740 IRBuilder<> IRB(I);
774 bool HWAddressSanitizer::tagAlloca(IRBuilder<> &IRB, AllocaInst *AI,
826 Value *HWAddressSanitizer::getNextTagWithCall(IRBuilder<> &IRB) {
830 Value *HWAddressSanitizer::getStackBaseTag(IRBuilder<> &IRB) {
854 Value *HWAddressSanitizer::getAllocaTag(IRBuilder<> &IRB, Value *StackTag,
862 Value *HWAddressSanitizer::getUARTag(IRBuilder<> &IRB, Value *StackTag) {
871 Value *HWAddressSanitizer::tagPointer(IRBuilder<> &IRB, Type *Ty,
889 Value *HWAddressSanitizer::untagPointer(IRBuilder<> &IRB, Value *PtrLong) {
903 Value *HWAddressSanitizer::getHwasanThreadSlotPtr(IRBuilder<> &IRB, Type *Ty) {
923 void HWAddressSanitizer::emitPrologue(IRBuilder<> &IRB, bool WithFrameRecord) {
1020 Value *HWAddressSanitizer::readRegister(IRBuilder<> &IRB, StringRef Name) {
1032 IRBuilder<> IRB(LP->getNextNode());
1052 IRBuilder<> IRB(AI->getNextNode());
1166 IRBuilder<> EntryIRB(InsertPt);
1481 IRBuilder<> IRB(BB);
lib/Transforms/Instrumentation/InstrOrderFile.cpp 127 IRBuilder<> entryB(NewEntry);
131 IRBuilder<> updateB(UpdateOrderFileBB);
lib/Transforms/Instrumentation/InstrProfiling.cpp 204 IRBuilder<> Builder(InsertPos);
608 IRBuilder<> Builder(Ind);
638 IRBuilder<> Builder(Inc);
961 IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
1007 IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", User));
1043 IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", F));
lib/Transforms/Instrumentation/MemorySanitizer.cpp 691 IRBuilder<> IRB(*C);
758 IRBuilder<> IRB(*C);
821 IRBuilder<> IRB(*C);
939 IRBuilder<> IRB(*C);
984 virtual void visitCallSite(CallSite &CS, IRBuilder<> &IRB) = 0;
1073 Value *updateOrigin(Value *V, IRBuilder<> &IRB) {
1078 Value *originToIntptr(IRBuilder<> &IRB, Value *Origin) {
1088 void paintOrigin(IRBuilder<> &IRB, Value *Origin, Value *OriginPtr,
1119 void storeOrigin(IRBuilder<> &IRB, Value *Addr, Value *Shadow, Value *Origin,
1152 IRBuilder<> IRBNew(CheckTerm);
1161 IRBuilder<> IRB(SI);
1186 void insertWarningFn(IRBuilder<> &IRB, Value *Origin) {
1205 IRBuilder<> IRB(OrigIns);
1255 IRBuilder<> IRB(F.getEntryBlock().getFirstNonPHI());
1375 Value *convertToShadowTyNoVec(Value *V, IRBuilder<> &IRB) {
1386 Value *getShadowPtrOffset(Value *Addr, IRBuilder<> &IRB) {
1407 IRBuilder<> &IRB,
1439 getShadowOriginPtrKernel(Value *Addr, IRBuilder<> &IRB, Type *ShadowTy,
1463 std::pair<Value *, Value *> getShadowOriginPtr(Value *Addr, IRBuilder<> &IRB,
1478 Value *getShadowPtrForArgument(Value *A, IRBuilder<> &IRB,
1488 Value *getOriginPtrForArgument(Value *A, IRBuilder<> &IRB,
1500 Value *getShadowPtrForRetval(Value *A, IRBuilder<> &IRB) {
1507 Value *getOriginPtrForRetval(IRBuilder<> &IRB) {
1603 IRBuilder<> EntryIRB(ActualFnStart->getFirstNonPHI());
1782 IRBuilder<> IRB(I.getNextNode());
1826 IRBuilder<> IRB(&I);
1860 IRBuilder<> IRB(&I);
1868 IRBuilder<> IRB(&I);
1876 IRBuilder<> IRB(&I);
1884 IRBuilder<> IRB(&I);
1890 IRBuilder<> IRB(&I);
1896 IRBuilder<> IRB(&I);
1908 IRBuilder<> IRB(&I);
1914 IRBuilder<> IRB(&I);
1921 IRBuilder<> IRB(&I);
1940 IRBuilder<> IRB(&I);
1962 IRBuilder<> IRB(&I);
2002 IRBuilder<> &IRB;
2006 Combiner(MemorySanitizerVisitor *MSV, IRBuilder<> &IRB)
2067 IRBuilder<> IRB(&I);
2084 Value *CreateShadowCast(IRBuilder<> &IRB, Value *V, Type *dstTy,
2105 Value *CreateAppToShadowCast(IRBuilder<> &IRB, Value *V) {
2117 IRBuilder<> IRB(&I);
2164 IRBuilder<> IRB(&I);
2189 IRBuilder<> IRB(&I);
2211 IRBuilder<> IRB(&I);
2246 Value *getLowestPossibleValue(IRBuilder<> &IRB, Value *A, Value *Sa,
2263 Value *getHighestPossibleValue(IRBuilder<> &IRB, Value *A, Value *Sa,
2284 IRBuilder<> IRB(&I);
2334 IRBuilder<> IRB(&I);
2378 IRBuilder<> IRB(&I);
2406 IRBuilder<> IRB(&I);
2420 IRBuilder<> IRB(&I);
2431 IRBuilder<> IRB(&I);
2453 IRBuilder<> IRB(&I);
2477 IRBuilder<> IRB(&I);
2527 IRBuilder<> IRB(&I);
2593 IRBuilder<> IRB(&I);
2618 IRBuilder<> IRB(&I);
2682 Value *Lower64ShadowExtend(IRBuilder<> &IRB, Value *S, Type *T) {
2692 Value *LowerElementShadowExtend(IRBuilder<> &IRB, Value *S, Type *T) {
2698 Value *VariableShadowExtend(IRBuilder<> &IRB, Value *S) {
2714 IRBuilder<> IRB(&I);
2780 IRBuilder<> IRB(&I);
2821 IRBuilder<> IRB(&I);
2837 IRBuilder<> IRB(&I);
2851 IRBuilder<> IRB(&I);
2864 IRBuilder<> IRB(&I);
2872 IRBuilder<> IRB(&I);
2889 IRBuilder<> IRB(&I);
2907 IRBuilder<> IRB(&I);
2937 IRBuilder<> IRB(&I);
2992 IRBuilder<> IRB(&I);
3290 IRBuilder<> IRB(&I);
3355 IRBuilder<> IRBBefore(&I);
3379 IRBuilder<> IRBAfter(&*NextInsn);
3400 IRBuilder<> IRB(&I);
3419 IRBuilder<> IRB(&I);
3447 void poisonAllocaUserspace(AllocaInst &I, IRBuilder<> &IRB, Value *Len) {
3469 void poisonAllocaKmsan(AllocaInst &I, IRBuilder<> &IRB, Value *Len) {
3484 IRBuilder<> IRB(InsPoint->getNextNode());
3506 IRBuilder<> IRB(&I);
3579 IRBuilder<> IRB(&I);
3591 IRBuilder<> IRB(&I);
3627 void instrumentAsmArgument(Value *Operand, Instruction &I, IRBuilder<> &IRB,
3694 IRBuilder<> IRB(&I);
3788 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
3884 Value *getShadowPtrForVAArgument(Type *Ty, IRBuilder<> &IRB,
3896 Value *getOriginPtrForVAArgument(Type *Ty, IRBuilder<> &IRB, int ArgOffset) {
3907 IRBuilder<> IRB(&I);
3941 IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI());
3959 IRBuilder<> IRB(OrigInst->getNextNode());
4017 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
4048 Value *getShadowPtrForVAArgument(Type *Ty, IRBuilder<> &IRB,
4060 IRBuilder<> IRB(&I);
4072 IRBuilder<> IRB(&I);
4086 IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI());
4102 IRBuilder<> IRB(OrigInst->getNextNode());
4166 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
4217 Value *getShadowPtrForVAArgument(Type *Ty, IRBuilder<> &IRB,
4229 IRBuilder<> IRB(&I);
4241 IRBuilder<> IRB(&I);
4253 Value* getVAField64(IRBuilder<> &IRB, Value *VAListTag, int offset) {
4263 Value* getVAField32(IRBuilder<> &IRB, Value *VAListTag, int offset) {
4279 IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI());
4296 IRBuilder<> IRB(OrigInst->getNextNode());
4393 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {
4484 Value *getShadowPtrForVAArgument(Type *Ty, IRBuilder<> &IRB,
4496 IRBuilder<> IRB(&I);
4508 IRBuilder<> IRB(&I);
4523 IRBuilder<> IRB(MSV.ActualFnStart->getFirstNonPHI());
4539 IRBuilder<> IRB(OrigInst->getNextNode());
4563 void visitCallSite(CallSite &CS, IRBuilder<> &IRB) override {}
lib/Transforms/Instrumentation/PGOInstrumentation.cpp 821 IRBuilder<> Builder(InstrBB, InstrBB->getFirstInsertionPt());
851 IRBuilder<> Builder(Cand.InsertPt);
1349 IRBuilder<> Builder(&SI);
lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp 353 IRBuilder<> IRB(BB);
383 IRBuilder<> IRBCase(CaseBB);
lib/Transforms/Instrumentation/PoisonChecking.cpp 91 static Value *buildOrChain(IRBuilder<> &B, ArrayRef<Value*> Ops) {
109 IRBuilder<> B(&I);
186 IRBuilder<> B(&I);
237 static void CreateAssert(IRBuilder<> &B, Value *Cond) {
251 static void CreateAssertNot(IRBuilder<> &B, Value *Cond) {
277 IRBuilder<> B(cast<Instruction>(&I));
lib/Transforms/Instrumentation/SanitizerCoverage.cpp 313 IRBuilder<> IRB(M.getContext());
373 IRBuilder<> IRB(*C);
468 IRBuilder<> IRBCtor(Ctor->getEntryBlock().getTerminator());
672 IRBuilder<> IRB(&*F.getEntryBlock().getFirstInsertionPt());
731 IRBuilder<> IRB(I);
748 IRBuilder<> IRB(I);
786 IRBuilder<> IRB(BO);
804 IRBuilder<> IRB(GEP);
816 IRBuilder<> IRB(ICMP);
864 IRBuilder<> IRB(&*IP);
900 IRBuilder<> ThenIRB(ThenTerm);
lib/Transforms/Instrumentation/ThreadSanitizer.cpp 203 IRBuilder<> IRB(M.getContext());
429 IRBuilder<> IRB(F.getEntryBlock().getFirstNonPHI());
432 while (IRBuilder<> *AtExit = EE.Next()) {
503 IRBuilder<> IRB(F.getEntryBlock().getFirstNonPHI());
510 while (IRBuilder<> *AtExit = EE.Next()) {
520 IRBuilder<> IRB(I);
575 static ConstantInt *createOrdering(IRBuilder<> *IRB, AtomicOrdering ord) {
601 IRBuilder<> IRB(I);
629 IRBuilder<> IRB(I);
lib/Transforms/Scalar/ADCE.cpp 663 IRBuilder<> Builder(PredTerm);
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp 495 IRBuilder<> B(WO);
642 IRBuilder<> B{Instr};
lib/Transforms/Scalar/Float2Int.cpp 461 IRBuilder<> IRB(I);
lib/Transforms/Scalar/IndVarSimplify.cpp 1073 IRBuilder<> Builder(Use);
1133 IRBuilder<> Builder(NarrowUse);
1225 IRBuilder<> Builder(NarrowUse);
1350 IRBuilder<> Builder(InsertPt);
1390 IRBuilder<> Builder(InsertPt);
1506 IRBuilder<> Builder(NarrowUse);
1566 IRBuilder<> Builder(&*WidePhi->getParent()->getFirstInsertionPt());
1595 IRBuilder<> Builder(DU.NarrowUse);
2486 IRBuilder<> Builder(BI);
2937 IRBuilder<> B(L->getLoopPreheader()->getTerminator());
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp 931 IRBuilder<> B(Preheader->getTerminator());
998 IRBuilder<> B(Preheader->getTerminator());
1264 IRBuilder<> B(PreheaderJump);
1844 IRBuilder<> B(ExprInsertPt);
lib/Transforms/Scalar/InferAddressSpaces.cpp 788 IRBuilder<> B(MI);
lib/Transforms/Scalar/LoopDataPrefetch.cpp 312 IRBuilder<> Builder(MemI);
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 959 IRBuilder<> Builder(Preheader->getTerminator());
1079 IRBuilder<> Builder(Preheader->getTerminator());
1634 static CallInst *createPopcntIntrinsic(IRBuilder<> &IRBuilder, Value *Val,
1647 static CallInst *createFFSIntrinsic(IRBuilder<> &IRBuilder, Value *Val,
1699 IRBuilder<> Builder(PreheaderBr);
1795 IRBuilder<> Builder(PreCondBr);
2353 IRBuilder<> Builder(NewBB);
2444 IRBuilder<> Builder(PhonySuccessorBB);
2553 IRBuilder<> Builder(OldTerminator);
2597 IRBuilder<> Builder(CurLoop->getLoopPreheader()->getTerminator());
lib/Transforms/Scalar/LoopPredication.cpp 397 IRBuilder<> Builder(Guard);
407 IRBuilder<> Builder(findInsertPt(Guard, {LHSV, RHSV}));
596 IRBuilder<> Builder(findInsertPt(Guard, {FirstIterationCheck, LimitCheck}));
644 IRBuilder<> Builder(findInsertPt(Guard, {FirstIterationCheck, LimitCheck}));
796 IRBuilder<> Builder(findInsertPt(Guard, Checks));
822 IRBuilder<> Builder(findInsertPt(BI, Checks));
lib/Transforms/Scalar/LoopSimplifyCFG.cpp 358 IRBuilder<> Builder(Preheader->getTerminator());
510 IRBuilder<> Builder(BB->getContext());
lib/Transforms/Scalar/LoopStrengthReduce.cpp 3210 IRBuilder<> Builder(InsertPt);
3230 IRBuilder<> Builder(L->getLoopLatch()->getTerminator());
lib/Transforms/Scalar/LowerAtomic.cpp 24 IRBuilder<> Builder(CXI);
43 IRBuilder<> Builder(RMWI);
lib/Transforms/Scalar/MakeGuardsExplicit.cpp 67 IRBuilder<> B(ExplicitGuard);
lib/Transforms/Scalar/MemCpyOptimizer.cpp 373 IRBuilder<> Builder(&*BI);
591 IRBuilder<> Builder(P);
688 IRBuilder<> Builder(SI);
983 IRBuilder<> Builder(M);
1042 IRBuilder<> Builder(MemCpy);
1127 IRBuilder<> Builder(MemCpy);
1154 IRBuilder<> Builder(M);
lib/Transforms/Scalar/MergeICmps.cpp 618 IRBuilder<> Builder(BB);
lib/Transforms/Scalar/NaryReassociate.cpp 393 IRBuilder<> Builder(GEP);
lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp 56 IRBuilder<> Builder(JoinBB, JoinBB->begin());
lib/Transforms/Scalar/Reassociate.cpp 1723 static Value *buildMultiplyTree(IRBuilder<> &Builder,
1746 ReassociatePass::buildMinimalMultiplyDAG(IRBuilder<> &Builder,
1817 IRBuilder<> Builder(I);
2037 IRBuilder<> Builder(I);
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp 1272 IRBuilder<> Builder) {
1425 IRBuilder<> Builder(Call);
1647 IRBuilder<> Builder(Relocate->getNextNode());
2619 IRBuilder<> B(&I);
lib/Transforms/Scalar/SROA.cpp 150 using IRBuilderTy = IRBuilder<ConstantFolder, IRBuilderPrefixedInserter>;
lib/Transforms/Scalar/Scalarizer.cpp 106 Value *operator()(IRBuilder<> &Builder, Value *Op0, Value *Op1,
119 Value *operator()(IRBuilder<> &Builder, Value *Op0, Value *Op1,
132 Value *operator()(IRBuilder<> &Builder, Value *Op, const Twine &Name) const {
144 Value *operator()(IRBuilder<> &Builder, Value *Op0, Value *Op1,
260 IRBuilder<> Builder(BB, BBI);
447 IRBuilder<> Builder(&I);
467 IRBuilder<> Builder(&I);
531 IRBuilder<> Builder(&CI);
558 IRBuilder<> Builder(&SI);
603 IRBuilder<> Builder(&GEPI);
650 IRBuilder<> Builder(&CI);
670 IRBuilder<> Builder(&BCI);
747 IRBuilder<> Builder(&PHI);
778 IRBuilder<> Builder(&LI);
804 IRBuilder<> Builder(&SI);
839 IRBuilder<> Builder(Op);
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp 815 IRBuilder<> Builder(Variadic);
887 IRBuilder<> Builder(Variadic);
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp 182 IRBuilder<> IRB(&BB);
lib/Transforms/Scalar/SpeculateAroundPHIs.cpp 700 IRBuilder<> IRB(SpecPNs[0]);
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp 228 IRBuilder<> &Builder, const DataLayout *DL,
572 IRBuilder<> &Builder,
636 IRBuilder<> Builder(C.Ins);
lib/Transforms/Utils/BuildLibCalls.cpp 822 Value *llvm::castToCStr(Value *V, IRBuilder<> &B) {
829 ArrayRef<Value *> Operands, IRBuilder<> &B,
847 Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL,
854 Value *llvm::emitStrDup(Value *Ptr, IRBuilder<> &B,
860 Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B,
868 Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
877 Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B,
884 Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilder<> &B,
891 Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
898 Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B,
906 IRBuilder<> &B, const DataLayout &DL,
929 Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B,
938 Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
947 Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B,
957 IRBuilder<> &B, const TargetLibraryInfo *TLI) {
965 ArrayRef<Value *> VariadicArgs, IRBuilder<> &B,
975 ArrayRef<Value *> VariadicArgs, IRBuilder<> &B,
984 Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilder<> &B,
991 Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
998 Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
1005 Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilder<> &B,
1013 IRBuilder<> &B, const TargetLibraryInfo *TLI) {
1021 IRBuilder<> &B, const TargetLibraryInfo *TLI) {
1043 IRBuilder<> &B,
1065 Value *llvm::emitUnaryFloatFnCall(Value *Op, StringRef Name, IRBuilder<> &B,
1075 LibFunc LongDoubleFn, IRBuilder<> &B,
1085 StringRef Name, IRBuilder<> &B,
1108 IRBuilder<> &B, const AttributeList &Attrs) {
1120 LibFunc LongDoubleFn, IRBuilder<> &B,
1129 Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B,
1152 Value *llvm::emitPutS(Value *Str, IRBuilder<> &B,
1169 Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B,
1190 Value *llvm::emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B,
1210 Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B,
1229 Value *llvm::emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B,
1248 Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B,
1272 Value *llvm::emitMalloc(Value *Num, IRBuilder<> &B, const DataLayout &DL,
1293 IRBuilder<> &B, const TargetLibraryInfo &TLI) {
1314 IRBuilder<> &B, const DataLayout &DL,
1336 Value *llvm::emitFGetCUnlocked(Value *File, IRBuilder<> &B,
1356 IRBuilder<> &B, const TargetLibraryInfo *TLI) {
1376 IRBuilder<> &B, const DataLayout &DL,
lib/Transforms/Utils/BypassSlowDivision.cpp 266 IRBuilder<> Builder(DivRemPair.BB, DivRemPair.BB->begin());
289 IRBuilder<> Builder(DivRemPair.BB, DivRemPair.BB->begin());
314 IRBuilder<> Builder(PhiBB, PhiBB->begin());
330 IRBuilder<> Builder(MainBB, MainBB->end());
373 IRBuilder<> Builder(SlowDivOrRem);
421 IRBuilder<> Builder(MainBB, MainBB->end());
438 IRBuilder<> Builder(MainBB, MainBB->end());
lib/Transforms/Utils/CallPromotionUtils.cpp 105 BasicBlock *MergeBlock, IRBuilder<> &Builder) {
259 IRBuilder<> Builder(CS.getInstruction());
lib/Transforms/Utils/EscapeEnumerator.cpp 29 IRBuilder<> *EscapeEnumerator::Next() {
lib/Transforms/Utils/FlattenCFG.cpp 40 bool FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder);
45 bool MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder);
136 bool FlattenCFGOpt::FlattenParallelAndOr(BasicBlock *BB, IRBuilder<> &Builder) {
283 IRBuilder<>::InsertPointGuard Guard(Builder);
398 bool FlattenCFGOpt::MergeIfRegion(BasicBlock *BB, IRBuilder<> &Builder) {
489 IRBuilder<> Builder(BB);
lib/Transforms/Utils/GuardUtils.cpp 51 IRBuilder<> B(DeoptBlockTerm);
lib/Transforms/Utils/InlineFunction.cpp 1250 IRBuilder<> Builder(InsertBlock, InsertBlock->begin());
1957 IRBuilder<> builder(&FirstNewBlock->front());
2155 IRBuilder<> Builder(CurBB);
2199 IRBuilder<> Builder(CurBB);
lib/Transforms/Utils/IntegerDivision.cpp 34 IRBuilder<> &Builder) {
80 IRBuilder<> &Builder) {
104 IRBuilder<> &Builder) {
151 IRBuilder<> &Builder) {
380 IRBuilder<> Builder(Rem);
438 IRBuilder<> Builder(Div);
503 IRBuilder<> Builder(Rem);
551 IRBuilder<> Builder(Rem);
600 IRBuilder<> Builder(Div);
649 IRBuilder<> Builder(Div);
lib/Transforms/Utils/LibCallsShrinkWrap.cpp 105 IRBuilder<> BBBuilder(CI);
113 Value *createCond(IRBuilder<> &BBBuilder, Value *Arg, CmpInst::Predicate Cmp,
123 IRBuilder<> BBBuilder(CI);
429 IRBuilder<> BBBuilder(CI);
lib/Transforms/Utils/Local.cpp 113 IRBuilder<> Builder(T);
lib/Transforms/Utils/LoopUnrollRuntime.cpp 149 IRBuilder<> B(InsertPt);
271 IRBuilder<> B(InsertPt);
353 IRBuilder<> Builder(LatchBR);
717 IRBuilder<> B(PreHeaderBR);
894 IRBuilder<> B2(NewPreHeader->getTerminator());
lib/Transforms/Utils/LoopUtils.cpp 557 IRBuilder<> Builder(OldBr);
742 Value *llvm::createMinMaxOp(IRBuilder<> &Builder,
771 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
789 llvm::getOrderedReduction(IRBuilder<> &Builder, Value *Acc, Value *Src,
820 llvm::getShuffleReduction(IRBuilder<> &Builder, Value *Src, unsigned Op,
863 IRBuilder<> &Builder, const TargetTransformInfo *TTI, unsigned Opcode,
934 Value *llvm::createTargetReduction(IRBuilder<> &B,
946 IRBuilder<>::FastMathFlagGuard FMFGuard(B);
lib/Transforms/Utils/LowerMemIntrinsics.cpp 56 IRBuilder<> PLBuilder(PreLoopBB->getTerminator());
69 IRBuilder<> LoopBuilder(LoopBB);
93 IRBuilder<> RBuilder(PostLoopBB ? PostLoopBB->getFirstNonPHI()
152 IRBuilder<> PLBuilder(PreLoopBB->getTerminator());
178 IRBuilder<> LoopBuilder(LoopBB);
220 IRBuilder<> RHBuilder(ResHeaderBB);
225 IRBuilder<> ResBuilder(ResLoopBB);
330 IRBuilder<> LoopBuilder(LoopBB);
350 IRBuilder<> FwdLoopBuilder(FwdLoopBB);
379 IRBuilder<> Builder(OrigBB->getTerminator());
391 IRBuilder<> LoopBuilder(LoopBB);
lib/Transforms/Utils/ModuleUtils.cpp 24 IRBuilder<> IRB(M.getContext());
132 IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB));
lib/Transforms/Utils/PredicateInfo.cpp 557 IRBuilder<> B(getBranchTerminator(ValInfo));
569 IRBuilder<> B(PAssume->AssumeInst);
lib/Transforms/Utils/SSAUpdaterBulk.cpp 159 IRBuilder<> B(FrontierBB, FrontierBB->begin());
lib/Transforms/Utils/SanitizerStats.cpp 42 void SanitizerStatReport::create(IRBuilder<> &B, SanitizerStatKind SK) {
97 IRBuilder<> B(BB);
lib/Transforms/Utils/SimplifyCFG.cpp 190 IRBuilder<> &Builder);
192 IRBuilder<> &Builder);
194 bool SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder);
195 bool SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder);
200 bool SimplifySwitch(SwitchInst *SI, IRBuilder<> &Builder);
202 bool SimplifyUncondBranch(BranchInst *BI, IRBuilder<> &Builder);
203 bool SimplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder);
206 IRBuilder<> &Builder);
817 Instruction *TI, BasicBlock *Pred, IRBuilder<> &Builder) {
1003 IRBuilder<> &Builder) {
1389 IRBuilder<NoFolder> Builder(NT);
2093 IRBuilder<NoFolder> Builder(BI);
2115 IRBuilder<NoFolder> Builder(BI);
2412 IRBuilder<NoFolder> Builder(InsertPt);
2446 IRBuilder<> &Builder) {
2706 IRBuilder<> Builder(PBI);
3058 IRBuilder<> QB(&*PostBB->getFirstInsertionPt());
3368 IRBuilder<NoFolder> Builder(PBI);
3481 IRBuilder<> Builder(OldTerm);
3591 ICmpInst *ICI, IRBuilder<> &Builder) {
3692 static bool SimplifyBranchOnICmpChain(BranchInst *BI, IRBuilder<> &Builder,
3807 bool SimplifyCFGOpt::SimplifyResume(ResumeInst *RI, IRBuilder<> &Builder) {
4108 bool SimplifyCFGOpt::SimplifyReturn(ReturnInst *RI, IRBuilder<> &Builder) {
4224 IRBuilder<> Builder(TI);
4337 static bool TurnSwitchRangeIntoICmp(SwitchInst *SI, IRBuilder<> &Builder) {
4864 IRBuilder<> &Builder) {
4886 static bool switchToSelect(SwitchInst *SI, IRBuilder<> &Builder,
4928 Value *BuildLookup(Value *Index, IRBuilder<> &Builder);
5092 Value *SwitchLookupTable::BuildLookup(Value *Index, IRBuilder<> &Builder) {
5291 static bool SwitchToLookupTable(SwitchInst *SI, IRBuilder<> &Builder,
5550 static bool ReduceSwitchRange(SwitchInst *SI, IRBuilder<> &Builder,
5633 bool SimplifyCFGOpt::SimplifySwitch(SwitchInst *SI, IRBuilder<> &Builder) {
5791 IRBuilder<> Builder(BI);
5800 IRBuilder<> &Builder) {
5860 bool SimplifyCFGOpt::SimplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) {
6022 IRBuilder<> Builder(T);
6075 IRBuilder<> Builder(BB);
lib/Transforms/Utils/SimplifyLibCalls.cpp 141 static bool isLocallyOpenedFile(Value *File, CallInst *CI, IRBuilder<> &B,
255 Value *LibCallSimplifier::optimizeStrCat(CallInst *CI, IRBuilder<> &B) {
277 IRBuilder<> &B) {
296 Value *LibCallSimplifier::optimizeStrNCat(CallInst *CI, IRBuilder<> &B) {
339 Value *LibCallSimplifier::optimizeStrChr(CallInst *CI, IRBuilder<> &B) {
384 Value *LibCallSimplifier::optimizeStrRChr(CallInst *CI, IRBuilder<> &B) {
412 Value *LibCallSimplifier::optimizeStrCmp(CallInst *CI, IRBuilder<> &B) {
467 Value *LibCallSimplifier::optimizeStrNCmp(CallInst *CI, IRBuilder<> &B) {
535 Value *LibCallSimplifier::optimizeStrNDup(CallInst *CI, IRBuilder<> &B) {
548 Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilder<> &B) {
570 Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilder<> &B) {
597 Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilder<> &B) {
645 Value *LibCallSimplifier::optimizeStringLength(CallInst *CI, IRBuilder<> &B,
736 Value *LibCallSimplifier::optimizeStrLen(CallInst *CI, IRBuilder<> &B) {
743 Value *LibCallSimplifier::optimizeWcslen(CallInst *CI, IRBuilder<> &B) {
753 Value *LibCallSimplifier::optimizeStrPBrk(CallInst *CI, IRBuilder<> &B) {
780 Value *LibCallSimplifier::optimizeStrTo(CallInst *CI, IRBuilder<> &B) {
791 Value *LibCallSimplifier::optimizeStrSpn(CallInst *CI, IRBuilder<> &B) {
812 Value *LibCallSimplifier::optimizeStrCSpn(CallInst *CI, IRBuilder<> &B) {
836 Value *LibCallSimplifier::optimizeStrStr(CallInst *CI, IRBuilder<> &B) {
893 Value *LibCallSimplifier::optimizeMemRChr(CallInst *CI, IRBuilder<> &B) {
899 Value *LibCallSimplifier::optimizeMemChr(CallInst *CI, IRBuilder<> &B) {
988 uint64_t Len, IRBuilder<> &B,
1065 IRBuilder<> &B) {
1088 Value *LibCallSimplifier::optimizeMemCmp(CallInst *CI, IRBuilder<> &B) {
1105 Value *LibCallSimplifier::optimizeBCmp(CallInst *CI, IRBuilder<> &B) {
1109 Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilder<> &B) {
1122 Value *LibCallSimplifier::optimizeMemPCpy(CallInst *CI, IRBuilder<> &B) {
1131 Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilder<> &B) {
1145 Value *LibCallSimplifier::foldMallocMemset(CallInst *Memset, IRBuilder<> &B) {
1188 Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilder<> &B) {
1204 Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilder<> &B) {
1216 static Value *replaceUnaryCall(CallInst *CI, IRBuilder<> &B, Intrinsic::ID IID) {
1218 IRBuilder<>::FastMathFlagGuard Guard(B);
1252 static Value *optimizeDoubleFP(CallInst *CI, IRBuilder<> &B,
1291 IRBuilder<>::FastMathFlagGuard Guard(B);
1310 static Value *optimizeUnaryDoubleFP(CallInst *CI, IRBuilder<> &B,
1316 static Value *optimizeBinaryDoubleFP(CallInst *CI, IRBuilder<> &B,
1322 Value *LibCallSimplifier::optimizeCAbs(CallInst *CI, IRBuilder<> &B) {
1327 IRBuilder<>::FastMathFlagGuard Guard(B);
1351 IRBuilder<> &B) {
1355 IRBuilder<>::FastMathFlagGuard Guard(B);
1385 static Value *getPow(Value *InnerChain[33], unsigned Exp, IRBuilder<> &B) {
1411 static Value *getIntToFPVal(Value *I2F, IRBuilder<> &B) {
1429 Value *LibCallSimplifier::replacePowWithExp(CallInst *Pow, IRBuilder<> &B) {
1570 Module *M, IRBuilder<> &B,
1591 Value *LibCallSimplifier::replacePowWithSqrt(CallInst *Pow, IRBuilder<> &B) {
1629 IRBuilder<> &B) {
1635 Value *LibCallSimplifier::optimizePow(CallInst *Pow, IRBuilder<> &B) {
1651 IRBuilder<>::FastMathFlagGuard Guard(B);
1760 Value *LibCallSimplifier::optimizeExp2(CallInst *CI, IRBuilder<> &B) {
1784 Value *LibCallSimplifier::optimizeFMinFMax(CallInst *CI, IRBuilder<> &B) {
1800 IRBuilder<>::FastMathFlagGuard Guard(B);
1811 Value *LibCallSimplifier::optimizeLog(CallInst *Log, IRBuilder<> &B) {
1916 IRBuilder<>::FastMathFlagGuard Guard(B);
1963 Value *LibCallSimplifier::optimizeSqrt(CallInst *CI, IRBuilder<> &B) {
2011 IRBuilder<>::FastMathFlagGuard Guard(B);
2032 Value *LibCallSimplifier::optimizeTan(CallInst *CI, IRBuilder<> &B) {
2069 static void insertSinCosCall(IRBuilder<> &B, Function *OrigCallee, Value *Arg,
2119 Value *LibCallSimplifier::optimizeSinCosPi(CallInst *CI, IRBuilder<> &B) {
2200 Value *LibCallSimplifier::optimizeFFS(CallInst *CI, IRBuilder<> &B) {
2214 Value *LibCallSimplifier::optimizeFls(CallInst *CI, IRBuilder<> &B) {
2226 Value *LibCallSimplifier::optimizeAbs(CallInst *CI, IRBuilder<> &B) {
2235 Value *LibCallSimplifier::optimizeIsDigit(CallInst *CI, IRBuilder<> &B) {
2243 Value *LibCallSimplifier::optimizeIsAscii(CallInst *CI, IRBuilder<> &B) {
2250 Value *LibCallSimplifier::optimizeToAscii(CallInst *CI, IRBuilder<> &B) {
2256 Value *LibCallSimplifier::optimizeAtoi(CallInst *CI, IRBuilder<> &B) {
2264 Value *LibCallSimplifier::optimizeStrtol(CallInst *CI, IRBuilder<> &B) {
2285 Value *LibCallSimplifier::optimizeErrorReporting(CallInst *CI, IRBuilder<> &B,
2325 Value *LibCallSimplifier::optimizePrintFString(CallInst *CI, IRBuilder<> &B) {
2378 Value *LibCallSimplifier::optimizePrintF(CallInst *CI, IRBuilder<> &B) {
2415 Value *LibCallSimplifier::optimizeSPrintFString(CallInst *CI, IRBuilder<> &B) {
2474 Value *LibCallSimplifier::optimizeSPrintF(CallInst *CI, IRBuilder<> &B) {
2510 Value *LibCallSimplifier::optimizeSnPrintFString(CallInst *CI, IRBuilder<> &B) {
2588 Value *LibCallSimplifier::optimizeSnPrintF(CallInst *CI, IRBuilder<> &B) {
2598 Value *LibCallSimplifier::optimizeFPrintFString(CallInst *CI, IRBuilder<> &B) {
2647 Value *LibCallSimplifier::optimizeFPrintF(CallInst *CI, IRBuilder<> &B) {
2682 Value *LibCallSimplifier::optimizeFWrite(CallInst *CI, IRBuilder<> &B) {
2713 Value *LibCallSimplifier::optimizeFPuts(CallInst *CI, IRBuilder<> &B) {
2745 Value *LibCallSimplifier::optimizeFPutc(CallInst *CI, IRBuilder<> &B) {
2755 Value *LibCallSimplifier::optimizeFGetc(CallInst *CI, IRBuilder<> &B) {
2762 Value *LibCallSimplifier::optimizeFGets(CallInst *CI, IRBuilder<> &B) {
2770 Value *LibCallSimplifier::optimizeFRead(CallInst *CI, IRBuilder<> &B) {
2779 Value *LibCallSimplifier::optimizePuts(CallInst *CI, IRBuilder<> &B) {
2793 Value *LibCallSimplifier::optimizeBCopy(CallInst *CI, IRBuilder<> &B) {
2809 IRBuilder<> &Builder) {
2888 IRBuilder<> &Builder) {
3000 IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles);
3047 IRBuilder<> TmpBuilder(SimplifiedCI);
3224 IRBuilder<> &B) {
3235 IRBuilder<> &B) {
3246 IRBuilder<> &B) {
3260 IRBuilder<> &B,
3305 IRBuilder<> &B,
3320 IRBuilder<> &B) {
3329 IRBuilder<> &B) {
3340 IRBuilder<> &B) {
3351 IRBuilder<> &B) {
3359 IRBuilder<> &B) {
3368 IRBuilder<> &B) {
3377 IRBuilder<> &B) {
3386 IRBuilder<> &B) {
3395 IRBuilder<> &B) {
3422 IRBuilder<> Builder(CI, /*FPMathTag=*/nullptr, OpBundles);
lib/Transforms/Utils/VNCoercion.cpp 151 IRBuilder<> &IRB, const DataLayout &DL) {
390 IRBuilder<> Builder(InsertPt);
426 IRBuilder<> Builder(SrcVal->getParent(), ++BasicBlock::iterator(SrcVal));
522 IRBuilder<> Builder(InsertPt);
523 return getMemInstValueForLoadHelper<Value, IRBuilder<>>(SrcInst, Offset,
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp 118 IRBuilder<> Builder;
lib/Transforms/Vectorize/LoopVectorize.cpp 492 void setDebugLocFromInst(IRBuilder<> &B, const Value *Ptr);
639 Value *emitTransformedIndex(IRBuilder<> &B, Value *Index, ScalarEvolution *SE,
706 IRBuilder<> Builder;
811 void InnerLoopVectorizer::setDebugLocFromInst(IRBuilder<> &B, const Value *Ptr) {
1664 IRBuilder<>::InsertPointGuard Guard(Builder);
2532 IRBuilder<> Builder(&*Header->getFirstInsertionPt());
2559 IRBuilder<> Builder(L->getLoopPreheader()->getTerminator());
2606 IRBuilder<> Builder(L->getLoopPreheader()->getTerminator());
2681 IRBuilder<> Builder(BB->getTerminator());
2796 IRBuilder<> &B, Value *Index, ScalarEvolution *SE, const DataLayout &DL,
3016 IRBuilder<> B(Lp->getLoopPreheader()->getTerminator());
3139 IRBuilder<> B(MiddleBlock->getTerminator());
3312 IRBuilder<> B(cast<Instruction>(I));
4216 IRBuilder<>::FastMathFlagGuard FMFG(Builder);
lib/Transforms/Vectorize/SLPVectorizer.cpp 1968 IRBuilder<> Builder;
3723 IRBuilder<>::InsertPointGuard Guard(Builder);
5690 IRBuilder<> &Builder) {
5788 Value *createOp(IRBuilder<> &Builder, const Twine &Name) const {
6024 Value *createOp(IRBuilder<> &Builder, const Twine &Name,
6048 Value *createOp(IRBuilder<> &Builder, const Twine &Name,
6390 IRBuilder<> Builder(cast<Instruction>(ReductionRoot));
6578 Value *emitReduction(Value *VectorizedValue, IRBuilder<> &Builder,
lib/Transforms/Vectorize/VPlan.cpp 294 IRBuilder<> &Builder = State.Builder;
377 IRBuilder<> Builder(State->CFG.PrevBB->getTerminator());
lib/Transforms/Vectorize/VPlan.h 235 IRBuilder<> &Builder, VectorizerValueMap &ValueMap,
312 IRBuilder<> &Builder;
tools/clang/lib/CodeGen/CGBlocks.cpp 1448 llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry",
tools/clang/lib/CodeGen/CGBuilder.h 41 typedef llvm::IRBuilder<llvm::ConstantFolder, CGBuilderInserterTy>
tools/clang/lib/CodeGen/CGCall.cpp 4430 llvm::IRBuilder<>::InsertPointGuard IPGuard(Builder);
tools/clang/lib/CodeGen/CGObjCGNU.cpp 1640 llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry",
tools/clang/lib/CodeGen/CodeGenFunction.cpp 2244 llvm::IRBuilder<> IRB(Builder.GetInsertBlock(), Builder.GetInsertPoint());
tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp 260 IRBuilder<> Builder(BasicBlock::Create(C, "entry", Func));
281 IRBuilder<> Builder(BasicBlock::Create(C, "entry", Func));
tools/lli/lli.cpp 307 IRBuilder<> Builder(Context);
tools/polly/include/polly/CodeGen/IRBuilder.h 156 typedef llvm::IRBuilder<llvm::ConstantFolder, IRInserter> PollyIRBuilder;
unittests/Analysis/BasicAliasAnalysisTest.cpp 36 IRBuilder<> B;
unittests/Analysis/MemorySSATest.cpp 33 IRBuilder<> B;
883 IRBuilder<> B(C);
922 IRBuilder<> B(C);
967 IRBuilder<> B(C);
1219 IRBuilder<> B(C);
1269 IRBuilder<> B(C);
unittests/Analysis/OrderedInstructionsTest.cpp 25 IRBuilder<> B(Ctx);
unittests/Analysis/ScalarEvolutionTest.cpp 767 IRBuilder<> Builder(Top);
839 IRBuilder<> Builder(Top);
939 IRBuilder<> Builder(Top);
1165 IRBuilder<> Builder(Top);
1227 IRBuilder<> Builder(Entry);
1279 IRBuilder<> Builder(Entry);
1328 IRBuilder<> Builder(Entry);
1379 IRBuilder<> Builder(Entry);
1430 IRBuilder<> Builder(Entry);
unittests/Analysis/SparsePropagation.cpp 230 IRBuilder<> Builder;
unittests/Analysis/VectorUtilsTest.cpp 66 IRBuilder<NoFolder> IRB;
unittests/ExecutionEngine/MCJIT/MCJITTestBase.h 35 IRBuilder<> Builder;
unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp 162 IRBuilder<> Builder(BarEntry);
178 IRBuilder<> Builder(FooEntry);
248 IRBuilder<> Builder(BarEntry);
262 IRBuilder<> Builder(BarEntry);
unittests/ExecutionEngine/Orc/OrcCAPITest.cpp 40 IRBuilder<> B(&Main->back());
unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp 137 IRBuilder<> B1(FooEntry);
145 IRBuilder<> B2(BarEntry);
191 IRBuilder<> B(BarEntry);
210 IRBuilder<> B(FooEntry);
unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp 104 IRBuilder<> B(&Main->back());
unittests/IR/BasicBlockTest.cpp 111 IRBuilder<> Builder1(BB1);
unittests/IR/CFGBuilder.cpp 46 IRBuilder<> IRB(From);
66 IRBuilder<> IRB(From);
91 IRBuilder<> IRB(BB);
unittests/IR/IRBuilderTest.cpp 51 IRBuilder<> Builder(BB);
126 IRBuilder<> Builder(BB);
171 IRBuilder<> Builder(BB);
297 IRBuilder<> Builder(BB);
328 IRBuilder<> Builder(BB);
351 IRBuilder<> Builder(BB);
365 IRBuilder<> Builder(BB);
377 IRBuilder<NoFolder> Builder(BB);
399 IRBuilder<> Builder(BB);
585 IRBuilder<NoFolder> Builder(BB);
635 IRBuilder<> Builder(BB);
645 IRBuilder<>::FastMathFlagGuard Guard(Builder);
660 IRBuilder<>::InsertPointGuard Guard(Builder);
670 IRBuilder<> Builder(BB);
691 IRBuilder<> Builder(BB);
713 IRBuilder<> Builder(BB);
769 IRBuilder<> Builder(BB);
784 IRBuilder<> Builder(BB);
819 IRBuilder<> Builder(Ctx);
835 IRBuilder<> Builder(BB);
857 IRBuilder<> Builder(BB);
unittests/IR/InstructionsTest.cpp 410 IRBuilder<> Builder(Context);
601 IRBuilder<NoFolder> B(Ctx);
660 IRBuilder<NoFolder> Builder(Context);
1039 IRBuilder<> Builder(Context);
1120 IRBuilder<> Builder(Context);
unittests/IR/PatternMatch.cpp 38 IRBuilder<NoFolder> IRB;
unittests/IR/VerifierTest.cpp 178 IRBuilder<> Builder(BasicBlock::Create(C, "", F));
unittests/Linker/LinkModulesTest.cpp 79 IRBuilder<> Builder(EntryBB);
143 IRBuilder<> Builder(BB);
158 IRBuilder<> Builder(BB);
unittests/ProfileData/InstrProfTest.cpp 295 IRBuilder<> Builder(BB);
unittests/Transforms/Utils/CloningTest.cpp 167 IRBuilder<> Builder(BB);
193 IRBuilder<> Builder(BB);
217 IRBuilder<> Builder1(BB1);
220 IRBuilder<> Builder2(BB2);
266 IRBuilder<> Builder1(BB1);
269 IRBuilder<> Builder2(BB2);
319 IRBuilder<> Builder1(BB1);
322 IRBuilder<> Builder2(BB2);
468 IRBuilder<> IBuilder(C);
732 IRBuilder<> IBuilder(C);
unittests/Transforms/Utils/FunctionComparatorTest.cpp 27 IRBuilder<> B(Ctx);
unittests/Transforms/Utils/IntegerDivisionTest.cpp 25 IRBuilder<> Builder(C);
55 IRBuilder<> Builder(C);
85 IRBuilder<> Builder(C);
115 IRBuilder<> Builder(C);
146 IRBuilder<> Builder(C);
176 IRBuilder<> Builder(C);
206 IRBuilder<> Builder(C);
236 IRBuilder<> Builder(C);
unittests/Transforms/Utils/LocalTest.cpp 28 IRBuilder<> builder(C);
70 IRBuilder<> B(C);
unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp 25 IRBuilder<> B(C);
112 IRBuilder<> B(C);