include/llvm/Support/GCOV.h

   1 //===- GCOV.h - LLVM coverage tool ----------------------------------------===//
   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 // This header provides the interface to read and write coverage files that
  11 // use 'gcov' format.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_SUPPORT_GCOV_H
  16 #define LLVM_SUPPORT_GCOV_H
  17
  18 #include "llvm/ADT/DenseMap.h"
  19 #include "llvm/ADT/MapVector.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 #include "llvm/ADT/StringMap.h"
  22 #include "llvm/Support/MemoryBuffer.h"
  23 #include "llvm/Support/raw_ostream.h"
  24
  25 namespace llvm {
  26
  27 class GCOVFunction;
  28 class GCOVBlock;
  29 class FileInfo;
  30
  31 namespace GCOV {
  32   enum GCOVVersion {
  33     V402,
  34     V404
  35   };
  36 } // end GCOV namespace
  37
  38 /// GCOVOptions - A struct for passing gcov options between functions.
  39 struct GCOVOptions {
  40   GCOVOptions(bool A, bool B, bool C, bool F, bool P, bool U, bool L, bool N)
  41       : AllBlocks(A), BranchInfo(B), BranchCount(C), FuncCoverage(F),
  42         PreservePaths(P), UncondBranch(U), LongFileNames(L), NoOutput(N) {}
  43
  44   bool AllBlocks;
  45   bool BranchInfo;
  46   bool BranchCount;
  47   bool FuncCoverage;
  48   bool PreservePaths;
  49   bool UncondBranch;
  50   bool LongFileNames;
  51   bool NoOutput;
  52 };
  53
  54 /// GCOVBuffer - A wrapper around MemoryBuffer to provide GCOV specific
  55 /// read operations.
  56 class GCOVBuffer {
  57 public:
  58   GCOVBuffer(MemoryBuffer *B) : Buffer(B), Cursor(0) {}
  59
  60   /// readGCNOFormat - Check GCNO signature is valid at the beginning of buffer.
  61   bool readGCNOFormat() {
  62     StringRef File = Buffer->getBuffer().slice(0, 4);
  63     if (File != "oncg") {
  64       errs() << "Unexpected file type: " << File << ".\n";
  65       return false;
  66     }
  67     Cursor = 4;
  68     return true;
  69   }
  70
  71   /// readGCDAFormat - Check GCDA signature is valid at the beginning of buffer.
  72   bool readGCDAFormat() {
  73     StringRef File = Buffer->getBuffer().slice(0, 4);
  74     if (File != "adcg") {
  75       errs() << "Unexpected file type: " << File << ".\n";
  76       return false;
  77     }
  78     Cursor = 4;
  79     return true;
  80   }
  81
  82   /// readGCOVVersion - Read GCOV version.
  83   bool readGCOVVersion(GCOV::GCOVVersion &Version) {
  84     StringRef VersionStr = Buffer->getBuffer().slice(Cursor, Cursor+4);
  85     if (VersionStr == "*204") {
  86       Cursor += 4;
  87       Version = GCOV::V402;
  88       return true;
  89     }
  90     if (VersionStr == "*404") {
  91       Cursor += 4;
  92       Version = GCOV::V404;
  93       return true;
  94     }
  95     errs() << "Unexpected version: " << VersionStr << ".\n";
  96     return false;
  97   }
  98
  99   /// readFunctionTag - If cursor points to a function tag then increment the
 100   /// cursor and return true otherwise return false.
 101   bool readFunctionTag() {
 102     StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor+4);
 103     if (Tag.empty() ||
 104         Tag[0] != '\0' || Tag[1] != '\0' ||
 105         Tag[2] != '\0' || Tag[3] != '\1') {
 106       return false;
 107     }
 108     Cursor += 4;
 109     return true;
 110   }
 111
 112   /// readBlockTag - If cursor points to a block tag then increment the
 113   /// cursor and return true otherwise return false.
 114   bool readBlockTag() {
 115     StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor+4);
 116     if (Tag.empty() ||
 117         Tag[0] != '\0' || Tag[1] != '\0' ||
 118         Tag[2] != '\x41' || Tag[3] != '\x01') {
 119       return false;
 120     }
 121     Cursor += 4;
 122     return true;
 123   }
 124
 125   /// readEdgeTag - If cursor points to an edge tag then increment the
 126   /// cursor and return true otherwise return false.
 127   bool readEdgeTag() {
 128     StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor+4);
 129     if (Tag.empty() ||
 130         Tag[0] != '\0' || Tag[1] != '\0' ||
 131         Tag[2] != '\x43' || Tag[3] != '\x01') {
 132       return false;
 133     }
 134     Cursor += 4;
 135     return true;
 136   }
 137
 138   /// readLineTag - If cursor points to a line tag then increment the
 139   /// cursor and return true otherwise return false.
 140   bool readLineTag() {
 141     StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor+4);
 142     if (Tag.empty() ||
 143         Tag[0] != '\0' || Tag[1] != '\0' ||
 144         Tag[2] != '\x45' || Tag[3] != '\x01') {
 145       return false;
 146     }
 147     Cursor += 4;
 148     return true;
 149   }
 150
 151   /// readArcTag - If cursor points to an gcda arc tag then increment the
 152   /// cursor and return true otherwise return false.
 153   bool readArcTag() {
 154     StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor+4);
 155     if (Tag.empty() ||
 156         Tag[0] != '\0' || Tag[1] != '\0' ||
 157         Tag[2] != '\xa1' || Tag[3] != '\1') {
 158       return false;
 159     }
 160     Cursor += 4;
 161     return true;
 162   }
 163
 164   /// readObjectTag - If cursor points to an object summary tag then increment
 165   /// the cursor and return true otherwise return false.
 166   bool readObjectTag() {
 167     StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor+4);
 168     if (Tag.empty() ||
 169         Tag[0] != '\0' || Tag[1] != '\0' ||
 170         Tag[2] != '\0' || Tag[3] != '\xa1') {
 171       return false;
 172     }
 173     Cursor += 4;
 174     return true;
 175   }
 176
 177   /// readProgramTag - If cursor points to a program summary tag then increment
 178   /// the cursor and return true otherwise return false.
 179   bool readProgramTag() {
 180     StringRef Tag = Buffer->getBuffer().slice(Cursor, Cursor+4);
 181     if (Tag.empty() ||
 182         Tag[0] != '\0' || Tag[1] != '\0' ||
 183         Tag[2] != '\0' || Tag[3] != '\xa3') {
 184       return false;
 185     }
 186     Cursor += 4;
 187     return true;
 188   }
 189
 190   bool readInt(uint32_t &Val) {
 191     if (Buffer->getBuffer().size() < Cursor+4) {
 192       errs() << "Unexpected end of memory buffer: " << Cursor+4 << ".\n";
 193       return false;
 194     }
 195     StringRef Str = Buffer->getBuffer().slice(Cursor, Cursor+4);
 196     Cursor += 4;
 197     Val = *(const uint32_t *)(Str.data());
 198     return true;
 199   }
 200
 201   bool readInt64(uint64_t &Val) {
 202     uint32_t Lo, Hi;
 203     if (!readInt(Lo) || !readInt(Hi)) return false;
 204     Val = ((uint64_t)Hi << 32) | Lo;
 205     return true;
 206   }
 207
 208   bool readString(StringRef &Str) {
 209     uint32_t Len = 0;
 210     // Keep reading until we find a non-zero length. This emulates gcov's
 211     // behaviour, which appears to do the same.
 212     while (Len == 0)
 213       if (!readInt(Len)) return false;
 214     Len *= 4;
 215     if (Buffer->getBuffer().size() < Cursor+Len) {
 216       errs() << "Unexpected end of memory buffer: " << Cursor+Len << ".\n";
 217       return false;
 218     }
 219     Str = Buffer->getBuffer().slice(Cursor, Cursor+Len).split('\0').first;
 220     Cursor += Len;
 221     return true;
 222   }
 223
 224   uint64_t getCursor() const { return Cursor; }
 225   void advanceCursor(uint32_t n) { Cursor += n*4; }
 226 private:
 227   MemoryBuffer *Buffer;
 228   uint64_t Cursor;
 229 };
 230
 231 /// GCOVFile - Collects coverage information for one pair of coverage file
 232 /// (.gcno and .gcda).
 233 class GCOVFile {
 234 public:
 235   GCOVFile() : GCNOInitialized(false), Checksum(0), Functions(), RunCount(0),
 236                ProgramCount(0) {}
 237   bool readGCNO(GCOVBuffer &Buffer);
 238   bool readGCDA(GCOVBuffer &Buffer);
 239   uint32_t getChecksum() const { return Checksum; }
 240   void dump() const;
 241   void collectLineCounts(FileInfo &FI);
 242 private:
 243   bool GCNOInitialized;
 244   GCOV::GCOVVersion Version;
 245   uint32_t Checksum;
 246   SmallVector<std::unique_ptr<GCOVFunction>, 16> Functions;
 247   uint32_t RunCount;
 248   uint32_t ProgramCount;
 249 };
 250
 251 /// GCOVEdge - Collects edge information.
 252 struct GCOVEdge {
 253   GCOVEdge(GCOVBlock &S, GCOVBlock &D) : Src(S), Dst(D), Count(0) {}
 254
 255   GCOVBlock &Src;
 256   GCOVBlock &Dst;
 257   uint64_t Count;
 258 };
 259
 260 /// GCOVFunction - Collects function information.
 261 class GCOVFunction {
 262 public:
 263   typedef SmallVectorImpl<std::unique_ptr<GCOVBlock>>::const_iterator
 264   BlockIterator;
 265
 266   GCOVFunction(GCOVFile &P) : Parent(P), Ident(0), LineNumber(0) {}
 267   bool readGCNO(GCOVBuffer &Buffer, GCOV::GCOVVersion Version);
 268   bool readGCDA(GCOVBuffer &Buffer, GCOV::GCOVVersion Version);
 269   StringRef getName() const { return Name; }
 270   StringRef getFilename() const { return Filename; }
 271   size_t getNumBlocks() const { return Blocks.size(); }
 272   uint64_t getEntryCount() const;
 273   uint64_t getExitCount() const;
 274
 275   BlockIterator block_begin() const { return Blocks.begin(); }
 276   BlockIterator block_end() const { return Blocks.end(); }
 277
 278   void dump() const;
 279   void collectLineCounts(FileInfo &FI);
 280 private:
 281   GCOVFile &Parent;
 282   uint32_t Ident;
 283   uint32_t Checksum;
 284   uint32_t LineNumber;
 285   StringRef Name;
 286   StringRef Filename;
 287   SmallVector<std::unique_ptr<GCOVBlock>, 16> Blocks;
 288   SmallVector<std::unique_ptr<GCOVEdge>, 16> Edges;
 289 };
 290
 291 /// GCOVBlock - Collects block information.
 292 class GCOVBlock {
 293   struct EdgeWeight {
 294     EdgeWeight(GCOVBlock *D): Dst(D), Count(0) {}
 295
 296     GCOVBlock *Dst;
 297     uint64_t Count;
 298   };
 299
 300   struct SortDstEdgesFunctor {
 301     bool operator()(const GCOVEdge *E1, const GCOVEdge *E2) {
 302       return E1->Dst.Number < E2->Dst.Number;
 303     }
 304   };
 305 public:
 306   typedef SmallVectorImpl<GCOVEdge *>::const_iterator EdgeIterator;
 307
 308   GCOVBlock(GCOVFunction &P, uint32_t N) : Parent(P), Number(N), Counter(0),
 309     DstEdgesAreSorted(true), SrcEdges(), DstEdges(), Lines() {}
 310   ~GCOVBlock();
 311   const GCOVFunction &getParent() const { return Parent; }
 312   void addLine(uint32_t N) { Lines.push_back(N); }
 313   uint32_t getLastLine() const { return Lines.back(); }
 314   void addCount(size_t DstEdgeNo, uint64_t N);
 315   uint64_t getCount() const { return Counter; }
 316
 317   void addSrcEdge(GCOVEdge *Edge) {
 318     assert(&Edge->Dst == this); // up to caller to ensure edge is valid
 319     SrcEdges.push_back(Edge);
 320   }
 321   void addDstEdge(GCOVEdge *Edge) {
 322     assert(&Edge->Src == this); // up to caller to ensure edge is valid
 323     // Check if adding this edge causes list to become unsorted.
 324     if (DstEdges.size() && DstEdges.back()->Dst.Number > Edge->Dst.Number)
 325       DstEdgesAreSorted = false;
 326     DstEdges.push_back(Edge);
 327   }
 328   size_t getNumSrcEdges() const { return SrcEdges.size(); }
 329   size_t getNumDstEdges() const { return DstEdges.size(); }
 330   void sortDstEdges();
 331
 332   EdgeIterator src_begin() const { return SrcEdges.begin(); }
 333   EdgeIterator src_end() const { return SrcEdges.end(); }
 334   EdgeIterator dst_begin() const { return DstEdges.begin(); }
 335   EdgeIterator dst_end() const { return DstEdges.end(); }
 336
 337   void dump() const;
 338   void collectLineCounts(FileInfo &FI);
 339 private:
 340   GCOVFunction &Parent;
 341   uint32_t Number;
 342   uint64_t Counter;
 343   bool DstEdgesAreSorted;
 344   SmallVector<GCOVEdge *, 16> SrcEdges;
 345   SmallVector<GCOVEdge *, 16> DstEdges;
 346   SmallVector<uint32_t, 16> Lines;
 347 };
 348
 349 class FileInfo {
 350   // It is unlikely--but possible--for multiple functions to be on the same line.
 351   // Therefore this typedef allows LineData.Functions to store multiple functions
 352   // per instance. This is rare, however, so optimize for the common case.
 353   typedef SmallVector<const GCOVFunction *, 1> FunctionVector;
 354   typedef DenseMap<uint32_t, FunctionVector> FunctionLines;
 355   typedef SmallVector<const GCOVBlock *, 4> BlockVector;
 356   typedef DenseMap<uint32_t, BlockVector> BlockLines;
 357
 358   struct LineData {
 359     LineData() : LastLine(0) {}
 360     BlockLines Blocks;
 361     FunctionLines Functions;
 362     uint32_t LastLine;
 363   };
 364
 365   struct GCOVCoverage {
 366     GCOVCoverage(StringRef Name) :
 367       Name(Name), LogicalLines(0), LinesExec(0), Branches(0), BranchesExec(0),
 368       BranchesTaken(0) {}
 369
 370     StringRef Name;
 371
 372     uint32_t LogicalLines;
 373     uint32_t LinesExec;
 374
 375     uint32_t Branches;
 376     uint32_t BranchesExec;
 377     uint32_t BranchesTaken;
 378   };
 379 public:
 380   FileInfo(const GCOVOptions &Options) :
 381     Options(Options), LineInfo(), RunCount(0), ProgramCount(0) {}
 382
 383   void addBlockLine(StringRef Filename, uint32_t Line, const GCOVBlock *Block) {
 384     if (Line > LineInfo[Filename].LastLine)
 385       LineInfo[Filename].LastLine = Line;
 386     LineInfo[Filename].Blocks[Line-1].push_back(Block);
 387   }
 388   void addFunctionLine(StringRef Filename, uint32_t Line,
 389                        const GCOVFunction *Function) {
 390     if (Line > LineInfo[Filename].LastLine)
 391       LineInfo[Filename].LastLine = Line;
 392     LineInfo[Filename].Functions[Line-1].push_back(Function);
 393   }
 394   void setRunCount(uint32_t Runs) { RunCount = Runs; }
 395   void setProgramCount(uint32_t Programs) { ProgramCount = Programs; }
 396   void print(StringRef MainFilename, StringRef GCNOFile, StringRef GCDAFile);
 397
 398 private:
 399   std::string getCoveragePath(StringRef Filename, StringRef MainFilename);
 400   std::unique_ptr<raw_ostream> openCoveragePath(StringRef CoveragePath);
 401   void printFunctionSummary(raw_ostream &OS,
 402                             const FunctionVector &Funcs) const;
 403   void printBlockInfo(raw_ostream &OS, const GCOVBlock &Block,
 404                       uint32_t LineIndex, uint32_t &BlockNo) const;
 405   void printBranchInfo(raw_ostream &OS, const GCOVBlock &Block,
 406                        GCOVCoverage &Coverage, uint32_t &EdgeNo);
 407   void printUncondBranchInfo(raw_ostream &OS, uint32_t &EdgeNo,
 408                              uint64_t Count) const;
 409
 410   void printCoverage(const GCOVCoverage &Coverage) const;
 411   void printFuncCoverage() const;
 412   void printFileCoverage() const;
 413
 414   const GCOVOptions &Options;
 415   StringMap<LineData> LineInfo;
 416   uint32_t RunCount;
 417   uint32_t ProgramCount;
 418
 419   typedef SmallVector<std::pair<std::string, GCOVCoverage>, 4>
 420       FileCoverageList;
 421   typedef MapVector<const GCOVFunction *, GCOVCoverage> FuncCoverageMap;
 422
 423   FileCoverageList FileCoverages;
 424   FuncCoverageMap FuncCoverages;
 425 };
 426
 427 }
 428
 429 #endif