[gcov] Fix wrong line hit counts when multiple blocks are on the same line

[calixte]

Summary

The goal of this patch is to have the same behaviour than gcc-gcov.
Currently the hit counts for a line is the sum of the counts for each block on that line.
The idea is to detect the cycles in the graph of blocks in using the algorithm by Hawick & James.
The count for a cycle is the min of the counts for each edge in the cycle.
Once we've the count for each cycle, we can sum them and add the transition counts of those cycles.

Fix both https://bugs.llvm.org/show_bug.cgi?id=38065 and https://bugs.llvm.org/show_bug.cgi?id=38066

[calixte]

Don't review for now: need to fix some things

[calixte]

Handle the case where a block has no predecessors and have a counter (such as entry blocks in functions).

[calixte]

Fix a comment

[calixte]

This patch requires to accept https://reviews.llvm.org/D49721 too to fix tests in compiler-rt.

[marco-c]

Looks good to me overall. One difference I noticed with GCC is that they repeat an additional cycle count when there's a negative cycle. But in our case we don't have negative counts, so this could not happen (here's a bug I found about negative counts in GCC: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67937).

A suggestion to "smoke test" the patch: take a set of gcda files from a Firefox run and check that we can still parse everything without crashing :)

lib/ProfileData/GCOV.cpp

488 ↗

(On Diff #156986)

These two functions are basically the same, modulo the name of the second argument.
Maybe you can have just one function GCOVBlock::inBlockVector and always use it?

528 ↗

(On Diff #156986)

You might also use the inBlockVector function here

553 ↗

(On Diff #156986)

Nit: you could use getNumSrcEdges() == 0 instead, to avoid adding a new function.

Also, it seems like we can always enter this branch when there are no predecessors, no matter if count is not 0.

556 ↗

(On Diff #156986)

Maybe better to use the public function getCount like we were doing before

558 ↗

(On Diff #156986)

I would add some comments, e.g. here you can say something along the lines of "Add counts coming from predecessor blocks that are not on the same line"

[lebedev.ri]

include/llvm/ProfileData/GCOV.h

380 ↗

(On Diff #156986)

I'm not sure this patch is formatted correctly.

[vsk]

Thanks for working on this!

lib/ProfileData/GCOV.cpp

454 ↗

(On Diff #156986)

Please use verb-like function names which describe the function's action, and end sentences in comments with periods (http://www.llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly).

466 ↗

(On Diff #156986)

Please apply clang-format over your changes (https://clang.llvm.org/docs/ClangFormat.html#script-for-patch-reformatting).

467 ↗

(On Diff #156986)

If you'd prefer, you can use range-based helpers from STLExtras.h. E.g 'find(Blocked, U)'.

[calixte]

Fix comments, function names and use llvm::find.

[calixte]

I collected 2808 gcda (over 3211 gcno) from firefox build and ran "llvm-cov gcov" on each of them and no crash at all.

llvm/trunk/include/llvm/ProfileData/GCOV.h

 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/raw_ostream.h"
+#include <algorithm>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
+#include <limits>
 #include <memory>
 #include <string>
 #include <utility>
 
 namespace llvm {
 
 class GCOVFunction;
 class GCOVBlock;

 
 /// GCOVEdge - Collects edge information.
 struct GCOVEdge {
   GCOVEdge(GCOVBlock &S, GCOVBlock &D) : Src(S), Dst(D) {}
 
   GCOVBlock &Src;
   GCOVBlock &Dst;
   uint64_t Count = 0;
+  uint64_t CyclesCount = 0;
 };
 
 /// GCOVFunction - Collects function information.
 class GCOVFunction {
 public:
-  using BlockIterator = pointee_iterator<SmallVectorImpl<
-      std::unique_ptr<GCOVBlock>>::const_iterator>;
+  using BlockIterator = pointee_iterator<
+      SmallVectorImpl<std::unique_ptr<GCOVBlock>>::const_iterator>;
 
   GCOVFunction(GCOVFile &P) : Parent(P) {}
 
   bool readGCNO(GCOVBuffer &Buffer, GCOV::GCOVVersion Version);
   bool readGCDA(GCOVBuffer &Buffer, GCOV::GCOVVersion Version);
   StringRef getName() const { return Name; }
   StringRef getFilename() const { return Filename; }
   size_t getNumBlocks() const { return Blocks.size(); }
class GCOVBlock {
   struct SortDstEdgesFunctor {
     bool operator()(const GCOVEdge *E1, const GCOVEdge *E2) {
       return E1->Dst.Number < E2->Dst.Number;
     }
   };
 
 public:
   using EdgeIterator = SmallVectorImpl<GCOVEdge *>::const_iterator;
+  using BlockVector = SmallVector<const GCOVBlock *, 4>;
+  using BlockVectorLists = SmallVector<BlockVector, 4>;
+  using Edges = SmallVector<GCOVEdge *, 4>;
 
   GCOVBlock(GCOVFunction &P, uint32_t N) : Parent(P), Number(N) {}
   ~GCOVBlock();
 
   const GCOVFunction &getParent() const { return Parent; }
   void addLine(uint32_t N) { Lines.push_back(N); }
   uint32_t getLastLine() const { return Lines.back(); }
   void addCount(size_t DstEdgeNo, uint64_t N);
public:
   iterator_range<EdgeIterator> dsts() const {
     return make_range(dst_begin(), dst_end());
   }
 
   void print(raw_ostream &OS) const;
   void dump() const;
   void collectLineCounts(FileInfo &FI);
 
+  static uint64_t getCycleCount(const Edges &Path);
+  static void unblock(const GCOVBlock *U, BlockVector &Blocked,
+                      BlockVectorLists &BlockLists);
+  static bool lookForCircuit(const GCOVBlock *V, const GCOVBlock *Start,
+                             Edges &Path, BlockVector &Blocked,
+                             BlockVectorLists &BlockLists,
+                             const BlockVector &Blocks, uint64_t &Count);
+  static void getCyclesCount(const BlockVector &Blocks, uint64_t &Count);
+  static uint64_t getLineCount(const BlockVector &Blocks);
+
 private:
   GCOVFunction &Parent;
   uint32_t Number;
   uint64_t Counter = 0;
   bool DstEdgesAreSorted = true;
   SmallVector<GCOVEdge *, 16> SrcEdges;
   SmallVector<GCOVEdge *, 16> DstEdges;
   SmallVector<uint32_t, 16> Lines;

llvm/trunk/lib/ProfileData/GCOV.cpp

 
 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());
-}
+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);
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());
-}
+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)
if (!Lines.empty()) {
     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());
-}
+LLVM_DUMP_METHOD void GCOVBlock::dump() const { print(dbgs()); }
 #endif
 
 //===----------------------------------------------------------------------===//
+// Cycles detection
+//
+// The algorithm in GCC is based on the algorihtm 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;
 }

 }
 
 std::unique_ptr<raw_ostream>
 FileInfo::openCoveragePath(StringRef CoveragePath) {
   if (Options.NoOutput)
     return llvm::make_unique<raw_null_ostream>();
 
   std::error_code EC;
-  auto OS = llvm::make_unique<raw_fd_ostream>(CoveragePath, EC,
-                                              sys::fs::F_Text);
+  auto OS =
+      llvm::make_unique<raw_fd_ostream>(CoveragePath, EC, sys::fs::F_Text);
   if (EC) {
     errs() << EC.message() << "\n";
     return llvm::make_unique<raw_null_ostream>();
   }
   return std::move(OS);
 }
 
 /// print -  Print source files with collected line count information.
for (uint32_t LineIndex = 0; LineIndex < Line.LastLine || !AllLines.empty();
         // 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;
-        uint64_t LineCount = 0;
         for (const GCOVBlock *Block : Blocks) {
-          if (Options.AllBlocks) {
-            // Only take the highest block count for that line.
-            uint64_t BlockCount = Block->getCount();
-            LineCount = LineCount > BlockCount ? LineCount : BlockCount;
-          } else {
-            // Sum up all of the block counts.
-            LineCount += Block->getCount();
-          }
-
           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
for (uint32_t LineIndex = 0; LineIndex < Line.LastLine || !AllLines.empty();
               ++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;
 

llvm/trunk/test/tools/llvm-cov/Inputs/test_-a.h.gcov

         -:    0:Source:./test.h
         -:    0:Graph:test.gcno
         -:    0:Data:test.gcda
         -:    0:Runs:2
         -:    0:Programs:1
-        2:    1:struct A {
+        4:    1:struct A {
         2:    1-block  0
         2:    1-block  1
         -:    2:  virtual void B();
         -:    3:};

llvm/trunk/test/tools/llvm-cov/Inputs/test_-a.cpp.gcov

$$$$$:   25-block  0
         6:   33:  for (int ii = 0; ii < 2; ii++)
         2:   33-block  0
         6:   33-block  1
         4:   33-block  2
        12:   34:    for (int jj = 0; jj < 2; jj++)
         4:   34-block  0
        12:   34-block  1
         8:   34-block  2
-        8:   35:      assign(ii, jj);
+       12:   35:      assign(ii, jj);
         8:   35-block  0
         4:   35-block  1
         2:   36:}
         2:   36-block  0
         -:   37:
         -:   38:int main() {
         2:   39:  initialize_grid();
         -:   40:

llvm/trunk/test/tools/llvm-cov/Inputs/test_-a_-b.h.gcov

         -:    0:Source:./test.h
         -:    0:Graph:test.gcno
         -:    0:Data:test.gcda
         -:    0:Runs:2
         -:    0:Programs:1
 function _ZN1AC1Ev called 2 returned 100% blocks executed 100%
 function _ZN1AC2Ev called 2 returned 100% blocks executed 100%
-        2:    1:struct A {
+        4:    1:struct A {
         2:    1-block  0
         2:    1-block  1
         -:    2:  virtual void B();
         -:    3:};

llvm/trunk/test/tools/llvm-cov/Inputs/test_-a_-b.cpp.gcov

 branch  1 taken 33%
         4:   33-block  2
        12:   34:    for (int jj = 0; jj < 2; jj++)
         4:   34-block  0
        12:   34-block  1
 branch  0 taken 67%
 branch  1 taken 33%
         8:   34-block  2
-        8:   35:      assign(ii, jj);
+       12:   35:      assign(ii, jj);
         8:   35-block  0
         4:   35-block  1
         2:   36:}
         2:   36-block  0
         -:   37:
 function main called 2 returned 100% blocks executed 94%
         -:   38:int main() {
         2:   39:  initialize_grid();

llvm/trunk/test/tools/llvm-cov/Inputs/test_-a_-b_-c_-u.h.gcov

         -:    0:Source:./test.h
         -:    0:Graph:test.gcno
         -:    0:Data:test.gcda
         -:    0:Runs:2
         -:    0:Programs:1
 function _ZN1AC1Ev called 2 returned 100% blocks executed 100%
 function _ZN1AC2Ev called 2 returned 100% blocks executed 100%
-        2:    1:struct A {
+        4:    1:struct A {
         2:    1-block  0
 unconditional  0 taken 2
         2:    1-block  1
 unconditional  1 taken 2
         -:    2:  virtual void B();
         -:    3:};

llvm/trunk/test/tools/llvm-cov/Inputs/test_-a_-b_-c_-u.cpp.gcov

unconditional  3 taken 4
        12:   34:    for (int jj = 0; jj < 2; jj++)
         4:   34-block  0
 unconditional  0 taken 4
        12:   34-block  1
 branch  1 taken 8
 branch  2 taken 4
         8:   34-block  2
 unconditional  3 taken 8
-        8:   35:      assign(ii, jj);
+       12:   35:      assign(ii, jj);
         8:   35-block  0
 unconditional  0 taken 8
         4:   35-block  1
 unconditional  1 taken 4
         2:   36:}
         2:   36-block  0
 unconditional  0 taken 2
         -:   37:

llvm/trunk/test/tools/llvm-cov/Inputs/test_-a_-b_-u.h.gcov

         -:    0:Source:./test.h
         -:    0:Graph:test.gcno
         -:    0:Data:test.gcda
         -:    0:Runs:2
         -:    0:Programs:1
 function _ZN1AC1Ev called 2 returned 100% blocks executed 100%
 function _ZN1AC2Ev called 2 returned 100% blocks executed 100%
-        2:    1:struct A {
+        4:    1:struct A {
         2:    1-block  0
 unconditional  0 taken 100%
         2:    1-block  1
 unconditional  1 taken 100%
         -:    2:  virtual void B();
         -:    3:};

llvm/trunk/test/tools/llvm-cov/Inputs/test_-a_-b_-u.cpp.gcov

unconditional  3 taken 100%
        12:   34:    for (int jj = 0; jj < 2; jj++)
         4:   34-block  0
 unconditional  0 taken 100%
        12:   34-block  1
 branch  1 taken 67%
 branch  2 taken 33%
         8:   34-block  2
 unconditional  3 taken 100%
-        8:   35:      assign(ii, jj);
+       12:   35:      assign(ii, jj);
         8:   35-block  0
 unconditional  0 taken 100%
         4:   35-block  1
 unconditional  1 taken 100%
         2:   36:}
         2:   36-block  0
 unconditional  0 taken 100%
         -:   37:

llvm/trunk/test/tools/llvm-cov/Inputs/test_missing.cpp.gcov

12884901888:   10:/*EOF*/
     #####:   25:/*EOF*/
         -:   26:/*EOF*/
         -:   27:/*EOF*/
        12:   28:/*EOF*/
        12:   29:/*EOF*/
        12:   30:/*EOF*/
         -:   31:/*EOF*/
         -:   32:/*EOF*/
-       21:   33:/*EOF*/
-       36:   34:/*EOF*/
+        9:   33:/*EOF*/
+       18:   34:/*EOF*/
        18:   35:/*EOF*/
         3:   36:/*EOF*/
         -:   37:/*EOF*/
         -:   38:/*EOF*/
         3:   39:/*EOF*/
         -:   40:/*EOF*/
         3:   41:/*EOF*/
         3:   42:/*EOF*/
         3:   43:/*EOF*/
         3:   44:/*EOF*/
         3:   45:/*EOF*/
         3:   46:/*EOF*/
     #####:   47:/*EOF*/
     #####:   48:/*EOF*/
         -:   49:/*EOF*/
         -:   50:/*EOF*/
-       66:   51:/*EOF*/
+       33:   51:/*EOF*/
        30:   52:/*EOF*/
         -:   53:/*EOF*/
         6:   54:/*EOF*/
         6:   55:/*EOF*/
         -:   56:/*EOF*/
         -:   57:/*EOF*/
         3:   58:/*EOF*/
         3:   59:/*EOF*/
         -:   60:/*EOF*/
         9:   61:/*EOF*/
         9:   62:/*EOF*/
         -:   63:/*EOF*/
        12:   64:/*EOF*/
        12:   65:/*EOF*/
        30:   66:/*EOF*/
         -:   67:/*EOF*/
         3:   68:/*EOF*/
-25769803782:   69:/*EOF*/
[phone]:   69:/*EOF*/
 12884901888:   70:/*EOF*/
         -:   71:/*EOF*/
         3:   72:/*EOF*/

llvm/trunk/test/tools/llvm-cov/Inputs/test_no_options.cpp.gcov

8589934592:   10:void A::B() {}
     #####:   25:  return foo() + 45;
         -:   26:}
         -:   27:
         8:   28:void assign(int ii, int jj) {
         8:   29:  grid[ii][jj] = (ii+1) * (jj+1);
         8:   30:}
         -:   31:
         -:   32:void initialize_grid() {
-       12:   33:  for (int ii = 0; ii < 2; ii++)
-       24:   34:    for (int jj = 0; jj < 2; jj++)
+        6:   33:  for (int ii = 0; ii < 2; ii++)
+       12:   34:    for (int jj = 0; jj < 2; jj++)
        12:   35:      assign(ii, jj);
         2:   36:}
         -:   37:
         -:   38:int main() {
         2:   39:  initialize_grid();
         -:   40:
         2:   41:  int a = 2;
         2:   42:  on = rand() % 2;
         2:   43:  if (on) {
         2:   44:    foo();
         2:   45:    ++a;
         2:   46:  } else {
     #####:   47:    bar();
     #####:   48:    a += rand();
         -:   49:  }
         -:   50:
-       44:   51:  for (int ii = 0; ii < 10; ++ii) {
+       22:   51:  for (int ii = 0; ii < 10; ++ii) {
        20:   52:    switch (rand() % 5) {
         -:   53:      case 0:
         4:   54:        a += rand();
         4:   55:        break;
         -:   56:      case 1:
         -:   57:      case 2:
         2:   58:        a += rand() / rand();
         2:   59:        break;
         -:   60:      case 3:
         6:   61:        a -= rand();
         6:   62:        break;
         -:   63:      default:
         8:   64:        a = -1;
         8:   65:    }
        20:   66:  }
         -:   67:
         2:   68:  A thing;
-17179869188:   69:  for (uint64_t ii = 0; ii < 4294967296; ++ii)
[phone]:   69:  for (uint64_t ii = 0; ii < 4294967296; ++ii)
 8589934592:   70:    thing.B();
         -:   71:
         2:   72:  return a + 8 + grid[2][3] + len;
         -:   73:  return more_useless();
         -:   74:}

llvm/trunk/test/tools/llvm-cov/Inputs/test_objdir.cpp.gcov

8589934592:   10:void A::B() {}
     #####:   25:  return foo() + 45;
         -:   26:}
         -:   27:
         8:   28:void assign(int ii, int jj) {
         8:   29:  grid[ii][jj] = (ii+1) * (jj+1);
         8:   30:}
         -:   31:
         -:   32:void initialize_grid() {
-       12:   33:  for (int ii = 0; ii < 2; ii++)
-       24:   34:    for (int jj = 0; jj < 2; jj++)
+        6:   33:  for (int ii = 0; ii < 2; ii++)
+       12:   34:    for (int jj = 0; jj < 2; jj++)
        12:   35:      assign(ii, jj);
         2:   36:}
         -:   37:
         -:   38:int main() {
         2:   39:  initialize_grid();
         -:   40:
         2:   41:  int a = 2;
         2:   42:  on = rand() % 2;
         2:   43:  if (on) {
         2:   44:    foo();
         2:   45:    ++a;
         2:   46:  } else {
     #####:   47:    bar();
     #####:   48:    a += rand();
         -:   49:  }
         -:   50:
-       44:   51:  for (int ii = 0; ii < 10; ++ii) {
+       22:   51:  for (int ii = 0; ii < 10; ++ii) {
        20:   52:    switch (rand() % 5) {
         -:   53:      case 0:
         4:   54:        a += rand();
         4:   55:        break;
         -:   56:      case 1:
         -:   57:      case 2:
         2:   58:        a += rand() / rand();
         2:   59:        break;
         -:   60:      case 3:
         6:   61:        a -= rand();
         6:   62:        break;
         -:   63:      default:
         8:   64:        a = -1;
         8:   65:    }
        20:   66:  }
         -:   67:
         2:   68:  A thing;
-17179869188:   69:  for (uint64_t ii = 0; ii < 4294967296; ++ii)
[phone]:   69:  for (uint64_t ii = 0; ii < 4294967296; ++ii)
 8589934592:   70:    thing.B();
         -:   71:
         2:   72:  return a + 8 + grid[2][3] + len;
         -:   73:  return more_useless();
         -:   74:}

llvm/trunk/test/tools/llvm-cov/Inputs/test_paths.cpp.gcov

12884901888:   10:void A::B() {}
     #####:   25:  return foo() + 45;
         -:   26:}
         -:   27:
        12:   28:void assign(int ii, int jj) {
        12:   29:  grid[ii][jj] = (ii+1) * (jj+1);
        12:   30:}
         -:   31:
         -:   32:void initialize_grid() {
-       21:   33:  for (int ii = 0; ii < 2; ii++)
-       36:   34:    for (int jj = 0; jj < 2; jj++)
+        9:   33:  for (int ii = 0; ii < 2; ii++)
+       18:   34:    for (int jj = 0; jj < 2; jj++)
        18:   35:      assign(ii, jj);
         3:   36:}
         -:   37:
         -:   38:int main() {
         3:   39:  initialize_grid();
         -:   40:
         3:   41:  int a = 2;
         3:   42:  on = rand() % 2;
         3:   43:  if (on) {
         3:   44:    foo();
         3:   45:    ++a;
         3:   46:  } else {
     #####:   47:    bar();
     #####:   48:    a += rand();
         -:   49:  }
         -:   50:
-       66:   51:  for (int ii = 0; ii < 10; ++ii) {
+       33:   51:  for (int ii = 0; ii < 10; ++ii) {
        30:   52:    switch (rand() % 5) {
         -:   53:      case 0:
         6:   54:        a += rand();
         6:   55:        break;
         -:   56:      case 1:
         -:   57:      case 2:
         3:   58:        a += rand() / rand();
         3:   59:        break;
         -:   60:      case 3:
         9:   61:        a -= rand();
         9:   62:        break;
         -:   63:      default:
        12:   64:        a = -1;
        12:   65:    }
        30:   66:  }
         -:   67:
         3:   68:  A thing;
-25769803782:   69:  for (uint64_t ii = 0; ii < 4294967296; ++ii)
[phone]:   69:  for (uint64_t ii = 0; ii < 4294967296; ++ii)
 12884901888:   70:    thing.B();
         -:   71:
         3:   72:  return a + 8 + grid[2][3] + len;
         -:   73:  return more_useless();
         -:   74:}

llvm/trunk/test/tools/llvm-cov/range_based_for.cpp

 // STDOUT: range_based_for.cpp:creating 'range_based_for.cpp.gcov'
 
 // RUN: FileCheck %s --check-prefix=GCOV < %t/range_based_for.cpp.gcov
 // GCOV: -:    0:Runs:1
 // GCOV: -:    0:Programs:1
 
 int main(int argc, const char *argv[]) { // GCOV: 1:    [[@LINE]]:int main(
   int V[] = {1, 2};                      // GCOV: 1:    [[@LINE]]:  int V[]
-  for (int &I : V) {                     // GCOV: 10:   [[@LINE]]:  for (
+  for (int &I : V) {                     // GCOV: 5:    [[@LINE]]:  for (
   }                                      // GCOV: 2:    [[@LINE]]:  }
   return 0;                              // GCOV: 1:    [[@LINE]]:  return
 }                                        // GCOV: -:    [[@LINE]]:}
 
 // llvm-cov doesn't work on big endian yet
 // XFAIL: powerpc-, powerpc64-, s390x, mips-, mips64-, sparc