namespace llvm {
class BasicBlock;
+ class Function;
class Pass;
/// ProfileInfo Class - This class holds and maintains edge profiling
/// information for some unit of code.
class ProfileInfo {
+ public:
+ // Types for handling profiling information.
+ typedef std::pair<const BasicBlock*, const BasicBlock*> Edge;
+
protected:
// EdgeCounts - Count the number of times a transition between two blocks is
// executed. As a special case, we also hold an edge from the null
// BasicBlock to the entry block to indicate how many times the function was
// entered.
- std::map<std::pair<BasicBlock*, BasicBlock*>, unsigned> EdgeCounts;
+ std::map<Edge, unsigned> EdgeCounts;
public:
static char ID; // Class identification, replacement for typeinfo
virtual ~ProfileInfo(); // We want to be subclassed
//===------------------------------------------------------------------===//
/// Profile Information Queries
///
- unsigned getExecutionCount(BasicBlock *BB) const;
+ unsigned getExecutionCount(const Function *F) const;
+
+ unsigned getExecutionCount(const BasicBlock *BB) const;
- unsigned getEdgeWeight(BasicBlock *Src, BasicBlock *Dest) const {
- std::map<std::pair<BasicBlock*, BasicBlock*>, unsigned>::const_iterator I=
+ unsigned getEdgeWeight(const BasicBlock *Src,
+ const BasicBlock *Dest) const {
+ std::map<Edge, unsigned>::const_iterator I =
EdgeCounts.find(std::make_pair(Src, Dest));
return I != EdgeCounts.end() ? I->second : 0;
}
ProfileInfo::~ProfileInfo() {}
-unsigned ProfileInfo::getExecutionCount(BasicBlock *BB) const {
- pred_iterator PI = pred_begin(BB), PE = pred_end(BB);
+unsigned ProfileInfo::getExecutionCount(const BasicBlock *BB) const {
+ pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB);
// Are there zero predecessors of this block?
if (PI == PE) {
// has a LARGE number of in-edges. Handle the common case of having only a
// few in-edges with special code.
//
- BasicBlock *FirstPred = *PI;
+ const BasicBlock *FirstPred = *PI;
unsigned Count = getEdgeWeight(FirstPred, BB);
++PI;
if (PI == PE) return Count; // Quick exit for single predecessor blocks
- BasicBlock *SecondPred = *PI;
+ const BasicBlock *SecondPred = *PI;
if (SecondPred != FirstPred) Count += getEdgeWeight(SecondPred, BB);
++PI;
if (PI == PE) return Count; // Quick exit for two predecessor blocks
- BasicBlock *ThirdPred = *PI;
+ const BasicBlock *ThirdPred = *PI;
if (ThirdPred != FirstPred && ThirdPred != SecondPred)
Count += getEdgeWeight(ThirdPred, BB);
++PI;
if (PI == PE) return Count; // Quick exit for three predecessor blocks
- std::set<BasicBlock*> ProcessedPreds;
+ std::set<const BasicBlock*> ProcessedPreds;
ProcessedPreds.insert(FirstPred);
ProcessedPreds.insert(SecondPred);
ProcessedPreds.insert(ThirdPred);
return Count;
}
+unsigned ProfileInfo::getExecutionCount(const Function *F) const {
+ if (F->isDeclaration()) return -1;
+ return getExecutionCount(&F->getEntryBlock());
+}
//===----------------------------------------------------------------------===//