| //===- GCOV.cpp - LLVM coverage tool --------------------------------------===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // GCOV implements the interface to read and write coverage files that use |
| // 'gcov' format. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "llvm/ProfileData/GCOV.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/Config/llvm-config.h" |
| #include "llvm/Support/Debug.h" |
| #include "llvm/Support/FileSystem.h" |
| #include "llvm/Support/Format.h" |
| #include "llvm/Support/Path.h" |
| #include "llvm/Support/MD5.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include <algorithm> |
| #include <system_error> |
| |
| using namespace llvm; |
| |
| //===----------------------------------------------------------------------===// |
| // GCOVFile implementation. |
| |
| /// readGCNO - Read GCNO buffer. |
| bool GCOVFile::readGCNO(GCOVBuffer &Buffer) { |
| if (!Buffer.readGCNOFormat()) |
| return false; |
| if (!Buffer.readGCOVVersion(Version)) |
| return false; |
| |
| if (!Buffer.readInt(Checksum)) |
| return false; |
| while (true) { |
| if (!Buffer.readFunctionTag()) |
| break; |
| auto GFun = std::make_unique<GCOVFunction>(*this); |
| if (!GFun->readGCNO(Buffer, Version)) |
| return false; |
| Functions.push_back(std::move(GFun)); |
| } |
| |
| GCNOInitialized = true; |
| return true; |
| } |
| |
| /// readGCDA - Read GCDA buffer. It is required that readGCDA() can only be |
| /// called after readGCNO(). |
| bool GCOVFile::readGCDA(GCOVBuffer &Buffer) { |
| assert(GCNOInitialized && "readGCDA() can only be called after readGCNO()"); |
| if (!Buffer.readGCDAFormat()) |
| return false; |
| GCOV::GCOVVersion GCDAVersion; |
| if (!Buffer.readGCOVVersion(GCDAVersion)) |
| return false; |
| if (Version != GCDAVersion) { |
| errs() << "GCOV versions do not match.\n"; |
| return false; |
| } |
| |
| uint32_t GCDAChecksum; |
| if (!Buffer.readInt(GCDAChecksum)) |
| return false; |
| if (Checksum != GCDAChecksum) { |
| errs() << "File checksums do not match: " << Checksum |
| << " != " << GCDAChecksum << ".\n"; |
| return false; |
| } |
| for (size_t i = 0, e = Functions.size(); i < e; ++i) { |
| if (!Buffer.readFunctionTag()) { |
| errs() << "Unexpected number of functions.\n"; |
| return false; |
| } |
| if (!Functions[i]->readGCDA(Buffer, Version)) |
| return false; |
| } |
| if (Buffer.readObjectTag()) { |
| uint32_t Length; |
| uint32_t Dummy; |
| if (!Buffer.readInt(Length)) |
| return false; |
| if (!Buffer.readInt(Dummy)) |
| return false; // checksum |
| if (!Buffer.readInt(Dummy)) |
| return false; // num |
| if (!Buffer.readInt(RunCount)) |
| return false; |
| Buffer.advanceCursor(Length - 3); |
| } |
| while (Buffer.readProgramTag()) { |
| uint32_t Length; |
| if (!Buffer.readInt(Length)) |
| return false; |
| Buffer.advanceCursor(Length); |
| ++ProgramCount; |
| } |
| |
| return true; |
| } |
| |
| void GCOVFile::print(raw_ostream &OS) const { |
| for (const auto &FPtr : Functions) |
| FPtr->print(OS); |
| } |
| |
| #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
| /// dump - Dump GCOVFile content to dbgs() for debugging purposes. |
| LLVM_DUMP_METHOD void GCOVFile::dump() const { print(dbgs()); } |
| #endif |
| |
| /// collectLineCounts - Collect line counts. This must be used after |
| /// reading .gcno and .gcda files. |
| void GCOVFile::collectLineCounts(FileInfo &FI) { |
| for (const auto &FPtr : Functions) |
| FPtr->collectLineCounts(FI); |
| FI.setRunCount(RunCount); |
| FI.setProgramCount(ProgramCount); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // GCOVFunction implementation. |
| |
| /// readGCNO - Read a function from the GCNO buffer. Return false if an error |
| /// occurs. |
| bool GCOVFunction::readGCNO(GCOVBuffer &Buff, GCOV::GCOVVersion Version) { |
| uint32_t Dummy; |
| if (!Buff.readInt(Dummy)) |
| return false; // Function header length |
| if (!Buff.readInt(Ident)) |
| return false; |
| if (!Buff.readInt(Checksum)) |
| return false; |
| if (Version != GCOV::V402) { |
| uint32_t CfgChecksum; |
| if (!Buff.readInt(CfgChecksum)) |
| return false; |
| if (Parent.getChecksum() != CfgChecksum) { |
| errs() << "File checksums do not match: " << Parent.getChecksum() |
| << " != " << CfgChecksum << " in (" << Name << ").\n"; |
| return false; |
| } |
| } |
| if (!Buff.readString(Name)) |
| return false; |
| if (!Buff.readString(Filename)) |
| return false; |
| if (!Buff.readInt(LineNumber)) |
| return false; |
| |
| // read blocks. |
| if (!Buff.readBlockTag()) { |
| errs() << "Block tag not found.\n"; |
| return false; |
| } |
| uint32_t BlockCount; |
| if (!Buff.readInt(BlockCount)) |
| return false; |
| for (uint32_t i = 0, e = BlockCount; i != e; ++i) { |
| if (!Buff.readInt(Dummy)) |
| return false; // Block flags; |
| Blocks.push_back(std::make_unique<GCOVBlock>(*this, i)); |
| } |
| |
| // read edges. |
| while (Buff.readEdgeTag()) { |
| uint32_t EdgeCount; |
| if (!Buff.readInt(EdgeCount)) |
| return false; |
| EdgeCount = (EdgeCount - 1) / 2; |
| uint32_t BlockNo; |
| if (!Buff.readInt(BlockNo)) |
| return false; |
| if (BlockNo >= BlockCount) { |
| errs() << "Unexpected block number: " << BlockNo << " (in " << Name |
| << ").\n"; |
| return false; |
| } |
| for (uint32_t i = 0, e = EdgeCount; i != e; ++i) { |
| uint32_t Dst; |
| if (!Buff.readInt(Dst)) |
| return false; |
| Edges.push_back(std::make_unique<GCOVEdge>(*Blocks[BlockNo], *Blocks[Dst])); |
| GCOVEdge *Edge = Edges.back().get(); |
| Blocks[BlockNo]->addDstEdge(Edge); |
| Blocks[Dst]->addSrcEdge(Edge); |
| if (!Buff.readInt(Dummy)) |
| return false; // Edge flag |
| } |
| } |
| |
| // read line table. |
| while (Buff.readLineTag()) { |
| uint32_t LineTableLength; |
| // Read the length of this line table. |
| if (!Buff.readInt(LineTableLength)) |
| return false; |
| uint32_t EndPos = Buff.getCursor() + LineTableLength * 4; |
| uint32_t BlockNo; |
| // Read the block number this table is associated with. |
| if (!Buff.readInt(BlockNo)) |
| return false; |
| if (BlockNo >= BlockCount) { |
| errs() << "Unexpected block number: " << BlockNo << " (in " << Name |
| << ").\n"; |
| return false; |
| } |
| GCOVBlock &Block = *Blocks[BlockNo]; |
| // Read the word that pads the beginning of the line table. This may be a |
| // flag of some sort, but seems to always be zero. |
| if (!Buff.readInt(Dummy)) |
| return false; |
| |
| // Line information starts here and continues up until the last word. |
| if (Buff.getCursor() != (EndPos - sizeof(uint32_t))) { |
| StringRef F; |
| // Read the source file name. |
| if (!Buff.readString(F)) |
| return false; |
| if (Filename != F) { |
| errs() << "Multiple sources for a single basic block: " << Filename |
| << " != " << F << " (in " << Name << ").\n"; |
| return false; |
| } |
| // Read lines up to, but not including, the null terminator. |
| while (Buff.getCursor() < (EndPos - 2 * sizeof(uint32_t))) { |
| uint32_t Line; |
| if (!Buff.readInt(Line)) |
| return false; |
| // Line 0 means this instruction was injected by the compiler. Skip it. |
| if (!Line) |
| continue; |
| Block.addLine(Line); |
| } |
| // Read the null terminator. |
| if (!Buff.readInt(Dummy)) |
| return false; |
| } |
| // The last word is either a flag or padding, it isn't clear which. Skip |
| // over it. |
| if (!Buff.readInt(Dummy)) |
| return false; |
| } |
| return true; |
| } |
| |
| /// readGCDA - Read a function from the GCDA buffer. Return false if an error |
| /// occurs. |
| bool GCOVFunction::readGCDA(GCOVBuffer &Buff, GCOV::GCOVVersion Version) { |
| uint32_t HeaderLength; |
| if (!Buff.readInt(HeaderLength)) |
| return false; // Function header length |
| |
| uint64_t EndPos = Buff.getCursor() + HeaderLength * sizeof(uint32_t); |
| |
| uint32_t GCDAIdent; |
| if (!Buff.readInt(GCDAIdent)) |
| return false; |
| if (Ident != GCDAIdent) { |
| errs() << "Function identifiers do not match: " << Ident |
| << " != " << GCDAIdent << " (in " << Name << ").\n"; |
| return false; |
| } |
| |
| uint32_t GCDAChecksum; |
| if (!Buff.readInt(GCDAChecksum)) |
| return false; |
| if (Checksum != GCDAChecksum) { |
| errs() << "Function checksums do not match: " << Checksum |
| << " != " << GCDAChecksum << " (in " << Name << ").\n"; |
| return false; |
| } |
| |
| uint32_t CfgChecksum; |
| if (Version != GCOV::V402) { |
| if (!Buff.readInt(CfgChecksum)) |
| return false; |
| if (Parent.getChecksum() != CfgChecksum) { |
| errs() << "File checksums do not match: " << Parent.getChecksum() |
| << " != " << CfgChecksum << " (in " << Name << ").\n"; |
| return false; |
| } |
| } |
| |
| if (Buff.getCursor() < EndPos) { |
| StringRef GCDAName; |
| if (!Buff.readString(GCDAName)) |
| return false; |
| if (Name != GCDAName) { |
| errs() << "Function names do not match: " << Name << " != " << GCDAName |
| << ".\n"; |
| return false; |
| } |
| } |
| |
| if (!Buff.readArcTag()) { |
| errs() << "Arc tag not found (in " << Name << ").\n"; |
| return false; |
| } |
| |
| uint32_t Count; |
| if (!Buff.readInt(Count)) |
| return false; |
| Count /= 2; |
| |
| // This for loop adds the counts for each block. A second nested loop is |
| // required to combine the edge counts that are contained in the GCDA file. |
| for (uint32_t BlockNo = 0; Count > 0; ++BlockNo) { |
| // The last block is always reserved for exit block |
| if (BlockNo >= Blocks.size()) { |
| errs() << "Unexpected number of edges (in " << Name << ").\n"; |
| return false; |
| } |
| if (BlockNo == Blocks.size() - 1) |
| errs() << "(" << Name << ") has arcs from exit block.\n"; |
| GCOVBlock &Block = *Blocks[BlockNo]; |
| for (size_t EdgeNo = 0, End = Block.getNumDstEdges(); EdgeNo < End; |
| ++EdgeNo) { |
| if (Count == 0) { |
| errs() << "Unexpected number of edges (in " << Name << ").\n"; |
| return false; |
| } |
| uint64_t ArcCount; |
| if (!Buff.readInt64(ArcCount)) |
| return false; |
| Block.addCount(EdgeNo, ArcCount); |
| --Count; |
| } |
| Block.sortDstEdges(); |
| } |
| return true; |
| } |
| |
| /// getEntryCount - Get the number of times the function was called by |
| /// retrieving the entry block's count. |
| uint64_t GCOVFunction::getEntryCount() const { |
| return Blocks.front()->getCount(); |
| } |
| |
| /// getExitCount - Get the number of times the function returned by retrieving |
| /// the exit block's count. |
| uint64_t GCOVFunction::getExitCount() const { |
| return Blocks.back()->getCount(); |
| } |
| |
| void GCOVFunction::print(raw_ostream &OS) const { |
| OS << "===== " << Name << " (" << Ident << ") @ " << Filename << ":" |
| << LineNumber << "\n"; |
| for (const auto &Block : Blocks) |
| Block->print(OS); |
| } |
| |
| #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
| /// dump - Dump GCOVFunction content to dbgs() for debugging purposes. |
| LLVM_DUMP_METHOD void GCOVFunction::dump() const { print(dbgs()); } |
| #endif |
| |
| /// collectLineCounts - Collect line counts. This must be used after |
| /// reading .gcno and .gcda files. |
| void GCOVFunction::collectLineCounts(FileInfo &FI) { |
| // If the line number is zero, this is a function that doesn't actually appear |
| // in the source file, so there isn't anything we can do with it. |
| if (LineNumber == 0) |
| return; |
| |
| for (const auto &Block : Blocks) |
| Block->collectLineCounts(FI); |
| FI.addFunctionLine(Filename, LineNumber, this); |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // GCOVBlock implementation. |
| |
| /// ~GCOVBlock - Delete GCOVBlock and its content. |
| GCOVBlock::~GCOVBlock() { |
| SrcEdges.clear(); |
| DstEdges.clear(); |
| Lines.clear(); |
| } |
| |
| /// addCount - Add to block counter while storing the edge count. If the |
| /// destination has no outgoing edges, also update that block's count too. |
| void GCOVBlock::addCount(size_t DstEdgeNo, uint64_t N) { |
| assert(DstEdgeNo < DstEdges.size()); // up to caller to ensure EdgeNo is valid |
| DstEdges[DstEdgeNo]->Count = N; |
| Counter += N; |
| if (!DstEdges[DstEdgeNo]->Dst.getNumDstEdges()) |
| DstEdges[DstEdgeNo]->Dst.Counter += N; |
| } |
| |
| /// sortDstEdges - Sort destination edges by block number, nop if already |
| /// sorted. This is required for printing branch info in the correct order. |
| void GCOVBlock::sortDstEdges() { |
| if (!DstEdgesAreSorted) |
| llvm::stable_sort(DstEdges, [](const GCOVEdge *E1, const GCOVEdge *E2) { |
| return E1->Dst.Number < E2->Dst.Number; |
| }); |
| } |
| |
| /// collectLineCounts - Collect line counts. This must be used after |
| /// reading .gcno and .gcda files. |
| void GCOVBlock::collectLineCounts(FileInfo &FI) { |
| for (uint32_t N : Lines) |
| FI.addBlockLine(Parent.getFilename(), N, this); |
| } |
| |
| void GCOVBlock::print(raw_ostream &OS) const { |
| OS << "Block : " << Number << " Counter : " << Counter << "\n"; |
| if (!SrcEdges.empty()) { |
| OS << "\tSource Edges : "; |
| for (const GCOVEdge *Edge : SrcEdges) |
| OS << Edge->Src.Number << " (" << Edge->Count << "), "; |
| OS << "\n"; |
| } |
| if (!DstEdges.empty()) { |
| OS << "\tDestination Edges : "; |
| for (const GCOVEdge *Edge : DstEdges) |
| OS << Edge->Dst.Number << " (" << Edge->Count << "), "; |
| OS << "\n"; |
| } |
| if (!Lines.empty()) { |
| OS << "\tLines : "; |
| for (uint32_t N : Lines) |
| OS << (N) << ","; |
| OS << "\n"; |
| } |
| } |
| |
| #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP) |
| /// dump - Dump GCOVBlock content to dbgs() for debugging purposes. |
| LLVM_DUMP_METHOD void GCOVBlock::dump() const { print(dbgs()); } |
| #endif |
| |
| //===----------------------------------------------------------------------===// |
| // Cycles detection |
| // |
| // The algorithm in GCC is based on the algorithm by Hawick & James: |
| // "Enumerating Circuits and Loops in Graphs with Self-Arcs and Multiple-Arcs" |
| // http://complexity.massey.ac.nz/cstn/013/cstn-013.pdf. |
| |
| /// Get the count for the detected cycle. |
| uint64_t GCOVBlock::getCycleCount(const Edges &Path) { |
| uint64_t CycleCount = std::numeric_limits<uint64_t>::max(); |
| for (auto E : Path) { |
| CycleCount = std::min(E->CyclesCount, CycleCount); |
| } |
| for (auto E : Path) { |
| E->CyclesCount -= CycleCount; |
| } |
| return CycleCount; |
| } |
| |
| /// Unblock a vertex previously marked as blocked. |
| void GCOVBlock::unblock(const GCOVBlock *U, BlockVector &Blocked, |
| BlockVectorLists &BlockLists) { |
| auto it = find(Blocked, U); |
| if (it == Blocked.end()) { |
| return; |
| } |
| |
| const size_t index = it - Blocked.begin(); |
| Blocked.erase(it); |
| |
| const BlockVector ToUnblock(BlockLists[index]); |
| BlockLists.erase(BlockLists.begin() + index); |
| for (auto GB : ToUnblock) { |
| GCOVBlock::unblock(GB, Blocked, BlockLists); |
| } |
| } |
| |
| bool GCOVBlock::lookForCircuit(const GCOVBlock *V, const GCOVBlock *Start, |
| Edges &Path, BlockVector &Blocked, |
| BlockVectorLists &BlockLists, |
| const BlockVector &Blocks, uint64_t &Count) { |
| Blocked.push_back(V); |
| BlockLists.emplace_back(BlockVector()); |
| bool FoundCircuit = false; |
| |
| for (auto E : V->dsts()) { |
| const GCOVBlock *W = &E->Dst; |
| if (W < Start || find(Blocks, W) == Blocks.end()) { |
| continue; |
| } |
| |
| Path.push_back(E); |
| |
| if (W == Start) { |
| // We've a cycle. |
| Count += GCOVBlock::getCycleCount(Path); |
| FoundCircuit = true; |
| } else if (find(Blocked, W) == Blocked.end() && // W is not blocked. |
| GCOVBlock::lookForCircuit(W, Start, Path, Blocked, BlockLists, |
| Blocks, Count)) { |
| FoundCircuit = true; |
| } |
| |
| Path.pop_back(); |
| } |
| |
| if (FoundCircuit) { |
| GCOVBlock::unblock(V, Blocked, BlockLists); |
| } else { |
| for (auto E : V->dsts()) { |
| const GCOVBlock *W = &E->Dst; |
| if (W < Start || find(Blocks, W) == Blocks.end()) { |
| continue; |
| } |
| const size_t index = find(Blocked, W) - Blocked.begin(); |
| BlockVector &List = BlockLists[index]; |
| if (find(List, V) == List.end()) { |
| List.push_back(V); |
| } |
| } |
| } |
| |
| return FoundCircuit; |
| } |
| |
| /// Get the count for the list of blocks which lie on the same line. |
| void GCOVBlock::getCyclesCount(const BlockVector &Blocks, uint64_t &Count) { |
| for (auto Block : Blocks) { |
| Edges Path; |
| BlockVector Blocked; |
| BlockVectorLists BlockLists; |
| |
| GCOVBlock::lookForCircuit(Block, Block, Path, Blocked, BlockLists, Blocks, |
| Count); |
| } |
| } |
| |
| /// Get the count for the list of blocks which lie on the same line. |
| uint64_t GCOVBlock::getLineCount(const BlockVector &Blocks) { |
| uint64_t Count = 0; |
| |
| for (auto Block : Blocks) { |
| if (Block->getNumSrcEdges() == 0) { |
| // The block has no predecessors and a non-null counter |
| // (can be the case with entry block in functions). |
| Count += Block->getCount(); |
| } else { |
| // Add counts from predecessors that are not on the same line. |
| for (auto E : Block->srcs()) { |
| const GCOVBlock *W = &E->Src; |
| if (find(Blocks, W) == Blocks.end()) { |
| Count += E->Count; |
| } |
| } |
| } |
| for (auto E : Block->dsts()) { |
| E->CyclesCount = E->Count; |
| } |
| } |
| |
| GCOVBlock::getCyclesCount(Blocks, Count); |
| |
| return Count; |
| } |
| |
| //===----------------------------------------------------------------------===// |
| // FileInfo implementation. |
| |
| // Safe integer division, returns 0 if numerator is 0. |
| static uint32_t safeDiv(uint64_t Numerator, uint64_t Divisor) { |
| if (!Numerator) |
| return 0; |
| return Numerator / Divisor; |
| } |
| |
| // This custom division function mimics gcov's branch ouputs: |
| // - Round to closest whole number |
| // - Only output 0% or 100% if it's exactly that value |
| static uint32_t branchDiv(uint64_t Numerator, uint64_t Divisor) { |
| if (!Numerator) |
| return 0; |
| if (Numerator == Divisor) |
| return 100; |
| |
| uint8_t Res = (Numerator * 100 + Divisor / 2) / Divisor; |
| if (Res == 0) |
| return 1; |
| if (Res == 100) |
| return 99; |
| return Res; |
| } |
| |
| namespace { |
| struct formatBranchInfo { |
| formatBranchInfo(const GCOV::Options &Options, uint64_t Count, uint64_t Total) |
| : Options(Options), Count(Count), Total(Total) {} |
| |
| void print(raw_ostream &OS) const { |
| if (!Total) |
| OS << "never executed"; |
| else if (Options.BranchCount) |
| OS << "taken " << Count; |
| else |
| OS << "taken " << branchDiv(Count, Total) << "%"; |
| } |
| |
| const GCOV::Options &Options; |
| uint64_t Count; |
| uint64_t Total; |
| }; |
| |
| static raw_ostream &operator<<(raw_ostream &OS, const formatBranchInfo &FBI) { |
| FBI.print(OS); |
| return OS; |
| } |
| |
| class LineConsumer { |
| std::unique_ptr<MemoryBuffer> Buffer; |
| StringRef Remaining; |
| |
| public: |
| LineConsumer(StringRef Filename) { |
| ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr = |
| MemoryBuffer::getFileOrSTDIN(Filename); |
| if (std::error_code EC = BufferOrErr.getError()) { |
| errs() << Filename << ": " << EC.message() << "\n"; |
| Remaining = ""; |
| } else { |
| Buffer = std::move(BufferOrErr.get()); |
| Remaining = Buffer->getBuffer(); |
| } |
| } |
| bool empty() { return Remaining.empty(); } |
| void printNext(raw_ostream &OS, uint32_t LineNum) { |
| StringRef Line; |
| if (empty()) |
| Line = "/*EOF*/"; |
| else |
| std::tie(Line, Remaining) = Remaining.split("\n"); |
| OS << format("%5u:", LineNum) << Line << "\n"; |
| } |
| }; |
| } // end anonymous namespace |
| |
| /// Convert a path to a gcov filename. If PreservePaths is true, this |
| /// translates "/" to "#", ".." to "^", and drops ".", to match gcov. |
| static std::string mangleCoveragePath(StringRef Filename, bool PreservePaths) { |
| if (!PreservePaths) |
| return sys::path::filename(Filename).str(); |
| |
| // This behaviour is defined by gcov in terms of text replacements, so it's |
| // not likely to do anything useful on filesystems with different textual |
| // conventions. |
| llvm::SmallString<256> Result(""); |
| StringRef::iterator I, S, E; |
| for (I = S = Filename.begin(), E = Filename.end(); I != E; ++I) { |
| if (*I != '/') |
| continue; |
| |
| if (I - S == 1 && *S == '.') { |
| // ".", the current directory, is skipped. |
| } else if (I - S == 2 && *S == '.' && *(S + 1) == '.') { |
| // "..", the parent directory, is replaced with "^". |
| Result.append("^#"); |
| } else { |
| if (S < I) |
| // Leave other components intact, |
| Result.append(S, I); |
| // And separate with "#". |
| Result.push_back('#'); |
| } |
| S = I + 1; |
| } |
| |
| if (S < I) |
| Result.append(S, I); |
| return Result.str(); |
| } |
| |
| std::string FileInfo::getCoveragePath(StringRef Filename, |
| StringRef MainFilename) { |
| if (Options.NoOutput) |
| // This is probably a bug in gcov, but when -n is specified, paths aren't |
| // mangled at all, and the -l and -p options are ignored. Here, we do the |
| // same. |
| return Filename; |
| |
| std::string CoveragePath; |
| if (Options.LongFileNames && !Filename.equals(MainFilename)) |
| CoveragePath = |
| mangleCoveragePath(MainFilename, Options.PreservePaths) + "##"; |
| CoveragePath += mangleCoveragePath(Filename, Options.PreservePaths); |
| if (Options.HashFilenames) { |
| MD5 Hasher; |
| MD5::MD5Result Result; |
| Hasher.update(Filename.str()); |
| Hasher.final(Result); |
| CoveragePath += "##" + Result.digest().str().str(); |
| } |
| CoveragePath += ".gcov"; |
| return CoveragePath; |
| } |
| |
| std::unique_ptr<raw_ostream> |
| FileInfo::openCoveragePath(StringRef CoveragePath) { |
| if (Options.NoOutput) |
| return std::make_unique<raw_null_ostream>(); |
| |
| std::error_code EC; |
| auto OS = |
| std::make_unique<raw_fd_ostream>(CoveragePath, EC, sys::fs::OF_Text); |
| if (EC) { |
| errs() << EC.message() << "\n"; |
| return std::make_unique<raw_null_ostream>(); |
| } |
| return std::move(OS); |
| } |
| |
| /// print - Print source files with collected line count information. |
| void FileInfo::print(raw_ostream &InfoOS, StringRef MainFilename, |
| StringRef GCNOFile, StringRef GCDAFile) { |
| SmallVector<StringRef, 4> Filenames; |
| for (const auto &LI : LineInfo) |
| Filenames.push_back(LI.first()); |
| llvm::sort(Filenames); |
| |
| for (StringRef Filename : Filenames) { |
| auto AllLines = LineConsumer(Filename); |
| |
| std::string CoveragePath = getCoveragePath(Filename, MainFilename); |
| std::unique_ptr<raw_ostream> CovStream = openCoveragePath(CoveragePath); |
| raw_ostream &CovOS = *CovStream; |
| |
| CovOS << " -: 0:Source:" << Filename << "\n"; |
| CovOS << " -: 0:Graph:" << GCNOFile << "\n"; |
| CovOS << " -: 0:Data:" << GCDAFile << "\n"; |
| CovOS << " -: 0:Runs:" << RunCount << "\n"; |
| CovOS << " -: 0:Programs:" << ProgramCount << "\n"; |
| |
| const LineData &Line = LineInfo[Filename]; |
| GCOVCoverage FileCoverage(Filename); |
| for (uint32_t LineIndex = 0; LineIndex < Line.LastLine || !AllLines.empty(); |
| ++LineIndex) { |
| if (Options.BranchInfo) { |
| FunctionLines::const_iterator FuncsIt = Line.Functions.find(LineIndex); |
| if (FuncsIt != Line.Functions.end()) |
| printFunctionSummary(CovOS, FuncsIt->second); |
| } |
| |
| BlockLines::const_iterator BlocksIt = Line.Blocks.find(LineIndex); |
| if (BlocksIt == Line.Blocks.end()) { |
| // No basic blocks are on this line. Not an executable line of code. |
| CovOS << " -:"; |
| AllLines.printNext(CovOS, LineIndex + 1); |
| } else { |
| const BlockVector &Blocks = BlocksIt->second; |
| |
| // Add up the block counts to form line counts. |
| DenseMap<const GCOVFunction *, bool> LineExecs; |
| for (const GCOVBlock *Block : Blocks) { |
| if (Options.FuncCoverage) { |
| // This is a slightly convoluted way to most accurately gather line |
| // statistics for functions. Basically what is happening is that we |
| // don't want to count a single line with multiple blocks more than |
| // once. However, we also don't simply want to give the total line |
| // count to every function that starts on the line. Thus, what is |
| // happening here are two things: |
| // 1) Ensure that the number of logical lines is only incremented |
| // once per function. |
| // 2) If there are multiple blocks on the same line, ensure that the |
| // number of lines executed is incremented as long as at least |
| // one of the blocks are executed. |
| const GCOVFunction *Function = &Block->getParent(); |
| if (FuncCoverages.find(Function) == FuncCoverages.end()) { |
| std::pair<const GCOVFunction *, GCOVCoverage> KeyValue( |
| Function, GCOVCoverage(Function->getName())); |
| FuncCoverages.insert(KeyValue); |
| } |
| GCOVCoverage &FuncCoverage = FuncCoverages.find(Function)->second; |
| |
| if (LineExecs.find(Function) == LineExecs.end()) { |
| if (Block->getCount()) { |
| ++FuncCoverage.LinesExec; |
| LineExecs[Function] = true; |
| } else { |
| LineExecs[Function] = false; |
| } |
| ++FuncCoverage.LogicalLines; |
| } else if (!LineExecs[Function] && Block->getCount()) { |
| ++FuncCoverage.LinesExec; |
| LineExecs[Function] = true; |
| } |
| } |
| } |
| |
| const uint64_t LineCount = GCOVBlock::getLineCount(Blocks); |
| if (LineCount == 0) |
| CovOS << " #####:"; |
| else { |
| CovOS << format("%9" PRIu64 ":", LineCount); |
| ++FileCoverage.LinesExec; |
| } |
| ++FileCoverage.LogicalLines; |
| |
| AllLines.printNext(CovOS, LineIndex + 1); |
| |
| uint32_t BlockNo = 0; |
| uint32_t EdgeNo = 0; |
| for (const GCOVBlock *Block : Blocks) { |
| // Only print block and branch information at the end of the block. |
| if (Block->getLastLine() != LineIndex + 1) |
| continue; |
| if (Options.AllBlocks) |
| printBlockInfo(CovOS, *Block, LineIndex, BlockNo); |
| if (Options.BranchInfo) { |
| size_t NumEdges = Block->getNumDstEdges(); |
| if (NumEdges > 1) |
| printBranchInfo(CovOS, *Block, FileCoverage, EdgeNo); |
| else if (Options.UncondBranch && NumEdges == 1) |
| printUncondBranchInfo(CovOS, EdgeNo, |
| (*Block->dst_begin())->Count); |
| } |
| } |
| } |
| } |
| FileCoverages.push_back(std::make_pair(CoveragePath, FileCoverage)); |
| } |
| |
| // FIXME: There is no way to detect calls given current instrumentation. |
| if (Options.FuncCoverage) |
| printFuncCoverage(InfoOS); |
| printFileCoverage(InfoOS); |
| } |
| |
| /// printFunctionSummary - Print function and block summary. |
| void FileInfo::printFunctionSummary(raw_ostream &OS, |
| const FunctionVector &Funcs) const { |
| for (const GCOVFunction *Func : Funcs) { |
| uint64_t EntryCount = Func->getEntryCount(); |
| uint32_t BlocksExec = 0; |
| for (const GCOVBlock &Block : Func->blocks()) |
| if (Block.getNumDstEdges() && Block.getCount()) |
| ++BlocksExec; |
| |
| OS << "function " << Func->getName() << " called " << EntryCount |
| << " returned " << safeDiv(Func->getExitCount() * 100, EntryCount) |
| << "% blocks executed " |
| << safeDiv(BlocksExec * 100, Func->getNumBlocks() - 1) << "%\n"; |
| } |
| } |
| |
| /// printBlockInfo - Output counts for each block. |
| void FileInfo::printBlockInfo(raw_ostream &OS, const GCOVBlock &Block, |
| uint32_t LineIndex, uint32_t &BlockNo) const { |
| if (Block.getCount() == 0) |
| OS << " $$$$$:"; |
| else |
| OS << format("%9" PRIu64 ":", Block.getCount()); |
| OS << format("%5u-block %2u\n", LineIndex + 1, BlockNo++); |
| } |
| |
| /// printBranchInfo - Print conditional branch probabilities. |
| void FileInfo::printBranchInfo(raw_ostream &OS, const GCOVBlock &Block, |
| GCOVCoverage &Coverage, uint32_t &EdgeNo) { |
| SmallVector<uint64_t, 16> BranchCounts; |
| uint64_t TotalCounts = 0; |
| for (const GCOVEdge *Edge : Block.dsts()) { |
| BranchCounts.push_back(Edge->Count); |
| TotalCounts += Edge->Count; |
| if (Block.getCount()) |
| ++Coverage.BranchesExec; |
| if (Edge->Count) |
| ++Coverage.BranchesTaken; |
| ++Coverage.Branches; |
| |
| if (Options.FuncCoverage) { |
| const GCOVFunction *Function = &Block.getParent(); |
| GCOVCoverage &FuncCoverage = FuncCoverages.find(Function)->second; |
| if (Block.getCount()) |
| ++FuncCoverage.BranchesExec; |
| if (Edge->Count) |
| ++FuncCoverage.BranchesTaken; |
| ++FuncCoverage.Branches; |
| } |
| } |
| |
| for (uint64_t N : BranchCounts) |
| OS << format("branch %2u ", EdgeNo++) |
| << formatBranchInfo(Options, N, TotalCounts) << "\n"; |
| } |
| |
| /// printUncondBranchInfo - Print unconditional branch probabilities. |
| void FileInfo::printUncondBranchInfo(raw_ostream &OS, uint32_t &EdgeNo, |
| uint64_t Count) const { |
| OS << format("unconditional %2u ", EdgeNo++) |
| << formatBranchInfo(Options, Count, Count) << "\n"; |
| } |
| |
| // printCoverage - Print generic coverage info used by both printFuncCoverage |
| // and printFileCoverage. |
| void FileInfo::printCoverage(raw_ostream &OS, |
| const GCOVCoverage &Coverage) const { |
| OS << format("Lines executed:%.2f%% of %u\n", |
| double(Coverage.LinesExec) * 100 / Coverage.LogicalLines, |
| Coverage.LogicalLines); |
| if (Options.BranchInfo) { |
| if (Coverage.Branches) { |
| OS << format("Branches executed:%.2f%% of %u\n", |
| double(Coverage.BranchesExec) * 100 / Coverage.Branches, |
| Coverage.Branches); |
| OS << format("Taken at least once:%.2f%% of %u\n", |
| double(Coverage.BranchesTaken) * 100 / Coverage.Branches, |
| Coverage.Branches); |
| } else { |
| OS << "No branches\n"; |
| } |
| OS << "No calls\n"; // to be consistent with gcov |
| } |
| } |
| |
| // printFuncCoverage - Print per-function coverage info. |
| void FileInfo::printFuncCoverage(raw_ostream &OS) const { |
| for (const auto &FC : FuncCoverages) { |
| const GCOVCoverage &Coverage = FC.second; |
| OS << "Function '" << Coverage.Name << "'\n"; |
| printCoverage(OS, Coverage); |
| OS << "\n"; |
| } |
| } |
| |
| // printFileCoverage - Print per-file coverage info. |
| void FileInfo::printFileCoverage(raw_ostream &OS) const { |
| for (const auto &FC : FileCoverages) { |
| const std::string &Filename = FC.first; |
| const GCOVCoverage &Coverage = FC.second; |
| OS << "File '" << Coverage.Name << "'\n"; |
| printCoverage(OS, Coverage); |
| if (!Options.NoOutput) |
| OS << Coverage.Name << ":creating '" << Filename << "'\n"; |
| OS << "\n"; |
| } |
| } |
