mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-26 05:32:25 +00:00
At -O123 the early-cse pass is run before instcombine has run. According to my
auto-simplier the transform most missed by early-cse is (zext X) != 0 -> X != 0. This patch adds this transform and some related logic to InstructionSimplify and removes some of the logic from instcombine (unfortunately not all because there are several situations in which instcombine can improve things by making new instructions, whereas instsimplify is not allowed to do this). At -O2 this often results in more than 15% more simplifications by early-cse, and results in hundreds of lines of bitcode being eliminated from the testsuite. I did see some small negative effects in the testsuite, for example a few additional instructions in three programs. One program, 483.xalancbmk, got an additional 35 instructions, which seems to be due to a function getting an additional instruction and then being inlined all over the place. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@123911 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Duncan Sands
parent
8197754be5
commit
9d32f60a6f
@ -1203,6 +1203,168 @@ static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
|
||||
// We already know that LHS != LHS.
|
||||
return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred));
|
||||
|
||||
// Compare of cast, for example (zext X) != 0 -> X != 0
|
||||
if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) {
|
||||
Instruction *LI = cast<CastInst>(LHS);
|
||||
Value *SrcOp = LI->getOperand(0);
|
||||
const Type *SrcTy = SrcOp->getType();
|
||||
const Type *DstTy = LI->getType();
|
||||
|
||||
// Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input
|
||||
// if the integer type is the same size as the pointer type.
|
||||
if (MaxRecurse && TD && isa<PtrToIntInst>(LI) &&
|
||||
TD->getPointerSizeInBits() == DstTy->getPrimitiveSizeInBits()) {
|
||||
if (Constant *RHSC = dyn_cast<Constant>(RHS)) {
|
||||
// Transfer the cast to the constant.
|
||||
if (Value *V = SimplifyICmpInst(Pred, SrcOp,
|
||||
ConstantExpr::getIntToPtr(RHSC, SrcTy),
|
||||
TD, DT, MaxRecurse-1))
|
||||
return V;
|
||||
} else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) {
|
||||
if (RI->getOperand(0)->getType() == SrcTy)
|
||||
// Compare without the cast.
|
||||
if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0),
|
||||
TD, DT, MaxRecurse-1))
|
||||
return V;
|
||||
}
|
||||
}
|
||||
|
||||
if (isa<ZExtInst>(LHS)) {
|
||||
// Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the
|
||||
// same type.
|
||||
if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) {
|
||||
if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
|
||||
// Compare X and Y. Note that signed predicates become unsigned.
|
||||
if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred),
|
||||
SrcOp, RI->getOperand(0), TD, DT,
|
||||
MaxRecurse-1))
|
||||
return V;
|
||||
}
|
||||
// Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended
|
||||
// too. If not, then try to deduce the result of the comparison.
|
||||
else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
|
||||
// Compute the constant that would happen if we truncated to SrcTy then
|
||||
// reextended to DstTy.
|
||||
Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy);
|
||||
Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy);
|
||||
|
||||
// If the re-extended constant didn't change then this is effectively
|
||||
// also a case of comparing two zero-extended values.
|
||||
if (RExt == CI && MaxRecurse)
|
||||
if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred),
|
||||
SrcOp, Trunc, TD, DT, MaxRecurse-1))
|
||||
return V;
|
||||
|
||||
// Otherwise the upper bits of LHS are zero while RHS has a non-zero bit
|
||||
// there. Use this to work out the result of the comparison.
|
||||
if (RExt != CI) {
|
||||
switch (Pred) {
|
||||
default:
|
||||
assert(false && "Unknown ICmp predicate!");
|
||||
// LHS <u RHS.
|
||||
case ICmpInst::ICMP_EQ:
|
||||
case ICmpInst::ICMP_UGT:
|
||||
case ICmpInst::ICMP_UGE:
|
||||
return ConstantInt::getFalse(CI->getContext());
|
||||
|
||||
case ICmpInst::ICMP_NE:
|
||||
case ICmpInst::ICMP_ULT:
|
||||
case ICmpInst::ICMP_ULE:
|
||||
return ConstantInt::getTrue(CI->getContext());
|
||||
|
||||
// LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS
|
||||
// is non-negative then LHS <s RHS.
|
||||
case ICmpInst::ICMP_SGT:
|
||||
case ICmpInst::ICMP_SGE:
|
||||
return CI->getValue().isNegative() ?
|
||||
ConstantInt::getTrue(CI->getContext()) :
|
||||
ConstantInt::getFalse(CI->getContext());
|
||||
|
||||
case ICmpInst::ICMP_SLT:
|
||||
case ICmpInst::ICMP_SLE:
|
||||
return CI->getValue().isNegative() ?
|
||||
ConstantInt::getFalse(CI->getContext()) :
|
||||
ConstantInt::getTrue(CI->getContext());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (isa<SExtInst>(LHS)) {
|
||||
// Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the
|
||||
// same type.
|
||||
if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) {
|
||||
if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
|
||||
// Compare X and Y. Note that the predicate does not change.
|
||||
if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0),
|
||||
TD, DT, MaxRecurse-1))
|
||||
return V;
|
||||
}
|
||||
// Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended
|
||||
// too. If not, then try to deduce the result of the comparison.
|
||||
else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
|
||||
// Compute the constant that would happen if we truncated to SrcTy then
|
||||
// reextended to DstTy.
|
||||
Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy);
|
||||
Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy);
|
||||
|
||||
// If the re-extended constant didn't change then this is effectively
|
||||
// also a case of comparing two sign-extended values.
|
||||
if (RExt == CI && MaxRecurse)
|
||||
if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, TD, DT,
|
||||
MaxRecurse-1))
|
||||
return V;
|
||||
|
||||
// Otherwise the upper bits of LHS are all equal, while RHS has varying
|
||||
// bits there. Use this to work out the result of the comparison.
|
||||
if (RExt != CI) {
|
||||
switch (Pred) {
|
||||
default:
|
||||
assert(false && "Unknown ICmp predicate!");
|
||||
case ICmpInst::ICMP_EQ:
|
||||
return ConstantInt::getFalse(CI->getContext());
|
||||
case ICmpInst::ICMP_NE:
|
||||
return ConstantInt::getTrue(CI->getContext());
|
||||
|
||||
// If RHS is non-negative then LHS <s RHS. If RHS is negative then
|
||||
// LHS >s RHS.
|
||||
case ICmpInst::ICMP_SGT:
|
||||
case ICmpInst::ICMP_SGE:
|
||||
return CI->getValue().isNegative() ?
|
||||
ConstantInt::getTrue(CI->getContext()) :
|
||||
ConstantInt::getFalse(CI->getContext());
|
||||
case ICmpInst::ICMP_SLT:
|
||||
case ICmpInst::ICMP_SLE:
|
||||
return CI->getValue().isNegative() ?
|
||||
ConstantInt::getFalse(CI->getContext()) :
|
||||
ConstantInt::getTrue(CI->getContext());
|
||||
|
||||
// If LHS is non-negative then LHS <u RHS. If LHS is negative then
|
||||
// LHS >u RHS.
|
||||
case ICmpInst::ICMP_UGT:
|
||||
case ICmpInst::ICMP_UGE:
|
||||
// Comparison is true iff the LHS <s 0.
|
||||
if (MaxRecurse)
|
||||
if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp,
|
||||
Constant::getNullValue(SrcTy),
|
||||
TD, DT, MaxRecurse-1))
|
||||
return V;
|
||||
break;
|
||||
case ICmpInst::ICMP_ULT:
|
||||
case ICmpInst::ICMP_ULE:
|
||||
// Comparison is true iff the LHS >=s 0.
|
||||
if (MaxRecurse)
|
||||
if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp,
|
||||
Constant::getNullValue(SrcTy),
|
||||
TD, DT, MaxRecurse-1))
|
||||
return V;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// 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))
|
||||
|
||||
@ -1540,46 +1540,25 @@ Instruction *InstCombiner::visitICmpInstWithCastAndCast(ICmpInst &ICI) {
|
||||
|
||||
// The re-extended constant changed so the constant cannot be represented
|
||||
// in the shorter type. Consequently, we cannot emit a simple comparison.
|
||||
// All the cases that fold to true or false will have already been handled
|
||||
// by SimplifyICmpInst, so only deal with the tricky case.
|
||||
|
||||
// First, handle some easy cases. We know the result cannot be equal at this
|
||||
// point so handle the ICI.isEquality() cases
|
||||
if (ICI.getPredicate() == ICmpInst::ICMP_EQ)
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(ICI.getContext()));
|
||||
if (ICI.getPredicate() == ICmpInst::ICMP_NE)
|
||||
return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(ICI.getContext()));
|
||||
if (isSignedCmp || !isSignedExt)
|
||||
return 0;
|
||||
|
||||
// Evaluate the comparison for LT (we invert for GT below). LE and GE cases
|
||||
// should have been folded away previously and not enter in here.
|
||||
Value *Result;
|
||||
if (isSignedCmp) {
|
||||
// We're performing a signed comparison.
|
||||
if (cast<ConstantInt>(CI)->getValue().isNegative())
|
||||
Result = ConstantInt::getFalse(ICI.getContext()); // X < (small) --> false
|
||||
else
|
||||
Result = ConstantInt::getTrue(ICI.getContext()); // X < (large) --> true
|
||||
} else {
|
||||
// We're performing an unsigned comparison.
|
||||
if (isSignedExt) {
|
||||
// We're performing an unsigned comp with a sign extended value.
|
||||
// This is true if the input is >= 0. [aka >s -1]
|
||||
Constant *NegOne = Constant::getAllOnesValue(SrcTy);
|
||||
Result = Builder->CreateICmpSGT(LHSCIOp, NegOne, ICI.getName());
|
||||
} else {
|
||||
// Unsigned extend & unsigned compare -> always true.
|
||||
Result = ConstantInt::getTrue(ICI.getContext());
|
||||
}
|
||||
}
|
||||
|
||||
// We're performing an unsigned comp with a sign extended value.
|
||||
// This is true if the input is >= 0. [aka >s -1]
|
||||
Constant *NegOne = Constant::getAllOnesValue(SrcTy);
|
||||
Value *Result = Builder->CreateICmpSGT(LHSCIOp, NegOne, ICI.getName());
|
||||
|
||||
// Finally, return the value computed.
|
||||
if (ICI.getPredicate() == ICmpInst::ICMP_ULT ||
|
||||
ICI.getPredicate() == ICmpInst::ICMP_SLT)
|
||||
if (ICI.getPredicate() == ICmpInst::ICMP_ULT)
|
||||
return ReplaceInstUsesWith(ICI, Result);
|
||||
|
||||
assert((ICI.getPredicate()==ICmpInst::ICMP_UGT ||
|
||||
ICI.getPredicate()==ICmpInst::ICMP_SGT) &&
|
||||
"ICmp should be folded!");
|
||||
if (Constant *CI = dyn_cast<Constant>(Result))
|
||||
return ReplaceInstUsesWith(ICI, ConstantExpr::getNot(CI));
|
||||
assert(ICI.getPredicate() == ICmpInst::ICMP_UGT && "ICmp should be folded!");
|
||||
return BinaryOperator::CreateNot(Result);
|
||||
}
|
||||
|
||||
|
||||
45
test/Transforms/InstSimplify/2011-01-18-Compare.ll
Normal file
45
test/Transforms/InstSimplify/2011-01-18-Compare.ll
Normal file
@ -0,0 +1,45 @@
|
||||
; RUN: opt < %s -instsimplify -S | FileCheck %s
|
||||
target datalayout = "p:32:32"
|
||||
|
||||
define i1 @ptrtoint() {
|
||||
; CHECK: @ptrtoint
|
||||
%a = alloca i8
|
||||
%tmp = ptrtoint i8* %a to i32
|
||||
%r = icmp eq i32 %tmp, 0
|
||||
ret i1 %r
|
||||
; CHECK: ret i1 false
|
||||
}
|
||||
|
||||
define i1 @zext(i32 %x) {
|
||||
; CHECK: @zext
|
||||
%e1 = zext i32 %x to i64
|
||||
%e2 = zext i32 %x to i64
|
||||
%r = icmp eq i64 %e1, %e2
|
||||
ret i1 %r
|
||||
; CHECK: ret i1 true
|
||||
}
|
||||
|
||||
define i1 @zext2(i1 %x) {
|
||||
; CHECK: @zext2
|
||||
%e = zext i1 %x to i32
|
||||
%c = icmp ne i32 %e, 0
|
||||
ret i1 %c
|
||||
; CHECK: ret i1 %x
|
||||
}
|
||||
|
||||
define i1 @sext(i32 %x) {
|
||||
; CHECK: @sext
|
||||
%e1 = sext i32 %x to i64
|
||||
%e2 = sext i32 %x to i64
|
||||
%r = icmp eq i64 %e1, %e2
|
||||
ret i1 %r
|
||||
; CHECK: ret i1 true
|
||||
}
|
||||
|
||||
define i1 @sext2(i1 %x) {
|
||||
; CHECK: @sext2
|
||||
%e = sext i1 %x to i32
|
||||
%c = icmp ne i32 %e, 0
|
||||
ret i1 %c
|
||||
; CHECK: ret i1 %x
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user