class Reassociate : public FunctionPass {
std::map<BasicBlock*, unsigned> RankMap;
- std::map<Instruction*, unsigned> InstRankMap;
+ std::map<Value*, unsigned> ValueRankMap;
public:
bool runOnFunction(Function &F);
void Reassociate::BuildRankMap(Function &F) {
unsigned i = 2;
+
+ // Assign distinct ranks to function arguments
+ for (Function::aiterator I = F.abegin(), E = F.aend(); I != E; ++I)
+ ValueRankMap[I] = ++i;
+
ReversePostOrderTraversal<Function*> RPOT(&F);
for (ReversePostOrderTraversal<Function*>::rpo_iterator I = RPOT.begin(),
E = RPOT.end(); I != E; ++I)
}
unsigned Reassociate::getRank(Value *V) {
- if (isa<Argument>(V)) return 1; // Function argument...
+ if (isa<Argument>(V)) return ValueRankMap[V]; // Function argument...
+
if (Instruction *I = dyn_cast<Instruction>(V)) {
// If this is an expression, return the 1+MAX(rank(LHS), rank(RHS)) so that
// we can reassociate expressions for code motion! Since we do not recurse
I->mayWriteToMemory()) // Cannot move inst if it writes to memory!
return RankMap[I->getParent()];
- unsigned &CachedRank = InstRankMap[I];
+ unsigned &CachedRank = ValueRankMap[I];
if (CachedRank) return CachedRank; // Rank already known?
// If not, compute it!
// We are done with the rank map...
RankMap.clear();
- InstRankMap.clear();
+ ValueRankMap.clear();
return Changed;
}