Index: lib/Transforms/InstCombine/InstCombine.h
===================================================================
--- lib/Transforms/InstCombine/InstCombine.h
+++ lib/Transforms/InstCombine/InstCombine.h
@@ -13,6 +13,7 @@
 #include "InstCombineWorklist.h"
 #include "llvm/Analysis/TargetFolder.h"
 #include "llvm/Analysis/ValueTracking.h"
+#include "llvm/IR/Dominators.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/InstVisitor.h"
 #include "llvm/IR/IntrinsicInst.h"
@@ -87,6 +88,7 @@
     : public FunctionPass,
       public InstVisitor<InstCombiner, Instruction *> {
   const DataLayout *DL;
+  const DominatorTree *DT;
   TargetLibraryInfo *TLI;
   bool MadeIRChange;
   LibCallSimplifier *Simplifier;
@@ -102,7 +104,8 @@
   BuilderTy *Builder;
 
   static char ID; // Pass identification, replacement for typeid
-  InstCombiner() : FunctionPass(ID), DL(nullptr), Builder(nullptr) {
+  InstCombiner()
+      : FunctionPass(ID), DL(nullptr), DT(nullptr), Builder(nullptr) {
     MinimizeSize = false;
     initializeInstCombinerPass(*PassRegistry::getPassRegistry());
   }
@@ -226,6 +229,8 @@
 
   // visitInstruction - Specify what to return for unhandled instructions...
   Instruction *visitInstruction(Instruction &I) { return nullptr; }
+  bool dominatesAllUses(SelectInst *SI, ICmpInst &ICmp, BasicBlock *D);
+  bool isChainSelectCmpBranch(SelectInst *SI);
 
 private:
   bool ShouldChangeType(Type *From, Type *To) const;
Index: lib/Transforms/InstCombine/InstCombineCompares.cpp
===================================================================
--- lib/Transforms/InstCombine/InstCombineCompares.cpp
+++ lib/Transforms/InstCombine/InstCombineCompares.cpp
@@ -2425,6 +2425,41 @@
   return GlobalSwapBenefits > 0;
 }
 
+//
+// true when \param SI dominates all of its uses or \param ICmp.
+//
+bool InstCombiner::dominatesAllUses(SelectInst *SI, ICmpInst &ICmp,
+                                    BasicBlock *D) {
+  bool dominates_all_uses = true;
+  for (auto I = SI->use_begin(), E = SI->use_end(); I != E; ++I) {
+    Use &U = *I;
+    auto *User = cast<Instruction>(U.getUser());
+    if (User == &ICmp || DT->dominates(D, User->getParent()))
+      continue;
+    dominates_all_uses = false;
+    break;
+  }
+  return dominates_all_uses;
+}
+
+//
+// true when the instruction sequence within a block is select-cmp-br.
+//
+bool InstCombiner::isChainSelectCmpBranch(SelectInst *SI) {
+  BasicBlock *BB = SI->getParent();
+  if (!BB)
+    return false;
+  if (!isa<BranchInst>(BB->getTerminator()))
+    return false;
+  BranchInst *BI = cast<BranchInst>(BB->getTerminator());
+  if (BI->getNumSuccessors() != 2)
+    return false;
+  ICmpInst *IC = dyn_cast<ICmpInst>(BI->getCondition());
+  if (IC && IC->getOperand(0) != SI)
+    return false;
+  return true;
+}
+
 Instruction *InstCombiner::visitICmpInst(ICmpInst &I) {
   bool Changed = false;
   Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
@@ -2881,8 +2916,75 @@
         // fold to a constant (in which case the icmp is replaced with a select
         // which will usually simplify) or this is the only user of the
         // select (in which case we are trading a select+icmp for a simpler
-        // select+icmp).
-        if ((Op1 && Op2) || (LHSI->hasOneUse() && (Op1 || Op2))) {
+        // select+icmp) or all uses of the select can be replaced based on
+        // dominance information ("global case").
+        //
+        // Example for global case:
+        //
+        // entry:
+        // %4 = select i1 %3, %C* %0, %C* null
+        // %5 = icmp eq %C* %4, null
+        // br i1 %5, label %9, label %7
+        // ...
+        // ; <label>:7                                       ; preds = %entry
+        // %8 = getelementptr inbounds %C* %4, i64 0, i32 0
+        // ...
+        //
+        // is transformed to
+        //
+        //  %5 = icmp eq %C* %0, null
+        //  %6 = select i1 %3, i1 %5, i1 true
+        //  br i1 %6, label %9, label %7
+        // ...
+        // ; <label>:7                                       ; preds = %entry
+        // %8 = getelementptr inbounds %C* %0, i64 0, i32 0  // replace by %0!
+        //
+        // Similar when the first operand of the select is a constant or/and
+        // the compare is for not equal rather than equal.
+
+        bool transform = false;
+        SelectInst *SI = cast<SelectInst>(LHSI);
+        if (Op1 && Op2)
+          transform = true;
+        else if (Op1 || Op2) {
+          if (LHSI->hasOneUse())
+            transform = true;
+          // Global cases
+          else if (InstCombiner::isChainSelectCmpBranch(SI)) {
+            // Code sequence is select - icmp.eq - br
+            int ReplaceWithOpd = 0;
+            if (Op2)
+              if (ConstantInt *CI = dyn_cast<ConstantInt>(Op2))
+                if (CI->getValue().getBoolValue())
+                  // Example:
+                  // %4 = select i1 %3, %C* %0, %C* null
+                  // %5 = icmp eq %C* %4, null
+                  // ==> replace select with first operand
+                  ReplaceWithOpd = 1;
+            if (Op1)
+              if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1))
+                if (CI->getValue().getBoolValue())
+                  // Example:
+                  // %4 = select i1 %3, %C* null, %C* %0
+                  // %5 = icmp eq %C* %4, null
+                  // ==> replace select with second operand
+                  ReplaceWithOpd = 2;
+            bool IsEQorNECompare = I.getPredicate() == ICmpInst::ICMP_EQ ||
+                                   I.getPredicate() == ICmpInst::ICMP_NE;
+            if (ReplaceWithOpd && IsEQorNECompare) {
+              // replace select with operand on else path for EQ compares.
+              // replace select with operand on then path for NE compares.
+              int Path = I.getPredicate() == ICmpInst::ICMP_EQ ? 1 : 0;
+              if (InstCombiner::dominatesAllUses(
+                      SI, I,
+                      SI->getParent()->getTerminator()->getSuccessor(Path))) {
+                SI->replaceAllUsesWith(SI->getOperand(ReplaceWithOpd));
+                transform = true;
+              }
+            }
+          }
+        }
+        if (transform) {
           if (!Op1)
             Op1 = Builder->CreateICmp(I.getPredicate(), LHSI->getOperand(1),
                                       RHSC, I.getName());
@@ -2891,6 +2993,7 @@
                                       RHSC, I.getName());
           return SelectInst::Create(LHSI->getOperand(0), Op1, Op2);
         }
+
         break;
       }
       case Instruction::IntToPtr:
Index: lib/Transforms/InstCombine/InstructionCombining.cpp
===================================================================
--- lib/Transforms/InstCombine/InstructionCombining.cpp
+++ lib/Transforms/InstCombine/InstructionCombining.cpp
@@ -92,6 +92,8 @@
 void InstCombiner::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.setPreservesCFG();
   AU.addRequired<TargetLibraryInfo>();
+  AU.addRequired<DominatorTreeWrapperPass>();
+  AU.addPreserved<DominatorTreeWrapperPass>();
 }
 
 
@@ -2909,6 +2911,7 @@
 
   DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
   DL = DLP ? &DLP->getDataLayout() : nullptr;
+  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   TLI = &getAnalysis<TargetLibraryInfo>();
   // Minimizing size?
   MinimizeSize = F.getAttributes().hasAttribute(AttributeSet::FunctionIndex,
Index: test/Transforms/InstCombine/select-cmp-br.ll
===================================================================
--- /dev/null
+++ test/Transforms/InstCombine/select-cmp-br.ll
@@ -0,0 +1,120 @@
+; Checks if select is replaced by or in select - cmp [eq|ne] - br sequence
+; RUN: opt -instcombine -S < %s | FileCheck %s
+
+%C = type <{ %struct.S }>
+%struct.S = type { i64*, i32, i32 }
+
+declare void @bar(%struct.S *) #1
+
+define void @foo(%C*) {
+entry:
+  %1 = getelementptr inbounds %C* %0, i64 0, i32 0, i32 0
+  %m = load i64** %1, align 8
+  %2 = getelementptr inbounds %C* %0, i64 1, i32 0, i32 0
+  %n = load i64** %2, align 8
+  %3 = getelementptr inbounds i64* %m, i64 9
+  %4 = bitcast i64* %3 to i64 (%C*)**
+  %5 = load i64 (%C*)** %4, align 8
+  %6 = icmp eq i64* %m, %n
+; CHECK-NOT: select
+  %7 = select i1 %6, %C* %0, %C* null
+  %8 = icmp eq %C* %7, null
+; CHECK: or
+  br i1 %8, label %12, label %10
+
+; <label>:9                                       ; preds = %10, %12
+  ret void
+
+; <label>:10                                      ; preds = %entry
+  %11 = getelementptr inbounds %C* %7, i64 0, i32 0
+  tail call void @bar(%struct.S* %11)
+  br label %9
+
+; <label>:12                                      ; preds = %entry
+  %13 = tail call i64 %5(%C* %0)
+  br label %9
+}
+define void @foo1(%C*) {
+entry:
+  %1 = getelementptr inbounds %C* %0, i64 0, i32 0, i32 0
+  %m = load i64** %1, align 8
+  %2 = getelementptr inbounds %C* %0, i64 1, i32 0, i32 0
+  %n = load i64** %2, align 8
+  %3 = getelementptr inbounds i64* %m, i64 9
+  %4 = bitcast i64* %3 to i64 (%C*)**
+  %5 = load i64 (%C*)** %4, align 8
+  %6 = icmp eq i64* %m, %n
+; CHECK-NOT: select
+  %7 = select i1 %6, %C* null, %C* %0
+  %8 = icmp eq %C* %7, null
+; CHECK: or
+  br i1 %8, label %12, label %10
+
+; <label>:9                                       ; preds = %10, %12
+  ret void
+
+; <label>:10                                      ; preds = %entry
+  %11 = getelementptr inbounds %C* %7, i64 0, i32 0
+  tail call void @bar(%struct.S* %11)
+  br label %9
+
+; <label>:12                                      ; preds = %entry
+  %13 = tail call i64 %5(%C* %0)
+  br label %9
+}
+define void @foo2(%C*) {
+entry:
+  %1 = getelementptr inbounds %C* %0, i64 0, i32 0, i32 0
+  %m = load i64** %1, align 8
+  %2 = getelementptr inbounds %C* %0, i64 1, i32 0, i32 0
+  %n = load i64** %2, align 8
+  %3 = getelementptr inbounds i64* %m, i64 9
+  %4 = bitcast i64* %3 to i64 (%C*)**
+  %5 = load i64 (%C*)** %4, align 8
+  %6 = icmp eq i64* %m, %n
+; CHECK-NOT: select
+  %7 = select i1 %6, %C* %0, %C* null
+  %8 = icmp ne %C* %7, null
+; CHECK: or
+  br i1 %8, label %10, label %12
+
+; <label>:9                                       ; preds = %10, %12
+  ret void
+
+; <label>:10                                      ; preds = %entry
+  %11 = getelementptr inbounds %C* %7, i64 0, i32 0
+  tail call void @bar(%struct.S* %11)
+  br label %9
+
+; <label>:12                                      ; preds = %entry
+  %13 = tail call i64 %5(%C* %0)
+  br label %9
+}
+define void @foo3(%C*) {
+entry:
+  %1 = getelementptr inbounds %C* %0, i64 0, i32 0, i32 0
+  %m = load i64** %1, align 8
+  %2 = getelementptr inbounds %C* %0, i64 1, i32 0, i32 0
+  %n = load i64** %2, align 8
+  %3 = getelementptr inbounds i64* %m, i64 9
+  %4 = bitcast i64* %3 to i64 (%C*)**
+  %5 = load i64 (%C*)** %4, align 8
+  %6 = icmp eq i64* %m, %n
+; CHECK-NOT: select
+  %7 = select i1 %6, %C* null, %C* %0
+  %8 = icmp ne %C* %7, null
+; CHECK: or
+  br i1 %8, label %10, label %12
+
+; <label>:9                                       ; preds = %10, %12
+  ret void
+
+; <label>:10                                      ; preds = %entry
+  %11 = getelementptr inbounds %C* %7, i64 0, i32 0
+  tail call void @bar(%struct.S* %11)
+  br label %9
+
+; <label>:12                                      ; preds = %entry
+  %13 = tail call i64 %5(%C* %0)
+  br label %9
+}