Read in the bytecode and profile information, but don't do anything with

it yet.

llvm-svn: 9556

tools/llvm-prof/ProfileInfo.cpp

@@ -0,0 +1,132 @@
+//===- ProfileInfo.cpp - Represents profile information -------------------===//
+// 
+//                      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 ProfileInfo class is used to represent profiling information read in from
+// the dump file.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ProfileInfo.h"
+#include <iostream>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+
+enum ProfilingType {
+  Arguments = 1,   // The command line argument block
+  Function  = 2,   // Function profiling information
+  Block     = 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);
+  }
+}
+
+// ProfileInfo ctor - Read the specified profiling data file, exiting the
+// program if the file is invalid or broken.
+//
+ProfileInfo::ProfileInfo(const char *ToolName, const std::string &Filename) {
+  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 Arguments: {
+      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 Function:
+      ReadProfilingBlock(ToolName, F, ShouldByteSwap, FunctionCounts);
+      break;
+      
+    case Block:
+      ReadProfilingBlock(ToolName, F, ShouldByteSwap, BlockCounts);
+      break;
+
+    default:
+      std::cerr << ToolName << ": Unknown packet type #" << PacketType << "!\n";
+      exit(1);
+    }
+  }
+  
+  fclose(F);
+}

tools/llvm-prof/ProfileInfo.h

@@ -0,0 +1,31 @@
+//===- ProfileInfo.h - Represents profile information -----------*- C++ -*-===//
+// 
+//                      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 ProfileInfo class is used to represent profiling information read in from
+// the dump file.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef PROFILEINFO_H
+#define PROFILEINFO_H
+
+#include <vector>
+#include <string>
+
+class ProfileInfo {
+  std::vector<std::string> CommandLines;
+  std::vector<unsigned>    FunctionCounts;
+  std::vector<unsigned>    BlockCounts;
+public:
+  // ProfileInfo ctor - Read the specified profiling data file, exiting the
+  // program if the file is invalid or broken.
+  ProfileInfo(const char *ToolName, const std::string &Filename);
+};
+
+#endif

tools/llvm-prof/llvm-prof.cpp

@@ -13,8 +13,10 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "ProfileInfo.h"
 #include "llvm/Bytecode/Reader.h"
 #include "Support/CommandLine.h"
+#include <iostream>
 
 namespace {
   cl::opt<std::string> 
@@ -28,9 +30,18 @@ namespace {
 
 int main(int argc, char **argv) {
   cl::ParseCommandLineOptions(argc, argv, " llvm profile dump decoder\n");
- 
 
+  // Read in the bytecode file...
+  std::string ErrorMessage;
+  Module *Result = ParseBytecodeFile(BytecodeFile, &ErrorMessage);
+  if (Result == 0) {
+    std::cerr << argv[0] << ": " << BytecodeFile << ": " << ErrorMessage
+              << "\n";
+    return 1;
+  }
 
+  // Read the profiling information
+  ProfileInfo PI(argv[0], ProfileDataFile);
 
   return 0;
 }