Coverage: add HasCodeBefore flag to a mapping region

[arphaman]

Summary

This patch adds a flag HasCodeBefore to a coverage mapping region.

This flag will be used by the coverage tool to compute the execution counts for each line in a source file
so that the lines' execution counts will show the execution count of a first piece of code on that line
instead of the execution count of the last mapping region on that line.

[bob.wilson]

This is good to commit, but see my suggested improvement below. I assume it will be tested once we get the llvm-cov support enabled?

[arphaman]

Thanks, I will add a constant for the shift amount to the mapping region.
Yes, this will be tested in llvm-cov.

[arphaman]

Closed by commit rL214740 (authored by @arphaman).

llvm/trunk/include/llvm/ProfileData/CoverageMapping.h

enum RegionKind {
     /// such as for a macro instantiation or #include file.
     ExpansionRegion,
 
     /// \brief A SkippedRegion represents a source range with code that
     /// was skipped by a preprocessor or similar means.
     SkippedRegion
   };
 
+  static const unsigned EncodingHasCodeBeforeBits = 1;
+
   Counter Count;
   unsigned FileID, ExpandedFileID;
   unsigned LineStart, ColumnStart, LineEnd, ColumnEnd;
   RegionKind Kind;
+  /// \brief A flag that is set to true when there is already code before
+  /// this region on the same line.
+  /// This is useful to accurately compute the execution counts for a line.
+  bool HasCodeBefore;
 
   CounterMappingRegion(Counter Count, unsigned FileID, unsigned LineStart,
                        unsigned ColumnStart, unsigned LineEnd,
-                       unsigned ColumnEnd, RegionKind Kind = CodeRegion)
+                       unsigned ColumnEnd, bool HasCodeBefore = false,
+                       RegionKind Kind = CodeRegion)
       : Count(Count), FileID(FileID), ExpandedFileID(0), LineStart(LineStart),
         ColumnStart(ColumnStart), LineEnd(LineEnd), ColumnEnd(ColumnEnd),
-        Kind(Kind) {}
+        Kind(Kind), HasCodeBefore(HasCodeBefore) {}
 
   bool operator<(const CounterMappingRegion &Other) const {
     if (FileID != Other.FileID)
       return FileID < Other.FileID;
     if (LineStart == Other.LineStart)
       return ColumnStart < Other.ColumnStart;
     return LineStart < Other.LineStart;
   }

llvm/trunk/lib/ProfileData/CoverageMappingReader.cpp

if (Tag != Counter::Zero) {
           break;
         default:
           return error(instrprof_error::malformed);
         }
       }
     }
 
     // Read the source range.
-    uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd;
+    uint64_t LineStartDelta, CodeBeforeColumnStart, NumLines, ColumnEnd;
     if (auto Err =
             readIntMax(LineStartDelta, std::numeric_limits<unsigned>::max()))
       return Err;
-    if (auto Err =
-            readIntMax(ColumnStart, std::numeric_limits<unsigned>::max()))
+    if (auto Err = readULEB128(CodeBeforeColumnStart))
       return Err;
+    bool HasCodeBefore = CodeBeforeColumnStart & 1;
+    uint64_t ColumnStart = CodeBeforeColumnStart >>
+                           CounterMappingRegion::EncodingHasCodeBeforeBits;
+    if (ColumnStart > std::numeric_limits<unsigned>::max())
+      return error(instrprof_error::malformed);
     if (auto Err = readIntMax(NumLines, std::numeric_limits<unsigned>::max()))
       return Err;
     if (auto Err = readIntMax(ColumnEnd, std::numeric_limits<unsigned>::max()))
       return Err;
     LineStart += LineStartDelta;
     // Adjust the column locations for the empty regions that are supposed to
     // cover whole lines. Those regions should be encoded with the
     // column range (1 -> std::numeric_limits<unsigned>::max()), but because
     // the encoded std::numeric_limits<unsigned>::max() is several bytes long,
     // we set the column range to (0 -> 0) to ensure that the column start and
     // column end take up one byte each.
     // The std::numeric_limits<unsigned>::max() is used to represent a column
     // position at the end of the line without knowing the length of that line.
     if (ColumnStart == 0 && ColumnEnd == 0) {
       ColumnStart = 1;
       ColumnEnd = std::numeric_limits<unsigned>::max();
     }
-    MappingRegions.push_back(
-        CounterMappingRegion(C, InferredFileID, LineStart, ColumnStart,
-                             LineStart + NumLines, ColumnEnd, Kind));
+    MappingRegions.push_back(CounterMappingRegion(
+        C, InferredFileID, LineStart, ColumnStart, LineStart + NumLines,
+        ColumnEnd, HasCodeBefore, Kind));
     MappingRegions.back().ExpandedFileID = ExpandedFileID;
   }
   return success();
 }
 
 std::error_code RawCoverageMappingReader::read(CoverageMappingRecord &Record) {
 
   // Read the virtual file mapping.

llvm/trunk/lib/ProfileData/CoverageMappingWriter.cpp

case CounterMappingRegion::SkippedRegion:
       assert(Count.isZero());
       encodeULEB128(unsigned(I.Kind)
                         << Counter::EncodingCounterTagAndExpansionRegionTagBits,
                     OS);
       break;
     }
     assert(I.LineStart >= PrevLineStart);
     encodeULEB128(I.LineStart - PrevLineStart, OS);
-    encodeULEB128(I.ColumnStart, OS);
+    uint64_t CodeBeforeColumnStart =
+        uint64_t(I.HasCodeBefore) |
+        (uint64_t(I.ColumnStart)
+         << CounterMappingRegion::EncodingHasCodeBeforeBits);
+    encodeULEB128(CodeBeforeColumnStart, OS);
     assert(I.LineEnd >= I.LineStart);
     encodeULEB128(I.LineEnd - I.LineStart, OS);
     encodeULEB128(I.ColumnEnd, OS);
     PrevLineStart = I.LineStart;
   }
   // Ensure that all file ids have at least one mapping region.
   assert(CurrentFileID == (VirtualFileMapping.size() - 1));
 }