Roll these back to r151448 until I figure out how they're breaking

MultiSource/Applications/lua.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@151463 91177308-0d34-0410-b5e6-96231b3b80d8

lib/Analysis/InstructionSimplify.cpp

@@ -21,7 +21,6 @@
 #include "llvm/Operator.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/InstructionSimplify.h"
-#include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/Dominators.h"
 #include "llvm/Analysis/ValueTracking.h"
@@ -1609,38 +1608,26 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
     }
   }
 
-  // icmp <object*>, <object*/null> - Different identified objects have
+  // icmp <alloca*>, <global/alloca*/null> - Different stack variables have
   // different addresses, and what's more the address of a stack variable is
-  // never equal to another argument.  Note that generalizing to the case where
+  // never null or equal to the address of a global.  Note that generalizing
-  // LHS is a global variable address or null is pointless, since if both LHS
+  // to the case where LHS is a global variable address or null is pointless,
-  // and RHS are constants then we already constant folded the compare, and if
+  // since if both LHS and RHS are constants then we already constant folded
-  // only one of them is then we moved it to RHS already.
+  // the compare, and if only one of them is then we moved it to RHS already.
   Value *LHSPtr = LHS->stripPointerCasts();
   Value *RHSPtr = RHS->stripPointerCasts();
   if (LHSPtr == RHSPtr)
     return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(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 (llvm::isIdentifiedObject(LHSPtr)) {
+  if (isa<AllocaInst>(LHSPtr)) {
     RHSPtr = stripPointerAdjustments(RHSPtr);
-    if (llvm::isKnownNonNull(LHSPtr) || llvm::isKnownNonNull(RHSPtr)) {
+    if (LHSPtr != RHSPtr &&
-      // If both sides are different identified objects, they aren't equal
+        (isa<GlobalValue>(RHSPtr) || isa<AllocaInst>(RHSPtr)  ||
-      // unless they're null.
+         isa<ConstantPointerNull>(RHSPtr)))
-      if (LHSPtr != RHSPtr && llvm::isIdentifiedObject(RHSPtr))
-        return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
-
-      // A local identified object (alloca or noalias call) can't equal any
-      // incoming argument, unless they're both null.
-      if ((isa<Instruction>(LHSPtr) && isa<Argument>(RHSPtr)) ||
-          (isa<Instruction>(RHSPtr) && isa<Argument>(LHSPtr)))
-        return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
-    }
-
-    // Assume that the constant null is on the right.
-    if (llvm::isKnownNonNull(LHSPtr) && isa<ConstantPointerNull>(RHSPtr))
       return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
   }
 
@@ -2252,25 +2239,6 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
       return getFalse(ITy);
   }
 
-  // Simplify comparisons of GEPs.
-  if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) {
-    if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) {
-      if (GLHS->getPointerOperand() == GRHS->getPointerOperand() &&
-          GLHS->hasAllConstantIndices() && GRHS->hasAllConstantIndices()) {
-        // The bases are equal and the indices are constant.  Build a constant
-        // expression GEP with the same indices and a null base pointer to see
-        // what constant folding can make out of it.
-        Constant *Null = Constant::getNullValue(GLHS->getPointerOperandType());
-        SmallVector<Value *, 4> IndicesLHS(GLHS->idx_begin(), GLHS->idx_end());
-        Constant *NewLHS = ConstantExpr::getGetElementPtr(Null, IndicesLHS);
-
-        SmallVector<Value *, 4> IndicesRHS(GRHS->idx_begin(), GRHS->idx_end());
-        Constant *NewRHS = ConstantExpr::getGetElementPtr(Null, IndicesRHS);
-        return ConstantExpr::getICmp(Pred, NewLHS, NewRHS);
-      }
-    }
-  }
-
   // If the comparison is with the result of a select instruction, check whether
   // comparing with either branch of the select always yields the same value.
   if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))

test/Transforms/InstCombine/icmp.ll

@@ -634,6 +634,8 @@ define i1 @test62(i8* %a) {
   %arrayidx2 = getelementptr inbounds i8* %a, i64 10
   %cmp = icmp slt i8* %arrayidx1, %arrayidx2
   ret i1 %cmp
+; Don't turn a signed cmp of GEPs into an index compare.
 ; CHECK: @test62
-; CHECK-NEXT: ret i1 true
+; CHECK: %cmp = icmp slt i8* %arrayidx1, %arrayidx2
+; CHECK-NEXT: ret i1 %cmp
 }

test/Transforms/InstSimplify/compare.ll

@@ -40,60 +40,6 @@ define i1 @gep2() {
 ; CHECK-NEXT: ret i1 true
 }
 
-; PR11238
-%gept = type { i32, i32 }
-@gepy = global %gept zeroinitializer, align 8
-@gepz = extern_weak global %gept
-
-define i1 @gep3() {
-; CHECK: @gep3
-  %x = alloca %gept, align 8
-  %a = getelementptr %gept* %x, i64 0, i32 0
-  %b = getelementptr %gept* %x, i64 0, i32 1
-  %equal = icmp eq i32* %a, %b
-  ret i1 %equal
-; CHECK-NEXT: ret i1 false
-}
-
-define i1 @gep4() {
-; CHECK: @gep4
-  %x = alloca %gept, align 8
-  %a = getelementptr %gept* @gepy, i64 0, i32 0
-  %b = getelementptr %gept* @gepy, i64 0, i32 1
-  %equal = icmp eq i32* %a, %b
-  ret i1 %equal
-; CHECK-NEXT: ret i1 false
-}
-
-define i1 @gep5() {
-; CHECK: @gep5
-  %x = alloca %gept, align 8
-  %a = getelementptr inbounds %gept* %x, i64 0, i32 1
-  %b = getelementptr %gept* @gepy, i64 0, i32 0
-  %equal = icmp eq i32* %a, %b
-  ret i1 %equal
-; CHECK-NEXT: ret i1 false
-}
-
-define i1 @gep6(%gept* %x) {
-; Same as @gep3 but potentially null.
-; CHECK: @gep6
-  %a = getelementptr %gept* %x, i64 0, i32 0
-  %b = getelementptr %gept* %x, i64 0, i32 1
-  %equal = icmp eq i32* %a, %b
-  ret i1 %equal
-; CHECK-NEXT: ret i1 false
-}
-
-define i1 @gep7(%gept* %x) {
-; CHECK: @gep7
-  %a = getelementptr %gept* %x, i64 0, i32 0
-  %b = getelementptr %gept* @gepz, i64 0, i32 0
-  %equal = icmp eq i32* %a, %b
-  ret i1 %equal
-; CHECK: ret i1 %equal
-}
-
 define i1 @zext(i32 %x) {
 ; CHECK: @zext
   %e1 = zext i32 %x to i64