[ValueTracking] Use dominate tree to get dominate predecessor condtion

[bcl5980]

Summary

For now isImpliedByDomCondition only check single predecessor to check if exist dominate condition. For example:

if (x ==y)
  if (z > 0)
     return x ^ y;

We can't detect the pattern x ^y is 0.
This patch invovle DomConditionInfo to maintain a list for every basic block to record all dominate conditions for this basic block.

Even though this patch increase some CPU overhead:
http://llvm-compile-time-tracker.com/compare.php?from=c508e933270d457166c3226b53d8c81619c3e350&to=d4b071718aae1f9f9a8fee31cd2fbee55b5e5d60&stat=instructions%3Au

It help to detect a lot of patterns in SPEC2017 and llvm-test-suite:

MultiSourc.../Benchmarks/nbench/nbench.test     45460.00   45508.00  0.1%
Bitcode/Be...an/halide_local_laplacian.test    199880.00  199976.00  0.0%
MultiSourc...nsumer-jpeg/consumer-jpeg.test    161822.00  161886.00  0.0%
MultiSourc...abench/jpeg/jpeg-6a/cjpeg.test    164107.00  164171.00  0.0%
MultiSourc...lications/SIBsim4/SIBsim4.test     46139.00   46155.00  0.0%
MultiSource/Benchmarks/PAQ8p/paq8p.test         95843.00   95875.00  0.0%
MultiSourc...pplications/oggenc/oggenc.test    257042.00  257074.00  0.0%
MultiSourc...marks/7zip/7zip-benchmark.test    907698.00  907794.00  0.0%
External/S...rlbench_r/500.perlbench_r.test   1697416.00 1697544.00  0.0%
External/S...rlbench_s/600.perlbench_s.test   1697416.00 1697544.00  0.0%
External/S...0.omnetpp_s/620.omnetpp_s.test   1236181.00 1236229.00  0.0%
External/S...0.omnetpp_r/520.omnetpp_r.test   1236181.00 1236229.00  0.0%
MultiSourc...ProxyApps-C++/CLAMR/CLAMR.test    705856.00  705872.00  0.0%
External/S...8.imagick_r/538.imagick_r.test   1718889.00 1718921.00  0.0%
External/S...8.imagick_s/638.imagick_s.test   1718889.00 1718921.00  0.0%
External/S...7rate/502.gcc_r/502.gcc_r.test   6969643.00 6969771.00  0.0%
External/S...speed/602.gcc_s/602.gcc_s.test   6969643.00 6969771.00  0.0%
External/S...511.povray_r/511.povray_r.test    905099.00  905115.00  0.0%
External/S...510.parest_r/510.parest_r.test   8515521.00 8515649.00  0.0%
External/S...6.blender_r/526.blender_r.test   8704919.00 8705047.00  0.0%
External/S...lancbmk_s/623.xalancbmk_s.test   2959781.00 2959813.00  0.0%
External/S...lancbmk_r/523.xalancbmk_r.test   2959781.00 2959813.00  0.0%

[bcl5980]

rebase code

[goldstein.w.n]

Can you be a little clearer about what cases we now cover that we didn't before?

llvm/lib/Analysis/DomConditionAnalysis.cpp

106

We have a vec of dominating conditions. Why are we only using the first one? The value of the this patch IIUC is that we should be able to get more conditions and more information, but returning the first one defeats that purpose.

llvm/test/Transforms/InstSimplify/domcondition.ll

219

Can you precommit tests so we can see diff this patch causes?

[bcl5980]

llvm/lib/Analysis/DomConditionAnalysis.cpp

106

If we have many dominate conditions for the same LHS and RHS, we can actually merge them into one. So return the first one is enough. For example:

if (x >= y)
  if ( x == y)
      return x ^ y;

We only need to check the dominate condition x == y. For now we will have two elements in the vector x > y, x == y.
Actually we just need the dominate condition x==y here. We can optimize this part in initialization later to make sure every LHS cmp RHS only have one element in the vector.
I can add a TODO in the code but the initialize cost is a already a little high now.

[bcl5980]

rebase precommit tests.

[bcl5980]

Ping.

[craig.topper]

llvm/lib/Analysis/DomConditionAnalysis.cpp

11

Is the BreadFirstIterator used?

llvm/lib/Analysis/ValueTracking.cpp

7947

You don't need to explicitly pass std::nulloptr. It will default construct that way.

7953

!IsImplied.has_value()

[bcl5980]

address comments.

llvm/include/llvm/Analysis/DomConditionAnalysis.h

+//===- DomConditionAnalysis.cpp - ------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements the DomConditionAnalysis class
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_DOMCONDITIONANALYSIS_H
+#define LLVM_ANALYSIS_DOMCONDITIONANALYSIS_H
+
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/IR/Dominators.h"
+#include "llvm/IR/Instructions.h"
+
+namespace llvm {
+
+struct DomCondition {
+  const BasicBlock *DomBB;
+  Value *LHS;
+  Value *RHS;
+  CmpInst::Predicate Pred;
+};
+
+class DomConditionInfo {
+  typedef SmallVector<DomCondition, 4> DomCondVector;
+
+private:
+  // Map from basic block to the list of conditions that dominate it.
+  SmallDenseMap<const BasicBlock *, DomCondVector, 8> DomCondMap;
+
+public:
+  DomConditionInfo() {}
+  DomConditionInfo(Function &F, DominatorTree &DT);
+
+  std::pair<const BasicBlock *, CmpInst::Predicate>
+  getDominatingCondition(const BasicBlock *BB, const Value *LHS,
+                         const Value *RHS) const;
+  void print(raw_ostream &OS) const;
+  void clear() { DomCondMap.clear(); }
+};
+
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_DOMCONDITIONANALYSIS_H
 No newline at end of file

llvm/include/llvm/Analysis/InstructionSimplify.h

 namespace llvm {
 
 template <typename T, typename... TArgs> class AnalysisManager;
 template <class T> class ArrayRef;
 class AssumptionCache;
 class BinaryOperator;
 class CallBase;
 class DataLayout;
+class DomConditionInfo;
 class DominatorTree;
 class Function;
 class Instruction;
 struct LoopStandardAnalysisResults;
 class MDNode;
 class Pass;
 template <class T, unsigned n> class SmallSetVector;
 class TargetLibraryInfo;
struct SimplifyQuery {
   // be safely used.
   const InstrInfoQuery IIQ;
 
   /// Controls whether simplifications are allowed to constrain the range of
   /// possible values for uses of undef. If it is false, simplifications are not
   /// allowed to assume a particular value for a use of undef for example.
   bool CanUseUndef = true;
 
+  const DomConditionInfo *DCI = nullptr;
+
   SimplifyQuery(const DataLayout &DL, const Instruction *CXTI = nullptr)
       : DL(DL), CxtI(CXTI) {}
 
   SimplifyQuery(const DataLayout &DL, const TargetLibraryInfo *TLI,
                 const DominatorTree *DT = nullptr,
                 AssumptionCache *AC = nullptr,
                 const Instruction *CXTI = nullptr, bool UseInstrInfo = true,
-                bool CanUseUndef = true)
+                bool CanUseUndef = true, const DomConditionInfo *DCI = nullptr)
       : DL(DL), TLI(TLI), DT(DT), AC(AC), CxtI(CXTI), IIQ(UseInstrInfo),
-        CanUseUndef(CanUseUndef) {}
+        CanUseUndef(CanUseUndef), DCI(DCI) {}
   SimplifyQuery getWithInstruction(Instruction *I) const {
     SimplifyQuery Copy(*this);
     Copy.CxtI = I;
     return Copy;
   }
   SimplifyQuery getWithoutUndef() const {
     SimplifyQuery Copy(*this);
     Copy.CanUseUndef = false;

llvm/include/llvm/Analysis/ValueTracking.h

 
 namespace llvm {
 
 class Operator;
 class AddOperator;
 class AllocaInst;
 class APInt;
 class AssumptionCache;
+class DomConditionInfo;
 class DominatorTree;
 class GEPOperator;
 class LoadInst;
 class WithOverflowInst;
 struct KnownBits;
 class Loop;
 class LoopInfo;
 class MDNode;
std::optional<bool> isImpliedCondition(const Value *LHS,
                                        bool LHSIsTrue = true,
                                        unsigned Depth = 0);
 
 /// Return the boolean condition value in the context of the given instruction
 /// if it is known based on dominating conditions.
 std::optional<bool> isImpliedByDomCondition(const Value *Cond,
                                             const Instruction *ContextI,
                                             const DataLayout &DL);
-std::optional<bool> isImpliedByDomCondition(CmpInst::Predicate Pred,
-                                            const Value *LHS, const Value *RHS,
-                                            const Instruction *ContextI,
-                                            const DataLayout &DL);
+std::optional<bool>
+isImpliedByDomCondition(CmpInst::Predicate Pred, const Value *LHS,
+                        const Value *RHS, const Instruction *ContextI,
+                        const DataLayout &DL,
+                        const DomConditionInfo *DCI = nullptr);
+
+/// If Ptr1 is provably equal to Ptr2 plus a constant offset, return that
+/// offset. For example, Ptr1 might be &A[42], and Ptr2 might be &A[40]. In
+/// this case offset would be -8.
+std::optional<int64_t> isPointerOffset(const Value *Ptr1, const Value *Ptr2,
 } // end namespace llvm
 
 #endif // LLVM_ANALYSIS_VALUETRACKING_H

llvm/lib/Analysis/CMakeLists.txt

add_llvm_component_library(LLVMAnalysis
   DDG.cpp
   DDGPrinter.cpp
   ConstraintSystem.cpp
   Delinearization.cpp
   DemandedBits.cpp
   DependenceAnalysis.cpp
   DependenceGraphBuilder.cpp
   DevelopmentModeInlineAdvisor.cpp
+  DomConditionAnalysis.cpp
   DomPrinter.cpp
   DomTreeUpdater.cpp
   DominanceFrontier.cpp
   FunctionPropertiesAnalysis.cpp
   GlobalsModRef.cpp
   GuardUtils.cpp
   HeatUtils.cpp
   IRSimilarityIdentifier.cpp

llvm/lib/Analysis/DomConditionAnalysis.cpp

+//===- DomConditionAnalysis.cpp -------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Analysis/DomConditionAnalysis.h"
+#include "llvm/IR/PatternMatch.h"
+
+using namespace llvm;
+using namespace PatternMatch;
+
+DomConditionInfo::DomConditionInfo(Function &F, DominatorTree &DT) {
+  DT.updateDFSNumbers();
+
+  for (auto &BB : F) {
+    if (BB.isEntryBlock())
+      continue;
+
+    auto *DTNode = DT.getNode(&BB);
+    if (!DTNode)
+      continue;
+
+    while (DTNode->getIDom()) {
+      auto *IDom = DTNode->getIDom();
+      auto *IDomBB = IDom->getBlock();
+
+      // We only handle the case where the terminator has two successors for
+      // now.
+      auto *Term = IDomBB->getTerminator();
+      if (Term->getNumSuccessors() != 2)
+        break;
+
+      auto &CurrentVec = DomCondMap[&BB];
+      if (auto *I = dyn_cast<Instruction>(Term->getOperand(0))) {
+        std::function<void(Instruction *, bool, bool)> GenDomCondMap;
+        GenDomCondMap = [&](Instruction *Cond, bool TrueEdge, bool FalseEdge) {
+          Value *X, *Y;
+          // We only handle the case where the terminator is an icmp for now.
+          if (const auto *Cmp = dyn_cast<ICmpInst>(Cond)) {
+            if (TrueEdge) {
+              auto *TrueBB = Term->getSuccessor(0);
+              BasicBlockEdge TrueEdge(IDomBB, TrueBB);
+              if (DT.dominates(TrueEdge, &BB))
+                CurrentVec.push_back({IDomBB, Cmp->getOperand(0),
+                                      Cmp->getOperand(1), Cmp->getPredicate()});
+            }
+            if (FalseEdge) {
+              auto *FalseBB = Term->getSuccessor(1);
+              BasicBlockEdge FalseEdge(IDomBB, FalseBB);
+              if (DT.dominates(FalseEdge, &BB))
+                CurrentVec.push_back({IDomBB, Cmp->getOperand(0),
+                                      Cmp->getOperand(1),
+                                      Cmp->getInversePredicate()});
+            }
+          } else if (match(Cond, m_LogicalAnd(m_Value(X), m_Value(Y)))) {
+            if (auto *I = dyn_cast<Instruction>(X))
+              GenDomCondMap(I, true, false);
+            if (auto *I = dyn_cast<Instruction>(Y))
+              GenDomCondMap(I, true, false);
+          } else if (match(Cond, m_LogicalOr(m_Value(X), m_Value(Y)))) {
+            if (auto *I = dyn_cast<Instruction>(X))
+              GenDomCondMap(I, false, true);
+            if (auto *I = dyn_cast<Instruction>(Y))
+              GenDomCondMap(I, false, true);
+          }
+        };
+        GenDomCondMap(I, true, true);
+      }
+
+      auto DomVec = DomCondMap.find(IDomBB);
+      if (DomVec != DomCondMap.end()) {
+        CurrentVec.append(DomVec->second.begin(), DomVec->second.end());
+        break;
+      }
+      DTNode = IDom;
+      continue;
+    }
+  }
+}
+
+void DomConditionInfo::print(raw_ostream &OS) const {
+  OS << "Basic Block Dominate Conditions:\n";
+  for (const auto &Entry : DomCondMap) {
+    OS << Entry.first->getName() << ":\n";
+    for (const auto &Cond : Entry.second) {
+      Cond.LHS->printAsOperand(OS, false);
+      OS << " " << CmpInst::getPredicateName(Cond.Pred) << " ";
+      Cond.RHS->printAsOperand(OS, false);
+    }
+    OS << "\n";
+  }
+}
+
+std::pair<const BasicBlock *, CmpInst::Predicate>
+DomConditionInfo::getDominatingCondition(const BasicBlock *BB, const Value *LHS,
+                                         const Value *RHS) const {
+  auto It = DomCondMap.find(BB);
+  if (It == DomCondMap.end())
+    return {nullptr, CmpInst::BAD_ICMP_PREDICATE};
+
+  for (const auto &Cond : It->second) {
+    if (Cond.LHS == LHS && Cond.RHS == RHS)
+      return {Cond.DomBB, Cond.Pred};
+
+    if (Cond.LHS == RHS && Cond.RHS == LHS)
+      return {Cond.DomBB, CmpInst::getSwappedPredicate(Cond.Pred)};
+  }
+  return {nullptr, CmpInst::BAD_ICMP_PREDICATE};
+}

llvm/lib/Analysis/InstructionSimplify.cpp

 /// Example: Op0 - Op1 --> 0 when Op0 == Op1
 static Value *simplifyByDomEq(unsigned Opcode, Value *Op0, Value *Op1,
                               const SimplifyQuery &Q, unsigned MaxRecurse) {
   // Recursive run it can not get any benefit
   if (MaxRecurse != RecursionLimit)
     return nullptr;
 
   std::optional<bool> Imp =
-      isImpliedByDomCondition(CmpInst::ICMP_EQ, Op0, Op1, Q.CxtI, Q.DL);
+      isImpliedByDomCondition(CmpInst::ICMP_EQ, Op0, Op1, Q.CxtI, Q.DL, Q.DCI);
   if (Imp && *Imp) {
     Type *Ty = Op0->getType();
     switch (Opcode) {
     case Instruction::Sub:
     case Instruction::Xor:
     case Instruction::URem:
     case Instruction::SRem:
       return Constant::getNullValue(Ty);
static Value *simplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
 
   if (Value *V = simplifyICmpWithMinMax(Pred, LHS, RHS, Q, MaxRecurse))
     return V;
 
   if (Value *V = simplifyICmpWithDominatingAssume(Pred, LHS, RHS, Q))
     return V;
 
   if (std::optional<bool> Res =
-          isImpliedByDomCondition(Pred, LHS, RHS, Q.CxtI, Q.DL))
+          isImpliedByDomCondition(Pred, LHS, RHS, Q.CxtI, Q.DL, Q.DCI))
     return ConstantInt::getBool(ITy, *Res);
 
   // Simplify comparisons of related pointers using a powerful, recursive
   // GEP-walk when we have target data available..
   if (LHS->getType()->isPointerTy())
     if (auto *C = computePointerICmp(Pred, LHS, RHS, Q))
       return C;
   if (auto *CLHS = dyn_cast<PtrToIntOperator>(LHS))

llvm/lib/Analysis/ValueTracking.cpp

 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumeBundleQueries.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/ConstantFolding.h"
+#include "llvm/Analysis/DomConditionAnalysis.h"
 #include "llvm/Analysis/GuardUtils.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/VectorUtils.h"
 #include "llvm/IR/Argument.h"
if (PredCond.first)
     return isImpliedCondition(PredCond.first, Cond, DL, PredCond.second);
   return std::nullopt;
 }
 
 std::optional<bool> llvm::isImpliedByDomCondition(CmpInst::Predicate Pred,
                                                   const Value *LHS,
                                                   const Value *RHS,
                                                   const Instruction *ContextI,
-                                                  const DataLayout &DL) {
+                                                  const DataLayout &DL,
+                                                  const DomConditionInfo *DCI) {
+  std::optional<bool> IsImplied;
   auto PredCond = getDomPredecessorCondition(ContextI);
   if (PredCond.first)
-    return isImpliedCondition(PredCond.first, Pred, LHS, RHS, DL,
-                              PredCond.second);
-  return std::nullopt;
+    IsImplied =
+        isImpliedCondition(PredCond.first, Pred, LHS, RHS, DL, PredCond.second);
+
+  if (DCI && !IsImplied.has_value() && ContextI && ContextI->getParent()) {
+    const BasicBlock *BB = ContextI->getParent();
+    auto DomCond = DCI->getDominatingCondition(BB, LHS, RHS);
+    if (DomCond.first)
+      IsImplied = isImpliedCondMatchingOperands(DomCond.second, Pred, false);
+  }
+  return IsImplied;
 }
 
 static void setLimitsForBinOp(const BinaryOperator &BO, APInt &Lower,
                               APInt &Upper, const InstrInfoQuery &IIQ,
                               bool PreferSignedRange) {
   unsigned Width = Lower.getBitWidth();
   const APInt *C;
   switch (BO.getOpcode()) {

llvm/lib/Transforms/Scalar/InstSimplifyPass.cpp

 //===- InstSimplifyPass.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/Scalar/InstSimplifyPass.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AssumptionCache.h"
+#include "llvm/Analysis/DomConditionAnalysis.h"
 #include "llvm/Analysis/InstructionSimplify.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Function.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/Scalar.h"
 #include "llvm/Transforms/Utils/Local.h"
void getAnalysisUsage(AnalysisUsage &AU) const override {
     AU.addRequired<TargetLibraryInfoWrapperPass>();
   }
 
   /// Remove instructions that simplify.
   bool runOnFunction(Function &F) override {
     if (skipFunction(F))
       return false;
 
-    const DominatorTree *DT =
-        &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
+    DominatorTree *DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
     const TargetLibraryInfo *TLI =
         &getAnalysis<TargetLibraryInfoWrapperPass>().getTLI(F);
     AssumptionCache *AC =
         &getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
     const DataLayout &DL = F.getParent()->getDataLayout();
-    const SimplifyQuery SQ(DL, TLI, DT, AC);
+    DomConditionInfo DCI(F, *DT);
+    const SimplifyQuery SQ(DL, TLI, DT, AC, nullptr, true, true, &DCI);
     return runImpl(F, SQ);
   }
 };
 } // namespace
 
 char InstSimplifyLegacyPass::ID = 0;
 INITIALIZE_PASS_BEGIN(InstSimplifyLegacyPass, "instsimplify",
                       "Remove redundant instructions", false, false)

 }
 
 PreservedAnalyses InstSimplifyPass::run(Function &F,
                                         FunctionAnalysisManager &AM) {
   auto &DT = AM.getResult<DominatorTreeAnalysis>(F);
   auto &TLI = AM.getResult<TargetLibraryAnalysis>(F);
   auto &AC = AM.getResult<AssumptionAnalysis>(F);
   const DataLayout &DL = F.getParent()->getDataLayout();
-  const SimplifyQuery SQ(DL, &TLI, &DT, &AC);
+  DomConditionInfo DCI(F, DT);
+  const SimplifyQuery SQ(DL, &TLI, &DT, &AC, nullptr, true, true, &DCI);
   bool Changed = runImpl(F, SQ);
   if (!Changed)
     return PreservedAnalyses::all();
 
   PreservedAnalyses PA;
   PA.preserveSet<CFGAnalyses>();
   return PA;
 }

llvm/test/Transforms/InstSimplify/domcondition.ll

 cond.true:
   %xor = xor i32 %x, %y
   br label %cond.end
 
 cond.end:
   %cond = phi i32 [ %xor, %cond.true ], [ 0, %entry ]
   ret i32 %cond
 }
 
 define i32 @xor_simplify_by_dci(i32 %x, i32 %y, i1 %c) {
 ; CHECK-LABEL: @xor_simplify_by_dci(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[CMP:%.*]] = icmp eq i32 [[X:%.*]], [[Y:%.*]]
 ; CHECK-NEXT:    br i1 [[CMP]], label [[COND_TRUE:%.*]], label [[COND_END:%.*]]
 ; CHECK:       cond.true:
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[XORBB:%.*]], label [[COND_END]]
 ; CHECK:       xorbb:
-; CHECK-NEXT:    [[XOR:%.*]] = xor i32 [[X]], [[Y]]
 ; CHECK-NEXT:    br label [[COND_END]]
 ; CHECK:       cond.end:
-; CHECK-NEXT:    [[COND:%.*]] = phi i32 [ [[XOR]], [[XORBB]] ], [ 0, [[ENTRY:%.*]] ], [ 0, [[COND_TRUE]] ]
-; CHECK-NEXT:    ret i32 [[COND]]
+; CHECK-NEXT:    ret i32 0
 ;
 entry:
   %cmp = icmp eq i32 %x, %y
   br i1 %cmp, label %cond.true, label %cond.end
 
 cond.true:
   br i1 %c, label %xorbb, label %cond.end
 
 xorbb:
   %xor = xor i32 %x, %y
   br label %cond.end
 
 cond.end:
   %cond = phi i32 [ %xor, %xorbb ], [ 0, %entry ], [0, %cond.true]
   ret i32 %cond
 }
 
 define void @icmp_simplify_by_dci(i32 %a, i32 %b, i1 %x) {
 ; CHECK-LABEL: @icmp_simplify_by_dci(
 ; CHECK-NEXT:    [[CMP1:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]]
 ; CHECK-NEXT:    br i1 [[CMP1]], label [[END:%.*]], label [[TAKEN:%.*]]
 ; CHECK:       taken:
 ; CHECK-NEXT:    br i1 [[X:%.*]], label [[SELBB:%.*]], label [[END]]
 ; CHECK:       selbb:
-; CHECK-NEXT:    [[CMP2:%.*]] = icmp ne i32 [[A]], [[B]]
-; CHECK-NEXT:    [[C:%.*]] = select i1 [[CMP2]], i32 20, i32 0
-; CHECK-NEXT:    call void @foo(i32 [[C]])
+; CHECK-NEXT:    call void @foo(i32 20)
 ; CHECK-NEXT:    br label [[END]]
 ; CHECK:       end:
 ; CHECK-NEXT:    ret void
 ;
   %cmp1 = icmp eq i32 %a, %b
   br i1 %cmp1, label %end, label %taken
 
 taken: