6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-09-26 09:18:56 +00:00
Code Issues Projects Releases Wiki Activity

Move code out of indentation one level to make it easier to read.

Browse Source 
Disable the xform for < > cases.  It turns out that the following is being
miscompiled:

bool %test(sbyte %S) {
        %T = cast sbyte %S to uint
        %V = setgt uint %T, 255
        ret bool %V
}


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@19628 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
2005-01-17 03:20:02 +00:00
parent 7ece380440
commit b352fa5853
1 changed files with 64 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -2438,13 +2438,11 @@ Instruction *InstCombiner::visitSetCondInst(BinaryOperator &I) {
break;
// (setcc (cast X to larger), CI)
case Instruction::Cast: {
Instruction* replacement =
visitSetCondInstWithCastAndConstant(I,cast<CastInst>(LHSI),CI);
if (replacement)
return replacement;
case Instruction::Cast:
if (Instruction *R =
visitSetCondInstWithCastAndConstant(I,cast<CastInst>(LHSI),CI))
return R;
break;
}
case Instruction::Shl: // (setcc (shl X, ShAmt), CI)
if (ConstantUInt *ShAmt = dyn_cast<ConstantUInt>(LHSI->getOperand(1))) {
@@ -2919,7 +2917,9 @@ InstCombiner::visitSetCondInstWithCastAndConstant(BinaryOperator&I,
ConstantInt* CI) {
const Type *SrcTy = LHSI->getOperand(0)->getType();
const Type *DestTy = LHSI->getType();
if (SrcTy->isIntegral() && DestTy->isIntegral()) {
if (!SrcTy->isIntegral() || !DestTy->isIntegral())
return 0;
unsigned SrcBits = SrcTy->getPrimitiveSize()*8;
unsigned DestBits = DestTy->getPrimitiveSize()*8;
if (SrcTy == Type::BoolTy)
@@ -2939,23 +2939,28 @@ InstCombiner::visitSetCondInstWithCastAndConstant(BinaryOperator&I,
// source type.
if (SrcTy->isSigned() && DestTy->isUnsigned()) {
CastInst* Cst = new CastInst(LHSI->getOperand(0),
SrcTy->getUnsignedVersion(), LHSI->getName());
SrcTy->getUnsignedVersion(),
LHSI->getName());
InsertNewInstBefore(Cst,I);
return new SetCondInst(I.getOpcode(), Cst,
ConstantExpr::getCast(CI, SrcTy->getUnsignedVersion()));
ConstantExpr::getCast(CI,
SrcTy->getUnsignedVersion()));
}
return new SetCondInst(I.getOpcode(), LHSI->getOperand(0),NewCst);
}
// The constant value before and after a cast to the source type
// is different, so various cases are possible depending on the
// opcode and the signs of the types involved in the cast.
switch (I.getOpcode()) {
case Instruction::SetLT: {
return 0;
Constant* Max = ConstantIntegral::getMaxValue(SrcTy);
Max = ConstantExpr::getCast(Max, DestTy);
return ReplaceInstUsesWith(I, ConstantExpr::getSetLT(Max, CI));
}
case Instruction::SetGT: {
return 0; // FIXME! RENABLE. This breaks for (cast sbyte to uint) > 255
Constant* Min = ConstantIntegral::getMinValue(SrcTy);
Min = ConstantExpr::getCast(Min, DestTy);
return ReplaceInstUsesWith(I, ConstantExpr::getSetGT(Min, CI));
@@ -2970,10 +2975,9 @@ InstCombiner::visitSetCondInstWithCastAndConstant(BinaryOperator&I,
return ReplaceInstUsesWith(I, ConstantBool::True);
case Instruction::SetLE:
case Instruction::SetGE:
assert(!"SetLE and SetGE should be handled elsewhere");
assert(0 && "SetLE and SetGE should be handled elsewhere");
default:
assert(!"unknown integer comparison");
}
assert(0 && "unknown integer comparison");
}
}
return 0;