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/GCOV.h" 16#include "llvm/ADT/OwningPtr.h" 17#include "llvm/ADT/STLExtras.h" 18#include "llvm/Support/MemoryObject.h" 19#include "llvm/Support/system_error.h" 20using namespace llvm; 21 22//===----------------------------------------------------------------------===// 23// GCOVFile implementation. 24 25/// ~GCOVFile - Delete GCOVFile and its content. 26GCOVFile::~GCOVFile() { 27 DeleteContainerPointers(Functions); 28} 29 30/// isGCDAFile - Return true if Format identifies a .gcda file. 31static bool isGCDAFile(GCOV::GCOVFormat Format) { 32 return Format == GCOV::GCDA_402 || Format == GCOV::GCDA_404; 33} 34 35/// isGCNOFile - Return true if Format identifies a .gcno file. 36static bool isGCNOFile(GCOV::GCOVFormat Format) { 37 return Format == GCOV::GCNO_402 || Format == GCOV::GCNO_404; 38} 39 40/// read - Read GCOV buffer. 41bool GCOVFile::read(GCOVBuffer &Buffer) { 42 GCOV::GCOVFormat Format = Buffer.readGCOVFormat(); 43 if (Format == GCOV::InvalidGCOV) 44 return false; 45 46 unsigned i = 0; 47 while (1) { 48 GCOVFunction *GFun = NULL; 49 if (isGCDAFile(Format)) { 50 // Use existing function while reading .gcda file. 51 assert(i < Functions.size() && ".gcda data does not match .gcno data"); 52 GFun = Functions[i]; 53 } else if (isGCNOFile(Format)){ 54 GFun = new GCOVFunction(); 55 Functions.push_back(GFun); 56 } 57 if (!GFun || !GFun->read(Buffer, Format)) 58 break; 59 ++i; 60 } 61 return true; 62} 63 64/// dump - Dump GCOVFile content on standard out for debugging purposes. 65void GCOVFile::dump() { 66 for (SmallVectorImpl<GCOVFunction *>::iterator I = Functions.begin(), 67 E = Functions.end(); I != E; ++I) 68 (*I)->dump(); 69} 70 71/// collectLineCounts - Collect line counts. This must be used after 72/// reading .gcno and .gcda files. 73void GCOVFile::collectLineCounts(FileInfo &FI) { 74 for (SmallVectorImpl<GCOVFunction *>::iterator I = Functions.begin(), 75 E = Functions.end(); I != E; ++I) 76 (*I)->collectLineCounts(FI); 77 FI.print(); 78} 79 80//===----------------------------------------------------------------------===// 81// GCOVFunction implementation. 82 83/// ~GCOVFunction - Delete GCOVFunction and its content. 84GCOVFunction::~GCOVFunction() { 85 DeleteContainerPointers(Blocks); 86} 87 88/// read - Read a aunction from the buffer. Return false if buffer cursor 89/// does not point to a function tag. 90bool GCOVFunction::read(GCOVBuffer &Buff, GCOV::GCOVFormat Format) { 91 if (!Buff.readFunctionTag()) 92 return false; 93 94 Buff.readInt(); // Function header length 95 Ident = Buff.readInt(); 96 Buff.readInt(); // Checksum #1 97 if (Format != GCOV::GCNO_402 && Format != GCOV::GCDA_402) 98 Buff.readInt(); // Checksum #2 99 100 Name = Buff.readString(); 101 if (Format == GCOV::GCNO_402 || Format == GCOV::GCNO_404) 102 Filename = Buff.readString(); 103 104 if (Format == GCOV::GCDA_402 || Format == GCOV::GCDA_404) { 105 Buff.readArcTag(); 106 uint32_t Count = Buff.readInt() / 2; 107 for (unsigned i = 0, e = Count; i != e; ++i) { 108 Blocks[i]->addCount(Buff.readInt64()); 109 } 110 return true; 111 } 112 113 LineNumber = Buff.readInt(); 114 115 // read blocks. 116 bool BlockTagFound = Buff.readBlockTag(); 117 (void)BlockTagFound; 118 assert(BlockTagFound && "Block Tag not found!"); 119 uint32_t BlockCount = Buff.readInt(); 120 for (int i = 0, e = BlockCount; i != e; ++i) { 121 Buff.readInt(); // Block flags; 122 Blocks.push_back(new GCOVBlock(i)); 123 } 124 125 // read edges. 126 while (Buff.readEdgeTag()) { 127 uint32_t EdgeCount = (Buff.readInt() - 1) / 2; 128 uint32_t BlockNo = Buff.readInt(); 129 assert(BlockNo < BlockCount && "Unexpected Block number!"); 130 for (int i = 0, e = EdgeCount; i != e; ++i) { 131 Blocks[BlockNo]->addEdge(Buff.readInt()); 132 Buff.readInt(); // Edge flag 133 } 134 } 135 136 // read line table. 137 while (Buff.readLineTag()) { 138 uint32_t LineTableLength = Buff.readInt(); 139 uint32_t Size = Buff.getCursor() + LineTableLength*4; 140 uint32_t BlockNo = Buff.readInt(); 141 assert(BlockNo < BlockCount && "Unexpected Block number!"); 142 GCOVBlock *Block = Blocks[BlockNo]; 143 Buff.readInt(); // flag 144 while (Buff.getCursor() != (Size - 4)) { 145 StringRef Filename = Buff.readString(); 146 if (Buff.getCursor() == (Size - 4)) break; 147 while (uint32_t L = Buff.readInt()) 148 Block->addLine(Filename, L); 149 } 150 Buff.readInt(); // flag 151 } 152 return true; 153} 154 155/// dump - Dump GCOVFunction content on standard out for debugging purposes. 156void GCOVFunction::dump() { 157 outs() << "===== " << Name << " @ " << Filename << ":" << LineNumber << "\n"; 158 for (SmallVectorImpl<GCOVBlock *>::iterator I = Blocks.begin(), 159 E = Blocks.end(); I != E; ++I) 160 (*I)->dump(); 161} 162 163/// collectLineCounts - Collect line counts. This must be used after 164/// reading .gcno and .gcda files. 165void GCOVFunction::collectLineCounts(FileInfo &FI) { 166 for (SmallVectorImpl<GCOVBlock *>::iterator I = Blocks.begin(), 167 E = Blocks.end(); I != E; ++I) 168 (*I)->collectLineCounts(FI); 169} 170 171//===----------------------------------------------------------------------===// 172// GCOVBlock implementation. 173 174/// ~GCOVBlock - Delete GCOVBlock and its content. 175GCOVBlock::~GCOVBlock() { 176 Edges.clear(); 177 DeleteContainerSeconds(Lines); 178} 179 180void GCOVBlock::addLine(StringRef Filename, uint32_t LineNo) { 181 GCOVLines *&LinesForFile = Lines[Filename]; 182 if (!LinesForFile) 183 LinesForFile = new GCOVLines(); 184 LinesForFile->add(LineNo); 185} 186 187/// collectLineCounts - Collect line counts. This must be used after 188/// reading .gcno and .gcda files. 189void GCOVBlock::collectLineCounts(FileInfo &FI) { 190 for (StringMap<GCOVLines *>::iterator I = Lines.begin(), 191 E = Lines.end(); I != E; ++I) 192 I->second->collectLineCounts(FI, I->first(), Counter); 193} 194 195/// dump - Dump GCOVBlock content on standard out for debugging purposes. 196void GCOVBlock::dump() { 197 outs() << "Block : " << Number << " Counter : " << Counter << "\n"; 198 if (!Edges.empty()) { 199 outs() << "\tEdges : "; 200 for (SmallVectorImpl<uint32_t>::iterator I = Edges.begin(), E = Edges.end(); 201 I != E; ++I) 202 outs() << (*I) << ","; 203 outs() << "\n"; 204 } 205 if (!Lines.empty()) { 206 outs() << "\tLines : "; 207 for (StringMap<GCOVLines *>::iterator LI = Lines.begin(), 208 LE = Lines.end(); LI != LE; ++LI) { 209 outs() << LI->first() << " -> "; 210 LI->second->dump(); 211 outs() << "\n"; 212 } 213 } 214} 215 216//===----------------------------------------------------------------------===// 217// GCOVLines implementation. 218 219/// collectLineCounts - Collect line counts. This must be used after 220/// reading .gcno and .gcda files. 221void GCOVLines::collectLineCounts(FileInfo &FI, StringRef Filename, 222 uint32_t Count) { 223 for (SmallVectorImpl<uint32_t>::iterator I = Lines.begin(), 224 E = Lines.end(); I != E; ++I) 225 FI.addLineCount(Filename, *I, Count); 226} 227 228/// dump - Dump GCOVLines content on standard out for debugging purposes. 229void GCOVLines::dump() { 230 for (SmallVectorImpl<uint32_t>::iterator I = Lines.begin(), 231 E = Lines.end(); I != E; ++I) 232 outs() << (*I) << ","; 233} 234 235//===----------------------------------------------------------------------===// 236// FileInfo implementation. 237 238/// addLineCount - Add line count for the given line number in a file. 239void FileInfo::addLineCount(StringRef Filename, uint32_t Line, uint32_t Count) { 240 if (LineInfo.find(Filename) == LineInfo.end()) { 241 OwningPtr<MemoryBuffer> Buff; 242 if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename, Buff)) { 243 errs() << Filename << ": " << ec.message() << "\n"; 244 return; 245 } 246 StringRef AllLines = Buff.take()->getBuffer(); 247 LineCounts L(AllLines.count('\n')+2); 248 L[Line-1] = Count; 249 LineInfo[Filename] = L; 250 return; 251 } 252 LineCounts &L = LineInfo[Filename]; 253 L[Line-1] = Count; 254} 255 256/// print - Print source files with collected line count information. 257void FileInfo::print() { 258 for (StringMap<LineCounts>::iterator I = LineInfo.begin(), E = LineInfo.end(); 259 I != E; ++I) { 260 StringRef Filename = I->first(); 261 outs() << Filename << "\n"; 262 LineCounts &L = LineInfo[Filename]; 263 OwningPtr<MemoryBuffer> Buff; 264 if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename, Buff)) { 265 errs() << Filename << ": " << ec.message() << "\n"; 266 return; 267 } 268 StringRef AllLines = Buff.take()->getBuffer(); 269 for (unsigned i = 0, e = L.size(); i != e; ++i) { 270 if (L[i]) 271 outs() << L[i] << ":\t"; 272 else 273 outs() << " :\t"; 274 std::pair<StringRef, StringRef> P = AllLines.split('\n'); 275 if (AllLines != P.first) 276 outs() << P.first; 277 outs() << "\n"; 278 AllLines = P.second; 279 } 280 } 281} 282 283 284