From: Nick Lewycky Date: Sat, 25 Feb 2012 23:01:19 +0000 (+0000) Subject: Roll these back to r151448 until I figure out how they're breaking X-Git-Url: http://plrg.eecs.uci.edu/git/?p=oota-llvm.git;a=commitdiff_plain;h=6fd3428afa46ace6712f0649bf4a7bd6799cc355 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 --- diff --git a/lib/Analysis/InstructionSimplify.cpp b/lib/Analysis/InstructionSimplify.cpp index 93f55684c24..37253f72cf6 100644 --- a/lib/Analysis/InstructionSimplify.cpp +++ b/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 , - Different identified objects have + // icmp , - 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 - // LHS is a global variable address or null is pointless, since if both LHS - // and RHS are constants then we already constant folded the compare, and if - // only one of them is then we moved it to RHS already. + // never null or equal to the address of a global. Note that generalizing + // to the case where LHS is a global variable address or null is pointless, + // since if both LHS and RHS are constants then we already constant folded + // 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(LHSPtr)) { RHSPtr = stripPointerAdjustments(RHSPtr); - if (llvm::isKnownNonNull(LHSPtr) || llvm::isKnownNonNull(RHSPtr)) { - // If both sides are different identified objects, they aren't equal - // unless they're null. - 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(LHSPtr) && isa(RHSPtr)) || - (isa(RHSPtr) && isa(LHSPtr))) - return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred)); - } - - // Assume that the constant null is on the right. - if (llvm::isKnownNonNull(LHSPtr) && isa(RHSPtr)) + if (LHSPtr != RHSPtr && + (isa(RHSPtr) || isa(RHSPtr) || + isa(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(LHS)) { - if (GEPOperator *GRHS = dyn_cast(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 IndicesLHS(GLHS->idx_begin(), GLHS->idx_end()); - Constant *NewLHS = ConstantExpr::getGetElementPtr(Null, IndicesLHS); - - SmallVector 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(LHS) || isa(RHS)) diff --git a/test/Transforms/InstCombine/icmp.ll b/test/Transforms/InstCombine/icmp.ll index a9ae221d8f9..dabb0f3adfe 100644 --- a/test/Transforms/InstCombine/icmp.ll +++ b/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 } diff --git a/test/Transforms/InstSimplify/compare.ll b/test/Transforms/InstSimplify/compare.ll index ea43f5fa45d..6ee6dfbdbc9 100644 --- a/test/Transforms/InstSimplify/compare.ll +++ b/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