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

Declarations

include/llvm/Analysis/TargetTransformInfo.h

   43 class BranchInst;

include/llvm/IR/Instruction.def

  128 HANDLE_TERM_INST  ( 2, Br            , BranchInst)

include/llvm/Transforms/Scalar/GVN.h

   40 class BranchInst;

include/llvm/Transforms/Scalar/JumpThreading.h

   34 class BranchInst;

include/llvm/Transforms/Utils/Local.h

   43 class BranchInst;

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

   49 class BranchInst;

tools/polly/include/polly/CodeGen/Utils.h

   24 class BranchInst;

References

examples/BrainF/BrainF.cpp

  186     BranchInst::Create(endbb, aberrorbb);
  451       BranchInst::Create(bb_0, oldbb, test_0, testbb);

examples/Fibonacci/fibonacci.cpp

   77   BranchInst::Create(RetBB, RecurseBB, CondInst, BB);

examples/ParallelJIT/ParallelJIT.cpp

  107   BranchInst::Create(RetBB, RecurseBB, CondInst, BB);

include/llvm/ADT/DenseMapInfo.h

   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }

include/llvm/Analysis/CFGPrinter.h

  130     if (const BranchInst *BI = dyn_cast<BranchInst>(Node->getTerminator()))
  130     if (const BranchInst *BI = dyn_cast<BranchInst>(Node->getTerminator()))

include/llvm/Analysis/LoopInfo.h

  752   BranchInst *getLoopGuardBranch() const;

include/llvm/Analysis/MemorySSAUpdater.h

  256   void changeCondBranchToUnconditionalTo(const BranchInst *BI,

include/llvm/Analysis/SparsePropagation.h

  293   if (BranchInst *BI = dyn_cast<BranchInst>(&TI)) {
  293   if (BranchInst *BI = dyn_cast<BranchInst>(&TI)) {

include/llvm/Analysis/TargetTransformInfo.h

   88   BranchInst *ExitBranch = nullptr;
  565   bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI,
 1208   virtual bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE,
 1488   bool canSaveCmp(Loop *L, BranchInst **BI,

include/llvm/Analysis/TargetTransformInfoImpl.h

  236   bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI,

include/llvm/IR/IRBuilder.h

  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  845   InstTy *Insert(InstTy *I, const Twine &Name = "") const {
  865   InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
  865   InstTy *addBranchMetadata(InstTy *I, MDNode *Weights, MDNode *Unpredictable) {
  899   BranchInst *CreateBr(BasicBlock *Dest) {
  900     return Insert(BranchInst::Create(Dest));
  905   BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
  908     return Insert(addBranchMetadata(BranchInst::Create(True, False, Cond),
  914   BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False,
  916     BranchInst *Br = BranchInst::Create(True, False, Cond);
  916     BranchInst *Br = BranchInst::Create(True, False, Cond);

include/llvm/IR/InstVisitor.h

  237   RetTy visitBranchInst(BranchInst &I) {

include/llvm/IR/Instructions.h

 2980   BranchInst(const BranchInst &BI);
 3001   BranchInst *cloneImpl() const;
 3031   static BranchInst *Create(BasicBlock *IfTrue,
 3033     return new(1) BranchInst(IfTrue, InsertBefore);
 3036   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
 3038     return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertBefore);
 3041   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *InsertAtEnd) {
 3042     return new(1) BranchInst(IfTrue, InsertAtEnd);
 3045   static BranchInst *Create(BasicBlock *IfTrue, BasicBlock *IfFalse,
 3047     return new(3) BranchInst(IfTrue, IfFalse, Cond, InsertAtEnd);
 3107 struct OperandTraits<BranchInst> : public VariadicOperandTraits<BranchInst, 1> {

include/llvm/IR/OperandTraits.h

   69   static Use *op_begin(SubClass* U) {
   71         !std::is_polymorphic<SubClass>::value,
   75   static Use *op_end(SubClass* U) {

include/llvm/IR/PatternMatch.h

   47 template <typename Val, typename Pattern> bool match(Val *V, const Pattern &P) {
 1384     if (auto *BI = dyn_cast<BranchInst>(V))
 1384     if (auto *BI = dyn_cast<BranchInst>(V))
 1404   template <typename OpTy> bool match(OpTy *V) {
 1405     if (auto *BI = dyn_cast<BranchInst>(V))
 1405     if (auto *BI = dyn_cast<BranchInst>(V))

include/llvm/IR/User.h

  127   template <int Idx, typename U> static Use &OpFrom(const U *that) {
  129       ? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
  130       : OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];

include/llvm/Support/Casting.h

   58     return To::classof(&Val);
   66   static inline bool doit(const From &) { return true; }
   77     return isa_impl<To, From>::doit(Val);
   92     return isa_impl<To, From>::doit(*Val);
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  165   using ret_type = To &;       // Normal case, return Ty&
  168   using ret_type = const To &; // Normal case, return Ty&
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  218   static typename cast_retty<To, From>::ret_type doit(From &Val) {
  219     return cast_convert_val<To, SimpleFrom,
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  248                                typename cast_retty<X, const Y>::ret_type>::type
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  331                             typename cast_retty<X, const Y>::ret_type>::type
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  338   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;

include/llvm/Support/PointerLikeTypeTraits.h

   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };

include/llvm/Transforms/Scalar/GVN.h

  289   bool processFoldableCondBr(BranchInst *BI);

include/llvm/Transforms/Scalar/JumpThreading.h

  149   bool ThreadGuard(BasicBlock *BB, IntrinsicInst *Guard, BranchInst *BI);

include/llvm/Transforms/Utils/Local.h

  234 bool FoldBranchToCommonDest(BranchInst *BI, MemorySSAUpdater *MSSAU = nullptr,

include/llvm/Transforms/Utils/PredicateInfo.h

  233   void processBranch(BranchInst *, BasicBlock *, SmallVectorImpl<Value *> &);

lib/Analysis/BranchProbabilityInfo.cpp

  257   if (!(isa<BranchInst>(TI) || isa<SwitchInst>(TI) || isa<IndirectBrInst>(TI)))
  401   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  401   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  492   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  492   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  661   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  661   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  779   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  779   const BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());

lib/Analysis/DivergenceAnalysis.cpp

  113   if (auto *BranchTerm = dyn_cast<BranchInst>(&Term)) {

lib/Analysis/InlineCost.cpp

  283   bool visitBranchInst(BranchInst &BI);
 1343 bool CallAnalyzer::visitBranchInst(BranchInst &BI) {
 1862     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
 1862     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {

lib/Analysis/LazyValueInfo.cpp

 1383   if (BranchInst *BI = dyn_cast<BranchInst>(BBFrom->getTerminator())) {
 1383   if (BranchInst *BI = dyn_cast<BranchInst>(BBFrom->getTerminator())) {

lib/Analysis/LoopInfo.cpp

  172     if (BranchInst *BI = dyn_cast_or_null<BranchInst>(Latch->getTerminator()))
  172     if (BranchInst *BI = dyn_cast_or_null<BranchInst>(Latch->getTerminator()))
  232   BranchInst *BI = dyn_cast_or_null<BranchInst>(Latch->getTerminator());
  232   BranchInst *BI = dyn_cast_or_null<BranchInst>(Latch->getTerminator());
  362 BranchInst *Loop::getLoopGuardBranch() const {
  391   BranchInst *GuardBI = dyn_cast<BranchInst>(GuardBB->getTerminator());
  391   BranchInst *GuardBI = dyn_cast<BranchInst>(GuardBB->getTerminator());

lib/Analysis/MemorySSAUpdater.cpp

 1398 void MemorySSAUpdater::changeCondBranchToUnconditionalTo(const BranchInst *BI,

lib/Analysis/MustExecute.cpp

  122   auto *BI = dyn_cast<BranchInst>(CondExitBlock->getTerminator());

lib/Analysis/ScalarEvolution.cpp

 4329       BranchInst *BI = dyn_cast<BranchInst>(Latch->getTerminator());
 4329       BranchInst *BI = dyn_cast<BranchInst>(Latch->getTerminator());
 5238 static bool BrPHIToSelect(DominatorTree &DT, BranchInst *BI, PHINode *Merge,
 5294     auto *BI = dyn_cast<BranchInst>(IDom->getTerminator());
 5294     auto *BI = dyn_cast<BranchInst>(IDom->getTerminator());
 6087       } else if (auto *BI = dyn_cast<BranchInst>(PoisonUser)) {
 7141   if (BranchInst *BI = dyn_cast<BranchInst>(Term)) {
 7141   if (BranchInst *BI = dyn_cast<BranchInst>(Term)) {
 9471   BranchInst *LoopContinuePredicate =
 9472     dyn_cast<BranchInst>(Latch->getTerminator());
 9535     BranchInst *ContinuePredicate = dyn_cast<BranchInst>(PBB->getTerminator());
 9535     BranchInst *ContinuePredicate = dyn_cast<BranchInst>(PBB->getTerminator());
 9646     BranchInst *LoopEntryPredicate =
 9647       dyn_cast<BranchInst>(Pair.first->getTerminator());

lib/Analysis/TargetTransformInfo.cpp

  115     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  115     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  276 bool TargetTransformInfo::canSaveCmp(Loop *L, BranchInst **BI,

lib/Analysis/ValueTracking.cpp

 1957         if (const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
 1957         if (const BranchInst *BI = dyn_cast<BranchInst>(Curr)) {
 4177   SmallVector<const BranchInst *, 2> GuardingBranches;
 4190           if (const auto *B = dyn_cast<BranchInst>(U)) {
 4190           if (const auto *B = dyn_cast<BranchInst>(U)) {

lib/AsmParser/LLParser.cpp

 5931     Inst = BranchInst::Create(BB);
 5944   Inst = BranchInst::Create(Op1, Op2, Op0);

lib/Bitcode/Reader/BitcodeReader.cpp

 4239         I = BranchInst::Create(TrueDest);
 4248         I = BranchInst::Create(TrueDest, FalseDest, Cond);

lib/Bitcode/Writer/BitcodeWriter.cpp

 2725       const BranchInst &II = cast<BranchInst>(I);
 2725       const BranchInst &II = cast<BranchInst>(I);

lib/CodeGen/CodeGenPrepare.cpp

  582     BranchInst *Term = dyn_cast<BranchInst>(SinglePred->getTerminator());
  582     BranchInst *Term = dyn_cast<BranchInst>(SinglePred->getTerminator());
  597   BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  597   BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  820   BranchInst *BI = cast<BranchInst>(BB->getTerminator());
  820   BranchInst *BI = cast<BranchInst>(BB->getTerminator());
 2051     BranchInst *BI = dyn_cast<BranchInst>(TailCallBB->getTerminator());
 2051     BranchInst *BI = dyn_cast<BranchInst>(TailCallBB->getTerminator());
 6015   BranchInst *TrueBranch = nullptr;
 6016   BranchInst *FalseBranch = nullptr;
 6025         TrueBranch = BranchInst::Create(EndBlock, TrueBlock);
 6035         FalseBranch = BranchInst::Create(EndBlock, FalseBlock);
 6051     auto *FalseBranch = BranchInst::Create(EndBlock, FalseBlock);
 6051     auto *FalseBranch = BranchInst::Create(EndBlock, FalseBlock);
 7200     auto *Br1 = cast<BranchInst>(BB.getTerminator());
 7200     auto *Br1 = cast<BranchInst>(BB.getTerminator());
 7239     auto *Br2 = IRBuilder<>(TmpBB).CreateCondBr(Cond2, TBB, FBB);

lib/CodeGen/DwarfEHPrepare.cpp

  241     BranchInst::Create(UnwindBB, Parent);

lib/CodeGen/ExpandMemCmp.cpp

  301     BranchInst *CmpBr =
  302         BranchInst::Create(EndBlock, LoadCmpBlocks[BlockIndex + 1], Cmp);
  306     BranchInst *CmpBr = BranchInst::Create(EndBlock);
  306     BranchInst *CmpBr = BranchInst::Create(EndBlock);
  413   BranchInst *CmpBr = BranchInst::Create(ResBlock.BB, NextBB, Cmp);
  413   BranchInst *CmpBr = BranchInst::Create(ResBlock.BB, NextBB, Cmp);
  484   BranchInst *CmpBr = BranchInst::Create(NextBB, ResBlock.BB, Cmp);
  484   BranchInst *CmpBr = BranchInst::Create(NextBB, ResBlock.BB, Cmp);
  507     BranchInst *NewBr = BranchInst::Create(EndBlock);
  507     BranchInst *NewBr = BranchInst::Create(EndBlock);
  521   BranchInst *NewBr = BranchInst::Create(EndBlock);
  521   BranchInst *NewBr = BranchInst::Create(EndBlock);

lib/CodeGen/GlobalISel/IRTranslator.cpp

  385   const BranchInst &BrInst = cast<BranchInst>(U);
  385   const BranchInst &BrInst = cast<BranchInst>(U);

lib/CodeGen/HardwareLoops.cpp

  164     BranchInst *ExitBranch  = nullptr;
  287   if (!isa<BranchInst>(Pred->getTerminator()))
  290   auto *BI = cast<BranchInst>(Pred->getTerminator());
  290   auto *BI = cast<BranchInst>(Pred->getTerminator());
  342       cast<BranchInst>(BB->getTerminator())->isUnconditional())
  383     auto *LoopGuard = cast<BranchInst>(BeginBB->getTerminator());
  383     auto *LoopGuard = cast<BranchInst>(BeginBB->getTerminator());

lib/CodeGen/IndirectBrExpandPass.cpp

  204       BranchInst::Create(SwitchBB, IBr);

lib/CodeGen/ScalarizeMaskedMemIntrin.cpp

  220     BranchInst::Create(CondBlock, NewIfBlock, Predicate, OldBr);
  351     BranchInst::Create(CondBlock, NewIfBlock, Predicate, OldBr);
  470     BranchInst::Create(CondBlock, NewIfBlock, Predicate, OldBr);
  589     BranchInst::Create(CondBlock, NewIfBlock, Predicate, OldBr);
  685     BranchInst::Create(CondBlock, NewIfBlock, Predicate, OldBr);
  791     BranchInst::Create(CondBlock, NewIfBlock, Predicate, OldBr);

lib/CodeGen/SelectionDAG/FastISel.cpp

 1842     const BranchInst *BI = cast<BranchInst>(I);
 1842     const BranchInst *BI = cast<BranchInst>(I);

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

 2222 void SelectionDAGBuilder::visitBr(const BranchInst &I) {

lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h

  632   void visitBr(const BranchInst &I);

lib/CodeGen/SjLjEHPrepare.cpp

  364           BranchInst::Create(II->getNormalDest(), II);

lib/CodeGen/WinEHPrepare.cpp

 1203       BranchInst *Goto = cast<BranchInst>(IncomingBlock->getTerminator());
 1203       BranchInst *Goto = cast<BranchInst>(IncomingBlock->getTerminator());

lib/ExecutionEngine/Interpreter/Execution.cpp

  934 void Interpreter::visitBranchInst(BranchInst &I) {

lib/ExecutionEngine/Interpreter/Interpreter.h

  123   void visitBranchInst(BranchInst &I);

lib/FuzzMutate/Operations.cpp

  152       BranchInst::Create(Block, Next, Srcs[0], Block->getTerminator());

lib/IR/AsmWriter.cpp

 3719   if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
 3719   if (isa<BranchInst>(I) && cast<BranchInst>(I).isConditional()) {
 3720     const BranchInst &BI(cast<BranchInst>(I));
 3720     const BranchInst &BI(cast<BranchInst>(I));

lib/IR/BasicBlock.cpp

  429   BranchInst *BI = BranchInst::Create(New, this);
  429   BranchInst *BI = BranchInst::Create(New, this);

lib/IR/Core.cpp

 2902   return unwrap<BranchInst>(Branch)->isConditional();
 2906   return wrap(unwrap<BranchInst>(Branch)->getCondition());
 2910   return unwrap<BranchInst>(Branch)->setCondition(unwrap(Cond));

lib/IR/Instructions.cpp

 1133                   OperandTraits<BranchInst>::op_end(this) - 1, 1,
 1142                   OperandTraits<BranchInst>::op_end(this) - 3, 3,
 1154                   OperandTraits<BranchInst>::op_end(this) - 1, 1, InsertAtEnd) {
 1162                   OperandTraits<BranchInst>::op_end(this) - 3, 3, InsertAtEnd) {
 1171 BranchInst::BranchInst(const BranchInst &BI)
 1173                   OperandTraits<BranchInst>::op_end(this) - BI.getNumOperands(),
 4262 BranchInst *BranchInst::cloneImpl() const {
 4263   return new(getNumOperands()) BranchInst(*this);

lib/IR/SafepointIRVerifier.cpp

  141       const BranchInst *BI = dyn_cast<BranchInst>(TI);
  141       const BranchInst *BI = dyn_cast<BranchInst>(TI);

lib/IR/Verifier.cpp

  468   void visitBranchInst(BranchInst &BI);
 2440 void Verifier::visitBranchInst(BranchInst &BI) {
 4033     if (BranchInst *BI = dyn_cast<BranchInst>(&I))
 4033     if (BranchInst *BI = dyn_cast<BranchInst>(&I))

lib/Target/AArch64/AArch64FastISel.cpp

  222   bool emitCompareAndBranch(const BranchInst *BI);
 2293 bool AArch64FastISel::emitCompareAndBranch(const BranchInst *BI) {
 2421   const BranchInst *BI = cast<BranchInst>(I);
 2421   const BranchInst *BI = cast<BranchInst>(I);

lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp

   55   void visitBranchInst(BranchInst &I);
  117 void AMDGPUAnnotateUniformValues::visitBranchInst(BranchInst &I) {

lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp

  118       if (const BranchInst *Br = dyn_cast<BranchInst>(&I)) {
  118       if (const BranchInst *Br = dyn_cast<BranchInst>(&I)) {

lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp

  149     BranchInst::Create(NewRetBlock, BB);
  182     } else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
  182     } else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
  198         BranchInst::Create(LoopHeaderBB, DummyReturnBB, BoolTrue, BB);
  206         BranchInst::Create(TransitionBB, DummyReturnBB, BoolTrue, BB);
  224         BranchInst::Create(UnreachableBlock, BB);

lib/Target/AMDGPU/SIAnnotateControlFlow.cpp

   81   bool isUniform(BranchInst *T);
   93   void openIf(BranchInst *Term);
   95   void insertElse(BranchInst *Term);
   99                       BranchInst *Term);
  101   void handleLoop(BranchInst *Term);
  162 bool SIAnnotateControlFlow::isUniform(BranchInst *T) {
  209 void SIAnnotateControlFlow::openIf(BranchInst *Term) {
  219 void SIAnnotateControlFlow::insertElse(BranchInst *Term) {
  230     Value *Cond, PHINode *Broken, llvm::Loop *L, BranchInst *Term) {
  257 void SIAnnotateControlFlow::handleLoop(BranchInst *Term) {
  333     BranchInst *Term = dyn_cast<BranchInst>(BB->getTerminator());
  333     BranchInst *Term = dyn_cast<BranchInst>(BB->getTerminator());

lib/Target/ARM/ARMFastISel.cpp

 1238   const BranchInst *BI = cast<BranchInst>(I);
 1238   const BranchInst *BI = cast<BranchInst>(I);

lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp

 2334       if (isa<BranchInst>(In) || isa<DbgInfoIntrinsic>(In))

lib/Target/Mips/MipsFastISel.cpp

  945   const BranchInst *BI = cast<BranchInst>(I);
  945   const BranchInst *BI = cast<BranchInst>(I);

lib/Target/NVPTX/NVPTXImageOptimizer.cpp

  152     if (BranchInst *BI = dyn_cast<BranchInst>(*UI)) {
  152     if (BranchInst *BI = dyn_cast<BranchInst>(*UI)) {
  161       BranchInst::Create(Dest, BI);

lib/Target/PowerPC/PPCFastISel.cpp

  770   const BranchInst *BI = cast<BranchInst>(I);
  770   const BranchInst *BI = cast<BranchInst>(I);

lib/Target/PowerPC/PPCTargetTransformInfo.cpp

  533     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  533     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  941 bool PPCTTIImpl::canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE,

lib/Target/PowerPC/PPCTargetTransformInfo.h

   60   bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI,

lib/Target/WebAssembly/WebAssemblyFastISel.cpp

 1270   const auto *Br = cast<BranchInst>(I);
 1270   const auto *Br = cast<BranchInst>(I);

lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp

  170       BranchInst::Create(FailBB, RetBB, Cmp, EntryBB);

lib/Target/X86/X86FastISel.cpp

 1627   const BranchInst *BI = cast<BranchInst>(I);
 1627   const BranchInst *BI = cast<BranchInst>(I);

lib/Transforms/Coroutines/CoroFrame.cpp

  849     auto *Terminator = BranchInst::Create(Succ, NewBB);
  849     auto *Terminator = BranchInst::Create(Succ, NewBB);

lib/Transforms/Coroutines/CoroSplit.cpp

  346     cast<BranchInst>(SuspendBB->getTerminator())->setSuccessor(0, LandingBB);
  574   auto BranchToEntry = cast<BranchInst>(Entry->user_back());
  601     auto Branch = cast<BranchInst>(MappedCS->getNextNode());
  917     if (auto *BR = dyn_cast<BranchInst>(I)) {
  917     if (auto *BR = dyn_cast<BranchInst>(I)) {
 1114     BranchInst::Create(Invoke->getNormalDest(), Invoke);
 1253     auto Branch = cast<BranchInst>(SuspendBB->getTerminator());

lib/Transforms/IPO/Attributor.cpp

 3595         BranchInst::Create(NBB, MallocCall->getParent());

lib/Transforms/IPO/CrossDSOCFI.cpp

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

lib/Transforms/IPO/GlobalOpt.cpp

 1359   BranchInst::Create(NullPtrBlock, ContBB, RunningOr, OrigBB);
 1373     Instruction *BI = BranchInst::Create(FreeBlock, NextBlock,
 1380     BranchInst::Create(NextBlock, FreeBlock);
 1385   BranchInst::Create(ContBB, NullPtrBlock);

lib/Transforms/IPO/LoopExtractor.cpp

  110   if (!isa<BranchInst>(EntryTI) ||
  111       !cast<BranchInst>(EntryTI)->isUnconditional() ||

lib/Transforms/IPO/LowerTypeTests.cpp

  780     if (auto *Br = dyn_cast<BranchInst>(*CI->user_begin()))
  780     if (auto *Br = dyn_cast<BranchInst>(*CI->user_begin()))
  784         BranchInst *NewBr = BranchInst::Create(Then, Else, OffsetInRange);
  784         BranchInst *NewBr = BranchInst::Create(Then, Else, OffsetInRange);

lib/Transforms/IPO/PartialInlining.cpp

  558   BranchInst *BR = dyn_cast<BranchInst>(EntryBlock->getTerminator());
  558   BranchInst *BR = dyn_cast<BranchInst>(EntryBlock->getTerminator());
  710     BranchInst *BR = dyn_cast<BranchInst>(E->getTerminator());
  710     BranchInst *BR = dyn_cast<BranchInst>(E->getTerminator());

lib/Transforms/IPO/SampleProfile.cpp

  671   if (isa<BranchInst>(Inst) || isa<IntrinsicInst>(Inst) || isa<PHINode>(Inst))
 1459     if (!isa<BranchInst>(TI) && !isa<SwitchInst>(TI))

lib/Transforms/IPO/WholeProgramDevirt.cpp

  339       BranchInst::Create(II->getNormalDest(), CS.getInstruction());

lib/Transforms/InstCombine/InstCombineCompares.cpp

   67     if (isa<BranchInst>(U))
 4848   auto *BI = dyn_cast_or_null<BranchInst>(BB->getTerminator());

lib/Transforms/InstCombine/InstCombineInternal.h

  437   Instruction *visitBranchInst(BranchInst &BI);

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

 1476   if (BranchInst *BI = dyn_cast<BranchInst>(BBI))
 1476   if (BranchInst *BI = dyn_cast<BranchInst>(BBI))
 1511   BranchInst *OtherBr = dyn_cast<BranchInst>(BBI);
 1511   BranchInst *OtherBr = dyn_cast<BranchInst>(BBI);

lib/Transforms/InstCombine/InstructionCombining.cpp

  981     BranchInst *BI = dyn_cast<BranchInst>(NonConstBB->getTerminator());
  981     BranchInst *BI = dyn_cast<BranchInst>(NonConstBB->getTerminator());
 2557 Instruction *InstCombiner::visitBranchInst(BranchInst &BI) {
 3446     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
 3446     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 1722       BranchInst *NewTerm = BranchInst::Create(CrashBlock, NextBB, Cmp2);
 1722       BranchInst *NewTerm = BranchInst::Create(CrashBlock, NextBB, Cmp2);

lib/Transforms/Instrumentation/BoundsChecking.cpp

  134     BranchInst::Create(GetTrapBB(IRB), OldBB);
  139   BranchInst::Create(GetTrapBB(IRB), Cont, Or, OldBB);

lib/Transforms/Instrumentation/ControlHeightReduction.cpp

  380   BranchInst *createMergedBranch(BasicBlock *PreEntryBlock,
  386                                BranchInst *MergedBR,
  659 static bool checkBiasedBranch(BranchInst *BI, Region *R,
  775     auto *BI = dyn_cast<BranchInst>(Entry->getTerminator());
  775     auto *BI = dyn_cast<BranchInst>(Entry->getTerminator());
  891   auto *Branch = RI.HasBranch ?
  892                  cast<BranchInst>(EntryBB->getTerminator()) : nullptr;
 1043     auto *BI = cast<BranchInst>(RI.R->getEntry()->getTerminator());
 1043     auto *BI = cast<BranchInst>(RI.R->getEntry()->getTerminator());
 1406       auto *BI = cast<BranchInst>(R->getEntry()->getTerminator());
 1406       auto *BI = cast<BranchInst>(R->getEntry()->getTerminator());
 1506       auto *BI = cast<BranchInst>(R->getEntry()->getTerminator());
 1506       auto *BI = cast<BranchInst>(R->getEntry()->getTerminator());
 1529     if (isa<BranchInst>(U) && cast<BranchInst>(U)->isConditional())
 1529     if (isa<BranchInst>(U) && cast<BranchInst>(U)->isConditional())
 1538     if (auto *BI = dyn_cast<BranchInst>(U)) {
 1538     if (auto *BI = dyn_cast<BranchInst>(U)) {
 1668       auto *BI = cast<BranchInst>(R->getEntry()->getTerminator());
 1668       auto *BI = cast<BranchInst>(R->getEntry()->getTerminator());
 1739   BranchInst *MergedBr = createMergedBranch(PreEntryBlock, EntryBlock,
 1815 BranchInst *CHR::createMergedBranch(BasicBlock *PreEntryBlock,
 1819   BranchInst *OldBR = cast<BranchInst>(PreEntryBlock->getTerminator());
 1819   BranchInst *OldBR = cast<BranchInst>(PreEntryBlock->getTerminator());
 1830   BranchInst *NewBR = BranchInst::Create(NewEntryBlock,
 1830   BranchInst *NewBR = BranchInst::Create(NewEntryBlock,
 1843                                   BranchInst *MergedBR,
 1889   auto *BI = cast<BranchInst>(R->getEntry()->getTerminator());
 1889   auto *BI = cast<BranchInst>(R->getEntry()->getTerminator());

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  985         BranchInst *BI = cast<BranchInst>(SplitBlockAndInsertIfThen(
  985         BranchInst *BI = cast<BranchInst>(SplitBlockAndInsertIfThen(
 1129     BranchInst *BI = cast<BranchInst>(SplitBlockAndInsertIfThen(
 1129     BranchInst *BI = cast<BranchInst>(SplitBlockAndInsertIfThen(
 1266     BranchInst *LastBr = BranchInst::Create(FallbackBB, FallbackBB, ShadowsEq);
 1266     BranchInst *LastBr = BranchInst::Create(FallbackBB, FallbackBB, ShadowsEq);

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

  698     cast<BranchInst>(CheckFailTerm)->setSuccessor(0, CheckTerm->getParent());
  943     auto *Br = cast<BranchInst>(SplitBlockAndInsertIfThen(
  943     auto *Br = cast<BranchInst>(SplitBlockAndInsertIfThen(

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

  261   BranchInst *BI = dyn_cast<BranchInst>(TI);
  261   BranchInst *BI = dyn_cast<BranchInst>(TI);
 1296     if (!(isa<BranchInst>(TI) || isa<SwitchInst>(TI) ||

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

  560       if (auto BR = dyn_cast<BranchInst>(CMP->user_back()))

lib/Transforms/Scalar/ADCE.cpp

  210   auto *BR = dyn_cast<BranchInst>(Term);
  210   auto *BR = dyn_cast<BranchInst>(Term);
  336   if (RemoveControlFlowFlag && (isa<BranchInst>(I) || isa<SwitchInst>(I)))
  664   auto *NewTerm = Builder.CreateBr(Target);

lib/Transforms/Scalar/CallSiteSplitting.cpp

  132   auto *BI = dyn_cast<BranchInst>(From->getTerminator());
  132   auto *BI = dyn_cast<BranchInst>(From->getTerminator());

lib/Transforms/Scalar/EarlyCSE.cpp

  698   bool handleBranchCondition(Instruction *CondInst, const BranchInst *BI,
  812                                      const BranchInst *BI, const BasicBlock *BB,
  883     auto *BI = dyn_cast<BranchInst>(Pred->getTerminator());
  883     auto *BI = dyn_cast<BranchInst>(Pred->getTerminator());

lib/Transforms/Scalar/GVN.cpp

 1983   if (BranchInst *BI = dyn_cast<BranchInst>(I)) {
 1983   if (BranchInst *BI = dyn_cast<BranchInst>(I)) {
 2613 bool GVN::processFoldableCondBr(BranchInst *BI) {

lib/Transforms/Scalar/GVNSink.cpp

  767     if (isa<BranchInst>(T) || isa<SwitchInst>(T))

lib/Transforms/Scalar/GuardWidening.cpp

  101     auto *Cond = cast<BranchInst>(I)->getCondition();
  104   return cast<BranchInst>(I)->getCondition();
  116   cast<BranchInst>(I)->setCondition(NewCond);
  278       auto *Cond = cast<BranchInst>(ToWiden)->getCondition();
  334       if (auto *BI = dyn_cast<BranchInst>(BB->getTerminator()))
  334       if (auto *BI = dyn_cast<BranchInst>(BB->getTerminator()))
  481       DominatingBlock = cast<BranchInst>(DominatingGuard)->getSuccessor(0);

lib/Transforms/Scalar/IndVarSimplify.cpp

  345       !isa<BranchInst>(Compare->user_back()))
  348   BranchInst *TheBr = cast<BranchInst>(Compare->user_back());
  348   BranchInst *TheBr = cast<BranchInst>(Compare->user_back());
  778         if (auto *BI = dyn_cast<BranchInst>(TermInst)) {
  778         if (auto *BI = dyn_cast<BranchInst>(TermInst)) {
 1878     auto *BI = dyn_cast<BranchInst>(TI);
 1878     auto *BI = dyn_cast<BranchInst>(TI);
 2059   BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2059   BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2078   BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2078   BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2252   Value *Cond = cast<BranchInst>(ExitingBB->getTerminator())->getCondition();
 2367     BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2367     BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2411     BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2411     BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2479   BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2479   BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2696     BranchInst *BI = dyn_cast<BranchInst>(ExitingBB->getTerminator());
 2696     BranchInst *BI = dyn_cast<BranchInst>(ExitingBB->getTerminator());
 2738     BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2738     BranchInst *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2845     BranchInst *BI = dyn_cast<BranchInst>(ExitingBB->getTerminator());
 2845     BranchInst *BI = dyn_cast<BranchInst>(ExitingBB->getTerminator());
 2942     auto *BI = cast<BranchInst>(ExitingBB->getTerminator());
 2942     auto *BI = cast<BranchInst>(ExitingBB->getTerminator());
 3041       if (!isa<BranchInst>(ExitingBB->getTerminator()))

lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

  224   extractRangeChecksFromBranch(BranchInst *BI, Loop *L, ScalarEvolution &SE,
  392     BranchInst *BI, Loop *L, ScalarEvolution &SE, BranchProbabilityInfo *BPI,
  451   BranchInst *LatchBr = nullptr;
  478     Result.LatchBr = cast<BranchInst>(Map(LatchBr));
  764   BranchInst *LatchBr = dyn_cast<BranchInst>(Latch->getTerminator());
  764   BranchInst *LatchBr = dyn_cast<BranchInst>(Latch->getTerminator());
 1260   BranchInst *PreheaderJump = cast<BranchInst>(Preheader->getTerminator());
 1260   BranchInst *PreheaderJump = cast<BranchInst>(Preheader->getTerminator());
 1305   BranchInst *BranchToContinuation =
 1306       BranchInst::Create(ContinuationBlock, RRI.PseudoExit);
 1348   BranchInst::Create(LS.Header, Preheader);
 1801     if (BranchInst *TBI = dyn_cast<BranchInst>(BBI->getTerminator()))
 1801     if (BranchInst *TBI = dyn_cast<BranchInst>(BBI->getTerminator()))

lib/Transforms/Scalar/JumpThreading.cpp

  211   BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
  211   BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
  229       BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator());
  229       BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator());
  264     BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator());
  264     BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator());
  420       auto *BI = dyn_cast<BranchInst>(BB.getTerminator());
  420       auto *BI = dyn_cast<BranchInst>(BB.getTerminator());
 1063   if (BranchInst *BI = dyn_cast<BranchInst>(Terminator)) {
 1063   if (BranchInst *BI = dyn_cast<BranchInst>(Terminator)) {
 1109     BranchInst::Create(BBTerm->getSuccessor(BestSucc), BBTerm);
 1142     BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
 1142     BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
 1162         BranchInst *UncondBr =
 1163           BranchInst::Create(CondBr->getSuccessor(ToKeep), CondBr);
 1214     if (PN->getParent() == BB && isa<BranchInst>(BB->getTerminator()))
 1226     if (PN->getParent() == BB && isa<BranchInst>(BB->getTerminator()))
 1231       CondInst->getParent() == BB && isa<BranchInst>(BB->getTerminator()))
 1243   auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
 1243   auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
 1255     auto *PBI = dyn_cast<BranchInst>(CurrentPred->getTerminator());
 1255     auto *PBI = dyn_cast<BranchInst>(CurrentPred->getTerminator());
 1268       BranchInst *UncondBI = BranchInst::Create(KeepSucc, BI);
 1268       BranchInst *UncondBI = BranchInst::Create(KeepSucc, BI);
 1636     else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
 1636     else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
 1694       BranchInst::Create(OnlyDest, Term);
 1781     if (BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator()))
 1781     if (BranchInst *PredBr = dyn_cast<BranchInst>(PredBB->getTerminator()))
 2026   BranchInst *NewBI = BranchInst::Create(SuccBB, NewBB);
 2026   BranchInst *NewBI = BranchInst::Create(SuccBB, NewBB);
 2305   BranchInst *OldPredBranch = dyn_cast<BranchInst>(PredBB->getTerminator());
 2305   BranchInst *OldPredBranch = dyn_cast<BranchInst>(PredBB->getTerminator());
 2313     OldPredBranch = cast<BranchInst>(PredBB->getTerminator());
 2363   BranchInst *BBBranch = cast<BranchInst>(BB->getTerminator());
 2363   BranchInst *BBBranch = cast<BranchInst>(BB->getTerminator());
 2436   BranchInst *PredTerm = cast<BranchInst>(Pred->getTerminator());
 2436   BranchInst *PredTerm = cast<BranchInst>(Pred->getTerminator());
 2443   BranchInst::Create(NewBB, BB, SI->getCondition(), Pred);
 2475     BranchInst *PredTerm = dyn_cast<BranchInst>(Pred->getTerminator());
 2475     BranchInst *PredTerm = dyn_cast<BranchInst>(Pred->getTerminator());
 2498   BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
 2498   BranchInst *CondBr = dyn_cast<BranchInst>(BB->getTerminator());
 2515     BranchInst *PredTerm = dyn_cast<BranchInst>(Pred->getTerminator());
 2515     BranchInst *PredTerm = dyn_cast<BranchInst>(Pred->getTerminator());
 2675   if (auto *BI = dyn_cast<BranchInst>(Parent->getTerminator()))
 2675   if (auto *BI = dyn_cast<BranchInst>(Parent->getTerminator()))
 2687                                     BranchInst *BI) {

lib/Transforms/Scalar/LICM.cpp

  583   DenseMap<BranchInst *, BasicBlock *> HoistableBranches;
  590   void registerPossiblyHoistableBranch(BranchInst *BI) {
  709     BranchInst *BI = It->first;
  747       BranchInst::Create(TargetSucc, HoistCommonSucc);
  751       BranchInst::Create(HoistCommonSucc, HoistTrueDest);
  755       BranchInst::Create(HoistCommonSucc, HoistFalseDest);
  780         BranchInst::Create(HoistTrueDest, HoistFalseDest, BI->getCondition()));
  927       if (BranchInst *BI = dyn_cast<BranchInst>(&I))
  927       if (BranchInst *BI = dyn_cast<BranchInst>(&I))

lib/Transforms/Scalar/LoopFuse.cpp

  151   BranchInst *GuardBranch;

lib/Transforms/Scalar/LoopIdiomRecognize.cpp

 1223 static Value *matchCondition(BranchInst *BI, BasicBlock *LoopEntry,
 1302             dyn_cast<BranchInst>(LoopEntry->getTerminator()), LoopEntry))
 1379     auto *PreCondBr = dyn_cast<BranchInst>(PreCondBB->getTerminator());
 1379     auto *PreCondBr = dyn_cast<BranchInst>(PreCondBB->getTerminator());
 1433           dyn_cast<BranchInst>(LoopEntry->getTerminator()), LoopEntry))
 1545     auto *PreCondBI = dyn_cast<BranchInst>(PreCondBB->getTerminator());
 1545     auto *PreCondBI = dyn_cast<BranchInst>(PreCondBB->getTerminator());
 1611   auto *EntryBI = dyn_cast<BranchInst>(PH->getTerminator());
 1611   auto *EntryBI = dyn_cast<BranchInst>(PH->getTerminator());
 1620   auto *PreCondBI = dyn_cast<BranchInst>(PreCondBB->getTerminator());
 1620   auto *PreCondBI = dyn_cast<BranchInst>(PreCondBB->getTerminator());
 1696   BranchInst *PreheaderBr = cast<BranchInst>(Preheader->getTerminator());
 1696   BranchInst *PreheaderBr = cast<BranchInst>(Preheader->getTerminator());
 1751   auto *LbBr = cast<BranchInst>(Body->getTerminator());
 1751   auto *LbBr = cast<BranchInst>(Body->getTerminator());
 1787   auto *PreCondBr = cast<BranchInst>(PreCondBB->getTerminator());
 1787   auto *PreCondBr = cast<BranchInst>(PreCondBB->getTerminator());
 1858     auto *LbBr = cast<BranchInst>(Body->getTerminator());
 1858     auto *LbBr = cast<BranchInst>(Body->getTerminator());
 2549     BranchInst *OldTerminator = cast<BranchInst>(BB->getTerminator());
 2549     BranchInst *OldTerminator = cast<BranchInst>(BB->getTerminator());

lib/Transforms/Scalar/LoopInterchange.cpp

  604   BranchInst *OuterLoopHeaderBI =
  605       dyn_cast<BranchInst>(OuterLoopHeader->getTerminator());
  745       !isa<BranchInst>(InnerLoopLatch->getTerminator()) ||
  746       !isa<BranchInst>(OuterLoop->getLoopLatch()->getTerminator())) {
  886     if (isa<BranchInst>(I) || isa<CmpInst>(I) || isa<TruncInst>(I) ||
 1285         cast<BranchInst>(InnerLoop->getLoopLatch()->getTerminator())
 1320 static void updateSuccessor(BranchInst *BI, BasicBlock *OldBB,
 1459   BranchInst *OuterLoopLatchBI =
 1460       dyn_cast<BranchInst>(OuterLoopLatch->getTerminator());
 1461   BranchInst *InnerLoopLatchBI =
 1462       dyn_cast<BranchInst>(InnerLoopLatch->getTerminator());
 1463   BranchInst *OuterLoopHeaderBI =
 1464       dyn_cast<BranchInst>(OuterLoopHeader->getTerminator());
 1465   BranchInst *InnerLoopHeaderBI =
 1466       dyn_cast<BranchInst>(InnerLoopHeader->getTerminator());
 1473   BranchInst *InnerLoopLatchPredecessorBI =
 1474       dyn_cast<BranchInst>(InnerLoopLatchPredecessor->getTerminator());
 1475   BranchInst *OuterLoopPredecessorBI =
 1476       dyn_cast<BranchInst>(OuterLoopPredecessor->getTerminator());
 1569   BranchInst *InnerTermBI =
 1570       cast<BranchInst>(InnerLoopPreHeader->getTerminator());

lib/Transforms/Scalar/LoopPredication.cpp

  296   bool widenWidenableBranchGuardConditions(BranchInst *Guard, SCEVExpander &Expander);
  807     BranchInst *BI, SCEVExpander &Expander) {
  843   auto *BI = dyn_cast<BranchInst>(LoopLatch->getTerminator());
  843   auto *BI = dyn_cast<BranchInst>(LoopLatch->getTerminator());
  996   SmallVector<BranchInst *, 4> GuardsAsWidenableBranches;
 1004           cast<BranchInst>(BB->getTerminator()));
 1015   for (auto *Guard : GuardsAsWidenableBranches)

lib/Transforms/Scalar/LoopRerollPass.cpp

  471       if (!isa<BranchInst>(TI) || !isa<CmpInst>(I))
 1184           Instruction *BI = dyn_cast<BranchInst>(*UUser->user_begin());
 1185           if (BI == cast<BranchInst>(Header->getTerminator()))
 1453     BranchInst *BI = cast<BranchInst>(Header->getTerminator());
 1453     BranchInst *BI = cast<BranchInst>(Header->getTerminator());

lib/Transforms/Scalar/LoopSimplifyCFG.cpp

   58   if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
   58   if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {

lib/Transforms/Scalar/LoopStrengthReduce.cpp

 2391     BranchInst *TermBr = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
 2391     BranchInst *TermBr = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
 3241   BranchInst *ExitBranch = nullptr;

lib/Transforms/Scalar/LoopUnrollPass.cpp

  567       if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  567       if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {

lib/Transforms/Scalar/LoopUnswitch.cpp

  260                                         BranchInst *OldBranch, Instruction *TI);
  563     BranchInst *BInst = dyn_cast<BranchInst>(DomBB->getTerminator());
  563     BranchInst *BInst = dyn_cast<BranchInst>(DomBB->getTerminator());
  728     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  728     if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  935                                                   BranchInst *OldBranch,
  958   BranchInst *BI =
 1031   auto *OldBranch = dyn_cast<BranchInst>(loopPreheader->getTerminator());
 1031   auto *OldBranch = dyn_cast<BranchInst>(loopPreheader->getTerminator());
 1093     if (BranchInst *BI = dyn_cast<BranchInst>(CurrentTerm)) {
 1093     if (BranchInst *BI = dyn_cast<BranchInst>(CurrentTerm)) {
 1125   if (BranchInst *BI = dyn_cast<BranchInst>(CurrentTerm)) {
 1125   if (BranchInst *BI = dyn_cast<BranchInst>(CurrentTerm)) {
 1353   BranchInst *OldBR = cast<BranchInst>(loopPreheader->getTerminator());
 1353   BranchInst *OldBR = cast<BranchInst>(loopPreheader->getTerminator());
 1558     BranchInst::Create(Abort, OldSISucc,
 1614     if (BranchInst *BI = dyn_cast<BranchInst>(I)) {
 1614     if (BranchInst *BI = dyn_cast<BranchInst>(I)) {

lib/Transforms/Scalar/LowerConstantIntrinsics.cpp

   56     BranchInst *BI = dyn_cast<BranchInst>(I);
   56     BranchInst *BI = dyn_cast<BranchInst>(I);
   77       BranchInst::Create(Target, Source);

lib/Transforms/Scalar/LowerExpectIntrinsic.cpp

  170     BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  170     BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator());
  176     BI = dyn_cast<BranchInst>(BB->getTerminator());
  198     BranchInst *BI = GetDomConditional(i);
  238 template <class BrSelInst> static bool handleBrSelExpect(BrSelInst &BSI) {
  314 static bool handleBranchExpect(BranchInst &BI) {
  318   return handleBrSelExpect<BranchInst>(BI);
  326     if (BranchInst *BI = dyn_cast<BranchInst>(BB.getTerminator())) {
  326     if (BranchInst *BI = dyn_cast<BranchInst>(BB.getTerminator())) {

lib/Transforms/Scalar/MakeGuardsExplicit.cpp

   61   BranchInst *ExplicitGuard = cast<BranchInst>(BB->getTerminator());
   61   BranchInst *ExplicitGuard = cast<BranchInst>(BB->getTerminator());

lib/Transforms/Scalar/MergeICmps.cpp

  237   BranchInst *BranchI = nullptr;
  356   auto *const BranchI = dyn_cast<BranchInst>(Block->getTerminator());
  356   auto *const BranchI = dyn_cast<BranchInst>(Block->getTerminator());

lib/Transforms/Scalar/MergedLoadStoreMotion.cpp

  142   auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
  142   auto *BI = dyn_cast<BranchInst>(BB->getTerminator());

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

 2582     if (auto *BI = dyn_cast<BranchInst>(TI))
 2582     if (auto *BI = dyn_cast<BranchInst>(TI))

lib/Transforms/Scalar/SCCP.cpp

  669   if (auto *BI = dyn_cast<BranchInst>(&TI)) {
  669   if (auto *BI = dyn_cast<BranchInst>(&TI)) {
 1672     if (auto *BI = dyn_cast<BranchInst>(TI)) {
 1672     if (auto *BI = dyn_cast<BranchInst>(TI)) {
 1980   } else if (BranchInst *BI = dyn_cast<BranchInst>(I)) {
 1980   } else if (BranchInst *BI = dyn_cast<BranchInst>(I)) {
 2152         BranchInst *BI = cast<BranchInst>(InstBB->getTerminator());
 2152         BranchInst *BI = cast<BranchInst>(InstBB->getTerminator());

lib/Transforms/Scalar/SimpleLoopUnswitch.cpp

  349 static bool unswitchTrivialBranch(Loop &L, BranchInst &BI, DominatorTree &DT,
  468       BranchInst::Create(ContinueBB, ParentBB);
  504       BranchInst::Create(ContinueBB, ParentBB);
  787     BranchInst::Create(CommonSuccBB, BB);
  902       auto *BI = dyn_cast<BranchInst>(CurrentBB->getTerminator());
  902       auto *BI = dyn_cast<BranchInst>(CurrentBB->getTerminator());
  910     auto *BI = dyn_cast<BranchInst>(CurrentTerm);
  910     auto *BI = dyn_cast<BranchInst>(CurrentTerm);
  931     BI = cast<BranchInst>(CurrentBB->getTerminator());
 1103   BranchInst::Create(ClonedSuccBB, ClonedParentBB);
 1907   BranchInst *BI = dyn_cast<BranchInst>(&TI);
 1907   BranchInst *BI = dyn_cast<BranchInst>(&TI);
 2133     BranchInst::Create(RetainedSuccBB, ParentBB);
 2374 static BranchInst *
 2394   BranchInst *CheckBI = cast<BranchInst>(CheckBB->getTerminator());
 2394   BranchInst *CheckBI = cast<BranchInst>(CheckBB->getTerminator());
 2564     auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
 2564     auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
 2687         auto &BI = cast<BranchInst>(TI);
 2687         auto &BI = cast<BranchInst>(TI);
 2732     BranchInst *BI = dyn_cast<BranchInst>(&TI);
 2732     BranchInst *BI = dyn_cast<BranchInst>(&TI);

lib/Transforms/Scalar/SimplifyCFGPass.cpp

  139     BranchInst::Create(RetBlock, &BB);

lib/Transforms/Scalar/SpeculativeExecution.cpp

  168   BranchInst *BI = dyn_cast<BranchInst>(B.getTerminator());
  168   BranchInst *BI = dyn_cast<BranchInst>(B.getTerminator());

lib/Transforms/Scalar/StructurizeCFG.cpp

   76 using BranchVector = SmallVector<BranchInst *, 8>;
  219   Value *buildCondition(BranchInst *Term, unsigned Idx, bool Invert);
  394     BranchInst *Term = cast<BranchInst>(BB->getTerminator());
  394     BranchInst *Term = cast<BranchInst>(BB->getTerminator());
  436 Value *StructurizeCFG::buildCondition(BranchInst *Term, unsigned Idx,
  463       BranchInst *Term = cast<BranchInst>(P->getTerminator());
  463       BranchInst *Term = cast<BranchInst>(P->getTerminator());
  541   for (BranchInst *Term : Conds) {
  714     BranchInst::Create(NewExit, BB);
  823     Conditions.push_back(BranchInst::Create(Entry, Next, BoolUndef, Flow));
  868     BranchInst::Create(LoopStart, NewEntry);
  875   LoopConds.push_back(BranchInst::Create(Next, LoopStart,
  948       auto Br = dyn_cast<BranchInst>(E->getEntry()->getTerminator());
  971         auto Br = dyn_cast<BranchInst>(BB->getTerminator());

lib/Transforms/Scalar/TailRecursionElimination.cpp

  575     BranchInst *BI = BranchInst::Create(OldEntry, NewEntry);
  575     BranchInst *BI = BranchInst::Create(OldEntry, NewEntry);
  676   BranchInst *NewBI = BranchInst::Create(OldEntry, Ret);
  676   BranchInst *NewBI = BranchInst::Create(OldEntry, Ret);
  701   SmallVector<BranchInst*, 8> UncondBranchPreds;
  705     if (BranchInst *BI = dyn_cast<BranchInst>(PTI))
  705     if (BranchInst *BI = dyn_cast<BranchInst>(PTI))
  711     BranchInst *BI = UncondBranchPreds.pop_back_val();

lib/Transforms/Utils/BasicBlockUtils.cpp

  194   BranchInst *PredBB_BI;
  198     if (!(PredBB_BI = dyn_cast<BranchInst>(PredBB->getTerminator())))
  200     BranchInst *BB_JmpI = dyn_cast<BranchInst>(BB->getTerminator());
  200     BranchInst *BB_JmpI = dyn_cast<BranchInst>(BB->getTerminator());
  529                            ArrayRef<BasicBlock *> Preds, BranchInst *BI,
  619   BranchInst *BI = BranchInst::Create(BB, NewBB);
  619   BranchInst *BI = BranchInst::Create(BB, NewBB);
  680   BranchInst *BI1 = BranchInst::Create(OrigBB, NewBB1);
  680   BranchInst *BI1 = BranchInst::Create(OrigBB, NewBB1);
  721     BranchInst *BI2 = BranchInst::Create(OrigBB, NewBB2);
  721     BranchInst *BI2 = BranchInst::Create(OrigBB, NewBB2);
  827       CheckTerm = BranchInst::Create(Tail, ThenBlock);
  831   BranchInst *HeadNewTerm =
  832     BranchInst::Create(/*ifTrue*/ThenBlock, /*ifFalse*/Tail, Cond);
  872   *ThenTerm = BranchInst::Create(Tail, ThenBlock);
  874   *ElseTerm = BranchInst::Create(Tail, ElseBlock);
  876   BranchInst *HeadNewTerm =
  877     BranchInst::Create(/*ifTrue*/ThenBlock, /*ifFalse*/ElseBlock, Cond);
  907   BranchInst *Pred1Br = dyn_cast<BranchInst>(Pred1->getTerminator());
  907   BranchInst *Pred1Br = dyn_cast<BranchInst>(Pred1->getTerminator());
  908   BranchInst *Pred2Br = dyn_cast<BranchInst>(Pred2->getTerminator());
  908   BranchInst *Pred2Br = dyn_cast<BranchInst>(Pred2->getTerminator());
  960   BranchInst *BI = dyn_cast<BranchInst>(CommonPred->getTerminator());
  960   BranchInst *BI = dyn_cast<BranchInst>(CommonPred->getTerminator());

lib/Transforms/Utils/BreakCriticalEdges.cpp

  164   BranchInst *NewBI = BranchInst::Create(DestBB, NewBB);
  164   BranchInst *NewBI = BranchInst::Create(DestBB, NewBB);

lib/Transforms/Utils/CloneFunction.cpp

  385   if (const BranchInst *BI = dyn_cast<BranchInst>(OldTI)) {
  385   if (const BranchInst *BI = dyn_cast<BranchInst>(OldTI)) {
  398         VMap[OldTI] = BranchInst::Create(Dest, NewBB);
  413       VMap[OldTI] = BranchInst::Create(Dest, NewBB);
  680     BranchInst *BI = dyn_cast<BranchInst>(I->getTerminator());
  680     BranchInst *BI = dyn_cast<BranchInst>(I->getTerminator());

lib/Transforms/Utils/CodeExtractor.cpp

  727         BranchInst::Create(ExitBB, NewBB);
 1301     BranchInst::Create(TheSwitch->getSuccessor(1), TheSwitch);
 1305     BranchInst::Create(TheSwitch->getSuccessor(1), TheSwitch->getSuccessor(2),
 1453   auto *BranchI = BranchInst::Create(header);
 1453   auto *BranchI = BranchInst::Create(header);

lib/Transforms/Utils/Evaluator.cpp

  610       if (BranchInst *BI = dyn_cast<BranchInst>(CurInst)) {
  610       if (BranchInst *BI = dyn_cast<BranchInst>(CurInst)) {

lib/Transforms/Utils/FlattenCFG.cpp

  151     BranchInst *PBI = dyn_cast<BranchInst>(Pred->getTerminator());
  151     BranchInst *PBI = dyn_cast<BranchInst>(Pred->getTerminator());
  223       BranchInst *BPS = dyn_cast<BranchInst>(PS->getTerminator());
  223       BranchInst *BPS = dyn_cast<BranchInst>(PS->getTerminator());
  237   BranchInst *PBI1 = dyn_cast<BranchInst>(PS1->getTerminator());
  237   BranchInst *PBI1 = dyn_cast<BranchInst>(PS1->getTerminator());
  238   BranchInst *PBI2 = dyn_cast<BranchInst>(PS2->getTerminator());
  238   BranchInst *PBI2 = dyn_cast<BranchInst>(PS2->getTerminator());
  254       auto *BI = cast<BranchInst>(CurrBlock->getTerminator());
  254       auto *BI = cast<BranchInst>(CurrBlock->getTerminator());
  281   BranchInst *PBI = cast<BranchInst>(FirstCondBlock->getTerminator());
  281   BranchInst *PBI = cast<BranchInst>(FirstCondBlock->getTerminator());
  292     PBI = cast<BranchInst>(FirstCondBlock->getTerminator());
  447   BranchInst *PBI = cast<BranchInst>(FirstEntryBlock->getTerminator());
  447   BranchInst *PBI = cast<BranchInst>(FirstEntryBlock->getTerminator());

lib/Transforms/Utils/GuardUtils.cpp

   35   auto *CheckBI = cast<BranchInst>(CheckBB->getTerminator());
   35   auto *CheckBI = cast<BranchInst>(CheckBB->getTerminator());

lib/Transforms/Utils/InlineFunction.cpp

  207   BranchInst::Create(Dest, Src);
 2235       BranchInst *NewBr = BranchInst::Create(II->getNormalDest(), TheCall);
 2235       BranchInst *NewBr = BranchInst::Create(II->getNormalDest(), TheCall);
 2265   BranchInst *CreatedBranchToNormalDest = nullptr;
 2269     CreatedBranchToNormalDest = BranchInst::Create(II->getNormalDest(), TheCall);
 2338       BranchInst* BI = BranchInst::Create(AfterCallBB, RI);
 2338       BranchInst* BI = BranchInst::Create(AfterCallBB, RI);
 2391   BasicBlock *CalleeEntry = cast<BranchInst>(Br)->getSuccessor(0);

lib/Transforms/Utils/Local.cpp

  116   if (auto *BI = dyn_cast<BranchInst>(T)) {
  116   if (auto *BI = dyn_cast<BranchInst>(T)) {
  272       BranchInst *NewBr = Builder.CreateCondBr(Cond,
  955   BasicBlock *Succ = cast<BranchInst>(BB->getTerminator())->getSuccessor(0);
 1963   BranchInst::Create(NormalDestBB, II);
 2114           BranchInst::Create(NormalDestBB, II);

lib/Transforms/Utils/LoopRotationUtils.cpp

  212   BranchInst *BI = dyn_cast<BranchInst>(OrigHeader->getTerminator());
  212   BranchInst *BI = dyn_cast<BranchInst>(OrigHeader->getTerminator());
  444   BranchInst *PHBI = cast<BranchInst>(OrigPreheader->getTerminator());
  444   BranchInst *PHBI = cast<BranchInst>(OrigPreheader->getTerminator());
  484     BranchInst *NewBI = BranchInst::Create(NewHeader, PHBI);
  484     BranchInst *NewBI = BranchInst::Create(NewHeader, PHBI);
  600   BranchInst *Jmp = dyn_cast<BranchInst>(Latch->getTerminator());
  600   BranchInst *Jmp = dyn_cast<BranchInst>(Latch->getTerminator());
  608   BranchInst *BI = dyn_cast<BranchInst>(LastExit->getTerminator());
  608   BranchInst *BI = dyn_cast<BranchInst>(LastExit->getTerminator());

lib/Transforms/Utils/LoopSimplify.cpp

  379   BranchInst *BETerminator = BranchInst::Create(Header, BEBlock);
  379   BranchInst *BETerminator = BranchInst::Create(Header, BEBlock);
  520     if (BranchInst *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator()))
  520     if (BranchInst *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator()))
  631       BranchInst *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator());
  631       BranchInst *BI = dyn_cast<BranchInst>(ExitingBlock->getTerminator());

lib/Transforms/Utils/LoopUnroll.cpp

  305   BranchInst *HeaderBI = dyn_cast<BranchInst>(Header->getTerminator());
  305   BranchInst *HeaderBI = dyn_cast<BranchInst>(Header->getTerminator());
  306   BranchInst *BI = dyn_cast<BranchInst>(LatchBlock->getTerminator());
  306   BranchInst *BI = dyn_cast<BranchInst>(LatchBlock->getTerminator());
  557     auto *Term = cast<BranchInst>(Header->getTerminator());
  557     auto *Term = cast<BranchInst>(Header->getTerminator());
  716     auto *Term = cast<BranchInst>(Src->getTerminator());
  716     auto *Term = cast<BranchInst>(Src->getTerminator());
  735       BranchInst::Create(Dest, Term);
  807       BranchInst *Term = cast<BranchInst>(Latches[i]->getTerminator());
  807       BranchInst *Term = cast<BranchInst>(Latches[i]->getTerminator());
  818         BranchInst::Create(Dest, Term);
  853           if (isa<BranchInst>(Term) && cast<BranchInst>(Term)->isConditional()) {
  853           if (isa<BranchInst>(Term) && cast<BranchInst>(Term)->isConditional()) {
  876     BranchInst *Term = dyn_cast<BranchInst>(Latch->getTerminator());
  876     BranchInst *Term = dyn_cast<BranchInst>(Latch->getTerminator());

lib/Transforms/Utils/LoopUnrollAndJam.cpp

  250   BranchInst *BI = dyn_cast<BranchInst>(LatchBlock->getTerminator());
  250   BranchInst *BI = dyn_cast<BranchInst>(LatchBlock->getTerminator());
  447   BranchInst *ForeTerm =
  448       cast<BranchInst>(ForeBlocksLast.back()->getTerminator());
  465     BranchInst *ForeTerm =
  466         cast<BranchInst>(ForeBlocksLast[It - 1]->getTerminator());
  472   BranchInst *SubTerm =
  473       cast<BranchInst>(SubLoopBlocksLast.back()->getTerminator());
  484     BranchInst *SubTerm =
  485         cast<BranchInst>(SubLoopBlocksLast[It - 1]->getTerminator());
  486     BranchInst::Create(SubLoopBlocksFirst[It], SubTerm);
  497   BranchInst *Term = cast<BranchInst>(AftBlocksLast.back()->getTerminator());
  497   BranchInst *Term = cast<BranchInst>(AftBlocksLast.back()->getTerminator());
  499     BranchInst::Create(LoopExit, Term);
  510     BranchInst *AftTerm =
  511         cast<BranchInst>(AftBlocksLast[It - 1]->getTerminator());
  512     BranchInst::Create(AftBlocksFirst[It], AftTerm);
  544     BranchInst *Term = dyn_cast<BranchInst>(BB->getTerminator());
  544     BranchInst *Term = dyn_cast<BranchInst>(BB->getTerminator());

lib/Transforms/Utils/LoopUnrollPeel.cpp

   90       const BranchInst *T = dyn_cast<BranchInst>(Latch->getTerminator());
   90       const BranchInst *T = dyn_cast<BranchInst>(Latch->getTerminator());
  178     auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
  178     auto *BI = dyn_cast<BranchInst>(BB->getTerminator());
  400 static void updateBranchWeights(BasicBlock *Header, BranchInst *LatchBR,
  424 static void initBranchWeights(BasicBlock *Header, BranchInst *LatchBR,
  441 static void fixupBranchWeights(BasicBlock *Header, BranchInst *LatchBR,
  518   BranchInst *LatchBR = cast<BranchInst>(NewLatch->getTerminator());
  518   BranchInst *LatchBR = cast<BranchInst>(NewLatch->getTerminator());
  685   BranchInst *LatchBR =
  686       cast<BranchInst>(cast<BasicBlock>(Latch)->getTerminator());
  715     auto *LatchBRCopy = cast<BranchInst>(VMap[LatchBR]);
  715     auto *LatchBRCopy = cast<BranchInst>(VMap[LatchBR]);

lib/Transforms/Utils/LoopUnrollRuntime.cpp

  352       BranchInst *LatchBR = cast<BranchInst>(NewBB->getTerminator());
  352       BranchInst *LatchBR = cast<BranchInst>(NewBB->getTerminator());
  567   BranchInst *LatchBR = cast<BranchInst>(Latch->getTerminator());
  567   BranchInst *LatchBR = cast<BranchInst>(Latch->getTerminator());
  635   BranchInst *PreHeaderBR = cast<BranchInst>(PreHeader->getTerminator());
  635   BranchInst *PreHeaderBR = cast<BranchInst>(PreHeader->getTerminator());
  712   PreHeaderBR = cast<BranchInst>(PreHeader->getTerminator());
  896     BranchInst *LatchBR = cast<BranchInst>(Latch->getTerminator());
  896     BranchInst *LatchBR = cast<BranchInst>(Latch->getTerminator());

lib/Transforms/Utils/LoopUtils.cpp

  529   auto *OldBr = dyn_cast<BranchInst>(Preheader->getTerminator());
  529   auto *OldBr = dyn_cast<BranchInst>(Preheader->getTerminator());
  687   BranchInst *LatchBR = dyn_cast<BranchInst>(Latch->getTerminator());
  687   BranchInst *LatchBR = dyn_cast<BranchInst>(Latch->getTerminator());

lib/Transforms/Utils/LoopVersioning.cpp

  110   BranchInst::Create(NonVersionedLoop->getLoopPreheader(),

lib/Transforms/Utils/LowerInvoke.cpp

   64       BranchInst::Create(II->getNormalDest(), II);

lib/Transforms/Utils/LowerMemIntrinsics.cpp

  344   BranchInst::Create(ExitBB, LoopBB, CompareN, ThenTerm);
  364   BranchInst::Create(ExitBB, FwdLoopBB, CompareN, ElseTerm);

lib/Transforms/Utils/LowerSwitch.cpp

  324   BranchInst::Create(LBranch, RBranch, Comp, NewNode);
  375   BranchInst::Create(Succ, Default, Comp, NewLeaf);
  465     BranchInst::Create(Default, OrigBlock);
  579       BranchInst::Create(Default, OrigBlock);
  598   BranchInst::Create(Default, NewDefault);
  609   BranchInst::Create(SwitchBlock, OrigBlock);

lib/Transforms/Utils/MisExpect.cpp

   55   if (auto *B = dyn_cast<BranchInst>(I)) {
   55   if (auto *B = dyn_cast<BranchInst>(I)) {

lib/Transforms/Utils/PredicateInfo.cpp

  391 void PredicateInfo::processBranch(BranchInst *BI, BasicBlock *BranchBB,
  495     if (auto *BI = dyn_cast<BranchInst>(BranchBB->getTerminator())) {
  495     if (auto *BI = dyn_cast<BranchInst>(BranchBB->getTerminator())) {

lib/Transforms/Utils/SimplifyCFG.cpp

  202   bool SimplifyUncondBranch(BranchInst *BI, IRBuilder<> &Builder);
  203   bool SimplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder);
  261 isProfitableToFoldUnconditional(BranchInst *SI1, BranchInst *SI2,
  261 isProfitableToFoldUnconditional(BranchInst *SI1, BranchInst *SI2,
  370   BranchInst *BI = dyn_cast<BranchInst>(PBB->getTerminator());
  370   BranchInst *BI = dyn_cast<BranchInst>(PBB->getTerminator());
  685   } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  685   } else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  706   } else if (BranchInst *BI = dyn_cast<BranchInst>(TI))
  706   } else if (BranchInst *BI = dyn_cast<BranchInst>(TI))
  736   BranchInst *BI = cast<BranchInst>(TI);
  736   BranchInst *BI = cast<BranchInst>(TI);
  850     if (isa<BranchInst>(TI)) {
  980   if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
  980   if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
 1204             BranchInst::Create(InfLoopBlock, InfLoopBlock);
 1237 static bool HoistThenElseCodeToIf(BranchInst *BI,
 1750     if (isa<BranchInst>(T) && cast<BranchInst>(T)->isUnconditional())
 1750     if (isa<BranchInst>(T) && cast<BranchInst>(T)->isUnconditional())
 1752     else if ((isa<BranchInst>(T) || isa<SwitchInst>(T)) && !Cond)
 1956 static bool SpeculativelyExecuteBB(BranchInst *BI, BasicBlock *ThenBB,
 2174 static bool FoldCondBranchOnPHI(BranchInst *BI, const DataLayout &DL,
 2225     BranchInst *CritEdgeBranch = BranchInst::Create(RealDest, EdgeBB);
 2225     BranchInst *CritEdgeBranch = BranchInst::Create(RealDest, EdgeBB);
 2378   if (cast<BranchInst>(IfBlock1->getTerminator())->isConditional()) {
 2391   if (cast<BranchInst>(IfBlock2->getTerminator())->isConditional()) {
 2445 static bool SimplifyCondBranchToTwoReturns(BranchInst *BI,
 2550 static bool extractPredSuccWeights(BranchInst *PBI, BranchInst *BI,
 2550 static bool extractPredSuccWeights(BranchInst *PBI, BranchInst *BI,
 2573 bool llvm::FoldBranchToCommonDest(BranchInst *BI, MemorySSAUpdater *MSSAU,
 2588       if (BranchInst *PBI = dyn_cast<BranchInst>(PB->getTerminator()))
 2588       if (BranchInst *PBI = dyn_cast<BranchInst>(PB->getTerminator()))
 2670     BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator());
 2670     BranchInst *PBI = dyn_cast<BranchInst>(PredBlock->getTerminator());
 2854       BranchInst *New_PBI = BranchInst::Create(TrueDest, PBI);
 2854       BranchInst *New_PBI = BranchInst::Create(TrueDest, PBI);
 3048   Value *PCond = cast<BranchInst>(PFB->getSinglePredecessor()->getTerminator())
 3050   Value *QCond = cast<BranchInst>(QFB->getSinglePredecessor()->getTerminator())
 3107 static bool mergeConditionalStores(BranchInst *PBI, BranchInst *QBI,
 3107 static bool mergeConditionalStores(BranchInst *PBI, BranchInst *QBI,
 3219 static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI,
 3219 static bool SimplifyCondBranchToCondBranch(BranchInst *PBI, BranchInst *BI,
 3253         if ((PBI = dyn_cast<BranchInst>(P->getTerminator())) && PBI != BI &&
 3357     BranchInst::Create(InfLoopBlock, InfLoopBlock);
 3493       BranchInst *NewBI = Builder.CreateCondBr(Cond, TrueBB, FalseBB);
 3692 static bool SimplifyBranchOnICmpChain(BranchInst *BI, IRBuilder<> &Builder,
 4086   BranchInst::Create(UnwindDest, RI->getParent());
 4115   SmallVector<BranchInst *, 8> CondBranchPreds;
 4119     if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) {
 4119     if (BranchInst *BI = dyn_cast<BranchInst>(PTI)) {
 4151     BranchInst *BI = CondBranchPreds.pop_back_val();
 4225     if (auto *BI = dyn_cast<BranchInst>(TI)) {
 4225     if (auto *BI = dyn_cast<BranchInst>(TI)) {
 4404   BranchInst *NewBI = Builder.CreateCondBr(Cmp, ContiguousDest, OtherDest);
 4524   BranchInst *Branch = dyn_cast<BranchInst>(BB->getTerminator());
 4524   BranchInst *Branch = dyn_cast<BranchInst>(BB->getTerminator());
 5226     User *PhiUser, BasicBlock *PhiBlock, BranchInst *RangeCheckBranch,
 5418   BranchInst *RangeCheckBranch = nullptr;
 5710     BranchInst::Create(IBI->getDestination(0), IBI);
 5743 static bool TryToMergeLandingPad(LandingPadInst *LPad, BranchInst *BI,
 5761     BranchInst *BI2 = dyn_cast<BranchInst>(I);
 5761     BranchInst *BI2 = dyn_cast<BranchInst>(I);
 5799 bool SimplifyCFGOpt::SimplifyUncondBranch(BranchInst *BI,
 5860 bool SimplifyCFGOpt::SimplifyCondBranch(BranchInst *BI, IRBuilder<> &Builder) {
 5947     if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator()))
 5947     if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator()))
 5955       if (BranchInst *PBI = dyn_cast<BranchInst>(PrevBB->getTerminator()))
 5955       if (BranchInst *PBI = dyn_cast<BranchInst>(PrevBB->getTerminator()))
 6023         if (BranchInst *BI = dyn_cast<BranchInst>(T)) {
 6023         if (BranchInst *BI = dyn_cast<BranchInst>(T)) {
 6084   if (auto *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
 6084   if (auto *BI = dyn_cast<BranchInst>(BB->getTerminator())) {

lib/Transforms/Utils/UnifyFunctionExitNodes.cpp

   69       BranchInst::Create(UnreachableBlock, BB);
  110     BranchInst::Create(NewRetBlock, BB);

lib/Transforms/Vectorize/LoopVectorizationLegality.cpp

  315   auto *LatchBr = dyn_cast<BranchInst>(Latch->getTerminator());
  315   auto *LatchBr = dyn_cast<BranchInst>(Latch->getTerminator());
  433     auto *Br = dyn_cast<BranchInst>(BB->getTerminator());
  433     auto *Br = dyn_cast<BranchInst>(BB->getTerminator());
  967     if (!isa<BranchInst>(BB->getTerminator())) {

lib/Transforms/Vectorize/LoopVectorize.cpp

 1742   auto *Br = cast<BranchInst>(LoopVectorLatch->getTerminator());
 1742   auto *Br = cast<BranchInst>(LoopVectorLatch->getTerminator());
 2706                       BranchInst::Create(Bypass, NewBB, CheckMinIters));
 2738                       BranchInst::Create(Bypass, NewBB, SCEVCheck));
 2784                       BranchInst::Create(Bypass, NewBB, MemRuntimeCheck));
 3044   BranchInst *ScalarLatchBr =
 3045       cast<BranchInst>(OrigLoop->getLoopLatch()->getTerminator());
 3064   BranchInst *BrInst = BranchInst::Create(ExitBlock, ScalarPH, CmpN);
 3064   BranchInst *BrInst = BranchInst::Create(ExitBlock, ScalarPH, CmpN);
 6112     BranchInst *BI = cast<BranchInst>(I);
 6112     BranchInst *BI = cast<BranchInst>(I);
 6654   BranchInst *BI = dyn_cast<BranchInst>(Src->getTerminator());
 6654   BranchInst *BI = dyn_cast<BranchInst>(Src->getTerminator());
 7056     BranchInst *Branch = dyn_cast<BranchInst>(BB->getTerminator());
 7056     BranchInst *Branch = dyn_cast<BranchInst>(BB->getTerminator());
 7133       if (isa<BranchInst>(Instr) ||
 7393   auto *CondBr = BranchInst::Create(State.CFG.PrevBB, nullptr, ConditionBit);
 7393   auto *CondBr = BranchInst::Create(State.CFG.PrevBB, nullptr, ConditionBit);

lib/Transforms/Vectorize/VPlan.cpp

  148       BranchInst::Create(NewBB, PredBB);
  222     auto *CondBr = BranchInst::Create(NewBB, nullptr, NewCond);
  222     auto *CondBr = BranchInst::Create(NewBB, nullptr, NewCond);
  440   BranchInst::Create(VectorLatchBB, LastBB);

lib/Transforms/Vectorize/VPlanHCFGBuilder.cpp

  203     if (auto *Br = dyn_cast<BranchInst>(Inst)) {
  203     if (auto *Br = dyn_cast<BranchInst>(Inst)) {
  290       auto *Br = cast<BranchInst>(TI);
  290       auto *Br = cast<BranchInst>(TI);

tools/bugpoint/CrashDebugger.cpp

  586         auto *BR = dyn_cast<BranchInst>(BB.getTerminator());
  586         auto *BR = dyn_cast<BranchInst>(BB.getTerminator());

tools/bugpoint/Miscompilation.cpp

  886           BranchInst::Create(LookupBB, DoCallBB, IsNull, EntryBB);
  901           BranchInst::Create(DoCallBB, LookupBB);

tools/clang/lib/CodeGen/Address.h

  108 template <class U> inline U cast(CodeGen::Address addr) {

tools/clang/lib/CodeGen/CGClass.cpp

 1923   llvm::BranchInst *zeroCheckBranch = nullptr;

tools/clang/lib/CodeGen/CGCleanup.cpp

  365   if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) {
  365   if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) {
  526   llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Pred->getTerminator());
  526   llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Pred->getTerminator());
  587   if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) {
  587   if (llvm::BranchInst *Br = dyn_cast<llvm::BranchInst>(Term)) {
  622       llvm::BranchInst::Create(si->case_begin()->getCaseSuccessor(), si);
  845         InstsToAppend.push_back(llvm::BranchInst::Create(BranchAfter));
  890         InstsToAppend.push_back(llvm::BranchInst::Create(BranchThroughDest));
 1052   llvm::BranchInst *BI = Builder.CreateBr(Dest.getBlock());

tools/clang/lib/CodeGen/CGException.cpp

 1253       auto *BI = cast<llvm::BranchInst>(TI);
 1253       auto *BI = cast<llvm::BranchInst>(TI);

tools/clang/lib/CodeGen/CGExpr.cpp

 3121   llvm::BranchInst *BI = Builder.CreateCondBr(Cond, Cont, CheckBB);

tools/clang/lib/CodeGen/CGStmt.cpp

  444   llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());
  444   llvm::BranchInst *BI = dyn_cast<llvm::BranchInst>(BB->getTerminator());

tools/clang/lib/CodeGen/CodeGenFunction.cpp

  265     llvm::BranchInst *BI =
  266       dyn_cast<llvm::BranchInst>(*ReturnBlock.getBlock()->user_begin());

tools/clang/lib/CodeGen/EHScopeStack.h

   52   llvm::BranchInst *InitialBranch;

tools/lldb/source/Expression/IRInterpreter.cpp

  932       const BranchInst *br_inst = dyn_cast<BranchInst>(inst);
  932       const BranchInst *br_inst = dyn_cast<BranchInst>(inst);

tools/llvm-diff/DifferenceEngine.cpp

  287     } else if (isa<BranchInst>(L)) {
  288       BranchInst *LI = cast<BranchInst>(L);
  288       BranchInst *LI = cast<BranchInst>(L);
  289       BranchInst *RI = cast<BranchInst>(R);
  289       BranchInst *RI = cast<BranchInst>(R);
  633   if (isa<BranchInst>(LTerm) && isa<InvokeInst>(RTerm)) {
  634     if (cast<BranchInst>(LTerm)->isConditional()) return;
  646   } else if (isa<InvokeInst>(LTerm) && isa<BranchInst>(RTerm)) {
  647     if (cast<BranchInst>(RTerm)->isConditional()) return;

tools/llvm-reduce/deltas/ReduceBasicBlocks.cpp

   39   bool IsBranch = isa<BranchInst>(Term);
   52     BranchInst::Create(ChunkSucessors[0], &BB);

tools/llvm-stress/llvm-stress.cpp

  722       BranchInst::Create(Curr, Next, Instr, Curr->getTerminator());

tools/polly/include/polly/CodeGen/IRBuilder.h

   60   void annotateLoopLatch(llvm::BranchInst *B, llvm::Loop *L, bool IsParallel,

tools/polly/include/polly/CodeGen/Utils.h

   68 std::pair<BBPair, llvm::BranchInst *>

tools/polly/include/polly/ScopDetection.h

  431   bool isValidBranch(BasicBlock &BB, BranchInst *BI, Value *Condition,

tools/polly/lib/Analysis/ScopBuilder.cpp

  750     BranchInst *BI = dyn_cast<BranchInst>(TI);
  750     BranchInst *BI = dyn_cast<BranchInst>(TI);

tools/polly/lib/Analysis/ScopDetection.cpp

  556 bool ScopDetection::isValidBranch(BasicBlock &BB, BranchInst *BI,
  659   if (BranchInst *BI = dyn_cast<BranchInst>(TI))
  659   if (BranchInst *BI = dyn_cast<BranchInst>(TI))

tools/polly/lib/CodeGen/BlockGenerators.cpp

  636   BranchInst *Branch = cast<BranchInst>(HeadBlock->getTerminator());
  636   BranchInst *Branch = cast<BranchInst>(HeadBlock->getTerminator());

tools/polly/lib/CodeGen/IRBuilder.cpp

  123 void ScopAnnotator::annotateLoopLatch(BranchInst *B, Loop *L, bool IsParallel,

tools/polly/lib/CodeGen/LoopGenerators.cpp

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

tools/polly/lib/CodeGen/Utils.cpp

   77 std::pair<polly::BBPair, BranchInst *>
  149   BranchInst *CondBr = Builder.CreateCondBr(RTC, StartBlock, S.getEntry());

tools/polly/lib/Support/ScopHelper.cpp

  451   if (BranchInst *BR = dyn_cast<BranchInst>(TI)) {
  451   if (BranchInst *BR = dyn_cast<BranchInst>(TI)) {

unittests/Analysis/DomTreeUpdaterTest.cpp

  182   BranchInst::Create(BB0, NewEntry);
  196   BranchInst::Create(BB1, NewEntry);
  273   BranchInst::Create(BB1, BB2, ConstantInt::getTrue(F->getContext()), BB0);
  371   BranchInst::Create(BB1, BB3, ConstantInt::getTrue(F->getContext()), BB0);
  405   BranchInst::Create(BB3, BB0);
  490   BranchInst::Create(BB1, BB2, ConstantInt::getTrue(F->getContext()), BB0);
  557   BranchInst::Create(BB0, NewEntry);
  574   BranchInst::Create(BB1, NewEntry);
  760   BranchInst::Create(BB1, BB0);
  790   BranchInst::Create(BB2, BB0);

unittests/Analysis/LoopInfoTest.cpp

  264         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  264         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  322         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  322         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  380         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  380         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  438         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  438         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  496         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  496         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  555         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  555         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  613         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  613         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  668         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  668         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  726         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  726         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  784         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  784         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  844         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  844         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  904         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
  904         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
 1073         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
 1073         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
 1142         BranchInst *OuterGuard = dyn_cast<BranchInst>(Entry->getTerminator());
 1142         BranchInst *OuterGuard = dyn_cast<BranchInst>(Entry->getTerminator());
 1147         BranchInst *InnerGuard = dyn_cast<BranchInst>(Header->getTerminator());
 1147         BranchInst *InnerGuard = dyn_cast<BranchInst>(Header->getTerminator());
 1234         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());
 1234         BranchInst *Guard = dyn_cast<BranchInst>(Entry->getTerminator());

unittests/Analysis/MemorySSATest.cpp

   87   BranchInst::Create(Merge, Left);
   88   BranchInst::Create(Merge, Right);
  310   BranchInst::Create(Merge, Left);
  311   BranchInst::Create(Merge, Right);
  346   BranchInst::Create(Merge, Left);
  347   BranchInst::Create(Merge, Right);
  392   BranchInst::Create(Merge, Left);
  393   BranchInst::Create(Merge, Right);
  436   BranchInst::Create(Merge, Left);
  437   BranchInst::Create(Merge, Right);
  490   BranchInst::Create(Merge, Left);
  491   BranchInst::Create(Merge, Right);
  535   BranchInst::Create(Merge, Left);
  536   BranchInst::Create(Merge, Right);
 1420   BranchInst::Create(Header, Entry);
 1426   BranchInst::Create(Exit, Body);
 1479   BranchInst::Create(Header, Entry);
 1487   BranchInst::Create(Exit, Body);
 1556   BranchInst::Create(DBlock, BBlock);
 1558   BranchInst::Create(DBlock, CBlock);
 1560   BranchInst::Create(EBlock, DBlock);
 1563   BranchInst::Create(EBlock, FBlock);

unittests/Analysis/PhiValuesTest.cpp

   36   BranchInst::Create(If, Else, UndefValue::get(I1Ty), Entry);
   37   BranchInst::Create(Then, If);
   38   BranchInst::Create(Then, Else);
  106   BranchInst::Create(If1, Else1, UndefValue::get(I1Ty), Entry);
  107   BranchInst::Create(Then, If1);
  108   BranchInst::Create(Then, Else1);
  109   BranchInst::Create(If2, Else2, UndefValue::get(I1Ty), Then);
  110   BranchInst::Create(End, If2);
  111   BranchInst::Create(End, Else2);

unittests/Analysis/ScalarEvolutionTest.cpp

  124   BranchInst::Create(LoopBB, EntryBB);
  125   BranchInst::Create(LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)),
  158   BranchInst::Create(LoopBB, EntryBB);
  173   BranchInst *Br = BranchInst::Create(
  173   BranchInst *Br = BranchInst::Create(
  340   BranchInst::Create(LoopBB, EntryBB);
  383   BranchInst::Create(LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)),
  684   BranchInst::Create(CondBB, EntryBB);
  704     BranchInst::Create(IncBB, NextBB, Cmp, CondBB);
  708     BranchInst::Create(CondBB, IncBB);
 1011   BranchInst::Create(LoopBB, EntryBB);
 1016   auto *Br = BranchInst::Create(
 1016   auto *Br = BranchInst::Create(
 1069   BranchInst::Create(LoopBB, EntryBB);
 1073   auto *Br = BranchInst::Create(
 1073   auto *Br = BranchInst::Create(

unittests/FuzzMutate/OperationsTest.cpp

  190   auto *UncondBr = cast<BranchInst>(BB->getTerminator());
  190   auto *UncondBr = cast<BranchInst>(BB->getTerminator());
  202   auto *CondBr = cast<BranchInst>(BB1->getTerminator());
  202   auto *CondBr = cast<BranchInst>(BB1->getTerminator());
  257   BranchInst::Create(BB2, BB3, ConstantInt::getFalse(Ctx), BB1);
  258   BranchInst::Create(BB3, BB2);

unittests/IR/BasicBlockTest.cpp

   31   BranchInst::Create(BB.get(), BB1.get());
   33   BranchInst::Create(BB.get(), BB2.get());
   42   auto *BI = BranchInst::Create(BB.get(), BB.get());
   42   auto *BI = BranchInst::Create(BB.get(), BB.get());

unittests/IR/DominatorTreeTest.cpp

  241         BranchInst::Create(BB4, BB3, ConstantInt::getTrue(F.getContext()), BB1);
  268         BranchInst::Create(BB0, NewEntry);

unittests/IR/IRBuilderTest.cpp

  332   BranchInst *BI = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);
  816   auto Br = BranchInst::Create(BB2, BB);

unittests/IR/InstructionsTest.cpp

  124   const BranchInst* b0 = BranchInst::Create(bb0);
  124   const BranchInst* b0 = BranchInst::Create(bb0);
  142   BranchInst* b1 = BranchInst::Create(bb0, bb1, One);
  142   BranchInst* b1 = BranchInst::Create(bb0, bb1, One);

unittests/IR/LegacyPassManagerTest.cpp

  594         BranchInst::Create(label_bb, label_entry_11);
  597         BranchInst::Create(label_bb, label_bb1, int1_f, label_bb);
  600         BranchInst::Create(label_bb1, label_return, int1_f, label_bb1);

unittests/IR/VerifierTest.cpp

   38   BranchInst *BI = BranchInst::Create(Exit, Exit, False, Entry);
   38   BranchInst *BI = BranchInst::Create(Exit, Exit, False, Entry);

unittests/Transforms/Scalar/LoopPassManagerTest.cpp

  911     BranchInst::Create(TrueBB, FalseBB, Cond, BB);
  961         BranchInst::Create(NewLoop010BB, NewLoop010PHBB);
  964         BranchInst::Create(&Loop01BB, NewLoop01LatchBB);
 1004         BranchInst::Create(NewLoop011BB, NewLoop011PHBB);
 1114     BranchInst::Create(TrueBB, FalseBB, Cond, BB);
 1150         BranchInst::Create(NewLoop01BB, NewLoop01PHBB);
 1208         BranchInst::Create(NewLoop03BB, NewLoop03PHBB);
 1210         BranchInst::Create(NewLoop04BB, NewLoop04PHBB);
 1212         BranchInst::Create(NewLoop040BB, NewLoop040PHBB);
 1214         BranchInst::Create(NewLoop04BB, NewLoop04LatchBB);
 1272         BranchInst::Create(NewLoop1BB, NewLoop1PHBB);
 1505             BranchInst::Create(NewLoop03BB, NewLoop03PHBB);
 1509             BranchInst::Create(&Loop0LatchBB, NewLoop03BB, Cond, NewLoop03BB);

unittests/Transforms/Utils/LocalTest.cpp

   36   BranchInst *br0 = builder.CreateCondBr(builder.getTrue(), bb0, bb1);
   39   BranchInst *br1 = builder.CreateBr(bb0);
   77   BranchInst::Create(BB, Entry);
   97   BranchInst::Create(BB, BB);
  219       BranchInst *Term = dyn_cast<BranchInst>(SinglePred->getTerminator());
  219       BranchInst *Term = dyn_cast<BranchInst>(SinglePred->getTerminator());

usr/include/c++/7.4.0/type_traits

 1983     { typedef _Up     type; };

utils/unittest/googletest/include/gtest/gtest-printers.h

  407                     T* p, ::std::ostream* os) {
  416     if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {