6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-26 21:32:10 +00:00
Code Issues Projects Releases Wiki Activity

Revert r114097, adding back in the assertion against replacing an Instruction by itself. Now that CorrelatedValuePropagation is

Browse Source 
more careful not to call SimplifyInstructionsInBlock() on an unreachable block, the issue has been fixed at a higher level.  Add
a big warning to SimplifyInstructionsInBlock() to hopefully prevent this in the future.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@114117 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Owen Anderson 2010-09-16 20:51:41 +00:00
parent 35aa94b229
commit 4e282decf3
3 changed files with 17 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/llvm/Analysis/InstructionSimplify.h
View File

@ -71,6 +71,8 @@ namespace llvm {
/// SimplifyInstruction - See if we can compute a simplified version of this
/// instruction. If not, this returns null.
/// WARNING: If called on unreachable code, an instruction may be reported
/// to simplify to itself.
Value *SimplifyInstruction(Instruction *I, const TargetData *TD = 0);

4
include/llvm/Transforms/Utils/Local.h
View File

@ -69,6 +69,10 @@ bool RecursivelyDeleteDeadPHINode(PHINode *PN);
///
/// This returns true if it changed the code, note that it can delete
/// instructions in other blocks as well in this block.
///
/// WARNING: Do not use this function on unreachable blocks, as recursive
/// simplification is not able to handle corner-case scenarios that can
/// arise in them.
bool SimplifyInstructionsInBlock(BasicBlock *BB, const TargetData *TD = 0);
//===----------------------------------------------------------------------===//

35
lib/Analysis/InstructionSimplify.cpp
View File

@ -423,44 +423,31 @@ Value *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
/// SimplifyInstruction - See if we can compute a simplified version of this
/// instruction. If not, this returns null.
Value *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD) {
Value *Ret = 0;
switch (I->getOpcode()) {
default:
return ConstantFoldInstruction(I, TD);
case Instruction::Add:
Ret = SimplifyAddInst(I->getOperand(0), I->getOperand(1),
cast<BinaryOperator>(I)->hasNoSignedWrap(),
cast<BinaryOperator>(I)->hasNoUnsignedWrap(), TD);
break;
return SimplifyAddInst(I->getOperand(0), I->getOperand(1),
cast<BinaryOperator>(I)->hasNoSignedWrap(),
cast<BinaryOperator>(I)->hasNoUnsignedWrap(), TD);
case Instruction::And:
Ret = SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD);
break;
return SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD);
case Instruction::Or:
Ret = SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD);
break;
return SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD);
case Instruction::ICmp:
Ret = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(),
I->getOperand(0), I->getOperand(1), TD);
break;
return SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(),
I->getOperand(0), I->getOperand(1), TD);
case Instruction::FCmp:
Ret = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(),
I->getOperand(0), I->getOperand(1), TD);
break;
return SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(),
I->getOperand(0), I->getOperand(1), TD);
case Instruction::Select:
Ret = SimplifySelectInst(I->getOperand(0), I->getOperand(1),
return SimplifySelectInst(I->getOperand(0), I->getOperand(1),
I->getOperand(2), TD);
break;
case Instruction::GetElementPtr: {
SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end());
Ret = SimplifyGEPInst(&Ops[0], Ops.size(), TD);
break;
return SimplifyGEPInst(&Ops[0], Ops.size(), TD);
}
}
// It is possible, in situations involving unreachable loops, to
// have a replacement that, through recursive simplification, ends up
// simplifying to itself.
return Ret != I ? Ret : 0;
}
/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then