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 (BlockFreqs.empty()) return;
  68       if (unsigned Count = BlockFreqs[BB])
  69         OS << ";;; Executed " << Count << " times.\n";
  70       else
  71         OS << ";;; Never executed!\n";
  72     }
  73   };
  74 }
  75
  76
  77 int main(int argc, char **argv) {
  78   cl::ParseCommandLineOptions(argc, argv, " llvm profile dump decoder\n");
  79
  80   // Read in the bytecode file...
  81   std::string ErrorMessage;
  82   Module *M = ParseBytecodeFile(BytecodeFile, &ErrorMessage);
  83   if (M == 0) {
  84     std::cerr << argv[0] << ": " << BytecodeFile << ": " << ErrorMessage
  85               << "\n";
  86     return 1;
  87   }
  88
  89   // Read the profiling information
  90   ProfileInfo PI(argv[0], ProfileDataFile, *M);
  91
  92   std::map<const Function  *, unsigned> FuncFreqs;
  93   std::map<const BasicBlock*, unsigned> BlockFreqs;
  94
  95   // Output a report.  Eventually, there will be multiple reports selectable on
  96   // the command line, for now, just keep things simple.
  97
  98   // Emit the most frequent function table...
  99   std::vector<std::pair<Function*, unsigned> > FunctionCounts;
 100   PI.getFunctionCounts(FunctionCounts);
 101   FuncFreqs.insert(FunctionCounts.begin(), FunctionCounts.end());
 102
 103   // Sort by the frequency, backwards.
 104   std::sort(FunctionCounts.begin(), FunctionCounts.end(),
 105             PairSecondSortReverse<Function*>());
 106
 107   unsigned long long TotalExecutions = 0;
 108   for (unsigned i = 0, e = FunctionCounts.size(); i != e; ++i)
 109     TotalExecutions += FunctionCounts[i].second;
 110
 111   std::cout << "===" << std::string(73, '-') << "===\n"
 112             << "LLVM profiling output for execution";
 113   if (PI.getNumExecutions() != 1) std::cout << "s";
 114   std::cout << ":\n";
 115
 116   for (unsigned i = 0, e = PI.getNumExecutions(); i != e; ++i) {
 117     std::cout << "  ";
 118     if (e != 1) std::cout << i+1 << ". ";
 119     std::cout << PI.getExecution(i) << "\n";
 120   }
 121
 122   std::cout << "\n===" << std::string(73, '-') << "===\n";
 123   std::cout << "Function execution frequencies:\n\n";
 124
 125   // Print out the function frequencies...
 126   printf(" ##   Frequency\n");
 127   for (unsigned i = 0, e = FunctionCounts.size(); i != e; ++i) {
 128     if (FunctionCounts[i].second == 0) {
 129       printf("\n  NOTE: %d function%s never executed!\n",
 130              e-i, e-i-1 ? "s were" : " was");
 131       break;
 132     }
 133
 134     printf("%3d. %5u/%llu %s\n", i+1, FunctionCounts[i].second, TotalExecutions,
 135            FunctionCounts[i].first->getName().c_str());
 136   }
 137
 138   std::set<Function*> FunctionsToPrint;
 139
 140   // If we have block count information, print out the LLVM module with
 141   // frequency annotations.
 142   if (PI.hasAccurateBlockCounts()) {
 143     std::vector<std::pair<BasicBlock*, unsigned> > Counts;
 144     PI.getBlockCounts(Counts);
 145
 146     TotalExecutions = 0;
 147     for (unsigned i = 0, e = Counts.size(); i != e; ++i)
 148       TotalExecutions += Counts[i].second;
 149
 150     // Sort by the frequency, backwards.
 151     std::sort(Counts.begin(), Counts.end(),
 152               PairSecondSortReverse<BasicBlock*>());
 153
 154     std::cout << "\n===" << std::string(73, '-') << "===\n";
 155     std::cout << "Top 20 most frequently executed basic blocks:\n\n";
 156
 157     // Print out the function frequencies...
 158     printf(" ##  \tFrequency\n");
 159     unsigned BlocksToPrint = Counts.size();
 160     if (BlocksToPrint > 20) BlocksToPrint = 20;
 161     for (unsigned i = 0; i != BlocksToPrint; ++i) {
 162       Function *F = Counts[i].first->getParent();
 163       printf("%3d. %5u/%llu\t%s() - %s\n", i+1,
 164              Counts[i].second, TotalExecutions,
 165              F->getName().c_str(), Counts[i].first->getName().c_str());
 166       FunctionsToPrint.insert(F);
 167     }
 168
 169     BlockFreqs.insert(Counts.begin(), Counts.end());
 170   }
 171
 172   if (PrintAnnotatedLLVM) {
 173     std::cout << "\n===" << std::string(73, '-') << "===\n";
 174     std::cout << "Annotated LLVM code for the module:\n\n";
 175
 176     if (FunctionsToPrint.empty())
 177       for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
 178         FunctionsToPrint.insert(I);
 179
 180     ProfileAnnotator PA(FuncFreqs, BlockFreqs);
 181
 182     for (std::set<Function*>::iterator I = FunctionsToPrint.begin(),
 183            E = FunctionsToPrint.end(); I != E; ++I)
 184       (*I)->print(std::cout, &PA);
 185   }
 186
 187   return 0;
 188 }