//
//===----------------------------------------------------------------------===//
+#define DEBUG_TYPE "simplifycfg"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/Constants.h"
#include "llvm/Instructions.h"
#include "llvm/Type.h"
#include "llvm/Support/CFG.h"
+#include "llvm/Support/Debug.h"
#include <algorithm>
#include <functional>
#include <set>
+
using namespace llvm;
// PropagatePredecessorsForPHIs - This gets "Succ" ready to have the
}
}
- // Loop over all of the PHI nodes in the successor BB
+ // Loop over all of the PHI nodes in the successor BB.
for (BasicBlock::iterator I = Succ->begin();
PHINode *PN = dyn_cast<PHINode>(I); ++I) {
Value *OldVal = PN->removeIncomingValue(BB, false);
assert(OldVal && "No entry in PHI for Pred BB!");
- // If this incoming value is one of the PHI nodes in BB...
+ // If this incoming value is one of the PHI nodes in BB, the new entries in
+ // the PHI node are the entries from the old PHI.
if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->getParent() == BB) {
PHINode *OldValPN = cast<PHINode>(OldVal);
- for (std::vector<BasicBlock*>::const_iterator PredI = BBPreds.begin(),
- End = BBPreds.end(); PredI != End; ++PredI) {
- PN->addIncoming(OldValPN->getIncomingValueForBlock(*PredI), *PredI);
- }
+ for (unsigned i = 0, e = OldValPN->getNumIncomingValues(); i != e; ++i)
+ PN->addIncoming(OldValPN->getIncomingValue(i),
+ OldValPN->getIncomingBlock(i));
} else {
for (std::vector<BasicBlock*>::const_iterator PredI = BBPreds.begin(),
End = BBPreds.end(); PredI != End; ++PredI) {
if (cast<LoadInst>(I)->isVolatile())
return false;
if (!isa<AllocaInst>(I->getOperand(0)) &&
- !isa<Constant>(I->getOperand(0)) &&
- !isa<GlobalValue>(I->getOperand(0)))
+ !isa<Constant>(I->getOperand(0)))
return false;
// Finally, we have to check to make sure there are no instructions
// GatherConstantSetEQs - Given a potentially 'or'd together collection of seteq
// instructions that compare a value against a constant, return the value being
// compared, and stick the constant into the Values vector.
-static Value *GatherConstantSetEQs(Value *V, std::vector<Constant*> &Values) {
+static Value *GatherConstantSetEQs(Value *V, std::vector<ConstantInt*> &Values){
if (Instruction *Inst = dyn_cast<Instruction>(V))
if (Inst->getOpcode() == Instruction::SetEQ) {
- if (Constant *C = dyn_cast<Constant>(Inst->getOperand(1))) {
+ if (ConstantInt *C = dyn_cast<ConstantInt>(Inst->getOperand(1))) {
Values.push_back(C);
return Inst->getOperand(0);
- } else if (Constant *C = dyn_cast<Constant>(Inst->getOperand(0))) {
+ } else if (ConstantInt *C = dyn_cast<ConstantInt>(Inst->getOperand(0))) {
Values.push_back(C);
return Inst->getOperand(1);
}
// 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<Constant*> &Values) {
+static Value *GatherConstantSetNEs(Value *V, std::vector<ConstantInt*> &Values){
if (Instruction *Inst = dyn_cast<Instruction>(V))
if (Inst->getOpcode() == Instruction::SetNE) {
- if (Constant *C = dyn_cast<Constant>(Inst->getOperand(1))) {
+ if (ConstantInt *C = dyn_cast<ConstantInt>(Inst->getOperand(1))) {
Values.push_back(C);
return Inst->getOperand(0);
- } else if (Constant *C = dyn_cast<Constant>(Inst->getOperand(0))) {
+ } else if (ConstantInt *C = dyn_cast<ConstantInt>(Inst->getOperand(0))) {
Values.push_back(C);
return Inst->getOperand(1);
}
} else if (Inst->getOpcode() == Instruction::Cast) {
// Cast of X to bool is really a comparison against zero.
assert(Inst->getType() == Type::BoolTy && "Can only handle bool values!");
- Values.push_back(Constant::getNullValue(Inst->getOperand(0)->getType()));
+ Values.push_back(ConstantInt::get(Inst->getOperand(0)->getType(), 0));
return Inst->getOperand(0);
} else if (Inst->getOpcode() == Instruction::And) {
if (Value *LHS = GatherConstantSetNEs(Inst->getOperand(0), Values))
/// bunch of comparisons of one value against constants, return the value and
/// the constants being compared.
static bool GatherValueComparisons(Instruction *Cond, Value *&CompVal,
- std::vector<Constant*> &Values) {
+ std::vector<ConstantInt*> &Values) {
if (Cond->getOpcode() == Instruction::Or) {
CompVal = GatherConstantSetEQs(Cond, Values);
if (SI1 == SI2) return false; // Can't merge with self!
// It is not safe to merge these two switch instructions if they have a common
- // successor, and if that successor has a PHI node, and if that PHI node has
+ // successor, and if that successor has a PHI node, and if *that* PHI node has
// conflicting incoming values from the two switch blocks.
BasicBlock *SI1BB = SI1->getParent();
BasicBlock *SI2BB = SI2->getParent();
/// AddPredecessorToBlock - Update PHI nodes in Succ to indicate that there will
/// now be entries in it from the 'NewPred' block. The values that will be
/// flowing into the PHI nodes will be the same as those coming in from
-/// ExistPred, and existing predecessor of Succ.
+/// ExistPred, an existing predecessor of Succ.
static void AddPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred,
BasicBlock *ExistPred) {
assert(std::find(succ_begin(ExistPred), succ_end(ExistPred), Succ) !=
return Changed;
}
+namespace {
+ /// ConstantIntOrdering - This class implements a stable ordering of constant
+ /// integers that does not depend on their address. This is important for
+ /// applications that sort ConstantInt's to ensure uniqueness.
+ struct ConstantIntOrdering {
+ bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const {
+ return LHS->getRawValue() < RHS->getRawValue();
+ }
+ };
+}
+
// SimplifyCFG - This function is used to do simplification of a CFG. For
// example, it adjusts branches to branches to eliminate the extra hop, it
// Remove basic blocks that have no predecessors... which are unreachable.
if (pred_begin(BB) == pred_end(BB) ||
*pred_begin(BB) == BB && ++pred_begin(BB) == pred_end(BB)) {
- //cerr << "Removing BB: \n" << BB;
+ DEBUG(std::cerr << "Removing BB: \n" << *BB);
// Loop through all of our successors and make sure they know that one
// of their predecessors is going away.
// we cannot do this transformation!
//
if (!PropagatePredecessorsForPHIs(BB, Succ)) {
- //cerr << "Killing Trivial BB: \n" << BB;
+ DEBUG(std::cerr << "Killing Trivial BB: \n" << *BB);
std::string OldName = BB->getName();
std::vector<BasicBlock*>
// this means that we should any newly added incoming edges should
// use the PHI node as the value for these edges, because they are
// loop back edges.
-
for (unsigned i = 0, e = OldSuccPreds.size(); i != e; ++i)
if (OldSuccPreds[i] != BB)
PN->addIncoming(PN, OldSuccPreds[i]);
if (!OldName.empty() && !Succ->hasName()) // Transfer name if we can
Succ->setName(OldName);
-
- //cerr << "Function after removal: \n" << M;
return true;
}
}
} else if (UnwindInst *UI = dyn_cast<UnwindInst>(BB->begin())) {
// Check to see if the first instruction in this block is just an unwind.
// If so, replace any invoke instructions which use this as an exception
- // destination with call instructions.
+ // destination with call instructions, and any unconditional branch
+ // predecessor with an unwind.
//
std::vector<BasicBlock*> Preds(pred_begin(BB), pred_end(BB));
while (!Preds.empty()) {
BasicBlock *Pred = Preds.back();
- if (InvokeInst *II = dyn_cast<InvokeInst>(Pred->getTerminator()))
+ if (BranchInst *BI = dyn_cast<BranchInst>(Pred->getTerminator())) {
+ if (BI->isUnconditional()) {
+ Pred->getInstList().pop_back(); // nuke uncond branch
+ new UnwindInst(Pred); // Use unwind.
+ Changed = true;
+ }
+ } else if (InvokeInst *II = dyn_cast<InvokeInst>(Pred->getTerminator()))
if (II->getUnwindDest() == BB) {
// Insert a new branch instruction before the invoke, because this
// is now a fall through...
for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI!=E; ++PI)
if (BranchInst *PBI = dyn_cast<BranchInst>((*PI)->getTerminator()))
if (PBI->isConditional() && SafeToMergeTerminators(BI, PBI)) {
+ BasicBlock *PredBlock = *PI;
if (PBI->getSuccessor(0) == FalseDest ||
PBI->getSuccessor(1) == TrueDest) {
// Invert the predecessors condition test (xor it with true),
if (PBI->getSuccessor(0) == TrueDest ||
PBI->getSuccessor(1) == FalseDest) {
- // Clone Cond into the predecessor basic block, and and the
+ // Clone Cond into the predecessor basic block, and or/and the
// two conditions together.
Instruction *New = Cond->clone();
New->setName(Cond->getName());
Cond->setName(Cond->getName()+".old");
- (*PI)->getInstList().insert(PBI, New);
+ PredBlock->getInstList().insert(PBI, New);
Instruction::BinaryOps Opcode =
PBI->getSuccessor(0) == TrueDest ?
Instruction::Or : Instruction::And;
New, "bothcond", PBI);
PBI->setCondition(NewCond);
if (PBI->getSuccessor(0) == BB) {
- AddPredecessorToBlock(TrueDest, *PI, BB);
+ AddPredecessorToBlock(TrueDest, PredBlock, BB);
PBI->setSuccessor(0, TrueDest);
}
if (PBI->getSuccessor(1) == BB) {
- AddPredecessorToBlock(FalseDest, *PI, BB);
+ AddPredecessorToBlock(FalseDest, PredBlock, BB);
PBI->setSuccessor(1, FalseDest);
}
return SimplifyCFG(BB) | 1;
}
if (OnlySucc) {
- //cerr << "Merging: " << BB << "into: " << OnlyPred;
+ DEBUG(std::cerr << "Merging: " << *BB << "into: " << *OnlyPred);
TerminatorInst *Term = OnlyPred->getTerminator();
// Resolve any PHI nodes at the start of the block. They are all
// If this is a bunch of seteq's or'd together, or if it's a bunch of
// 'setne's and'ed together, collect them.
Value *CompVal = 0;
- std::vector<Constant*> Values;
+ std::vector<ConstantInt*> Values;
bool TrueWhenEqual = GatherValueComparisons(Cond, CompVal, Values);
if (CompVal && CompVal->getType()->isInteger()) {
// There might be duplicate constants in the list, which the switch
// instruction can't handle, remove them now.
- std::sort(Values.begin(), Values.end());
+ std::sort(Values.begin(), Values.end(), ConstantIntOrdering());
Values.erase(std::unique(Values.begin(), Values.end()), Values.end());
// Figure out which block is which destination.
//
BasicBlock *IfTrue, *IfFalse;
if (Value *IfCond = GetIfCondition(BB, IfTrue, IfFalse)) {
- //std::cerr << "FOUND IF CONDITION! " << *IfCond << " T: "
- // << IfTrue->getName() << " F: " << IfFalse->getName() << "\n";
+ DEBUG(std::cerr << "FOUND IF CONDITION! " << *IfCond << " T: "
+ << IfTrue->getName() << " F: " << IfFalse->getName() << "\n");
// Figure out where to insert instructions as necessary.
BasicBlock::iterator AfterPHIIt = BB->begin();
projects / oota-llvm.git / blobdiff