Jumpthreading change to handle return block

llvm/include/llvm/Transforms/Scalar/JumpThreading.h

public:
   void FindLoopHeaders(Function &F);
   bool ProcessBlock(BasicBlock *BB);
   bool MaybeMergeBasicBlockIntoOnlyPred(BasicBlock *BB);
   void UpdateSSA(BasicBlock *BB, BasicBlock *NewBB,
                  DenseMap<Instruction *, Value *> &ValueMapping);
   DenseMap<Instruction *, Value *> CloneInstructions(BasicBlock::iterator BI,
                                                      BasicBlock::iterator BE,
                                                      BasicBlock *NewBB,
-                                                     BasicBlock *PredBB);
+                                                     BasicBlock *PredBB,
+                                                     BasicBlock *SuccBB,
+                                                     Value *PredVal);
   bool ThreadEdge(BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs,
-                  BasicBlock *SuccBB);
+                  BasicBlock *SuccBB, Value *PredVal = nullptr);
   bool DuplicateCondBranchOnPHIIntoPred(
       BasicBlock *BB, const SmallVectorImpl<BasicBlock *> &PredBBs);
 
   bool ComputeValueKnownInPredecessorsImpl(
       Value *V, BasicBlock *BB, jumpthreading::PredValueInfo &Result,
       jumpthreading::ConstantPreference Preference,
       DenseSet<std::pair<Value *, BasicBlock *>> &RecursionSet,
       Instruction *CxtI = nullptr);

llvm/lib/Transforms/Scalar/JumpThreading.cpp

if (BranchInst *BI = dyn_cast<BranchInst>(Terminator)) {
     Condition = BI->getCondition();
   } else if (SwitchInst *SI = dyn_cast<SwitchInst>(Terminator)) {
     Condition = SI->getCondition();
   } else if (IndirectBrInst *IB = dyn_cast<IndirectBrInst>(Terminator)) {
     // Can't thread indirect branch with no successors.
     if (IB->getNumSuccessors() == 0) return false;
     Condition = IB->getAddress()->stripPointerCasts();
     Preference = WantBlockAddress;
+  } else if (ReturnInst *RetInst = dyn_cast<ReturnInst>(Terminator)) {
+    auto *RV = RetInst->getReturnValue();
+    if (!RV || !(Condition = dyn_cast<CmpInst>(RV)))
+      return false;
   } else {
     return false; // Must be an invoke or callbr.
   }
 
   // Run constant folding to see if we can reduce the condition to a simple
   // constant.
   if (Instruction *I = dyn_cast<Instruction>(Condition)) {
     Value *SimpleVal =
         ConstantFoldInstruction(I, BB->getModule()->getDataLayout(), TLI);
     if (SimpleVal) {
       I->replaceAllUsesWith(SimpleVal);
       if (isInstructionTriviallyDead(I, TLI))
         I->eraseFromParent();
       Condition = SimpleVal;
     }
   }
 
   // If the terminator is branching on an undef, we can pick any of the
   // successors to branch to.  Let GetBestDestForJumpOnUndef decide.
-  if (isa<UndefValue>(Condition)) {
+  if (isa<UndefValue>(Condition) && BB->getTerminator()->getNumSuccessors()) {
     unsigned BestSucc = GetBestDestForJumpOnUndef(BB);
     std::vector<DominatorTree::UpdateType> Updates;
 
     // Fold the branch/switch.
     Instruction *BBTerm = BB->getTerminator();
     Updates.reserve(BBTerm->getNumSuccessors());
     for (unsigned i = 0, e = BBTerm->getNumSuccessors(); i != e; ++i) {
       if (i == BestSucc) continue;
bool JumpThreadingPass::ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
   for (const auto &PredValue : PredValues) {
     BasicBlock *Pred = PredValue.second;
     if (!SeenPreds.insert(Pred).second)
       continue;  // Duplicate predecessor entry.
 
     Constant *Val = PredValue.first;
 
     BasicBlock *DestBB;
-    if (isa<UndefValue>(Val))
-      DestBB = nullptr;
-    else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator())) {
+    auto *TI = BB->getTerminator();
+    if (isa<UndefValue>(Val) && TI->getNumSuccessors() != 0)
+      DestBB = TI->getSuccessor(GetBestDestForJumpOnUndef(BB));
+    else if (BranchInst *BI = dyn_cast<BranchInst>(TI)) {
       assert(isa<ConstantInt>(Val) && "Expecting a constant integer");
       DestBB = BI->getSuccessor(cast<ConstantInt>(Val)->isZero());
-    } else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) {
+    } else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
       assert(isa<ConstantInt>(Val) && "Expecting a constant integer");
       DestBB = SI->findCaseValue(cast<ConstantInt>(Val))->getCaseSuccessor();
+    } else if (ReturnInst *RI = dyn_cast<ReturnInst>(TI)) {
+      (void) RI;
+      assert(RI->getReturnValue() == Cond &&
+             "Expecting comparison result returned");
+      DestBB = nullptr;
     } else {
-      assert(isa<IndirectBrInst>(BB->getTerminator())
-              && "Unexpected terminator");
+      assert(isa<IndirectBrInst>(TI) && "Unexpected terminator");
       assert(isa<BlockAddress>(Val) && "Expecting a constant blockaddress");
       DestBB = cast<BlockAddress>(Val)->getBasicBlock();
     }
 
     // If we have exactly one destination, remember it for efficiency below.
     if (PredToDestList.empty()) {
       OnlyDest = DestBB;
       OnlyVal = Val;
if (BB->hasNPredecessors(PredToDestList.size())) {
         // is because we use the guards/assume to reason about the `Cond` value
         // at the end of block, but RAUW unconditionally replaces all uses
         // including the guards/assumes themselves and the uses before the
         // guard/assume.
         else if (OnlyVal && OnlyVal != MultipleVal &&
                  CondInst->getParent() == BB)
           ReplaceFoldableUses(CondInst, OnlyVal);
       }
+      SimplifyInstructionsInBlock(BB, TLI);
       return true;
     }
   }
 
   // Determine which is the most common successor.  If we have many inputs and
   // this block is a switch, we want to start by threading the batch that goes
   // to the most popular destination first.  If we only know about one
   // threadable destination (the common case) we can avoid this.
if (PredToDestList.empty())
       return false;
 
     MostPopularDest = FindMostPopularDest(BB, PredToDestList);
   }
 
   // Now that we know what the most popular destination is, factor all
   // predecessors that will jump to it into a single predecessor.
   SmallVector<BasicBlock*, 16> PredsToFactor;
+  Value *PredVal = nullptr;
+  if (MostPopularDest) {
     for (const auto &PredToDest : PredToDestList)
       if (PredToDest.second == MostPopularDest) {
         BasicBlock *Pred = PredToDest.first;
 
         // This predecessor may be a switch or something else that has multiple
         // edges to the block.  Factor each of these edges by listing them
         // according to # occurrences in PredsToFactor.
         for (BasicBlock *Succ : successors(Pred))
           if (Succ == BB)
             PredsToFactor.push_back(Pred);
       }
-
-  // If the threadable edges are branching on an undefined value, we get to pick
-  // the destination that these predecessors should get to.
-  if (!MostPopularDest)
-    MostPopularDest = BB->getTerminator()->
-                            getSuccessor(GetBestDestForJumpOnUndef(BB));
+  } else {
+    LLVM_DEBUG(auto *TI = BB->getTerminator();
+               assert(isa<ReturnInst>(TI)););
+    auto *Pred = PredToDestList.begin()->first;
+    PredsToFactor.push_back(Pred);
+    // We need to find the pred val associated with the selected pred:
+    for (const auto &PredValue : PredValues) {
+      if (PredValue.second == Pred) {
+        PredVal = PredValue.first;
+        break;
+      }
+    }
+    // FIXME: add support for factoring predecessors with
+    // the same PredVal
+    assert(PredVal && "non null pred val expected!");
+  }
 
   // Ok, try to thread it!
-  return ThreadEdge(BB, PredsToFactor, MostPopularDest);
+  return ThreadEdge(BB, PredsToFactor, MostPopularDest, PredVal);
 }
 
 /// ProcessBranchOnPHI - We have an otherwise unthreadable conditional branch on
 /// a PHI node in the current block.  See if there are any simplifications we
 /// can do based on inputs to the phi node.
 bool JumpThreadingPass::ProcessBranchOnPHI(PHINode *PN) {
   BasicBlock *BB = PN->getParent();
 

 }
 
 /// Clone instructions in range [BI, BE) to NewBB.  For PHI nodes, we only clone
 /// arguments that come from PredBB.  Return the map from the variables in the
 /// source basic block to the variables in the newly created basic block.
 DenseMap<Instruction *, Value *>
 JumpThreadingPass::CloneInstructions(BasicBlock::iterator BI,
                                      BasicBlock::iterator BE, BasicBlock *NewBB,
-                                     BasicBlock *PredBB) {
+                                     BasicBlock *PredBB,
+                                     BasicBlock *SuccBB,
+                                     Value *PredVal) {
   // We are going to have to map operands from the source basic block to the new
   // copy of the block 'NewBB'.  If there are PHI nodes in the source basic
   // block, evaluate them to account for entry from PredBB.
   DenseMap<Instruction *, Value *> ValueMapping;
 
   // Clone the phi nodes of the source basic block into NewBB.  The resulting
   // phi nodes are trivial since NewBB only has one predecessor, but SSAUpdater
   // might need to rewrite the operand of the cloned phi.
   for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI) {
     PHINode *NewPN = PHINode::Create(PN->getType(), 1, PN->getName(), NewBB);
     NewPN->addIncoming(PN->getIncomingValueForBlock(PredBB), PredBB);
     ValueMapping[PN] = NewPN;
   }
 
   // Clone the non-phi instructions of the source basic block into NewBB,
   // keeping track of the mapping and using it to remap operands in the cloned
   // instructions.
   for (; BI != BE; ++BI) {
+    if (SuccBB && BI->isTerminator())
+      break;
     Instruction *New = BI->clone();
+    assert(!BI->isTerminator() || isa<ReturnInst>(New));
     New->setName(BI->getName());
     NewBB->getInstList().push_back(New);
     ValueMapping[&*BI] = New;
 
     // Remap operands to patch up intra-block references.
     for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
       if (Instruction *Inst = dyn_cast<Instruction>(New->getOperand(i))) {
         DenseMap<Instruction *, Value *>::iterator I = ValueMapping.find(Inst);
         if (I != ValueMapping.end())
           New->setOperand(i, I->second);
       }
+    if (ReturnInst *RetInst = dyn_cast<ReturnInst>(New)) {
+      assert(PredVal && !SuccBB);
+      New->replaceUsesOfWith(RetInst->getReturnValue(), PredVal);
+    }
   }
 
   return ValueMapping;
 }
 
 /// ThreadEdge - We have decided that it is safe and profitable to factor the
 /// blocks in PredBBs to one predecessor, then thread an edge from it to SuccBB
 /// across BB.  Transform the IR to reflect this change.
+/// When SuccBB is nullptr, there is no edge threading to be done. Instead, this
+/// method clones BB into the predecessor block to allow simplification of
+/// of instructions inside BB. For this case (SuccBB == nullptr) currently, only
+/// BB with return instruction is handled. FIXME: handle it for general case, and
+/// make this a utility.
 bool JumpThreadingPass::ThreadEdge(BasicBlock *BB,
                                    const SmallVectorImpl<BasicBlock *> &PredBBs,
-                                   BasicBlock *SuccBB) {
+                                   BasicBlock *SuccBB, Value *PredVal) {
   // If threading to the same block as we come from, we would infinite loop.
   if (SuccBB == BB) {
     LLVM_DEBUG(dbgs() << "  Not threading across BB '" << BB->getName()
                       << "' - would thread to self!\n");
     return false;
   }
 
   // If threading this would thread across a loop header, don't thread the edge.
if (PredBBs.size() == 1)
     PredBB = PredBBs[0];
   else {
     LLVM_DEBUG(dbgs() << "  Factoring out " << PredBBs.size()
                       << " common predecessors.\n");
     PredBB = SplitBlockPreds(BB, PredBBs, ".thr_comm");
   }
 
   // And finally, do it!
+  if (SuccBB)
     LLVM_DEBUG(dbgs() << "  Threading edge from '" << PredBB->getName()
                       << "' to '" << SuccBB->getName()
-                    << "' with cost: " << JumpThreadCost
+                      << "' with cost: " << JumpThreadCost << "\n");
+  else
+    LLVM_DEBUG(dbgs() << "  Cloning BB '" << BB->getName() << "' into '"
+                      << PredBB->getName() << "' with cost: " << JumpThreadCost
                       << ", across block:\n    " << *BB << "\n");
 
   if (DTU->hasPendingDomTreeUpdates())
     LVI->disableDT();
   else
     LVI->enableDT();
   LVI->threadEdge(PredBB, BB, SuccBB);
 
   BasicBlock *NewBB = BasicBlock::Create(BB->getContext(),
                                          BB->getName()+".thread",
                                          BB->getParent(), BB);
   NewBB->moveAfter(PredBB);
 
   // Set the block frequency of NewBB.
   if (HasProfileData) {
     auto NewBBFreq =
         BFI->getBlockFreq(PredBB) * BPI->getEdgeProbability(PredBB, BB);
     BFI->setBlockFreq(NewBB, NewBBFreq.getFrequency());
   }
 
   // Copy all the instructions from BB to NewBB except the terminator.
+  auto BE = BB->end();
+  if (SuccBB)
+    BE = std::prev(BE);
   DenseMap<Instruction *, Value *> ValueMapping =
-      CloneInstructions(BB->begin(), std::prev(BB->end()), NewBB, PredBB);
+      CloneInstructions(BB->begin(), BE, NewBB, PredBB, 
+                        SuccBB, PredVal);
 
   // We didn't copy the terminator from BB over to NewBB, because there is now
   // an unconditional jump to SuccBB.  Insert the unconditional jump.
-  BranchInst *NewBI = BranchInst::Create(SuccBB, NewBB);
+  BranchInst *NewBI = SuccBB ? BranchInst::Create(SuccBB, NewBB) : nullptr;
+  if (NewBI) {
     NewBI->setDebugLoc(BB->getTerminator()->getDebugLoc());
-
-  // Check to see if SuccBB has PHI nodes. If so, we need to add entries to the
-  // PHI nodes for NewBB now.
+    // Check to see if SuccBB has PHI nodes. If so, we need to add entries to
+    // the PHI nodes for NewBB now.
     AddPHINodeEntriesForMappedBlock(SuccBB, BB, NewBB, ValueMapping);
+  }
 
   // Update the terminator of PredBB to jump to NewBB instead of BB.  This
   // eliminates predecessors from BB, which requires us to simplify any PHI
   // nodes in BB.
   Instruction *PredTerm = PredBB->getTerminator();
   for (unsigned i = 0, e = PredTerm->getNumSuccessors(); i != e; ++i)
     if (PredTerm->getSuccessor(i) == BB) {
       BB->removePredecessor(PredBB, true);
       PredTerm->setSuccessor(i, NewBB);
     }
 
   // Enqueue required DT updates.
   DTU->applyUpdatesPermissive({{DominatorTree::Insert, NewBB, SuccBB},
                                {DominatorTree::Insert, PredBB, NewBB},
                                {DominatorTree::Delete, PredBB, BB}});
 
   UpdateSSA(BB, NewBB, ValueMapping);
 
   // At this point, the IR is fully up to date and consistent.  Do a quick scan
   // over the new instructions and zap any that are constants or dead.  This
   // frequently happens because of phi translation.
   SimplifyInstructionsInBlock(NewBB, TLI);
 
   // Update the edge weight from BB to SuccBB, which should be less than before.
+  if (NewBI)
     UpdateBlockFreqAndEdgeWeight(PredBB, BB, NewBB, SuccBB);
 
   // Threaded an edge!
   ++NumThreads;
   return true;
 }
 
 /// Create a new basic block that will be the predecessor of BB and successor of
 /// all blocks in Preds. When profile data is available, update the frequency of

 /// select is not jump-threaded, it will be folded again in the later
 /// optimizations.
 bool JumpThreadingPass::TryToUnfoldSelectInCurrBB(BasicBlock *BB) {
   // If threading this would thread across a loop header, don't thread the edge.
   // See the comments above FindLoopHeaders for justifications and caveats.
   if (LoopHeaders.count(BB))
     return false;
 
+  auto IsConstOrAddr = [](Value *V) {
+    if (isa<ConstantInt>(V))
+      return true;
+    V = V->stripInBoundsConstantOffsets();
+    if (isa<ConstantArray>(V) || isa<AllocaInst>(V) || isa<GlobalVariable>(V))
+      return true;
+    return false;
+  };
+
   for (BasicBlock::iterator BI = BB->begin();
        PHINode *PN = dyn_cast<PHINode>(BI); ++BI) {
     // Look for a Phi having at least one constant incoming value.
-    if (llvm::all_of(PN->incoming_values(),
-                     [](Value *V) { return !isa<ConstantInt>(V); }))
+    if (llvm::none_of(PN->incoming_values(), IsConstOrAddr))
       continue;
 
     auto isUnfoldCandidate = [BB](SelectInst *SI, Value *V) {
       // Check if SI is in BB and use V as condition.
       if (SI->getParent() != BB)
         return false;
       Value *Cond = SI->getCondition();
       return (Cond && Cond == V && Cond->getType()->isIntegerTy(1));
     };
 
     SelectInst *SI = nullptr;
     for (Use &U : PN->uses()) {
       if (ICmpInst *Cmp = dyn_cast<ICmpInst>(U.getUser())) {
         // Look for a ICmp in BB that compares PN with a constant and is the
         // condition of a Select.
         if (Cmp->getParent() == BB && Cmp->hasOneUse() &&
-            isa<ConstantInt>(Cmp->getOperand(1 - U.getOperandNo())))
+            IsConstOrAddr(Cmp->getOperand(1 - U.getOperandNo())))
           if (SelectInst *SelectI = dyn_cast<SelectInst>(Cmp->user_back()))
             if (isUnfoldCandidate(SelectI, Cmp->use_begin()->get())) {
               SI = SelectI;
               break;
             }
       } else if (SelectInst *SelectI = dyn_cast<SelectInst>(U.getUser())) {
         // Look for a Select in BB that uses PN as condition.
         if (isUnfoldCandidate(SelectI, U.get())) {

llvm/test/Transforms/JumpThreading/addr.ll

+; RUN: opt -jump-threading -S < %s | FileCheck %s
+%"struct.std::array" = type { [3 x i32] }
+
+@r = dso_local local_unnamed_addr global i32 0, align 4
+@_ZL1x = internal constant %"struct.std::array" { [3 x i32] [i32 1, i32 7, i32 17] }, align 4
+
+; Function Attrs: nounwind uwtable
+define dso_local void @foo1(i32 %arg) local_unnamed_addr #0 {
+bb:
+  switch i32 %arg, label %bb1 [
+    i32 1, label %bb4
+    i32 7, label %bb3
+  ]
+
+bb1:                                              ; preds = %bb
+  %tmp = icmp eq i32 %arg, 17
+  %tmp2 = select i1 %tmp, i32* getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 2), i32* getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 1, i32 0, i64 0)
+  br label %bb4
+
+bb3:                                              ; preds = %bb
+  br label %bb4
+
+bb4:                                              ; preds = %bb3, %bb1, %bb
+  %tmp5 = phi i32* [ getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 0), %bb ], [ %tmp2, %bb1 ], [ getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 1), %bb3 ]
+; CHECK: [[VAL:%.*]] = phi i32 [ 10,{{.*}}], [ 20, {{.*}}]
+  %tmp6 = icmp eq i32* %tmp5, getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 1, i32 0, i64 0)
+; CHECK-NOT: icmp
+; CHECK-NOT: select
+  %tmp7 = select i1 %tmp6, i32 20, i32 10
+  store i32 %tmp7, i32* @r, align 4
+; CHECK: store i32 [[VAL]], i32* @r
+  ret void
+}
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @foo2(i32 %arg) local_unnamed_addr #0 {
+bb:
+  %tmp = alloca [100 x i32], align 16
+  %tmp1 = bitcast [100 x i32]* %tmp to i8*
+  call void @llvm.lifetime.start.p0i8(i64 400, i8* nonnull %tmp1) #2
+  switch i32 %arg, label %bb2 [
+    i32 1, label %bb6
+    i32 7, label %bb5
+  ]
+
+bb2:                                              ; preds = %bb
+  %tmp3 = icmp eq i32 %arg, 17
+  %tmp4 = select i1 %tmp3, i32* getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 2), i32* getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 1, i32 0, i64 0)
+  br label %bb6
+
+bb5:                                              ; preds = %bb
+  br label %bb6
+
+bb6:                                              ; preds = %bb5, %bb2, %bb
+  %tmp7 = phi i32* [ getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 0), %bb ], [ %tmp4, %bb2 ], [ getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 1), %bb5 ]
+; CHECK: [[VAL:%.*]] = phi i32 [ 10,{{.*}}], [ 20, {{.*}}]
+  %tmp8 = icmp eq i32* %tmp7, getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 1, i32 0, i64 0)
+  %tmp9 = select i1 %tmp8, i32 20, i32 10
+; CHECK-NOT: select
+  store i32 %tmp9, i32* @r, align 4
+; CHECK: store i32 [[VAL]]
+  %tmp10 = zext i32 %tmp9 to i64
+  %tmp11 = getelementptr inbounds [100 x i32], [100 x i32]* %tmp, i64 0, i64 %tmp10
+  store i32 10, i32* %tmp11, align 8
+  %tmp12 = getelementptr inbounds [100 x i32], [100 x i32]* %tmp, i64 0, i64 10
+  %tmp13 = load i32, i32* %tmp12, align 8
+  call void @llvm.lifetime.end.p0i8(i64 400, i8* nonnull %tmp1) #2
+  ret i32 %tmp13
+}
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture) #1
+
+; Function Attrs: argmemonly nounwind willreturn
+declare void @llvm.lifetime.end.p0i8(i64 immarg, i8* nocapture) #1
+
+attributes #0 = { nounwind uwtable }
+attributes #1 = { argmemonly nounwind willreturn }
+attributes #2 = { nounwind }

llvm/test/Transforms/JumpThreading/return.ll

+; RUN: opt -jump-threading -S < %s | FileCheck %s
+%"struct.std::array" = type { [3 x i32] }
+
+@_ZL1x = internal constant %"struct.std::array" { [3 x i32] [i32 1, i32 7, i32 17] }, align 4
+@g = dso_local global [10 x i32] zeroinitializer, align 16
+
+; Function Attrs: norecurse nounwind readonly uwtable
+define dso_local zeroext i1 @foo1(i32 %arg) local_unnamed_addr #0 {
+bb:
+  switch i32 %arg, label %bb1 [
+    i32 1, label %bb4
+    i32 7, label %bb3
+  ]
+
+bb1:                                              ; preds = %bb
+  %tmp = icmp eq i32 %arg, 17
+  %tmp2 = select i1 %tmp, i32* getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 2), i32* getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 1, i32 0, i64 0)
+  br label %bb4
+; CHECK: ret i1 true
+
+bb3:                                              ; preds = %bb
+  br label %bb4
+; CHECK: ret i1 true
+
+bb4:                                              ; preds = %bb3, %bb1, %bb
+  %tmp5 = phi i32* [ getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 0), %bb ], [ %tmp2, %bb1 ], [ getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 0, i32 0, i64 1), %bb3 ]
+  %tmp6 = icmp ne i32* %tmp5, getelementptr inbounds (%"struct.std::array", %"struct.std::array"* @_ZL1x, i64 1, i32 0, i64 0)
+  ret i1 %tmp6
+}
+
+; Function Attrs: norecurse nounwind readonly uwtable
+define dso_local zeroext i1 @foo2(i32 %arg, i32* readnone %arg1) local_unnamed_addr #0 {
+bb:
+  %tmp = icmp sgt i32 %arg, 5
+  br i1 %tmp, label %bb8, label %bb2
+; CHECK: ret i1 true
+
+bb2:                                              ; preds = %bb
+  %tmp3 = icmp sgt i32 %arg, 1
+  br i1 %tmp3, label %bb8, label %bb4
+; CHECK: ret i1 false
+
+bb4:                                              ; preds = %bb2
+  %tmp5 = icmp eq i32 %arg, 1
+  %tmp6 = getelementptr inbounds i32, i32* %arg1, i64 1
+  %tmp7 = select i1 %tmp5, i32* %arg1, i32* %tmp6
+  br label %bb8
+
+bb8:                                              ; preds = %bb4, %bb2, %bb
+  %tmp9 = phi i32* [ getelementptr inbounds ([10 x i32], [10 x i32]* @g, i64 0, i64 0), %bb ], [ getelementptr inbounds ([10 x i32], [10 x i32]* @g, i64 0, i64 1), %bb2 ], [ %tmp7, %bb4 ]
+  %tmp10 = icmp eq i32* %tmp9, getelementptr inbounds ([10 x i32], [10 x i32]* @g, i64 0, i64 0)
+  ret i1 %tmp10
+}
+
+define linkonce_odr hidden i1 @foo3() {
+entry:
+  br label %land.rhs7
+
+land.rhs7:                                        ; preds = %entry
+  br i1 undef, label %land.rhs22, label %lor.lhs.false17
+
+lor.lhs.false17:                                  ; preds = %land.rhs7
+  unreachable
+
+land.rhs22:                                       ; preds = %land.rhs7
+  %tobool30 = icmp ne i32 undef, 0
+  ret i1 %tobool30
+; CHECK: ret i1 undef
+}
+
+define linkonce_odr hidden i1 @foo4() {
+entry:
+  %neg = and i32 undef, 2097152
+  %tobool = icmp eq i32 %neg, 0
+  br label %land.rhs7
+
+land.rhs7:                                        ; preds = %entry
+  br i1 %tobool, label %land.rhs22, label %lor.lhs.false17
+; CHECK: ret i1 false
+
+lor.lhs.false17:                                  ; preds = %land.rhs7
+  unreachable
+
+land.rhs22:                                       ; preds = %land.rhs7
+  %tobool30 = icmp ne i32 %neg, 0
+  ret i1 %tobool30
+}
+
+define i1 @foo5() {
+bb:
+  %l = load i8, i8* undef, align 8
+  %i = icmp ne i8 %l, 0
+  br i1 %i, label %t1, label %t2
+; CHECK: ret i1 false
+
+t1:                                               ; preds = %bb
+  unreachable
+
+t2:                                               ; preds = %bb
+  ret i1 %i
+}
+
+attributes #0 = { norecurse nounwind readonly uwtable }