lib/IR/GCOV.cpp

   1 //===- GCOVr.cpp - 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 // GCOV implements the interface to read and write coverage files that use
  11 // 'gcov' format.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Support/Debug.h"
  16 #include "llvm/Support/GCOV.h"
  17 #include "llvm/ADT/OwningPtr.h"
  18 #include "llvm/ADT/STLExtras.h"
  19 #include "llvm/Support/Format.h"
  20 #include "llvm/Support/MemoryObject.h"
  21 #include "llvm/Support/system_error.h"
  22 using namespace llvm;
  23
  24 //===----------------------------------------------------------------------===//
  25 // GCOVFile implementation.
  26
  27 /// ~GCOVFile - Delete GCOVFile and its content.
  28 GCOVFile::~GCOVFile() {
  29   DeleteContainerPointers(Functions);
  30 }
  31
  32 /// readGCNO - Read GCNO buffer.
  33 bool GCOVFile::readGCNO(GCOVBuffer &Buffer) {
  34   if (!Buffer.readGCNOFormat()) return false;
  35   if (!Buffer.readGCOVVersion(Version)) return false;
  36
  37   if (!Buffer.readInt(Checksum)) return false;
  38   while (true) {
  39     if (!Buffer.readFunctionTag()) break;
  40     GCOVFunction *GFun = new GCOVFunction(*this);
  41     if (!GFun->readGCNO(Buffer, Version))
  42       return false;
  43     Functions.push_back(GFun);
  44   }
  45
  46   GCNOInitialized = true;
  47   return true;
  48 }
  49
  50 /// readGCDA - Read GCDA buffer. It is required that readGCDA() can only be
  51 /// called after readGCNO().
  52 bool GCOVFile::readGCDA(GCOVBuffer &Buffer) {
  53   assert(GCNOInitialized && "readGCDA() can only be called after readGCNO()");
  54   if (!Buffer.readGCDAFormat()) return false;
  55   GCOV::GCOVVersion GCDAVersion;
  56   if (!Buffer.readGCOVVersion(GCDAVersion)) return false;
  57   if (Version != GCDAVersion) {
  58     errs() << "GCOV versions do not match.\n";
  59     return false;
  60   }
  61
  62   uint32_t GCDAChecksum;
  63   if (!Buffer.readInt(GCDAChecksum)) return false;
  64   if (Checksum != GCDAChecksum) {
  65     errs() << "File checksums do not match: " << Checksum << " != "
  66            << GCDAChecksum << ".\n";
  67     return false;
  68   }
  69   for (size_t i = 0, e = Functions.size(); i < e; ++i) {
  70     if (!Buffer.readFunctionTag()) {
  71       errs() << "Unexpected number of functions.\n";
  72       return false;
  73     }
  74     if (!Functions[i]->readGCDA(Buffer, Version))
  75       return false;
  76   }
  77   if (Buffer.readObjectTag()) {
  78     uint32_t Length;
  79     uint32_t Dummy;
  80     if (!Buffer.readInt(Length)) return false;
  81     if (!Buffer.readInt(Dummy)) return false; // checksum
  82     if (!Buffer.readInt(Dummy)) return false; // num
  83     if (!Buffer.readInt(RunCount)) return false;;
  84     Buffer.advanceCursor(Length-3);
  85   }
  86   while (Buffer.readProgramTag()) {
  87     uint32_t Length;
  88     if (!Buffer.readInt(Length)) return false;
  89     Buffer.advanceCursor(Length);
  90     ++ProgramCount;
  91   }
  92
  93   return true;
  94 }
  95
  96 /// dump - Dump GCOVFile content to dbgs() for debugging purposes.
  97 void GCOVFile::dump() const {
  98   for (SmallVectorImpl<GCOVFunction *>::const_iterator I = Functions.begin(),
  99          E = Functions.end(); I != E; ++I)
 100     (*I)->dump();
 101 }
 102
 103 /// collectLineCounts - Collect line counts. This must be used after
 104 /// reading .gcno and .gcda files.
 105 void GCOVFile::collectLineCounts(FileInfo &FI) {
 106   for (SmallVectorImpl<GCOVFunction *>::iterator I = Functions.begin(),
 107          E = Functions.end(); I != E; ++I)
 108     (*I)->collectLineCounts(FI);
 109   FI.setRunCount(RunCount);
 110   FI.setProgramCount(ProgramCount);
 111 }
 112
 113 //===----------------------------------------------------------------------===//
 114 // GCOVFunction implementation.
 115
 116 /// ~GCOVFunction - Delete GCOVFunction and its content.
 117 GCOVFunction::~GCOVFunction() {
 118   DeleteContainerPointers(Blocks);
 119   DeleteContainerPointers(Edges);
 120 }
 121
 122 /// readGCNO - Read a function from the GCNO buffer. Return false if an error
 123 /// occurs.
 124 bool GCOVFunction::readGCNO(GCOVBuffer &Buff, GCOV::GCOVVersion Version) {
 125   uint32_t Dummy;
 126   if (!Buff.readInt(Dummy)) return false; // Function header length
 127   if (!Buff.readInt(Ident)) return false;
 128   if (!Buff.readInt(Dummy)) return false; // Checksum #1
 129   if (Version != GCOV::V402) {
 130     uint32_t CfgChecksum;
 131     if (!Buff.readInt(CfgChecksum)) return false;
 132     if (Parent.getChecksum() != CfgChecksum) {
 133       errs() << "File checksums do not match: " << Parent.getChecksum()
 134              << " != " << CfgChecksum << " in (" << Name << ").\n";
 135       return false;
 136     }
 137   }
 138   if (!Buff.readString(Name)) return false;
 139   if (!Buff.readString(Filename)) return false;
 140   if (!Buff.readInt(LineNumber)) return false;
 141
 142   // read blocks.
 143   if (!Buff.readBlockTag()) {
 144     errs() << "Block tag not found.\n";
 145     return false;
 146   }
 147   uint32_t BlockCount;
 148   if (!Buff.readInt(BlockCount)) return false;
 149   for (uint32_t i = 0, e = BlockCount; i != e; ++i) {
 150     if (!Buff.readInt(Dummy)) return false; // Block flags;
 151     Blocks.push_back(new GCOVBlock(*this, i));
 152   }
 153
 154   // read edges.
 155   while (Buff.readEdgeTag()) {
 156     uint32_t EdgeCount;
 157     if (!Buff.readInt(EdgeCount)) return false;
 158     EdgeCount = (EdgeCount - 1) / 2;
 159     uint32_t BlockNo;
 160     if (!Buff.readInt(BlockNo)) return false;
 161     if (BlockNo >= BlockCount) {
 162       errs() << "Unexpected block number (in " << Name << ").\n";
 163       return false;
 164     }
 165     for (uint32_t i = 0, e = EdgeCount; i != e; ++i) {
 166       uint32_t Dst;
 167       if (!Buff.readInt(Dst)) return false;
 168       GCOVEdge *Edge = new GCOVEdge(Blocks[BlockNo], Blocks[Dst]);
 169       Edges.push_back(Edge);
 170       Blocks[BlockNo]->addDstEdge(Edge);
 171       Blocks[Dst]->addSrcEdge(Edge);
 172       if (!Buff.readInt(Dummy)) return false; // Edge flag
 173     }
 174   }
 175
 176   // read line table.
 177   while (Buff.readLineTag()) {
 178     uint32_t LineTableLength;
 179     if (!Buff.readInt(LineTableLength)) return false;
 180     uint32_t EndPos = Buff.getCursor() + LineTableLength*4;
 181     uint32_t BlockNo;
 182     if (!Buff.readInt(BlockNo)) return false;
 183     if (BlockNo >= BlockCount) {
 184       errs() << "Unexpected block number (in " << Name << ").\n";
 185       return false;
 186     }
 187     GCOVBlock *Block = Blocks[BlockNo];
 188     if (!Buff.readInt(Dummy)) return false; // flag
 189     while (Buff.getCursor() != (EndPos - 4)) {
 190       StringRef F;
 191       if (!Buff.readString(F)) return false;
 192       if (F != Filename) {
 193         errs() << "Multiple sources for a single basic block (in "
 194                << Name << ").\n";
 195         return false;
 196       }
 197       if (Buff.getCursor() == (EndPos - 4)) break;
 198       while (true) {
 199         uint32_t Line;
 200         if (!Buff.readInt(Line)) return false;
 201         if (!Line) break;
 202         Block->addLine(Line);
 203       }
 204     }
 205     if (!Buff.readInt(Dummy)) return false; // flag
 206   }
 207   return true;
 208 }
 209
 210 /// readGCDA - Read a function from the GCDA buffer. Return false if an error
 211 /// occurs.
 212 bool GCOVFunction::readGCDA(GCOVBuffer &Buff, GCOV::GCOVVersion Version) {
 213   uint32_t Dummy;
 214   if (!Buff.readInt(Dummy)) return false; // Function header length
 215   uint32_t GCDAIdent;
 216   if (!Buff.readInt(GCDAIdent)) return false;
 217   if (Ident != GCDAIdent) {
 218     errs() << "Function identifiers do not match: " << Ident << " != "
 219            << GCDAIdent << " (in " << Name << ").\n";
 220     return false;
 221   }
 222
 223   if (!Buff.readInt(Dummy)) return false; // Checksum #1
 224
 225
 226   uint32_t CfgChecksum;
 227   if (Version != GCOV::V402) {
 228     if (!Buff.readInt(CfgChecksum)) return false;
 229     if (Parent.getChecksum() != CfgChecksum) {
 230       errs() << "File checksums do not match: " << Parent.getChecksum()
 231              << " != " << CfgChecksum << " (in " << Name << ").\n";
 232       return false;
 233     }
 234   }
 235
 236   StringRef GCDAName;
 237   if (!Buff.readString(GCDAName)) return false;
 238   if (Name != GCDAName) {
 239     errs() << "Function names do not match: " << Name << " != " << GCDAName
 240            << ".\n";
 241     return false;
 242   }
 243
 244   if (!Buff.readArcTag()) {
 245     errs() << "Arc tag not found (in " << Name << ").\n";
 246     return false;
 247   }
 248
 249   uint32_t Count;
 250   if (!Buff.readInt(Count)) return false;
 251   Count /= 2;
 252
 253   // This for loop adds the counts for each block. A second nested loop is
 254   // required to combine the edge counts that are contained in the GCDA file.
 255   for (uint32_t BlockNo = 0; Count > 0; ++BlockNo) {
 256     // The last block is always reserved for exit block
 257     if (BlockNo >= Blocks.size()-1) {
 258       errs() << "Unexpected number of edges (in " << Name << ").\n";
 259       return false;
 260     }
 261     GCOVBlock &Block = *Blocks[BlockNo];
 262     for (size_t EdgeNo = 0, End = Block.getNumDstEdges(); EdgeNo < End;
 263            ++EdgeNo) {
 264       if (Count == 0) {
 265         errs() << "Unexpected number of edges (in " << Name << ").\n";
 266         return false;
 267       }
 268       uint64_t ArcCount;
 269       if (!Buff.readInt64(ArcCount)) return false;
 270       Block.addCount(EdgeNo, ArcCount);
 271       --Count;
 272     }
 273   }
 274   return true;
 275 }
 276
 277 /// dump - Dump GCOVFunction content to dbgs() for debugging purposes.
 278 void GCOVFunction::dump() const {
 279   dbgs() <<  "===== " << Name << " @ " << Filename << ":" << LineNumber << "\n";
 280   for (SmallVectorImpl<GCOVBlock *>::const_iterator I = Blocks.begin(),
 281          E = Blocks.end(); I != E; ++I)
 282     (*I)->dump();
 283 }
 284
 285 /// collectLineCounts - Collect line counts. This must be used after
 286 /// reading .gcno and .gcda files.
 287 void GCOVFunction::collectLineCounts(FileInfo &FI) {
 288   for (SmallVectorImpl<GCOVBlock *>::iterator I = Blocks.begin(),
 289          E = Blocks.end(); I != E; ++I)
 290     (*I)->collectLineCounts(FI);
 291 }
 292
 293 //===----------------------------------------------------------------------===//
 294 // GCOVBlock implementation.
 295
 296 /// ~GCOVBlock - Delete GCOVBlock and its content.
 297 GCOVBlock::~GCOVBlock() {
 298   SrcEdges.clear();
 299   DstEdges.clear();
 300   Lines.clear();
 301 }
 302
 303 /// addCount - Add to block counter while storing the edge count. If the
 304 /// destination has no outgoing edges, also update that block's count too.
 305 void GCOVBlock::addCount(size_t DstEdgeNo, uint64_t N) {
 306   assert(DstEdgeNo < DstEdges.size()); // up to caller to ensure EdgeNo is valid
 307   DstEdges[DstEdgeNo]->Count = N;
 308   Counter += N;
 309   if (!DstEdges[DstEdgeNo]->Dst->getNumDstEdges())
 310     DstEdges[DstEdgeNo]->Dst->Counter += N;
 311 }
 312
 313 /// collectLineCounts - Collect line counts. This must be used after
 314 /// reading .gcno and .gcda files.
 315 void GCOVBlock::collectLineCounts(FileInfo &FI) {
 316   for (SmallVectorImpl<uint32_t>::iterator I = Lines.begin(),
 317          E = Lines.end(); I != E; ++I)
 318     FI.addBlockLine(Parent.getFilename(), *I, this);
 319 }
 320
 321 /// dump - Dump GCOVBlock content to dbgs() for debugging purposes.
 322 void GCOVBlock::dump() const {
 323   dbgs() << "Block : " << Number << " Counter : " << Counter << "\n";
 324   if (!SrcEdges.empty()) {
 325     dbgs() << "\tSource Edges : ";
 326     for (EdgeIterator I = SrcEdges.begin(), E = SrcEdges.end(); I != E; ++I) {
 327       const GCOVEdge *Edge = *I;
 328       dbgs() << Edge->Src->Number << " (" << Edge->Count << "), ";
 329     }
 330     dbgs() << "\n";
 331   }
 332   if (!DstEdges.empty()) {
 333     dbgs() << "\tDestination Edges : ";
 334     for (EdgeIterator I = DstEdges.begin(), E = DstEdges.end(); I != E; ++I) {
 335       const GCOVEdge *Edge = *I;
 336       dbgs() << Edge->Dst->Number << " (" << Edge->Count << "), ";
 337     }
 338     dbgs() << "\n";
 339   }
 340   if (!Lines.empty()) {
 341     dbgs() << "\tLines : ";
 342     for (SmallVectorImpl<uint32_t>::const_iterator I = Lines.begin(),
 343            E = Lines.end(); I != E; ++I)
 344       dbgs() << (*I) << ",";
 345     dbgs() << "\n";
 346   }
 347 }
 348
 349 //===----------------------------------------------------------------------===//
 350 // FileInfo implementation.
 351
 352 /// print -  Print source files with collected line count information.
 353 void FileInfo::print(StringRef GCNOFile, StringRef GCDAFile) const {
 354   for (StringMap<LineData>::const_iterator I = LineInfo.begin(),
 355          E = LineInfo.end(); I != E; ++I) {
 356     StringRef Filename = I->first();
 357     OwningPtr<MemoryBuffer> Buff;
 358     if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename, Buff)) {
 359       errs() << Filename << ": " << ec.message() << "\n";
 360       return;
 361     }
 362     StringRef AllLines = Buff->getBuffer();
 363
 364     std::string CovFilename = Filename.str() + ".llcov";
 365     std::string ErrorInfo;
 366     raw_fd_ostream OS(CovFilename.c_str(), ErrorInfo);
 367     if (!ErrorInfo.empty())
 368       errs() << ErrorInfo << "\n";
 369
 370     OS << "        -:    0:Source:" << Filename << "\n";
 371     OS << "        -:    0:Graph:" << GCNOFile << "\n";
 372     OS << "        -:    0:Data:" << GCDAFile << "\n";
 373     OS << "        -:    0:Runs:" << RunCount << "\n";
 374     OS << "        -:    0:Programs:" << ProgramCount << "\n";
 375
 376     const LineData &Line = I->second;
 377     for (uint32_t i = 0; !AllLines.empty(); ++i) {
 378       LineData::const_iterator BlocksIt = Line.find(i);
 379
 380       // Add up the block counts to form line counts.
 381       if (BlocksIt != Line.end()) {
 382         const BlockVector &Blocks = BlocksIt->second;
 383         uint64_t LineCount = 0;
 384         for (BlockVector::const_iterator I = Blocks.begin(), E = Blocks.end();
 385                I != E; ++I) {
 386           LineCount += (*I)->getCount();
 387         }
 388         if (LineCount == 0)
 389           OS << "    #####:";
 390         else
 391           OS << format("%9" PRIu64 ":", LineCount);
 392       } else {
 393         OS << "        -:";
 394       }
 395       std::pair<StringRef, StringRef> P = AllLines.split('\n');
 396       OS << format("%5u:", i+1) << P.first << "\n";
 397       AllLines = P.second;
 398     }
 399   }
 400 }