bool ProgramAnalysis :: AnalyseFunction(Function &F)
{
//Clear hottrace and merge_blocks
HotTraceCounter = 0;
MergeCounter = 0;
DEBUG(errs()<<"\n==== Hot trace - Function : "<< F.getName() <<" ====\n");
DEBUG(errs()<<"BasicBlock \t Execution Count Predecessors\n");
DEBUG(errs()<<"=========================================================");
BasicBlock* bb=F.begin();
//Calculate the Loop Backedges and set them in BackEdges
FindFunctionBackedges(F,BackEdges);
while (true)//Form the Hot trace.
{
DEBUG(errs() << "\n==========Hot trace:" << bb->getName() << "---"<<(int)PI->getExecutionCount(bb)<<"--");
for (pred_iterator PI = pred_begin(bb), E = pred_end(bb); PI != E; ++PI)
{
BasicBlock *Pred = *PI;
DEBUG(errs()<<" ;"<<Pred->getName());
}
checkNumPredecessors(bb);
if (getNextBasicBlock(bb))
bb = NextBlock;
else
break;
}//while Loop
//------- print Trace----------
//testTrace();
//------------------------------
//F.dump();
return true;
}
Slice::Slice(Instruction& I, Slices& S, string name)
: value(I), block(*I.getParent()), function(*block.getParent()),
context(function.getContext()), slices(S), name(name) {
EdgeList backedges;
FindFunctionBackedges(function, backedges);
queue<Instruction*> workList;
workList.push(&I);
while (!workList.empty()) {
Instruction* I = workList.front();
workList.pop();
if (values.count(I) || inputs.count(I))
continue;
if (PHINode* Phi = dyn_cast<PHINode>(I)) {
if (hasIncomingBackEdge(Phi, backedges)) {
inputs.insert(I);
continue;
}
}
if (GlobalValue* G = usedGlobal(I))
inputs.insert(G);
if (Value* Q = getQuantifiedVariable(I))
inputs.insert(Q);
// Add inputs from any subslices, excluding quantified variables
if (Slice* S = getSubslice(I,slices))
for (unordered_set<Value*>::iterator V = S->inputs.begin(),
E = S->inputs.end(); V != E; ++V)
if (!inputs.count(*V) && !dyn_cast<ConstantDataSequential>(*V))
inputs.insert(*V);
values.insert(I);
values.insert(I->getParent());
// ENSURE EACH BLOCK HAS A TERMINATOR
if (BranchInst* Br = dyn_cast<BranchInst>(I->getParent()->getTerminator()))
if (I->getParent() != &block)
workList.push(Br);
if (BranchInst* Br = dyn_cast<BranchInst>(I)) {
if (Br->isConditional()) {
if (Instruction* J = dyn_cast<Instruction>(Br->getCondition())) {
workList.push(J);
}
values.insert(Br->getSuccessor(1));
}
values.insert(Br->getSuccessor(0));
continue;
}
if (PHINode* Phi = dyn_cast<PHINode>(I)) {
for (PHINode::block_iterator B = Phi->block_begin(); B != Phi->block_end(); ++B) {
workList.push( (*B)->getTerminator() );
}
}
for (User::op_iterator U = I->op_begin(); U != I->op_end(); ++U) {
if (Instruction* J = dyn_cast<Instruction>(U)) {
if (!contains(backedges,J->getParent(),I->getParent())) {
workList.push(J);
}
}
}
}
}
