[llvm-commits] CVS: llvm/lib/Analysis/ProfileInfoLoader.cpp

[Chris Lattner]

Changes in directory llvm/lib/Analysis:

ProfileInfoLoader.cpp added (r1.1)

---
Log message:

Factor this code out of llvm-prof


---
Diffs of the changes:  (+180 -0)

Index: llvm/lib/Analysis/ProfileInfoLoader.cpp
diff -c /dev/null llvm/lib/Analysis/ProfileInfoLoader.cpp:1.1
*** /dev/null	Tue Feb 10 23:54:35 2004
--- llvm/lib/Analysis/ProfileInfoLoader.cpp	Tue Feb 10 23:54:25 2004
***************
*** 0 ****
--- 1,180 ----
+ //===- ProfileInfoLoad.cpp - Load profile information from disk -----------===//
+ // 
+ //                      The LLVM Compiler Infrastructure
+ //
+ // This file was developed by the LLVM research group and is distributed under
+ // the University of Illinois Open Source License. See LICENSE.TXT for details.
+ // 
+ //===----------------------------------------------------------------------===//
+ //
+ // The ProfileInfoLoader class is used to load and represent profiling
+ // information read in from the dump file.
+ //
+ //===----------------------------------------------------------------------===//
+ 
+ #include "llvm/Analysis/ProfileInfoLoader.h"
+ #include "llvm/Module.h"
+ #include <cstdio>
+ using namespace llvm;
+ 
+ enum ProfilingType {
+   ArgumentInfo = 1,   // The command line argument block
+   FunctionInfo = 2,   // Function profiling information
+   BlockInfo    = 3,   // Block profiling information
+ };
+ 
+ // ByteSwap - Byteswap 'Var' if 'Really' is true.
+ //
+ static inline unsigned ByteSwap(unsigned Var, bool Really) {
+   if (!Really) return Var;
+   return ((Var & (255<< 0)) << 24) | 
+          ((Var & (255<< 8)) <<  8) | 
+          ((Var & (255<<16)) >>  8) | 
+          ((Var & (255<<24)) >> 24);
+ }
+ 
+ static void ReadProfilingBlock(const char *ToolName, FILE *F,
+                                bool ShouldByteSwap,
+                                std::vector<unsigned> &Data) {
+   // Read the number of entries...
+   unsigned NumEntries;
+   if (fread(&NumEntries, sizeof(unsigned), 1, F) != 1) {
+     std::cerr << ToolName << ": data packet truncated!\n";
+     perror(0);
+     exit(1);
+   }
+   NumEntries = ByteSwap(NumEntries, ShouldByteSwap);
+ 
+   // Read the counts...
+   std::vector<unsigned> TempSpace(NumEntries);
+ 
+   // Read in the block of data...
+   if (fread(&TempSpace[0], sizeof(unsigned)*NumEntries, 1, F) != 1) {
+     std::cerr << ToolName << ": data packet truncated!\n";
+     perror(0);
+     exit(1);
+   }
+ 
+   // Make sure we have enough space...
+   if (Data.size() < NumEntries)
+     Data.resize(NumEntries);
+   
+   // Accumulate the data we just read into the data.
+   if (!ShouldByteSwap) {
+     for (unsigned i = 0; i != NumEntries; ++i)
+       Data[i] += TempSpace[i];
+   } else {
+     for (unsigned i = 0; i != NumEntries; ++i)
+       Data[i] += ByteSwap(TempSpace[i], true);
+   }
+ }
+ 
+ // ProfileInfoLoader ctor - Read the specified profiling data file, exiting the
+ // program if the file is invalid or broken.
+ //
+ ProfileInfoLoader::ProfileInfoLoader(const char *ToolName,
+                                      const std::string &Filename,
+                                      Module &TheModule) : M(TheModule) {
+   FILE *F = fopen(Filename.c_str(), "r");
+   if (F == 0) {
+     std::cerr << ToolName << ": Error opening '" << Filename << ": ";
+     perror(0);
+     exit(1);
+   }
+ 
+   // Keep reading packets until we run out of them.
+   unsigned PacketType;
+   while (fread(&PacketType, sizeof(unsigned), 1, F) == 1) {
+     // If the low eight bits of the packet are zero, we must be dealing with an
+     // endianness mismatch.  Byteswap all words read from the profiling
+     // information.
+     bool ShouldByteSwap = (char)PacketType == 0;
+     PacketType = ByteSwap(PacketType, ShouldByteSwap);
+ 
+     switch (PacketType) {
+     case ArgumentInfo: {
+       unsigned ArgLength;
+       if (fread(&ArgLength, sizeof(unsigned), 1, F) != 1) {
+         std::cerr << ToolName << ": arguments packet truncated!\n";
+         perror(0);
+         exit(1);
+       }
+       ArgLength = ByteSwap(ArgLength, ShouldByteSwap);
+ 
+       // Read in the arguments...
+       std::vector<char> Chars(ArgLength+4);
+ 
+       if (ArgLength)
+         if (fread(&Chars[0], (ArgLength+3) & ~3, 1, F) != 1) {
+           std::cerr << ToolName << ": arguments packet truncated!\n";
+           perror(0);
+           exit(1);
+         }
+       CommandLines.push_back(std::string(&Chars[0], &Chars[ArgLength]));
+       break;
+     }
+       
+     case FunctionInfo:
+       ReadProfilingBlock(ToolName, F, ShouldByteSwap, FunctionCounts);
+       break;
+       
+     case BlockInfo:
+       ReadProfilingBlock(ToolName, F, ShouldByteSwap, BlockCounts);
+       break;
+ 
+     default:
+       std::cerr << ToolName << ": Unknown packet type #" << PacketType << "!\n";
+       exit(1);
+     }
+   }
+   
+   fclose(F);
+ }
+ 
+ 
+ // getFunctionCounts - This method is used by consumers of function counting
+ // information.  If we do not directly have function count information, we
+ // compute it from other, more refined, types of profile information.
+ //
+ void ProfileInfoLoader::getFunctionCounts(std::vector<std::pair<Function*,
+                                                       unsigned> > &Counts) {
+   if (FunctionCounts.empty()) {
+     // Synthesize function frequency information from the number of times their
+     // entry blocks were executed.
+     std::vector<std::pair<BasicBlock*, unsigned> > BlockCounts;
+     getBlockCounts(BlockCounts);
+ 
+     for (unsigned i = 0, e = BlockCounts.size(); i != e; ++i)
+       if (&BlockCounts[i].first->getParent()->front() == BlockCounts[i].first)
+         Counts.push_back(std::make_pair(BlockCounts[i].first->getParent(),
+                                         BlockCounts[i].second));
+     return;
+   }
+   
+   unsigned Counter = 0;
+   for (Module::iterator I = M.begin(), E = M.end();
+        I != E && Counter != FunctionCounts.size(); ++I)
+     if (!I->isExternal())
+       Counts.push_back(std::make_pair(I, FunctionCounts[Counter++]));
+ }
+ 
+ // getBlockCounts - This method is used by consumers of block counting
+ // information.  If we do not directly have block count information, we
+ // compute it from other, more refined, types of profile information.
+ //
+ void ProfileInfoLoader::getBlockCounts(std::vector<std::pair<BasicBlock*,
+                                                          unsigned> > &Counts) {
+   if (BlockCounts.empty()) {
+     std::cerr << "Block counts not available, and no synthesis "
+               << "is implemented yet!\n";
+     return;
+   }
+ 
+   unsigned Counter = 0;
+   for (Module::iterator F = M.begin(), E = M.end(); F != E; ++F)
+     for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
+       Counts.push_back(std::make_pair(BB, BlockCounts[Counter++]));
+       if (Counter == BlockCounts.size())
+         return;
+     }
+ }