reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

examples/BrainF/BrainF.cpp

  268             builder->CreateCondBr(test_2, aberrorbb, nextbb);

examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp

  852   Builder->CreateCondBr(CondV, ThenBB, ElseBB);
  972   Builder->CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp

  852   Builder->CreateCondBr(CondV, ThenBB, ElseBB);
  972   Builder->CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp

  851   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
  971   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp

  837   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
  957   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp

  861   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
  981   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/Chapter5/toy.cpp

  638   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
  750   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/Chapter6/toy.cpp

  750   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
  862   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/Chapter7/toy.cpp

  857   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
  977   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/Chapter8/toy.cpp

  856   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
  976   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);

examples/Kaleidoscope/Chapter9/toy.cpp

 1019   Builder.CreateCondBr(CondV, ThenBB, ElseBB);
 1141   Builder.CreateCondBr(EndCond, LoopBB, AfterBB);

lib/CodeGen/AtomicExpandPass.cpp

  908     Builder.CreateCondBr(Success, EndBB, FailureBB);
  917   Builder.CreateCondBr(ShouldContinue, LoopBB, EndBB);
 1042   Builder.CreateCondBr(TryAgain, LoopBB, ExitBB);
 1199   Builder.CreateCondBr(ShouldStore, ReleasingStoreBB, NoStoreBB);
 1212   Builder.CreateCondBr(StoreSuccess, SuccessBB,
 1224     Builder.CreateCondBr(ShouldStore, TryStoreBB, NoStoreBB);
 1401   Builder.CreateCondBr(Success, ExitBB, LoopBB);

lib/CodeGen/CodeGenPrepare.cpp

 1754   Builder.CreateCondBr(Cmp, EndBlock, CallBlock);
 7239     auto *Br2 = IRBuilder<>(TmpBB).CreateCondBr(Cond2, TBB, FBB);

lib/CodeGen/StackProtector.cpp

  512       B.CreateCondBr(Cmp, NewBB, FailBB, Weights);

lib/ExecutionEngine/Orc/Speculation.cpp

  119           Mutator.CreateCondBr(CanSpeculate, SpeculateBlock, &ProgramEntry);

lib/IR/Core.cpp

 3095   return wrap(unwrap(B)->CreateCondBr(unwrap(If), unwrap(Then), unwrap(Else)));

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 2224     Builder.CreateCondBr(Cond, MemmoveB, NewPreheader);

lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp

  558   IRB.CreateCondBr(Cmp1, ThenBB1, ElseBB1);
  572   IRB.CreateCondBr(Cmp2, ThenBB2, EndBB2);
  765       IRB.CreateCondBr(Cmp, II->getUnwindDest(), II->getNormalDest());

lib/Transforms/Coroutines/CoroSplit.cpp

  388     Builder.CreateCondBr(Cond, ResumeBB, NewSwitchBB);

lib/Transforms/IPO/CrossDSOCFI.cpp

  151     BranchInst *BI = IRBTest.CreateCondBr(Test, ExitBB, TrapBB);

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

 1281       LastBr = NextIRB.CreateCondBr(ShadowsEq, FallbackBB, FallbackBB);

lib/Transforms/Instrumentation/GCOVProfiling.cpp

 1126   Builder.CreateCondBr(EnterCounterLoopCond, CounterLoopHeader, FileLoopLatch);
 1171   Builder.CreateCondBr(CounterLoopCond, CounterLoopHeader, FileLoopLatch);
 1180   Builder.CreateCondBr(FileLoopCond, FileLoopHeader, ExitBB);

lib/Transforms/Instrumentation/InstrOrderFile.cpp

  142     entryB.CreateCondBr(IsNotExecuted, UpdateOrderFileBB, OrigEntry);

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

 1282   B.CreateCondBr(EnterLoopCond, LS.Header, RRI.PseudoExit);
 1303   B.CreateCondBr(IterationsLeft, RRI.PseudoExit, LS.LatchExit);

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 2446     Builder.CreateCondBr(ComparedEqual, ComparedEqualBB, ComparedUnequalBB);
 2555     Builder.CreateCondBr(ConstantInt::getTrue(Context), SuccessorBB,

lib/Transforms/Scalar/MergeICmps.cpp

  669     Builder.CreateCondBr(IsEqual, NextCmpBlock, PhiBB);

lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp

   79   Builder.CreateCondBr(FCmp, JoinBB, LibCallBB);

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

  186   IRB.CreateCondBr(Cond, Direction ? &UnswitchedSucc : &NormalSucc,

lib/Transforms/Utils/BypassSlowDivision.cpp

  423     Builder.CreateCondBr(CmpV, Fast.BB, SuccessorBB);
  439     Builder.CreateCondBr(CmpV, Fast.BB, Slow.BB);

lib/Transforms/Utils/IntegerDivision.cpp

  262   Builder.CreateCondBr(EarlyRet, End, BB1);
  275   Builder.CreateCondBr(SkipLoop, LoopExit, Preheader);
  321   Builder.CreateCondBr(Tmp12, LoopExit, DoWhile);

lib/Transforms/Utils/Local.cpp

  272       BranchInst *NewBr = Builder.CreateCondBr(Cond,

lib/Transforms/Utils/LoopUnrollRuntime.cpp

  164   B.CreateCondBr(BrLoopExit, OriginalLoopLatchExit, NewPreHeader);
  279   B.CreateCondBr(BrLoopExit, EpilogPreHeader, Exit);
  365         Builder.CreateCondBr(IdxCmp, FirstLoopBB, InsertBot);
  755   B.CreateCondBr(BranchVal, RemainderLoop, UnrollingLoop);

lib/Transforms/Utils/LoopUtils.cpp

  558   Builder.CreateCondBr(Builder.getFalse(), L->getHeader(), ExitBlock);

lib/Transforms/Utils/LowerMemIntrinsics.cpp

   86     LoopBuilder.CreateCondBr(LoopBuilder.CreateICmpULT(NewIndex, LoopEndCI),
  211     PLBuilder.CreateCondBr(PLBuilder.CreateICmpNE(RuntimeLoopCount, Zero),
  215     LoopBuilder.CreateCondBr(
  221     RHBuilder.CreateCondBr(RHBuilder.CreateICmpNE(RuntimeResidual, Zero),
  247     ResBuilder.CreateCondBr(
  256     PLBuilder.CreateCondBr(PLBuilder.CreateICmpNE(RuntimeLoopCount, Zero),
  259     LoopBuilder.CreateCondBr(
  339   LoopBuilder.CreateCondBr(
  359   FwdLoopBuilder.CreateCondBr(FwdLoopBuilder.CreateICmpEQ(FwdIndexPtr, CopyLen),
  386   Builder.CreateCondBr(
  404   LoopBuilder.CreateCondBr(LoopBuilder.CreateICmpULT(NewIndex, CopyLen), LoopBB,

lib/Transforms/Utils/SimplifyCFG.cpp

 3493       BranchInst *NewBI = Builder.CreateCondBr(Cond, TrueBB, FalseBB);
 3761       Builder.CreateCondBr(ExtraCase, EdgeBB, NewBB);
 3763       Builder.CreateCondBr(ExtraCase, NewBB, EdgeBB);
 4404   BranchInst *NewBI = Builder.CreateCondBr(Cmp, ContiguousDest, OtherDest);
 5428         Builder.CreateCondBr(Cmp, LookupBB, SI->getDefaultDest());
 5465     Builder.CreateCondBr(LoBit, LookupBB, SI->getDefaultDest());

lib/Transforms/Vectorize/LoopVectorize.cpp

 2546   Builder.CreateCondBr(ICmp, L->getExitBlock(), Header);

tools/clang/lib/CodeGen/CGAtomic.cpp

  391   CGF.Builder.CreateCondBr(Cmp, ContinueBB, StoreExpectedBB);
 1761   CGF.Builder.CreateCondBr(Res, ExitBB, ContBB);
 1793   CGF.Builder.CreateCondBr(Res.second, ExitBB, ContBB);
 1844   CGF.Builder.CreateCondBr(Res, ExitBB, ContBB);
 1873   CGF.Builder.CreateCondBr(Res.second, ExitBB, ContBB);

tools/clang/lib/CodeGen/CGBuiltin.cpp

  935     Builder.CreateCondBr(IsZero, End, NotZero);
 2315     Builder.CreateCondBr(IsZero, End, NotZero);
 2323     Builder.CreateCondBr(IsNan, End, NotNan);
 2334     Builder.CreateCondBr(IsInf, End, NotInf);
 2511     Builder.CreateCondBr(SizeEq0, Exit, CmpGT);
 2525     Builder.CreateCondBr(DstGtSrc, Exit, CmpLT);
 2529     Builder.CreateCondBr(DstLtSrc, Exit, Next);
 2537     Builder.CreateCondBr(NextSizeEq0, Exit, CmpGT);

tools/clang/lib/CodeGen/CGCUDANV.cpp

  366     CGF.Builder.CreateCondBr(CBZero, NextBlock, EndBlock);
  643       CtorBuilder.CreateCondBr(EQZero, IfBlock, ExitBlock);
  785     DtorBuilder.CreateCondBr(NEZero, IfBlock, ExitBlock);

tools/clang/lib/CodeGen/CGCall.cpp

 3011   Builder.CreateCondBr(CanNullCheck, Check, NoCheck);
 3131     CGF.Builder.CreateCondBr(isNull, contBB, writebackBB);
 3281       CGF.Builder.CreateCondBr(isNull, contBB, copyBB);

tools/clang/lib/CodeGen/CGClass.cpp

  335     Builder.CreateCondBr(isNull, endBB, notNullBB);
  407     Builder.CreateCondBr(IsNull, CastNull, CastNotNull);
 1577     CGF.Builder.CreateCondBr(ShouldCallDelete, continueBB, callDeleteBB);
 1936     zeroCheckBranch = Builder.CreateCondBr(iszero, loopBB, loopBB);
 2009   Builder.CreateCondBr(done, contBB, loopBB);
 2697     Builder.CreateCondBr(DerivedNotNull, CheckBlock, ContBlock);

tools/clang/lib/CodeGen/CGCleanup.cpp

  567     CGF.Builder.CreateCondBr(IsActive, CleanupBB, ContBB);

tools/clang/lib/CodeGen/CGCoroutine.cpp

  206     CGF.Builder.CreateCondBr(SuspendRet, RealSuspendBlock, ReadyBlock);
  410       CGF.Builder.CreateCondBr(CoroEnd, ResumeBB, CleanupContBB);
  458     CGF.Builder.CreateCondBr(Cond, FreeBB, AfterFreeBB);
  565   Builder.CreateCondBr(CoroAlloc, AllocBB, InitBB);
  578     Builder.CreateCondBr(Cond, InitBB, RetOnFailureBB);
  651         Builder.CreateCondBr(SkipBody, ContBB, BodyBB);

tools/clang/lib/CodeGen/CGDecl.cpp

  495         CGF.Builder.CreateCondBr(DidNRVO, SkipDtorBB, RunDtorBB);
 1714     Builder.CreateCondBr(IsZeroSizedVLA, ContBB, SetupBB);
 1735     Builder.CreateCondBr(Done, ContBB, LoopBB);
 2157     Builder.CreateCondBr(isEmpty, doneBB, bodyBB);
 2184   Builder.CreateCondBr(done, doneBB, bodyBB);

tools/clang/lib/CodeGen/CGDeclCXX.cpp

  331   Builder.CreateCondBr(NeedsInit, InitBlock, NoInitBlock, Weights);

tools/clang/lib/CodeGen/CGException.cpp

  505     CGF.Builder.CreateCondBr(failsFilter, unexpectedBB,
 1034     CGF.Builder.CreateCondBr(MatchesTypeIndex, Handler.Block, NextBlock);
 1115     CGF.Builder.CreateCondBr(matchesTypeIndex, handler.Block, nextBlock);
 1283       CGF.Builder.CreateCondBr(ShouldEndCatch, EndCatchBB, CleanupContBB);
 1326         CGF.Builder.CreateCondBr(ShouldRethrow, RethrowBB, ContBB);

tools/clang/lib/CodeGen/CGExpr.cpp

  703         Builder.CreateCondBr(IsNonNull, Rest, Done);
  790       Builder.CreateCondBr(IsNonNull, VptrNotNull, Done);
 3054   llvm::Instruction *Branch = Builder.CreateCondBr(JointCond, Cont, Handlers);
 3103     Builder.CreateCondBr(FatalCond, NonFatalHandlerBB, FatalHandlerBB);
 3121   llvm::BranchInst *BI = Builder.CreateCondBr(Cond, Cont, CheckBB);
 3289     Builder.CreateCondBr(Checked, Cont, TrapBB);
 3296     Builder.CreateCondBr(Checked, Cont, TrapBB);
 4816       Builder.CreateCondBr(CalleeSigMatch, TypeCheck, Cont);

tools/clang/lib/CodeGen/CGExprAgg.cpp

  625     Builder.CreateCondBr(done, endBB, bodyBB);
 1722   Builder.CreateCondBr(done, endBB, bodyBB);

tools/clang/lib/CodeGen/CGExprCXX.cpp

 1220     Builder.CreateCondBr(IsEmpty, ContBB, LoopBB);
 1264   Builder.CreateCondBr(IsEnd, ContBB, LoopBB);
 1666     Builder.CreateCondBr(isNull, contBB, notNullBB);
 2024   Builder.CreateCondBr(IsNull, DeleteEnd, DeleteNotNull);
 2132     CGF.Builder.CreateCondBr(IsNull, BadTypeidBlock, EndBlock);
 2237     Builder.CreateCondBr(IsNull, CastNull, CastNotNull);

tools/clang/lib/CodeGen/CGExprComplex.cpp

  716       llvm::Instruction *Branch = Builder.CreateCondBr(IsRNaN, INaNBB, ContBB);
  728       Branch = Builder.CreateCondBr(IsINaN, LibCallBB, ContBB);

tools/clang/lib/CodeGen/CGExprScalar.cpp

 2567     Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
 2923     Builder.CreateCondBr(success, contBB, atomicPHI->getParent());
 3114   Builder.CreateCondBr(overflow, overflowBB, continueBB);
 3625       Builder.CreateCondBr(ValidExponent, CheckShiftBase, Cont);

tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp

  380     CGF.Builder.CreateCondBr(Done, ExitBB, LoopBB);

tools/clang/lib/CodeGen/CGObjC.cpp

 1721   Builder.CreateCondBr(
 1767   Builder.CreateCondBr(Builder.CreateICmpEQ(currentMutations, initialMutations),
 1868   Builder.CreateCondBr(
 1890   Builder.CreateCondBr(Builder.CreateICmpEQ(refetchCount, zero),

tools/clang/lib/CodeGen/CGObjCGNU.cpp

 2659     Builder.CreateCondBr(isNil, continueBB, messageBB);
 3827     Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB);

tools/clang/lib/CodeGen/CGObjCMac.cpp

 1719     CGF.Builder.CreateCondBr(isNull, NullBB, callBB);
 4141       CGF.Builder.CreateCondBr(CGF.Builder.CreateLoad(CallTryExitVar),
 4529   CGF.Builder.CreateCondBr(DidCatch, TryHandler, TryBlock);
 4593       CGF.Builder.CreateCondBr(Threw, CatchHandler, CatchBlock);
 4663       CGF.Builder.CreateCondBr(CGF.Builder.CreateIsNotNull(Match, "matched"),

tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp

  887   CGF.Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);
  936   CGF.Builder.CreateCondBr(Done, DoneBB, BodyBB);
 3183       CGF.Builder.CreateCondBr(CallBool, ThenBlock, ContBlock);
 3500         CGF.Builder.CreateCondBr(Cmp, ExitBB, ContBB);
 5491   CGF.Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);
 5529   CGF.Builder.CreateCondBr(Done, DoneBB, BodyBB);
 6408       CGF.Builder.CreateCondBr(Cmp, ExitBB, ContBB);
 6443       CGF.Builder.CreateCondBr(Cmp, ExitBB, ContBB);
 8912   MapperCGF.Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);
 8969     MapperCGF.Builder.CreateCondBr(IsMember, TypeBB, MemberCombineBB);
 9006     MapperCGF.Builder.CreateCondBr(IsAlloc, AllocBB, AllocElseBB);
 9018     MapperCGF.Builder.CreateCondBr(IsTo, ToBB, ToElseBB);
 9029     MapperCGF.Builder.CreateCondBr(IsFrom, FromBB, EndBB);
 9063   MapperCGF.Builder.CreateCondBr(IsDone, ExitBB, BodyBB);
 9099   MapperCGF.Builder.CreateCondBr(IsArray, IsDeleteBB, ExitBB);
 9114   MapperCGF.Builder.CreateCondBr(DeleteCond, BodyBB, ExitBB);
 9289     CGF.Builder.CreateCondBr(Failed, OffloadFailedBlock, OffloadContBlock);

tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp

  139       CGF.Builder.CreateCondBr(CallBool, ThenBlock, ContBlock);
 1211   Bld.CreateCondBr(IsWorker, WorkerBB, MasterCheckBB);
 1220   Bld.CreateCondBr(IsMaster, MasterBB, EST.ExitBB);
 1445   Bld.CreateCondBr(ShouldTerminate, ExitBB, SelectWorkersBB);
 1451   Bld.CreateCondBr(IsActive, ExecuteBB, BarrierBB);
 1468     Bld.CreateCondBr(WorkFnMatch, ExecuteFNBB, CheckNextBB);
 2154       Bld.CreateCondBr(IsSPMD, SPMDBB, NonSPMDBB);
 2415         Bld.CreateCondBr(I->getSecond().IsInSPMDModeFlag, ExitBB, NonSPMDBB);
 2619       Bld.CreateCondBr(IsSPMD, SeqBB, ParallelCheckBB);
 2629       Bld.CreateCondBr(Res, SeqBB, MasterBB);
 2774   CGF.Builder.CreateCondBr(CmpLoopBound, TestBB, ExitBB);
 2782   CGF.Builder.CreateCondBr(CmpThreadToCounter, BodyBB, SyncBB);
 2913       Bld.CreateCondBr(Bld.CreateICmpSGT(PtrDiff, Bld.getInt64(IntSize - 1)),
 3272         Bld.CreateCondBr(Cmp, BodyBB, ExitBB);
 3285       Bld.CreateCondBr(IsWarpMaster, ThenBB, ElseBB);
 3342       Bld.CreateCondBr(IsActiveThread, W0ThenBB, W0ElseBB);
 3573   Bld.CreateCondBr(CondReduce, ThenBB, ElseBB);
 3599   Bld.CreateCondBr(CondCopy, CpyThenBB, CpyElseBB);
 4406   CGF.Builder.CreateCondBr(Cond, ThenBB, ExitBB);

tools/clang/lib/CodeGen/CGStmt.cpp

  758     Builder.CreateCondBr(
  843     Builder.CreateCondBr(
  913     Builder.CreateCondBr(
  994   Builder.CreateCondBr(
 1243   Builder.CreateCondBr(Cond, CaseDest, FalseDest, Weights);

tools/clang/lib/CodeGen/CGStmtOpenMP.cpp

  659   Builder.CreateCondBr(IsEmpty, DoneBB, BodyBB);
  692   Builder.CreateCondBr(Done, DoneBB, BodyBB);
  942           Builder.CreateCondBr(
 1044     Builder.CreateCondBr(IsLastIterCond, ThenBB, DoneBB);
 1248           CGF.Builder.CreateCondBr(Cond, ThenBB, DoneBB);
 1495           Builder.CreateCondBr(Cond, ThenBB, DoneBB);
 1730           Builder.CreateCondBr(Cond, ThenBB, DoneBB);
 1909   Builder.CreateCondBr(BoolCondVal, LoopBody, ExitBlock);

tools/clang/lib/CodeGen/CGVTables.cpp

   86     CGF.Builder.CreateCondBr(IsNull, AdjustNull, AdjustNotNull);

tools/clang/lib/CodeGen/CodeGenFunction.cpp

 1558   Builder.CreateCondBr(CondV, TrueBlock, FalseBlock, Weights, Unpredictable);
 1612   Builder.CreateCondBr(done, contBB, loopBB);
 2320     Builder.CreateCondBr(Condition, RetBlock, CurBlock);

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

  622   Builder.CreateCondBr(IsVirtual, FnVirtual, FnNonVirtual);
 1432     CGF.Builder.CreateCondBr(IsNull, BadCastBlock, CastEnd);
 2329     Builder.CreateCondBr(Builder.CreateIsNotNull(V, "tobool"),
 2693       Builder.CreateCondBr(Have, InitBB, ExitBB);

tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp

 1122   CGF.Builder.CreateCondBr(IsCompleteObject,
 1145   CGF.Builder.CreateCondBr(IsCompleteObject,
 2579     Builder.CreateCondBr(ShouldDoInit, InitBlock, EndBlock);
 2997     Builder.CreateCondBr(IsVirtual, VBaseAdjustBB, SkipAdjustBB);
 3126   Builder.CreateCondBr(IsNotNull, ConvertBB, ContinueBB);

tools/clang/lib/CodeGen/TargetInfo.cpp

 3772   CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);
 4242   Builder.CreateCondBr(CC, UsingRegs, UsingOverflow);
 5367   CGF.Builder.CreateCondBr(UsingStack, OnStackBlock, MaybeRegBlock);
 5402   CGF.Builder.CreateCondBr(InRegs, InRegBlock, OnStackBlock);
 6766   CGF.Builder.CreateCondBr(InRegs, InRegBlock, InMemBlock);

tools/polly/lib/CodeGen/IslExprBuilder.cpp

  614   auto BR = Builder.CreateCondBr(Builder.getTrue(), NextBB, CondBB);

tools/polly/lib/CodeGen/IslNodeBuilder.cpp

  811   Builder.CreateCondBr(Predicate, ThenBB, ElseBB);
 1292   Builder.CreateCondBr(Cond, ExecBB, MergeBB);

tools/polly/lib/CodeGen/LoopGenerators.cpp

  138     Builder.CreateCondBr(LoopGuard, PreHeaderBB, ExitBB);
  160   BranchInst *B = Builder.CreateCondBr(LoopCondition, HeaderBB, ExitBB);

tools/polly/lib/CodeGen/LoopGeneratorsGOMP.cpp

  141   Builder.CreateCondBr(HasNextSchedule, PreHeaderBB, ExitBB);

tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp

  209       Builder.CreateCondBr(HasIteration, PreHeaderBB, ExitBB);
  216       Builder.CreateCondBr(HasIteration, PreHeaderBB, ExitBB);
  241       Builder.CreateCondBr(HasIteration, PreHeaderBB, ExitBB);

tools/polly/lib/CodeGen/PerfMonitor.cpp

  236   Builder.CreateCondBr(HasRunBefore, EarlyReturn, InitBB);

tools/polly/lib/CodeGen/Utils.cpp

  149   BranchInst *CondBr = Builder.CreateCondBr(RTC, StartBlock, S.getEntry());

unittests/Analysis/MemorySSATest.cpp

   83   B.CreateCondBr(B.getTrue(), Left, Right);
  121   B.CreateCondBr(B.getTrue(), Left, Right);
  211   B.CreateCondBr(B.getTrue(), Left, Right);
  255   B.CreateCondBr(B.getTrue(), Left, Right);
  307   B.CreateCondBr(B.getTrue(), Left, Right);
  343   B.CreateCondBr(B.getTrue(), Left, Right);
  389   B.CreateCondBr(B.getTrue(), Left, Right);
  433   B.CreateCondBr(B.getTrue(), Left, Right);
  486   B.CreateCondBr(B.getTrue(), Left, Right);
  531   B.CreateCondBr(B.getTrue(), Left, Right);
  713   B.CreateCondBr(UndefValue::get(Type::getInt1Ty(C)), IfThen, IfEnd);
  894   B.CreateCondBr(B.getTrue(), LoopMainBB, LoopStartBB);
  898   B.CreateCondBr(B.getTrue(), LoopStartBB, AfterLoopBB);
 1291   B.CreateCondBr(B.getTrue(), BlockA, BlockB);
 1423   B.CreateCondBr(B.getTrue(), Exit, Body);
 1442   B.CreateCondBr(B.getTrue(), Header, Exit);
 1483   B.CreateCondBr(B.getTrue(), Exit, Body);
 1504   B.CreateCondBr(B.getTrue(), Header, Exit);
 1552   B.CreateCondBr(B.getTrue(), ABlock, FBlock);
 1554   B.CreateCondBr(B.getTrue(), BBlock, CBlock);
 1573   B.CreateCondBr(B.getTrue(), CBlock, EBlock);

unittests/Analysis/ScalarEvolutionTest.cpp

  776   Builder.CreateCondBr(UndefValue::get(T_int1), L, Post);
  852   auto *Br = cast<Instruction>(Builder.CreateCondBr(Cond, L, Post));
  884   Builder.CreateCondBr(NewCond, L, Post);
  952   auto *Br = cast<Instruction>(Builder.CreateCondBr(Cond, L, Post));
  973   Builder.CreateCondBr(NewCond, L, Post);
 1178   Builder.CreateCondBr(Cond, L, Post);
 1229   Builder.CreateCondBr(Cond, Exit, Body);
 1281   Builder.CreateCondBr(Cond, Exit, Body);

unittests/Analysis/SparsePropagation.cpp

  385   Builder.CreateCondBr(Cond, Then, Else);
  425   Builder.CreateCondBr(Cond, Then, Else);

unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

  169     Builder.CreateCondBr(Builder.CreateICmpEQ(Param, Zero),

unittests/IR/IRBuilderTest.cpp

  332   BranchInst *BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
  341   BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB, Weights);

unittests/IR/PatternMatch.cpp

 1087   Value *Br1 = IRB.CreateCondBr(IRB.getTrue(), TrueBB, FalseBB);
 1107   Value *Br2 = IRB.CreateCondBr(IRB.getTrue(), TrueBB, TrueBB);

unittests/ProfileData/InstrProfTest.cpp

  300   Instruction *Inst = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
  301   Instruction *Inst2 = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);

unittests/Transforms/Utils/LocalTest.cpp

   36   BranchInst *br0 = builder.CreateCondBr(builder.getTrue(), bb0, bb1);

unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp

   53   B.CreateCondBr(B.getTrue(), TrueBB, FalseBB);
  141   B.CreateCondBr(B.getTrue(), LoopMainBB, LoopStartBB);
  149   B.CreateCondBr(B.getTrue(), LoopStartBB, AfterLoopBB);