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" 20 using namespace llvm; 21 22 //===----------------------------------------------------------------------===// 23 // GCOVFile implementation. 24 25 /// ~GCOVFile - Delete GCOVFile and its content. 26 GCOVFile::~GCOVFile() { 27 DeleteContainerPointers(Functions); 28 } 29 30 /// isGCDAFile - Return true if Format identifies a .gcda file. 31 static 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. 36 static bool isGCNOFile(GCOV::GCOVFormat Format) { 37 return Format == GCOV::GCNO_402 || Format == GCOV::GCNO_404; 38 } 39 40 /// read - Read GCOV buffer. 41 bool 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. 65 void 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. 73 void 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. 84 GCOVFunction::~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. 90 bool 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. 156 void 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. 165 void 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. 175 GCOVBlock::~GCOVBlock() { 176 Edges.clear(); 177 DeleteContainerSeconds(Lines); 178 } 179 180 void 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. 189 void 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. 196 void 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. 221 void 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. 229 void 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. 239 void 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. 257 void 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
