6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-22 10:29:35 +00:00
Code Issues Projects Releases Wiki Activity

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

Browse Source 
MultiSource/Applications/lua.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@151463 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Nick Lewycky 2012-02-25 23:01:19 +00:00
parent 28e215ba63
commit 6fd3428afa
3 changed files with 13 additions and 97 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
lib/Analysis/InstructionSimplify.cpp
View File

@ -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
// 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<AllocaInst>(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<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))
if (LHSPtr != RHSPtr &&
(isa<GlobalValue>(RHSPtr) || isa<AllocaInst>(RHSPtr) ||
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))

4
test/Transforms/InstCombine/icmp.ll
View File

@ -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
}

54
test/Transforms/InstSimplify/compare.ll
View File

@ -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