1 //===- ProfileInfoLoaderPass.cpp - LLVM Pass to load profile info ---------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements a concrete implementation of profiling information that
11 // loads the information from a profile dump file.
13 //===----------------------------------------------------------------------===//
14 #define DEBUG_TYPE "profile-loader"
15 #include "llvm/Analysis/Passes.h"
16 #include "llvm/ADT/SmallSet.h"
17 #include "llvm/ADT/Statistic.h"
18 #include "llvm/Analysis/ProfileInfo.h"
19 #include "llvm/Analysis/ProfileInfoLoader.h"
20 #include "llvm/IR/BasicBlock.h"
21 #include "llvm/IR/InstrTypes.h"
22 #include "llvm/IR/LLVMContext.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/Pass.h"
25 #include "llvm/Support/CFG.h"
26 #include "llvm/Support/CommandLine.h"
27 #include "llvm/Support/Debug.h"
28 #include "llvm/Support/Format.h"
29 #include "llvm/Support/raw_ostream.h"
33 STATISTIC(NumEdgesRead, "The # of edges read.");
35 static cl::opt<std::string>
36 ProfileInfoFilename("profile-info-file", cl::init("llvmprof.out"),
37 cl::value_desc("filename"),
38 cl::desc("Profile file loaded by -profile-loader"));
41 class LoaderPass : public ModulePass, public ProfileInfo {
43 std::set<Edge> SpanningTree;
44 std::set<const BasicBlock*> BBisUnvisited;
47 static char ID; // Class identification, replacement for typeinfo
48 explicit LoaderPass(const std::string &filename = "")
49 : ModulePass(ID), Filename(filename) {
50 initializeLoaderPassPass(*PassRegistry::getPassRegistry());
51 if (filename.empty()) Filename = ProfileInfoFilename;
54 virtual void getAnalysisUsage(AnalysisUsage &AU) const {
58 virtual const char *getPassName() const {
59 return "Profiling information loader";
62 // recurseBasicBlock() - Calculates the edge weights for as much basic
63 // blocks as possbile.
64 virtual void recurseBasicBlock(const BasicBlock *BB);
65 virtual void readEdgeOrRemember(Edge, Edge&, unsigned &, double &);
66 virtual void readEdge(ProfileInfo::Edge, std::vector<unsigned>&);
68 /// getAdjustedAnalysisPointer - This method is used when a pass implements
69 /// an analysis interface through multiple inheritance. If needed, it
70 /// should override this to adjust the this pointer as needed for the
71 /// specified pass info.
72 virtual void *getAdjustedAnalysisPointer(AnalysisID PI) {
73 if (PI == &ProfileInfo::ID)
74 return (ProfileInfo*)this;
78 /// run - Load the profile information from the specified file.
79 virtual bool runOnModule(Module &M);
81 } // End of anonymous namespace
83 char LoaderPass::ID = 0;
84 INITIALIZE_AG_PASS(LoaderPass, ProfileInfo, "profile-loader",
85 "Load profile information from llvmprof.out", false, true, false)
87 char &llvm::ProfileLoaderPassID = LoaderPass::ID;
89 ModulePass *llvm::createProfileLoaderPass() { return new LoaderPass(); }
91 /// createProfileLoaderPass - This function returns a Pass that loads the
92 /// profiling information for the module from the specified filename, making it
93 /// available to the optimizers.
94 Pass *llvm::createProfileLoaderPass(const std::string &Filename) {
95 return new LoaderPass(Filename);
98 void LoaderPass::readEdgeOrRemember(Edge edge, Edge &tocalc,
99 unsigned &uncalc, double &count) {
101 if ((w = getEdgeWeight(edge)) == MissingValue) {
109 // recurseBasicBlock - Visits all neighbours of a block and then tries to
110 // calculate the missing edge values.
111 void LoaderPass::recurseBasicBlock(const BasicBlock *BB) {
113 // break recursion if already visited
114 if (BBisUnvisited.find(BB) == BBisUnvisited.end()) return;
115 BBisUnvisited.erase(BB);
118 for (succ_const_iterator bbi = succ_begin(BB), bbe = succ_end(BB);
120 recurseBasicBlock(*bbi);
122 for (const_pred_iterator bbi = pred_begin(BB), bbe = pred_end(BB);
124 recurseBasicBlock(*bbi);
128 if (CalculateMissingEdge(BB, tocalc)) {
129 SpanningTree.erase(tocalc);
133 void LoaderPass::readEdge(ProfileInfo::Edge e,
134 std::vector<unsigned> &ECs) {
135 if (ReadCount < ECs.size()) {
136 double weight = ECs[ReadCount++];
137 if (weight != ProfileInfoLoader::Uncounted) {
138 // Here the data realm changes from the unsigned of the file to the
139 // double of the ProfileInfo. This conversion is save because we know
140 // that everything thats representable in unsinged is also representable
142 EdgeInformation[getFunction(e)][e] += (double)weight;
144 DEBUG(dbgs() << "--Read Edge Counter for " << e
145 << " (# "<< (ReadCount-1) << "): "
146 << (unsigned)getEdgeWeight(e) << "\n");
148 // This happens only if reading optimal profiling information, not when
149 // reading regular profiling information.
150 SpanningTree.insert(e);
155 bool LoaderPass::runOnModule(Module &M) {
156 ProfileInfoLoader PIL("profile-loader", Filename);
158 EdgeInformation.clear();
159 std::vector<unsigned> Counters = PIL.getRawEdgeCounts();
160 if (Counters.size() > 0) {
162 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
163 if (F->isDeclaration()) continue;
164 DEBUG(dbgs() << "Working on " << F->getName() << "\n");
165 readEdge(getEdge(0,&F->getEntryBlock()), Counters);
166 for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
167 TerminatorInst *TI = BB->getTerminator();
168 for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
169 readEdge(getEdge(BB,TI->getSuccessor(s)), Counters);
173 if (ReadCount != Counters.size()) {
174 M.getContext().emitWarning("profile information is inconsistent "
175 "with the current program");
177 NumEdgesRead = ReadCount;
180 Counters = PIL.getRawOptimalEdgeCounts();
181 if (Counters.size() > 0) {
183 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
184 if (F->isDeclaration()) continue;
185 DEBUG(dbgs() << "Working on " << F->getName() << "\n");
186 readEdge(getEdge(0,&F->getEntryBlock()), Counters);
187 for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
188 TerminatorInst *TI = BB->getTerminator();
189 if (TI->getNumSuccessors() == 0) {
190 readEdge(getEdge(BB,0), Counters);
192 for (unsigned s = 0, e = TI->getNumSuccessors(); s != e; ++s) {
193 readEdge(getEdge(BB,TI->getSuccessor(s)), Counters);
196 while (SpanningTree.size() > 0) {
198 unsigned size = SpanningTree.size();
200 BBisUnvisited.clear();
201 for (std::set<Edge>::iterator ei = SpanningTree.begin(),
202 ee = SpanningTree.end(); ei != ee; ++ei) {
203 BBisUnvisited.insert(ei->first);
204 BBisUnvisited.insert(ei->second);
206 while (BBisUnvisited.size() > 0) {
207 recurseBasicBlock(*BBisUnvisited.begin());
210 if (SpanningTree.size() == size) {
212 for (std::set<Edge>::iterator ei = SpanningTree.begin(),
213 ee = SpanningTree.end(); ei != ee; ++ei) {
214 DEBUG(dbgs()<< *ei <<",");
216 assert(0 && "No edge calculated!");
221 if (ReadCount != Counters.size()) {
222 M.getContext().emitWarning("profile information is inconsistent "
223 "with the current program");
225 NumEdgesRead = ReadCount;
228 BlockInformation.clear();
229 Counters = PIL.getRawBlockCounts();
230 if (Counters.size() > 0) {
232 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
233 if (F->isDeclaration()) continue;
234 for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB)
235 if (ReadCount < Counters.size())
236 // Here the data realm changes from the unsigned of the file to the
237 // double of the ProfileInfo. This conversion is save because we know
238 // that everything thats representable in unsinged is also
239 // representable in double.
240 BlockInformation[F][BB] = (double)Counters[ReadCount++];
242 if (ReadCount != Counters.size()) {
243 M.getContext().emitWarning("profile information is inconsistent "
244 "with the current program");
248 FunctionInformation.clear();
249 Counters = PIL.getRawFunctionCounts();
250 if (Counters.size() > 0) {
252 for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F) {
253 if (F->isDeclaration()) continue;
254 if (ReadCount < Counters.size())
255 // Here the data realm changes from the unsigned of the file to the
256 // double of the ProfileInfo. This conversion is save because we know
257 // that everything thats representable in unsinged is also
258 // representable in double.
259 FunctionInformation[F] = (double)Counters[ReadCount++];
261 if (ReadCount != Counters.size()) {
262 M.getContext().emitWarning("profile information is inconsistent "
263 "with the current program");