Index: lib/Transforms/InstCombine/InstCombine.h
===================================================================
--- lib/Transforms/InstCombine/InstCombine.h
+++ lib/Transforms/InstCombine/InstCombine.h
@@ -14,6 +14,7 @@
 #include "llvm/Analysis/AssumptionTracker.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"
@@ -97,8 +98,8 @@
       public InstVisitor<InstCombiner, Instruction *> {
   AssumptionTracker *AT;
   const DataLayout *DL;
-  TargetLibraryInfo *TLI;
   DominatorTree *DT; // not required
+  TargetLibraryInfo *TLI;
   bool MadeIRChange;
   LibCallSimplifier *Simplifier;
   bool MinimizeSize;
@@ -113,7 +114,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());
   }
@@ -242,6 +244,8 @@
 
   // visitInstruction - Specify what to return for unhandled instructions...
   Instruction *visitInstruction(Instruction &I) { return nullptr; }
+  bool dominatesAllUses(Instruction *DEF, Instruction *USE, 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,42 @@
   return GlobalSwapBenefits > 0;
 }
 
+//
+// true when \param USE is the only use of \param DEF in the parent block and
+// all other uses of \param DEF in in blocks dominated by block \param D.
+//
+bool InstCombiner::dominatesAllUses(Instruction *DEF, Instruction *USE,
+                                    BasicBlock *D) {
+  assert(DEF && DEF->getParent() == USE->getParent() &&
+         "select and cmp must be in the same block");
+  bool DominatesAll = true;
+  for (auto I = DEF->use_begin(), E = DEF->use_end(); I != E; ++I) {
+    Use &U = *I;
+    auto *User = cast<Instruction>(U.getUser());
+    if (User == USE || (DT && DT->dominates(D, User->getParent())))
+      continue;
+    DominatesAll = false;
+    break;
+  }
+  return DominatesAll;
+}
+
+//
+// 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;
+  auto *BI = dyn_cast_or_null<BranchInst>(BB->getTerminator());
+  if (!BI || BI->getNumSuccessors() != 2)
+    return false;
+  auto *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 +2917,72 @@
         // 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|ne] - br
+            unsigned ReplaceWithOpd = 0;
+            if (ConstantInt *CI = dyn_cast_or_null<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 (ConstantInt *CI = dyn_cast_or_null<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;
+            if (ReplaceWithOpd && I.isEquality()) {
+              // Replace select with operand on else path for EQ compares.
+              // Replace select with operand on then path for NE compares.
+              BasicBlock *Succ =
+                  I.getPredicate() == ICmpInst::ICMP_EQ
+                      ? SI->getParent()->getTerminator()->getSuccessor(1)
+                      : SI->getParent()->getTerminator()->getSuccessor(0);
+              if (InstCombiner::dominatesAllUses(SI, &I, Succ)) {
+                SI->replaceAllUsesWith(SI->getOperand(ReplaceWithOpd));
+                Transform = true;
+              }
+            }
+          }
+        }
+        if (Transform) {
           if (!Op1)
             Op1 = Builder->CreateICmp(I.getPredicate(), LHSI->getOperand(1),
                                       RHSC, I.getName());
@@ -2891,6 +2991,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
@@ -89,6 +89,7 @@
                 "Combine redundant instructions", false, false)
 INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
 INITIALIZE_PASS_DEPENDENCY(TargetLibraryInfo)
+INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 INITIALIZE_PASS_END(InstCombiner, "instcombine",
                 "Combine redundant instructions", false, false)
 
@@ -96,6 +97,8 @@
   AU.setPreservesCFG();
   AU.addRequired<AssumptionTracker>();
   AU.addRequired<TargetLibraryInfo>();
+  AU.addRequired<DominatorTreeWrapperPass>();
+  AU.addPreserved<DominatorTreeWrapperPass>();
 }
 
 
@@ -2932,12 +2935,9 @@
   AT = &getAnalysis<AssumptionTracker>();
   DataLayoutPass *DLP = getAnalysisIfAvailable<DataLayoutPass>();
   DL = DLP ? &DLP->getDataLayout() : nullptr;
+  DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
   TLI = &getAnalysis<TargetLibraryInfo>();
 
-  DominatorTreeWrapperPass *DTWP =
-      getAnalysisIfAvailable<DominatorTreeWrapperPass>();
-  DT = DTWP ? &DTWP->getDomTree() : nullptr;
-
   // Minimizing size?
   MinimizeSize = F.getAttributes().hasAttribute(AttributeSet::FunctionIndex,
                                                 Attribute::MinSize);
Index: test/Transforms/InstCombine/pr12338.ll
===================================================================
--- test/Transforms/InstCombine/pr12338.ll
+++ test/Transforms/InstCombine/pr12338.ll
@@ -2,11 +2,11 @@
 
 define void @entry() nounwind {
 entry:
+; CHECK: br label %for.cond
   br label %for.cond
 
 for.cond:
   %local = phi <1 x i32> [ <i32 0>, %entry ], [ %phi2, %cond.end47 ]
-; CHECK: sub <1 x i32> <i32 92>, %local
   %phi3 = sub <1 x i32> zeroinitializer, %local
   br label %cond.end
 
Index: test/Transforms/InstCombine/select-cmp-br.ll
===================================================================
--- /dev/null
+++ test/Transforms/InstCombine/select-cmp-br.ll
@@ -0,0 +1,127 @@
+; Replace a 'select' with '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 @test1(%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
+  %7 = select i1 %6, %C* %0, %C* null
+  %8 = icmp eq %C* %7, null
+  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
+; CHECK-LABEL: @test1(
+; CHECK-NOT: select
+; CHECK: or
+}
+
+define void @test2(%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
+  %7 = select i1 %6, %C* null, %C* %0
+  %8 = icmp eq %C* %7, null
+  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
+; CHECK-LABEL: @test2(
+; CHECK-NOT: select
+; CHECK: or
+}
+
+define void @test3(%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
+  %7 = select i1 %6, %C* %0, %C* null
+  %8 = icmp ne %C* %7, null
+  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
+; CHECK-LABEL: @test3(
+; CHECK-NOT: select
+; CHECK: or
+}
+
+define void @test4(%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
+  %7 = select i1 %6, %C* null, %C* %0
+  %8 = icmp ne %C* %7, null
+  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
+; CHECK-LABEL: @test4(
+; CHECK-NOT: select
+; CHECK: or
+}