tools/llvm-prof/llvm-prof.cpp

   1 //===- llvm-prof.cpp - Read in and process llvmprof.out data files --------===//
   2 //
   3 //                      The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This tools is meant for use with the various LLVM profiling instrumentation
  11 // passes.  It reads in the data file produced by executing an instrumented
  12 // program, and outputs a nice report.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "ProfileInfo.h"
  17 #include "llvm/Module.h"
  18 #include "llvm/Assembly/AsmAnnotationWriter.h"
  19 #include "llvm/Bytecode/Reader.h"
  20 #include "Support/CommandLine.h"
  21 #include <iostream>
  22 #include <cstdio>
  23 #include <map>
  24 #include <set>
  25
  26 namespace {
  27   cl::opt<std::string>
  28   BytecodeFile(cl::Positional, cl::desc("<program bytecode file>"),
  29                cl::Required);
  30
  31   cl::opt<std::string>
  32   ProfileDataFile(cl::Positional, cl::desc("<llvmprof.out file>"),
  33                   cl::Optional, cl::init("llvmprof.out"));
  34
  35   cl::opt<bool>
  36   PrintAnnotatedLLVM("annotated-llvm",
  37                      cl::desc("Print LLVM code with frequency annotations"));
  38   cl::alias PrintAnnotated2("A", cl::desc("Alias for --annotated-llvm"),
  39                             cl::aliasopt(PrintAnnotatedLLVM));
  40 }
  41
  42 // PairSecondSort - A sorting predicate to sort by the second element of a pair.
  43 template<class T>
  44 struct PairSecondSortReverse
  45   : public std::binary_function<std::pair<T, unsigned>,
  46                                 std::pair<T, unsigned>, bool> {
  47   bool operator()(const std::pair<T, unsigned> &LHS,
  48                   const std::pair<T, unsigned> &RHS) const {
  49     return LHS.second > RHS.second;
  50   }
  51 };
  52
  53 namespace {
  54   class ProfileAnnotator : public AssemblyAnnotationWriter {
  55     std::map<const Function  *, unsigned> &FuncFreqs;
  56     std::map<const BasicBlock*, unsigned> &BlockFreqs;
  57   public:
  58     ProfileAnnotator(std::map<const Function  *, unsigned> &FF,
  59                      std::map<const BasicBlock*, unsigned> &BF)
  60       : FuncFreqs(FF), BlockFreqs(BF) {}
  61
  62     virtual void emitFunctionAnnot(const Function *F, std::ostream &OS) {
  63       OS << ";;; %" << F->getName() << " called " << FuncFreqs[F]
  64          << " times.\n;;;\n";
  65     }
  66     virtual void emitBasicBlockAnnot(const BasicBlock *BB, std::ostream &OS) {
  67       if (unsigned Count = BlockFreqs[BB])
  68         OS << ";;; Executed " << Count << " times.\n";
  69       else
  70         OS << ";;; Never executed!\n";
  71     }
  72   };
  73 }
  74
  75
  76 int main(int argc, char **argv) {
  77   cl::ParseCommandLineOptions(argc, argv, " llvm profile dump decoder\n");
  78
  79   // Read in the bytecode file...
  80   std::string ErrorMessage;
  81   Module *M = ParseBytecodeFile(BytecodeFile, &ErrorMessage);
  82   if (M == 0) {
  83     std::cerr << argv[0] << ": " << BytecodeFile << ": " << ErrorMessage
  84               << "\n";
  85     return 1;
  86   }
  87
  88   // Read the profiling information
  89   ProfileInfo PI(argv[0], ProfileDataFile, *M);
  90
  91   std::map<const Function  *, unsigned> FuncFreqs;
  92   std::map<const BasicBlock*, unsigned> BlockFreqs;
  93
  94   // Output a report.  Eventually, there will be multiple reports selectable on
  95   // the command line, for now, just keep things simple.
  96
  97   // Emit the most frequent function table...
  98   std::vector<std::pair<Function*, unsigned> > FunctionCounts;
  99   PI.getFunctionCounts(FunctionCounts);
 100   FuncFreqs.insert(FunctionCounts.begin(), FunctionCounts.end());
 101
 102   // Sort by the frequency, backwards.
 103   std::sort(FunctionCounts.begin(), FunctionCounts.end(),
 104             PairSecondSortReverse<Function*>());
 105
 106   unsigned TotalExecutions = 0;
 107   for (unsigned i = 0, e = FunctionCounts.size(); i != e; ++i)
 108     TotalExecutions += FunctionCounts[i].second;
 109
 110   std::cout << "===" << std::string(73, '-') << "===\n"
 111             << "LLVM profiling output for execution";
 112   if (PI.getNumExecutions() != 1) std::cout << "s";
 113   std::cout << ":\n";
 114
 115   for (unsigned i = 0, e = PI.getNumExecutions(); i != e; ++i) {
 116     std::cout << "  ";
 117     if (e != 1) std::cout << i+1 << ". ";
 118     std::cout << PI.getExecution(i) << "\n";
 119   }
 120
 121   std::cout << "\n===" << std::string(73, '-') << "===\n";
 122   std::cout << "Function execution frequencies:\n\n";
 123
 124   // Print out the function frequencies...
 125   printf(" ##   Frequency\n");
 126   for (unsigned i = 0, e = FunctionCounts.size(); i != e; ++i) {
 127     if (FunctionCounts[i].second == 0) {
 128       printf("\n  NOTE: %d function%s never executed!\n",
 129              e-i, e-i-1 ? "s were" : " was");
 130       break;
 131     }
 132
 133     printf("%3d. %5d/%d %s\n", i+1, FunctionCounts[i].second, TotalExecutions,
 134            FunctionCounts[i].first->getName().c_str());
 135   }
 136
 137   std::set<Function*> FunctionsToPrint;
 138
 139   // If we have block count information, print out the LLVM module with
 140   // frequency annotations.
 141   if (PI.hasAccurateBlockCounts()) {
 142     std::vector<std::pair<BasicBlock*, unsigned> > Counts;
 143     PI.getBlockCounts(Counts);
 144
 145     TotalExecutions = 0;
 146     for (unsigned i = 0, e = Counts.size(); i != e; ++i)
 147       TotalExecutions += Counts[i].second;
 148
 149     // Sort by the frequency, backwards.
 150     std::sort(Counts.begin(), Counts.end(),
 151               PairSecondSortReverse<BasicBlock*>());
 152
 153     std::cout << "\n===" << std::string(73, '-') << "===\n";
 154     std::cout << "Top 20 most frequently executed basic blocks:\n\n";
 155
 156     // Print out the function frequencies...
 157     printf(" ##   Frequency\n");
 158     unsigned BlocksToPrint = Counts.size();
 159     if (BlocksToPrint > 20) BlocksToPrint = 20;
 160     for (unsigned i = 0; i != BlocksToPrint; ++i) {
 161       Function *F = Counts[i].first->getParent();
 162       printf("%3d. %5d/%d %s() - %s\n", i+1, Counts[i].second, TotalExecutions,
 163              F->getName().c_str(), Counts[i].first->getName().c_str());
 164       FunctionsToPrint.insert(F);
 165     }
 166
 167     BlockFreqs.insert(Counts.begin(), Counts.end());
 168   }
 169
 170   if (PrintAnnotatedLLVM) {
 171     std::cout << "\n===" << std::string(73, '-') << "===\n";
 172     std::cout << "Annotated LLVM code for the module:\n\n";
 173
 174     if (FunctionsToPrint.empty())
 175       for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
 176         FunctionsToPrint.insert(I);
 177
 178     ProfileAnnotator PA(FuncFreqs, BlockFreqs);
 179
 180     for (std::set<Function*>::iterator I = FunctionsToPrint.begin(),
 181            E = FunctionsToPrint.end(); I != E; ++I)
 182       (*I)->print(std::cout, &PA);
 183   }
 184
 185   return 0;
 186 }