6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-18 12:29:27 +00:00
Code Issues Projects Releases Wiki Activity

Enhance instcombine to be more aggressive about folding casts of

Browse Source 
operations of casts.  This implements InstCombine/zext-fold.ll


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@40726 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2007-08-02 06:11:14 +00:00
parent bfbfcdafbe
commit 951626b437
2 changed files with 54 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -6313,7 +6313,7 @@ Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
/// This is a truncation operation if Ty is smaller than V->getType(), or an
/// extension operation if Ty is larger.
static bool CanEvaluateInDifferentType(Value *V, const IntegerType *Ty,
int &NumCastsRemoved) {
unsigned CastOpc, int &NumCastsRemoved) {
// We can always evaluate constants in another type.
if (isa<ConstantInt>(V))
return true;
@ -6323,30 +6323,48 @@ static bool CanEvaluateInDifferentType(Value *V, const IntegerType *Ty,
const IntegerType *OrigTy = cast<IntegerType>(V->getType());
// If this is an extension or truncate, we can often eliminate it.
if (isa<TruncInst>(I) || isa<ZExtInst>(I) || isa<SExtInst>(I)) {
// If this is a cast from the destination type, we can trivially eliminate
// it, and this will remove a cast overall.
if (I->getOperand(0)->getType() == Ty) {
// If the first operand is itself a cast, and is eliminable, do not count
// this as an eliminable cast. We would prefer to eliminate those two
// casts first.
if (!isa<CastInst>(I->getOperand(0)))
++NumCastsRemoved;
return true;
}
}
// We can't extend or shrink something that has multiple uses: doing so would
// require duplicating the instruction in general, which isn't profitable.
if (!I->hasOneUse()) return false;
switch (I->getOpcode()) {
case Instruction::Add:
case Instruction::Sub:
case Instruction::And:
case Instruction::Or:
case Instruction::Xor:
if (!I->hasOneUse()) return false;
// These operators can all arbitrarily be extended or truncated.
return CanEvaluateInDifferentType(I->getOperand(0), Ty, NumCastsRemoved) &&
CanEvaluateInDifferentType(I->getOperand(1), Ty, NumCastsRemoved);
return CanEvaluateInDifferentType(I->getOperand(0), Ty, CastOpc,
NumCastsRemoved) &&
CanEvaluateInDifferentType(I->getOperand(1), Ty, CastOpc,
NumCastsRemoved);
case Instruction::Shl:
if (!I->hasOneUse()) return false;
// If we are truncating the result of this SHL, and if it's a shift of a
// constant amount, we can always perform a SHL in a smaller type.
if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
uint32_t BitWidth = Ty->getBitWidth();
if (BitWidth < OrigTy->getBitWidth() &&
CI->getLimitedValue(BitWidth) < BitWidth)
return CanEvaluateInDifferentType(I->getOperand(0), Ty,NumCastsRemoved);
return CanEvaluateInDifferentType(I->getOperand(0), Ty, CastOpc,
NumCastsRemoved);
}
break;
case Instruction::LShr:
if (!I->hasOneUse()) return false;
// If this is a truncate of a logical shr, we can truncate it to a smaller
// lshr iff we know that the bits we would otherwise be shifting in are
// already zeros.
@ -6357,22 +6375,17 @@ static bool CanEvaluateInDifferentType(Value *V, const IntegerType *Ty,
MaskedValueIsZero(I->getOperand(0),
APInt::getHighBitsSet(OrigBitWidth, OrigBitWidth-BitWidth)) &&
CI->getLimitedValue(BitWidth) < BitWidth) {
return CanEvaluateInDifferentType(I->getOperand(0), Ty,NumCastsRemoved);
return CanEvaluateInDifferentType(I->getOperand(0), Ty, CastOpc,
NumCastsRemoved);
}
}
break;
case Instruction::Trunc:
case Instruction::ZExt:
case Instruction::SExt:
// If this is a cast from the destination type, we can trivially eliminate
// it, and this will remove a cast overall.
if (I->getOperand(0)->getType() == Ty) {
// If the first operand is itself a cast, and is eliminable, do not count
// this as an eliminable cast. We would prefer to eliminate those two
// casts first.
if (isa<CastInst>(I->getOperand(0)))
return true;
case Instruction::Trunc:
// If this is the same kind of case as our original (e.g. zext+zext), we
// can safely eliminate it.
if (I->getOpcode() == CastOpc) {
++NumCastsRemoved;
return true;
}
@ -6414,14 +6427,16 @@ Value *InstCombiner::EvaluateInDifferentType(Value *V, const Type *Ty,
case Instruction::Trunc:
case Instruction::ZExt:
case Instruction::SExt:
case Instruction::BitCast:
// If the source type of the cast is the type we're trying for then we can
// just return the source. There's no need to insert it because its not new.
// just return the source. There's no need to insert it because it is not
// new.
if (I->getOperand(0)->getType() == Ty)
return I->getOperand(0);
// Some other kind of cast, which shouldn't happen, so just ..
// FALL THROUGH
// Otherwise, must be the same type of case, so just reinsert a new one.
Res = CastInst::create(cast<CastInst>(I)->getOpcode(), I->getOperand(0),
Ty, I->getName());
break;
default:
// TODO: Can handle more cases here.
assert(0 && "Unreachable!");
@ -6597,14 +6612,12 @@ Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) {
int NumCastsRemoved = 0;
if (!isa<BitCastInst>(CI) &&
CanEvaluateInDifferentType(SrcI, cast<IntegerType>(DestTy),
NumCastsRemoved)) {
CI.getOpcode(), NumCastsRemoved)) {
// If this cast is a truncate, evaluting in a different type always
// eliminates the cast, so it is always a win. If this is a noop-cast
// this just removes a noop cast which isn't pointful, but simplifies
// the code. If this is a zero-extension, we need to do an AND to
// maintain the clear top-part of the computation, so we require that
// the input have eliminated at least one cast. If this is a sign
// extension, we insert two new casts (to do the extension) so we
// eliminates the cast, so it is always a win. If this is a zero-extension,
// we need to do an AND to maintain the clear top-part of the computation,
// so we require that the input have eliminated at least one cast. If this
// is a sign extension, we insert two new casts (to do the extension) so we
// require that two casts have been eliminated.
bool DoXForm;
switch (CI.getOpcode()) {
@ -6621,9 +6634,6 @@ Instruction *InstCombiner::commonIntCastTransforms(CastInst &CI) {
case Instruction::SExt:
DoXForm = NumCastsRemoved >= 2;
break;
case Instruction::BitCast:
DoXForm = false;
break;
}
if (DoXForm) {

12
test/Transforms/InstCombine/zext-fold.ll Normal file
View File

@ -0,0 +1,12 @@
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep {zext } | wc -l | grep 1
; PR1570
define i32 @test2(float %X, float %Y) {
entry:
%tmp3 = fcmp uno float %X, %Y ; <i1> [#uses=1]
%tmp34 = zext i1 %tmp3 to i8 ; <i8> [#uses=1]
%tmp = xor i8 %tmp34, 1 ; <i8> [#uses=1]
%toBoolnot5 = zext i8 %tmp to i32 ; <i32> [#uses=1]
ret i32 %toBoolnot5
}