lib/Analysis/ProfileDataLoader.cpp

   1 //===- ProfileDataLoader.cpp - Load profile information from disk ---------===//
   2 //
   3 //                      The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // The ProfileDataLoader class is used to load raw profiling data from the dump
  11 // file.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/ADT/ArrayRef.h"
  16 #include "llvm/ADT/OwningPtr.h"
  17 #include "llvm/Module.h"
  18 #include "llvm/InstrTypes.h"
  19 #include "llvm/Analysis/ProfileDataLoader.h"
  20 #include "llvm/Analysis/ProfileDataTypes.h"
  21 #include "llvm/Support/raw_ostream.h"
  22 #include "llvm/Support/system_error.h"
  23 #include <cstdio>
  24 #include <cstdlib>
  25 using namespace llvm;
  26
  27 raw_ostream &llvm::operator<<(raw_ostream &O, std::pair<const BasicBlock *,
  28                                                         const BasicBlock *> E) {
  29   O << "(";
  30
  31   if (E.first)
  32     O << E.first->getName();
  33   else
  34     O << "0";
  35
  36   O << ",";
  37
  38   if (E.second)
  39     O << E.second->getName();
  40   else
  41     O << "0";
  42
  43   return O << ")";
  44 }
  45
  46 /// AddCounts - Add 'A' and 'B', accounting for the fact that the value of one
  47 /// (or both) may not be defined.
  48 static unsigned AddCounts(unsigned A, unsigned B) {
  49   // If either value is undefined, use the other.
  50   // Undefined + undefined = undefined.
  51   if (A == ProfileDataLoader::Uncounted) return B;
  52   if (B == ProfileDataLoader::Uncounted) return A;
  53
  54   // Saturate to the maximum storable value.  This could change taken/nottaken
  55   // ratios, but is presumably better than wrapping and thus potentially
  56   // inverting ratios.
  57   uint64_t tmp = (uint64_t)A + (uint64_t)B;
  58   if (tmp > (uint64_t)ProfileDataLoader::MaxCount)
  59     tmp = ProfileDataLoader::MaxCount;
  60   return (unsigned)tmp;
  61 }
  62
  63 /// ReadProfilingData - Load 'NumEntries' items of type 'T' from file 'F'
  64 template <typename T>
  65 static void ReadProfilingData(const char *ToolName, FILE *F,
  66                               T *Data, size_t NumEntries) {
  67   // Read in the block of data...
  68   if (fread(Data, sizeof(T), NumEntries, F) != NumEntries)
  69     report_fatal_error(Twine(ToolName) + ": Profiling data truncated");
  70 }
  71
  72 /// ReadProfilingNumEntries - Read how many entries are in this profiling data
  73 /// packet.
  74 static unsigned ReadProfilingNumEntries(const char *ToolName, FILE *F,
  75                                         bool ShouldByteSwap) {
  76   unsigned Entry;
  77   ReadProfilingData<unsigned>(ToolName, F, &Entry, 1);
  78   return ShouldByteSwap ? ByteSwap_32(Entry) : Entry;
  79 }
  80
  81 /// ReadProfilingBlock - Read the number of entries in the next profiling data
  82 /// packet and then accumulate the entries into 'Data'.
  83 static void ReadProfilingBlock(const char *ToolName, FILE *F,
  84                                bool ShouldByteSwap,
  85                                SmallVector<unsigned, 32> &Data) {
  86   // Read the number of entries...
  87   unsigned NumEntries = ReadProfilingNumEntries(ToolName, F, ShouldByteSwap);
  88
  89   // Read in the data.
  90   SmallVector<unsigned, 8> TempSpace(NumEntries);
  91   ReadProfilingData<unsigned>(ToolName, F, TempSpace.data(), NumEntries);
  92
  93   // Make sure we have enough space ...
  94   if (Data.size() < NumEntries)
  95     Data.resize(NumEntries, ProfileDataLoader::Uncounted);
  96
  97   // Accumulate the data we just read into the existing data.
  98   for (unsigned i = 0; i < NumEntries; ++i) {
  99     unsigned Entry = ShouldByteSwap ? ByteSwap_32(TempSpace[i]) : TempSpace[i];
 100     Data[i] = AddCounts(Entry, Data[i]);
 101   }
 102 }
 103
 104 /// ReadProfilingArgBlock - Read the command line arguments that the progam was
 105 /// run with when the current profiling data packet(s) were generated.
 106 static void ReadProfilingArgBlock(const char *ToolName, FILE *F,
 107                                   bool ShouldByteSwap,
 108                                   SmallVector<std::string, 1> &CommandLines) {
 109   // Read the number of bytes ...
 110   unsigned ArgLength = ReadProfilingNumEntries(ToolName, F, ShouldByteSwap);
 111
 112   // Read in the arguments (if there are any to read).  Round up the length to
 113   // the nearest 4-byte multiple.
 114   SmallVector<char, 8> Args(ArgLength+4);
 115   if (ArgLength)
 116     ReadProfilingData<char>(ToolName, F, Args.data(), (ArgLength+3) & ~3);
 117
 118   // Store the arguments.
 119   CommandLines.push_back(std::string(&Args[0], &Args[ArgLength]));
 120 }
 121
 122 const unsigned ProfileDataLoader::Uncounted = ~0U;
 123 const unsigned ProfileDataLoader::MaxCount = ~0U - 1U;
 124
 125 /// ProfileDataLoader ctor - Read the specified profiling data file, reporting
 126 /// a fatal error if the file is invalid or broken.
 127 ProfileDataLoader::ProfileDataLoader(const char *ToolName,
 128                                      const std::string &Filename)
 129   : Filename(Filename) {
 130   FILE *F = fopen(Filename.c_str(), "rb");
 131   if (F == 0)
 132     report_fatal_error(Twine(ToolName) + ": Error opening '" +
 133                        Filename + "': ");
 134
 135   // Keep reading packets until we run out of them.
 136   unsigned PacketType;
 137   while (fread(&PacketType, sizeof(unsigned), 1, F) == 1) {
 138     // If the low eight bits of the packet are zero, we must be dealing with an
 139     // endianness mismatch.  Byteswap all words read from the profiling
 140     // information.  This can happen when the compiler host and target have
 141     // different endianness.
 142     bool ShouldByteSwap = (char)PacketType == 0;
 143     PacketType = ShouldByteSwap ? ByteSwap_32(PacketType) : PacketType;
 144
 145     switch (PacketType) {
 146       case ArgumentInfo:
 147         ReadProfilingArgBlock(ToolName, F, ShouldByteSwap, CommandLines);
 148         break;
 149
 150       case EdgeInfo:
 151         ReadProfilingBlock(ToolName, F, ShouldByteSwap, EdgeCounts);
 152         break;
 153
 154       default:
 155         report_fatal_error(std::string(ToolName)
 156                            + ": Unknown profiling packet type");
 157         break;
 158     }
 159   }
 160
 161   fclose(F);
 162 }