[Coverage] Move logic to encode filenames and mappings into llvm (NFC)

Currently, frontends which emit source-based code coverage have to
duplicate logic to encode filenames and raw coverage mappings properly.
This violates an abstraction layer and forces frontends to copy tricky
code.

Introduce llvm::coverage::encodeFilenamesAndRawMappings() to take care
of this.

This will help us experiment with zlib-compressing coverage mapping
data.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@273055 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/ProfileData/Coverage/CoverageMappingWriter.h

@@ -23,19 +23,6 @@
 namespace llvm {
 namespace coverage {
 
-/// \brief Writer of the filenames section for the instrumentation
-/// based code coverage.
-class CoverageFilenamesSectionWriter {
-  ArrayRef<StringRef> Filenames;
-
-public:
-  CoverageFilenamesSectionWriter(ArrayRef<StringRef> Filenames)
-      : Filenames(Filenames) {}
-
-  /// \brief Write encoded filenames to the given output stream.
-  void write(raw_ostream &OS);
-};
-
 /// \brief Writer for instrumentation based coverage mapping data.
 class CoverageMappingWriter {
   ArrayRef<unsigned> VirtualFileMapping;
@@ -57,6 +44,17 @@ public:
   void write(raw_ostream &OS);
 };
 
+/// \brief Encode a list of filenames and raw coverage mapping data using the
+/// latest coverage data format.
+///
+/// Set \p FilenamesSize to the size of the filenames section.
+///
+/// Set \p CoverageMappingsSize to the size of the coverage mapping section
+/// (including any necessary padding bytes).
+Expected<std::string> encodeFilenamesAndRawMappings(
+    ArrayRef<std::string> Filenames, ArrayRef<std::string> CoverageMappings,
+    size_t &FilenamesSize, size_t &CoverageMappingsSize);
+
 } // end namespace coverage
 } // end namespace llvm
 

lib/ProfileData/Coverage/CoverageMappingWriter.cpp

@@ -18,14 +18,6 @@
 using namespace llvm;
 using namespace coverage;
 
-void CoverageFilenamesSectionWriter::write(raw_ostream &OS) {
-  encodeULEB128(Filenames.size(), OS);
-  for (const auto &Filename : Filenames) {
-    encodeULEB128(Filename.size(), OS);
-    OS << Filename;
-  }
-}
-
 namespace {
 /// \brief Gather only the expressions that are used by the mapping
 /// regions in this function.
@@ -181,3 +173,52 @@ void CoverageMappingWriter::write(raw_ostream &OS) {
   // Ensure that all file ids have at least one mapping region.
   assert(CurrentFileID == (VirtualFileMapping.size() - 1));
 }
+
+/// \brief Encode coverage data into \p OS.
+static void encodeCoverageData(ArrayRef<std::string> Filenames,
+                               ArrayRef<std::string> CoverageMappings,
+                               size_t &FilenamesSize,
+                               size_t &CoverageMappingsSize, raw_ostream &OS) {
+  size_t OSOffset = OS.GetNumBytesInBuffer();
+
+  // Encode the filenames.
+  encodeULEB128(Filenames.size(), OS);
+  for (const auto &Filename : Filenames) {
+    encodeULEB128(Filename.size(), OS);
+    OS << Filename;
+  }
+
+  FilenamesSize = OS.GetNumBytesInBuffer() - OSOffset;
+
+  // Encode the coverage mappings.
+  for (const auto &RawMapping : CoverageMappings)
+    OS << RawMapping;
+
+  // Pad the output stream to an 8-byte boundary. Account for the padding bytes
+  // in \p CoverageMappingsSize.
+  if (size_t Rem = OS.GetNumBytesInBuffer() % 8) {
+    CoverageMappingsSize += 8 - Rem;
+    for (size_t I = 0, S = 8 - Rem; I < S; ++I)
+      OS << '\0';
+  }
+
+  CoverageMappingsSize = OS.GetNumBytesInBuffer() - FilenamesSize - OSOffset;
+}
+
+namespace llvm {
+namespace coverage {
+
+Expected<std::string> encodeFilenamesAndRawMappings(
+    ArrayRef<std::string> Filenames, ArrayRef<std::string> CoverageMappings,
+    size_t &FilenamesSize, size_t &CoverageMappingsSize) {
+  std::string CoverageData;
+  {
+    raw_string_ostream OS{CoverageData};
+    encodeCoverageData(Filenames, CoverageMappings, FilenamesSize,
+                       CoverageMappingsSize, OS);
+  }
+  return std::move(CoverageData);
+}
+
+} // end namespace coverage
+} // end namespace llvm