6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-05-16 07:38:43 +00:00
Code Issues Projects Releases Wiki Activity

merge two very similar functions into one that has a bool argument.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@121678 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2010-12-13 04:26:26 +00:00
parent de7f920835
commit 0aa749bde7
1 changed files with 26 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

73
lib/Transforms/Utils/SimplifyCFG.cpp
View File

@ -291,61 +291,39 @@ static ConstantInt *GetConstantInt(Value *V, const TargetData *TD) {
return 0; return 0;
} }
/// GatherConstantSetEQs - Given a potentially 'or'd together collection of /// GatherConstantCompares - Given a potentially 'or'd or 'and'd together
/// icmp_eq instructions that compare a value against a constant, return the /// collection of icmp eq/ne instructions that compare a value against a
/// value being compared, and stick the constant into the Values vector. /// constant, return the value being compared, and stick the constant into the
/// Values vector.
static Value * static Value *
GatherConstantSetEQs(Value *V, std::vector<ConstantInt*> &Values, GatherConstantCompares(Value *V, std::vector<ConstantInt*> &Vals, Value *&Extra,
const TargetData *TD) { const TargetData *TD, bool isEQ) {
Instruction *Inst = dyn_cast<Instruction>(V); Instruction *I = dyn_cast<Instruction>(V);
if (Inst == 0) return 0; if (I == 0) return 0;
if (Inst->getOpcode() == Instruction::ICmp && if (ICmpInst *ICI = dyn_cast<ICmpInst>(I)) {
cast<ICmpInst>(Inst)->getPredicate() == ICmpInst::ICMP_EQ) { if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE))
if (ConstantInt *C = GetConstantInt(Inst->getOperand(1), TD)) { if (ConstantInt *C = GetConstantInt(I->getOperand(1), TD)) {
Values.push_back(C); Vals.push_back(C);
return Inst->getOperand(0); return I->getOperand(0);
} }
return 0; return 0;
} }
if (Inst->getOpcode() == Instruction::Or) { if (I->getOpcode() != (isEQ ? Instruction::Or : Instruction::And))
if (Value *LHS = GatherConstantSetEQs(Inst->getOperand(0), Values, TD))
if (Value *RHS = GatherConstantSetEQs(Inst->getOperand(1), Values, TD))
if (LHS == RHS)
return LHS;
}
return 0;
}
/// GatherConstantSetNEs - Given a potentially 'and'd together collection of
/// setne instructions that compare a value against a constant, return the value
/// being compared, and stick the constant into the Values vector.
static Value *
GatherConstantSetNEs(Value *V, std::vector<ConstantInt*> &Values,
const TargetData *TD) {
Instruction *Inst = dyn_cast<Instruction>(V);
if (Inst == 0) return 0;
if (Inst->getOpcode() == Instruction::ICmp &&
cast<ICmpInst>(Inst)->getPredicate() == ICmpInst::ICMP_NE) {
if (ConstantInt *C = GetConstantInt(Inst->getOperand(1), TD)) {
Values.push_back(C);
return Inst->getOperand(0);
}
return 0; return 0;
}
if (Inst->getOpcode() == Instruction::And) { if (Value *LHS = GatherConstantCompares(I->getOperand(0), Vals, Extra, TD,
if (Value *LHS = GatherConstantSetNEs(Inst->getOperand(0), Values, TD)) isEQ)) {
if (Value *RHS = GatherConstantSetNEs(Inst->getOperand(1), Values, TD)) if (Value *RHS = GatherConstantCompares(I->getOperand(1), Vals, Extra, TD,
if (LHS == RHS) isEQ)) {
return LHS; if (LHS == RHS)
return LHS;
}
} }
return 0; return 0;
} }
static void EraseTerminatorInstAndDCECond(TerminatorInst *TI) { static void EraseTerminatorInstAndDCECond(TerminatorInst *TI) {
Instruction* Cond = 0; Instruction* Cond = 0;
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) { if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
@ -2070,12 +2048,13 @@ bool SimplifyCFGOpt::run(BasicBlock *BB) {
Value *CompVal = 0; Value *CompVal = 0;
std::vector<ConstantInt*> Values; std::vector<ConstantInt*> Values;
bool TrueWhenEqual = true; bool TrueWhenEqual = true;
Value *ExtraCase = 0;
if (Instruction *Cond = dyn_cast<Instruction>(BI->getCondition())) { if (Instruction *Cond = dyn_cast<Instruction>(BI->getCondition())) {
if (Cond->getOpcode() == Instruction::Or) { if (Cond->getOpcode() == Instruction::Or) {
CompVal = GatherConstantSetEQs(Cond, Values, TD); CompVal = GatherConstantCompares(Cond, Values, ExtraCase, TD, true);
} else if (Cond->getOpcode() == Instruction::And) { } else if (Cond->getOpcode() == Instruction::And) {
CompVal = GatherConstantSetNEs(Cond, Values, TD); CompVal = GatherConstantCompares(Cond, Values, ExtraCase, TD, false);
TrueWhenEqual = false; TrueWhenEqual = false;
} }
} }