diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp
index 88a2c53e806..9b0ce1113ac 100644
--- a/lib/Analysis/InstructionSimplify.cpp
+++ b/lib/Analysis/InstructionSimplify.cpp
@@ -1520,6 +1520,15 @@ static Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred,
   return 0;
 }
 
+/// stripPointerAdjustments - This is like Value::stripPointerCasts, but also
+/// removes inbounds gep operations, regardless of their indices.
+static Value *stripPointerAdjustments(Value *V) {
+  if (GEPOperator *GEP = dyn_cast<GEPOperator>(V))
+    if (GEP->isInBounds())
+      return stripPointerAdjustments(GEP->getOperand(0)->stripPointerCasts());
+  return V;
+}
+
 /// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
 /// fold the result.  If not, this returns null.
 static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
@@ -1595,10 +1604,18 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
   Value *RHSPtr = RHS->stripPointerCasts();
   if (LHSPtr == RHSPtr)
     return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred));
-  if (isa<AllocaInst>(LHSPtr) && (isa<GlobalValue>(RHSPtr) ||
-                                  isa<AllocaInst>(RHSPtr)  ||
-                                  isa<ConstantPointerNull>(RHSPtr)))
-    return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
+  
+  // Be more aggressive about stripping pointer adjustments when checking a
+  // comparison of an alloca address to another object.  We can rip off all
+  // inbounds GEP operations, even if they are variable.
+  LHSPtr = stripPointerAdjustments(LHSPtr);
+  if (isa<AllocaInst>(LHSPtr)) {
+    RHSPtr = stripPointerAdjustments(RHSPtr);
+    if (LHSPtr != RHSPtr &&
+        (isa<GlobalValue>(RHSPtr) || isa<AllocaInst>(RHSPtr)  ||
+         isa<ConstantPointerNull>(RHSPtr)))
+      return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
+  }
 
   // If we are comparing with zero then try hard since this is a common case.
   if (match(RHS, m_Zero())) {
diff --git a/test/Transforms/InstSimplify/compare.ll b/test/Transforms/InstSimplify/compare.ll
index 92b8fc7e3a9..f22ac46397f 100644
--- a/test/Transforms/InstSimplify/compare.ll
+++ b/test/Transforms/InstSimplify/compare.ll
@@ -446,9 +446,20 @@ define <2 x i1> @vectorselect1(<2 x i1> %cond) {
 ; CHECK: ret <2 x i1> %cond
 }
 
-define <2 x i1> @vectorselectcrash(i32 %arg1) { ; PR11948
+; PR11948
+define <2 x i1> @vectorselectcrash(i32 %arg1) {
   %tobool40 = icmp ne i32 %arg1, 0
   %cond43 = select i1 %tobool40, <2 x i16> <i16 -5, i16 66>, <2 x i16> <i16 46, i16 1>
   %cmp45 = icmp ugt <2 x i16> %cond43, <i16 73, i16 21>
   ret <2 x i1> %cmp45
 }
+
+; PR12013
+define i1 @alloca_compare(i64 %idx) {
+  %sv = alloca { i32, i32, [124 x i32] }
+  %1 = getelementptr inbounds { i32, i32, [124 x i32] }* %sv, i32 0, i32 2, i64 %idx
+  %2 = icmp eq i32* %1, null
+  ret i1 %2
+  ; CHECK: alloca_compare
+  ; CHECK: ret i1 false
+}