[PATCH] D19333: Move coverage related code into a separate library

Easwaran Raman via llvm-commits llvm-commits at lists.llvm.org
Fri Apr 22 12:46:48 PDT 2016


I've attached the patch.

On Thu, Apr 21, 2016 at 6:11 PM, Justin Bogner <mail at justinbogner.com>
wrote:

> Easwaran Raman <eraman at google.com> writes:
> > eraman created this revision.
> > eraman added reviewers: bogner, vsk, davidxl.
> > eraman added a subscriber: llvm-commits.
> >
> > Recently, I ran into a circular dependency problem when I made
> > Analysis depend on ProfileData.  See
> > http://lists.llvm.org/pipermail/llvm-dev/2016-April/098400.html for
> > more context. ProfileData has an existing dependence on Analysis
> > through Object and Bitcode. Only the Coverage code depends on
> > Object. Splitting Coverage data into its own library removes the
> > ProfileData->Analysis dependence. Does this seem reasonable?
> >
> > Notes:
> > * I have modeled this on Codegen which has some files underneath as
> > well as subdirs that correspond to separate libraries.
> > * Clang code that includes coverage headers need to be changed as
> > well. Will send a patch once there is a general agreement on this
> > patch.
> > * I have used "svn mv" to move coverage related code into the new
> > directory to preserver history.
> > * I have not split the ProfileData unittest to a separate Coverage
> > directory thinking there will be only one file there, but perhaps that
> > also needs to be split?
> > * check-all runs successfully, but it's quite likely that I have
> > overlooked something.
>
> It seems like phab corrupted this patch - it doesn't apply at all. Could
> you attach it to the email thread please?
>
> > http://reviews.llvm.org/D19333
> >
> > Files:
> >   include/llvm/ProfileData/Coverage/CoverageMappingReader.h
> >   include/llvm/ProfileData/Coverage/CoverageMappingWriter.h
> >   include/llvm/ProfileData/CoverageMapping.h
> >   include/llvm/ProfileData/CoverageMappingReader.h
> >   include/llvm/ProfileData/CoverageMappingWriter.h
> >   lib/ProfileData/CMakeLists.txt
> >   lib/ProfileData/Coverage/CMakeLists.txt
> >   lib/ProfileData/Coverage/CoverageMapping.cpp
> >   lib/ProfileData/Coverage/CoverageMappingReader.cpp
> >   lib/ProfileData/Coverage/CoverageMappingWriter.cpp
> >   lib/ProfileData/Coverage/LLVMBuild.txt
> >   lib/ProfileData/CoverageMapping.cpp
> >   lib/ProfileData/CoverageMappingReader.cpp
> >   lib/ProfileData/CoverageMappingWriter.cpp
> >   lib/ProfileData/LLVMBuild.txt
> >   tools/llvm-cov/CMakeLists.txt
> >   tools/llvm-cov/CodeCoverage.cpp
> >   tools/llvm-cov/CoverageFilters.h
> >   tools/llvm-cov/CoverageSummaryInfo.h
> >   tools/llvm-cov/LLVMBuild.txt
> >   tools/llvm-cov/SourceCoverageView.h
> >   unittests/ProfileData/CMakeLists.txt
> >   unittests/ProfileData/CoverageMappingTest.cpp
> >
> > Index: unittests/ProfileData/CoverageMappingTest.cpp
> > ===================================================================
> > --- unittests/ProfileData/CoverageMappingTest.cpp
> > +++ unittests/ProfileData/CoverageMappingTest.cpp
> > @@ -7,9 +7,9 @@
> >  //
> >
> //===----------------------------------------------------------------------===//
> >
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > -#include "llvm/ProfileData/CoverageMappingReader.h"
> > -#include "llvm/ProfileData/CoverageMappingWriter.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMapping.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMappingWriter.h"
> >  #include "llvm/ProfileData/InstrProfReader.h"
> >  #include "llvm/ProfileData/InstrProfWriter.h"
> >  #include "llvm/Support/raw_ostream.h"
> > Index: unittests/ProfileData/CMakeLists.txt
> > ===================================================================
> > --- unittests/ProfileData/CMakeLists.txt
> > +++ unittests/ProfileData/CMakeLists.txt
> > @@ -1,5 +1,6 @@
> >  set(LLVM_LINK_COMPONENTS
> >    Core
> > +  Coverage
> >    ProfileData
> >    Support
> >    )
> > Index: tools/llvm-cov/SourceCoverageView.h
> > ===================================================================
> > --- tools/llvm-cov/SourceCoverageView.h
> > +++ tools/llvm-cov/SourceCoverageView.h
> > @@ -15,7 +15,7 @@
> >  #define LLVM_COV_SOURCECOVERAGEVIEW_H
> >
> >  #include "CoverageViewOptions.h"
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMapping.h"
> >  #include "llvm/Support/MemoryBuffer.h"
> >  #include <vector>
> >
> > Index: tools/llvm-cov/LLVMBuild.txt
> > ===================================================================
> > --- tools/llvm-cov/LLVMBuild.txt
> > +++ tools/llvm-cov/LLVMBuild.txt
> > @@ -19,4 +19,4 @@
> >  type = Tool
> >  name = llvm-cov
> >  parent = Tools
> > -required_libraries = ProfileData Support Instrumentation
> > +required_libraries = Coverage Support Instrumentation
> > Index: tools/llvm-cov/CoverageSummaryInfo.h
> > ===================================================================
> > --- tools/llvm-cov/CoverageSummaryInfo.h
> > +++ tools/llvm-cov/CoverageSummaryInfo.h
> > @@ -15,7 +15,7 @@
> >  #ifndef LLVM_COV_COVERAGESUMMARYINFO_H
> >  #define LLVM_COV_COVERAGESUMMARYINFO_H
> >
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMapping.h"
> >  #include "llvm/Support/raw_ostream.h"
> >
> >  namespace llvm {
> > Index: tools/llvm-cov/CoverageFilters.h
> > ===================================================================
> > --- tools/llvm-cov/CoverageFilters.h
> > +++ tools/llvm-cov/CoverageFilters.h
> > @@ -14,7 +14,7 @@
> >  #ifndef LLVM_COV_COVERAGEFILTERS_H
> >  #define LLVM_COV_COVERAGEFILTERS_H
> >
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMapping.h"
> >  #include <memory>
> >  #include <vector>
> >
> > Index: tools/llvm-cov/CodeCoverage.cpp
> > ===================================================================
> > --- tools/llvm-cov/CodeCoverage.cpp
> > +++ tools/llvm-cov/CodeCoverage.cpp
> > @@ -13,15 +13,15 @@
> >  //
> >
> //===----------------------------------------------------------------------===//
> >
> > -#include "RenderingSupport.h"
> >  #include "CoverageFilters.h"
> >  #include "CoverageReport.h"
> >  #include "CoverageViewOptions.h"
> > +#include "RenderingSupport.h"
> >  #include "SourceCoverageView.h"
> >  #include "llvm/ADT/SmallString.h"
> >  #include "llvm/ADT/StringRef.h"
> >  #include "llvm/ADT/Triple.h"
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMapping.h"
> >  #include "llvm/ProfileData/InstrProfReader.h"
> >  #include "llvm/Support/CommandLine.h"
> >  #include "llvm/Support/FileSystem.h"
> > Index: tools/llvm-cov/CMakeLists.txt
> > ===================================================================
> > --- tools/llvm-cov/CMakeLists.txt
> > +++ tools/llvm-cov/CMakeLists.txt
> > @@ -1,4 +1,4 @@
> > -set(LLVM_LINK_COMPONENTS core support object profiledata)
> > +set(LLVM_LINK_COMPONENTS core support object coverage profiledata)
> >
> >  add_llvm_tool(llvm-cov
> >    llvm-cov.cpp
> > Index: lib/ProfileData/LLVMBuild.txt
> > ===================================================================
> > --- lib/ProfileData/LLVMBuild.txt
> > +++ lib/ProfileData/LLVMBuild.txt
> > @@ -15,8 +15,11 @@
> >  ;
> >
> ;===------------------------------------------------------------------------===;
> >
> > +[common]
> > +subdirectories = Coverage
> > +
> >  [component_0]
> >  type = Library
> >  name = ProfileData
> >  parent = Libraries
> > -required_libraries = Core Support Object
> > +required_libraries = Core Support
> > Index: lib/ProfileData/CoverageMappingWriter.cpp
> > ===================================================================
> > --- lib/ProfileData/CoverageMappingWriter.cpp
> > +++ lib/ProfileData/CoverageMappingWriter.cpp
> > @@ -1,183 +0,0 @@
> > -//=-- CoverageMappingWriter.cpp - Code coverage mapping writer
> -------------=//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file contains support for writing coverage mapping data for
> > -// instrumentation based coverage.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#include "llvm/ProfileData/CoverageMappingWriter.h"
> > -#include "llvm/Support/LEB128.h"
> > -
> > -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.
> > -class CounterExpressionsMinimizer {
> > -  ArrayRef<CounterExpression> Expressions;
> > -  llvm::SmallVector<CounterExpression, 16> UsedExpressions;
> > -  std::vector<unsigned> AdjustedExpressionIDs;
> > -
> > -public:
> > -  void mark(Counter C) {
> > -    if (!C.isExpression())
> > -      return;
> > -    unsigned ID = C.getExpressionID();
> > -    AdjustedExpressionIDs[ID] = 1;
> > -    mark(Expressions[ID].LHS);
> > -    mark(Expressions[ID].RHS);
> > -  }
> > -
> > -  void gatherUsed(Counter C) {
> > -    if (!C.isExpression() ||
> !AdjustedExpressionIDs[C.getExpressionID()])
> > -      return;
> > -    AdjustedExpressionIDs[C.getExpressionID()] = UsedExpressions.size();
> > -    const auto &E = Expressions[C.getExpressionID()];
> > -    UsedExpressions.push_back(E);
> > -    gatherUsed(E.LHS);
> > -    gatherUsed(E.RHS);
> > -  }
> > -
> > -  CounterExpressionsMinimizer(ArrayRef<CounterExpression> Expressions,
> > -                              ArrayRef<CounterMappingRegion>
> MappingRegions)
> > -      : Expressions(Expressions) {
> > -    AdjustedExpressionIDs.resize(Expressions.size(), 0);
> > -    for (const auto &I : MappingRegions)
> > -      mark(I.Count);
> > -    for (const auto &I : MappingRegions)
> > -      gatherUsed(I.Count);
> > -  }
> > -
> > -  ArrayRef<CounterExpression> getExpressions() const { return
> UsedExpressions; }
> > -
> > -  /// \brief Adjust the given counter to correctly transition from the
> old
> > -  /// expression ids to the new expression ids.
> > -  Counter adjust(Counter C) const {
> > -    if (C.isExpression())
> > -      C =
> Counter::getExpression(AdjustedExpressionIDs[C.getExpressionID()]);
> > -    return C;
> > -  }
> > -};
> > -}
> > -
> > -/// \brief Encode the counter.
> > -///
> > -/// The encoding uses the following format:
> > -/// Low 2 bits - Tag:
> > -///   Counter::Zero(0) - A Counter with kind Counter::Zero
> > -///   Counter::CounterValueReference(1) - A counter with kind
> > -///     Counter::CounterValueReference
> > -///   Counter::Expression(2) + CounterExpression::Subtract(0) -
> > -///     A counter with kind Counter::Expression and an expression
> > -///     with kind CounterExpression::Subtract
> > -///   Counter::Expression(2) + CounterExpression::Add(1) -
> > -///     A counter with kind Counter::Expression and an expression
> > -///     with kind CounterExpression::Add
> > -/// Remaining bits - Counter/Expression ID.
> > -static unsigned encodeCounter(ArrayRef<CounterExpression> Expressions,
> > -                              Counter C) {
> > -  unsigned Tag = unsigned(C.getKind());
> > -  if (C.isExpression())
> > -    Tag += Expressions[C.getExpressionID()].Kind;
> > -  unsigned ID = C.getCounterID();
> > -  assert(ID <=
> > -         (std::numeric_limits<unsigned>::max() >>
> Counter::EncodingTagBits));
> > -  return Tag | (ID << Counter::EncodingTagBits);
> > -}
> > -
> > -static void writeCounter(ArrayRef<CounterExpression> Expressions,
> Counter C,
> > -                         raw_ostream &OS) {
> > -  encodeULEB128(encodeCounter(Expressions, C), OS);
> > -}
> > -
> > -void CoverageMappingWriter::write(raw_ostream &OS) {
> > -  // Sort the regions in an ascending order by the file id and the
> starting
> > -  // location.
> > -  std::stable_sort(MappingRegions.begin(), MappingRegions.end());
> > -
> > -  // Write out the fileid -> filename mapping.
> > -  encodeULEB128(VirtualFileMapping.size(), OS);
> > -  for (const auto &FileID : VirtualFileMapping)
> > -    encodeULEB128(FileID, OS);
> > -
> > -  // Write out the expressions.
> > -  CounterExpressionsMinimizer Minimizer(Expressions, MappingRegions);
> > -  auto MinExpressions = Minimizer.getExpressions();
> > -  encodeULEB128(MinExpressions.size(), OS);
> > -  for (const auto &E : MinExpressions) {
> > -    writeCounter(MinExpressions, Minimizer.adjust(E.LHS), OS);
> > -    writeCounter(MinExpressions, Minimizer.adjust(E.RHS), OS);
> > -  }
> > -
> > -  // Write out the mapping regions.
> > -  // Split the regions into subarrays where each region in a
> > -  // subarray has a fileID which is the index of that subarray.
> > -  unsigned PrevLineStart = 0;
> > -  unsigned CurrentFileID = ~0U;
> > -  for (auto I = MappingRegions.begin(), E = MappingRegions.end(); I !=
> E; ++I) {
> > -    if (I->FileID != CurrentFileID) {
> > -      // Ensure that all file ids have at least one mapping region.
> > -      assert(I->FileID == (CurrentFileID + 1));
> > -      // Find the number of regions with this file id.
> > -      unsigned RegionCount = 1;
> > -      for (auto J = I + 1; J != E && I->FileID == J->FileID; ++J)
> > -        ++RegionCount;
> > -      // Start a new region sub-array.
> > -      encodeULEB128(RegionCount, OS);
> > -
> > -      CurrentFileID = I->FileID;
> > -      PrevLineStart = 0;
> > -    }
> > -    Counter Count = Minimizer.adjust(I->Count);
> > -    switch (I->Kind) {
> > -    case CounterMappingRegion::CodeRegion:
> > -      writeCounter(MinExpressions, Count, OS);
> > -      break;
> > -    case CounterMappingRegion::ExpansionRegion: {
> > -      assert(Count.isZero());
> > -      assert(I->ExpandedFileID <=
> > -             (std::numeric_limits<unsigned>::max() >>
> > -              Counter::EncodingCounterTagAndExpansionRegionTagBits));
> > -      // Mark an expansion region with a set bit that follows the
> counter tag,
> > -      // and pack the expanded file id into the remaining bits.
> > -      unsigned EncodedTagExpandedFileID =
> > -          (1 << Counter::EncodingTagBits) |
> > -          (I->ExpandedFileID
> > -           << Counter::EncodingCounterTagAndExpansionRegionTagBits);
> > -      encodeULEB128(EncodedTagExpandedFileID, OS);
> > -      break;
> > -    }
> > -    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);
> > -    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));
> > -}
> > Index: lib/ProfileData/CoverageMappingReader.cpp
> > ===================================================================
> > --- lib/ProfileData/CoverageMappingReader.cpp
> > +++ lib/ProfileData/CoverageMappingReader.cpp
> > @@ -1,619 +0,0 @@
> > -//=-- CoverageMappingReader.cpp - Code coverage mapping reader ----*-
> C++ -*-=//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file contains support for reading coverage mapping data for
> > -// instrumentation based coverage.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#include "llvm/ProfileData/CoverageMappingReader.h"
> > -#include "llvm/ADT/DenseSet.h"
> > -#include "llvm/Object/MachOUniversal.h"
> > -#include "llvm/Object/ObjectFile.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/Endian.h"
> > -#include "llvm/Support/LEB128.h"
> > -#include "llvm/Support/MathExtras.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -
> > -using namespace llvm;
> > -using namespace coverage;
> > -using namespace object;
> > -
> > -#define DEBUG_TYPE "coverage-mapping"
> > -
> > -void CoverageMappingIterator::increment() {
> > -  // Check if all the records were read or if an error occurred while
> reading
> > -  // the next record.
> > -  if (Reader->readNextRecord(Record))
> > -    *this = CoverageMappingIterator();
> > -}
> > -
> > -std::error_code RawCoverageReader::readULEB128(uint64_t &Result) {
> > -  if (Data.size() < 1)
> > -    return coveragemap_error::truncated;
> > -  unsigned N = 0;
> > -  Result = decodeULEB128(reinterpret_cast<const uint8_t
> *>(Data.data()), &N);
> > -  if (N > Data.size())
> > -    return coveragemap_error::malformed;
> > -  Data = Data.substr(N);
> > -  return std::error_code();
> > -}
> > -
> > -std::error_code RawCoverageReader::readIntMax(uint64_t &Result,
> > -                                              uint64_t MaxPlus1) {
> > -  if (auto Err = readULEB128(Result))
> > -    return Err;
> > -  if (Result >= MaxPlus1)
> > -    return coveragemap_error::malformed;
> > -  return std::error_code();
> > -}
> > -
> > -std::error_code RawCoverageReader::readSize(uint64_t &Result) {
> > -  if (auto Err = readULEB128(Result))
> > -    return Err;
> > -  // Sanity check the number.
> > -  if (Result > Data.size())
> > -    return coveragemap_error::malformed;
> > -  return std::error_code();
> > -}
> > -
> > -std::error_code RawCoverageReader::readString(StringRef &Result) {
> > -  uint64_t Length;
> > -  if (auto Err = readSize(Length))
> > -    return Err;
> > -  Result = Data.substr(0, Length);
> > -  Data = Data.substr(Length);
> > -  return std::error_code();
> > -}
> > -
> > -std::error_code RawCoverageFilenamesReader::read() {
> > -  uint64_t NumFilenames;
> > -  if (auto Err = readSize(NumFilenames))
> > -    return Err;
> > -  for (size_t I = 0; I < NumFilenames; ++I) {
> > -    StringRef Filename;
> > -    if (auto Err = readString(Filename))
> > -      return Err;
> > -    Filenames.push_back(Filename);
> > -  }
> > -  return std::error_code();
> > -}
> > -
> > -std::error_code RawCoverageMappingReader::decodeCounter(unsigned Value,
> > -                                                        Counter &C) {
> > -  auto Tag = Value & Counter::EncodingTagMask;
> > -  switch (Tag) {
> > -  case Counter::Zero:
> > -    C = Counter::getZero();
> > -    return std::error_code();
> > -  case Counter::CounterValueReference:
> > -    C = Counter::getCounter(Value >> Counter::EncodingTagBits);
> > -    return std::error_code();
> > -  default:
> > -    break;
> > -  }
> > -  Tag -= Counter::Expression;
> > -  switch (Tag) {
> > -  case CounterExpression::Subtract:
> > -  case CounterExpression::Add: {
> > -    auto ID = Value >> Counter::EncodingTagBits;
> > -    if (ID >= Expressions.size())
> > -      return coveragemap_error::malformed;
> > -    Expressions[ID].Kind = CounterExpression::ExprKind(Tag);
> > -    C = Counter::getExpression(ID);
> > -    break;
> > -  }
> > -  default:
> > -    return coveragemap_error::malformed;
> > -  }
> > -  return std::error_code();
> > -}
> > -
> > -std::error_code RawCoverageMappingReader::readCounter(Counter &C) {
> > -  uint64_t EncodedCounter;
> > -  if (auto Err =
> > -          readIntMax(EncodedCounter,
> std::numeric_limits<unsigned>::max()))
> > -    return Err;
> > -  if (auto Err = decodeCounter(EncodedCounter, C))
> > -    return Err;
> > -  return std::error_code();
> > -}
> > -
> > -static const unsigned EncodingExpansionRegionBit = 1
> > -                                                   <<
> Counter::EncodingTagBits;
> > -
> > -/// \brief Read the sub-array of regions for the given inferred file id.
> > -/// \param NumFileIDs the number of file ids that are defined for this
> > -/// function.
> > -std::error_code RawCoverageMappingReader::readMappingRegionsSubArray(
> > -    std::vector<CounterMappingRegion> &MappingRegions, unsigned
> InferredFileID,
> > -    size_t NumFileIDs) {
> > -  uint64_t NumRegions;
> > -  if (auto Err = readSize(NumRegions))
> > -    return Err;
> > -  unsigned LineStart = 0;
> > -  for (size_t I = 0; I < NumRegions; ++I) {
> > -    Counter C;
> > -    CounterMappingRegion::RegionKind Kind =
> CounterMappingRegion::CodeRegion;
> > -
> > -    // Read the combined counter + region kind.
> > -    uint64_t EncodedCounterAndRegion;
> > -    if (auto Err = readIntMax(EncodedCounterAndRegion,
> > -                              std::numeric_limits<unsigned>::max()))
> > -      return Err;
> > -    unsigned Tag = EncodedCounterAndRegion & Counter::EncodingTagMask;
> > -    uint64_t ExpandedFileID = 0;
> > -    if (Tag != Counter::Zero) {
> > -      if (auto Err = decodeCounter(EncodedCounterAndRegion, C))
> > -        return Err;
> > -    } else {
> > -      // Is it an expansion region?
> > -      if (EncodedCounterAndRegion & EncodingExpansionRegionBit) {
> > -        Kind = CounterMappingRegion::ExpansionRegion;
> > -        ExpandedFileID = EncodedCounterAndRegion >>
> > -
>  Counter::EncodingCounterTagAndExpansionRegionTagBits;
> > -        if (ExpandedFileID >= NumFileIDs)
> > -          return coveragemap_error::malformed;
> > -      } else {
> > -        switch (EncodedCounterAndRegion >>
> > -                Counter::EncodingCounterTagAndExpansionRegionTagBits) {
> > -        case CounterMappingRegion::CodeRegion:
> > -          // Don't do anything when we have a code region with a zero
> counter.
> > -          break;
> > -        case CounterMappingRegion::SkippedRegion:
> > -          Kind = CounterMappingRegion::SkippedRegion;
> > -          break;
> > -        default:
> > -          return coveragemap_error::malformed;
> > -        }
> > -      }
> > -    }
> > -
> > -    // Read the source range.
> > -    uint64_t LineStartDelta, ColumnStart, NumLines, ColumnEnd;
> > -    if (auto Err =
> > -            readIntMax(LineStartDelta,
> std::numeric_limits<unsigned>::max()))
> > -      return Err;
> > -    if (auto Err = readULEB128(ColumnStart))
> > -      return Err;
> > -    if (ColumnStart > std::numeric_limits<unsigned>::max())
> > -      return coveragemap_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();
> > -    }
> > -
> > -    DEBUG({
> > -      dbgs() << "Counter in file " << InferredFileID << " " <<
> LineStart << ":"
> > -             << ColumnStart << " -> " << (LineStart + NumLines) << ":"
> > -             << ColumnEnd << ", ";
> > -      if (Kind == CounterMappingRegion::ExpansionRegion)
> > -        dbgs() << "Expands to file " << ExpandedFileID;
> > -      else
> > -        CounterMappingContext(Expressions).dump(C, dbgs());
> > -      dbgs() << "\n";
> > -    });
> > -
> > -    MappingRegions.push_back(CounterMappingRegion(
> > -        C, InferredFileID, ExpandedFileID, LineStart, ColumnStart,
> > -        LineStart + NumLines, ColumnEnd, Kind));
> > -  }
> > -  return std::error_code();
> > -}
> > -
> > -std::error_code RawCoverageMappingReader::read() {
> > -
> > -  // Read the virtual file mapping.
> > -  llvm::SmallVector<unsigned, 8> VirtualFileMapping;
> > -  uint64_t NumFileMappings;
> > -  if (auto Err = readSize(NumFileMappings))
> > -    return Err;
> > -  for (size_t I = 0; I < NumFileMappings; ++I) {
> > -    uint64_t FilenameIndex;
> > -    if (auto Err = readIntMax(FilenameIndex,
> TranslationUnitFilenames.size()))
> > -      return Err;
> > -    VirtualFileMapping.push_back(FilenameIndex);
> > -  }
> > -
> > -  // Construct the files using unique filenames and virtual file
> mapping.
> > -  for (auto I : VirtualFileMapping) {
> > -    Filenames.push_back(TranslationUnitFilenames[I]);
> > -  }
> > -
> > -  // Read the expressions.
> > -  uint64_t NumExpressions;
> > -  if (auto Err = readSize(NumExpressions))
> > -    return Err;
> > -  // Create an array of dummy expressions that get the proper counters
> > -  // when the expressions are read, and the proper kinds when the
> counters
> > -  // are decoded.
> > -  Expressions.resize(
> > -      NumExpressions,
> > -      CounterExpression(CounterExpression::Subtract, Counter(),
> Counter()));
> > -  for (size_t I = 0; I < NumExpressions; ++I) {
> > -    if (auto Err = readCounter(Expressions[I].LHS))
> > -      return Err;
> > -    if (auto Err = readCounter(Expressions[I].RHS))
> > -      return Err;
> > -  }
> > -
> > -  // Read the mapping regions sub-arrays.
> > -  for (unsigned InferredFileID = 0, S = VirtualFileMapping.size();
> > -       InferredFileID < S; ++InferredFileID) {
> > -    if (auto Err = readMappingRegionsSubArray(MappingRegions,
> InferredFileID,
> > -
> VirtualFileMapping.size()))
> > -      return Err;
> > -  }
> > -
> > -  // Set the counters for the expansion regions.
> > -  // i.e. Counter of expansion region = counter of the first region
> > -  // from the expanded file.
> > -  // Perform multiple passes to correctly propagate the counters through
> > -  // all the nested expansion regions.
> > -  SmallVector<CounterMappingRegion *, 8> FileIDExpansionRegionMapping;
> > -  FileIDExpansionRegionMapping.resize(VirtualFileMapping.size(),
> nullptr);
> > -  for (unsigned Pass = 1, S = VirtualFileMapping.size(); Pass < S;
> ++Pass) {
> > -    for (auto &R : MappingRegions) {
> > -      if (R.Kind != CounterMappingRegion::ExpansionRegion)
> > -        continue;
> > -      assert(!FileIDExpansionRegionMapping[R.ExpandedFileID]);
> > -      FileIDExpansionRegionMapping[R.ExpandedFileID] = &R;
> > -    }
> > -    for (auto &R : MappingRegions) {
> > -      if (FileIDExpansionRegionMapping[R.FileID]) {
> > -        FileIDExpansionRegionMapping[R.FileID]->Count = R.Count;
> > -        FileIDExpansionRegionMapping[R.FileID] = nullptr;
> > -      }
> > -    }
> > -  }
> > -
> > -  return std::error_code();
> > -}
> > -
> > -std::error_code InstrProfSymtab::create(SectionRef &Section) {
> > -  if (auto Err = Section.getContents(Data))
> > -    return Err;
> > -  Address = Section.getAddress();
> > -  return std::error_code();
> > -}
> > -
> > -StringRef InstrProfSymtab::getFuncName(uint64_t Pointer, size_t Size) {
> > -  if (Pointer < Address)
> > -    return StringRef();
> > -  auto Offset = Pointer - Address;
> > -  if (Offset + Size > Data.size())
> > -    return StringRef();
> > -  return Data.substr(Pointer - Address, Size);
> > -}
> > -
> > -namespace {
> > -struct CovMapFuncRecordReader {
> > -  // The interface to read coverage mapping function records for
> > -  // a module. \p Buf is a reference to the buffer pointer pointing
> > -  // to the \c CovHeader of coverage mapping data associated with
> > -  // the module.
> > -  virtual std::error_code readFunctionRecords(const char *&Buf,
> > -                                              const char *End) = 0;
> > -  virtual ~CovMapFuncRecordReader() {}
> > -  template <class IntPtrT, support::endianness Endian>
> > -  static std::unique_ptr<CovMapFuncRecordReader>
> > -  get(coverage::CovMapVersion Version, InstrProfSymtab &P,
> > -      std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
> > -      std::vector<StringRef> &F);
> > -};
> > -
> > -// A class for reading coverage mapping function records for a module.
> > -template <coverage::CovMapVersion Version, class IntPtrT,
> > -          support::endianness Endian>
> > -class VersionedCovMapFuncRecordReader : public CovMapFuncRecordReader {
> > -  typedef typename coverage::CovMapTraits<
> > -      Version, IntPtrT>::CovMapFuncRecordType FuncRecordType;
> > -  typedef typename coverage::CovMapTraits<Version, IntPtrT>::NameRefType
> > -      NameRefType;
> > -
> > -  llvm::DenseSet<NameRefType> UniqueFunctionMappingData;
> > -  InstrProfSymtab &ProfileNames;
> > -  std::vector<StringRef> &Filenames;
> > -  std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records;
> > -
> > -public:
> > -  VersionedCovMapFuncRecordReader(
> > -      InstrProfSymtab &P,
> > -      std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
> > -      std::vector<StringRef> &F)
> > -      : ProfileNames(P), Filenames(F), Records(R) {}
> > -  ~VersionedCovMapFuncRecordReader() override {}
> > -
> > -  std::error_code readFunctionRecords(const char *&Buf,
> > -                                      const char *End) override {
> > -    using namespace support;
> > -    if (Buf + sizeof(CovMapHeader) > End)
> > -      return coveragemap_error::malformed;
> > -    auto CovHeader = reinterpret_cast<const coverage::CovMapHeader
> *>(Buf);
> > -    uint32_t NRecords = CovHeader->getNRecords<Endian>();
> > -    uint32_t FilenamesSize = CovHeader->getFilenamesSize<Endian>();
> > -    uint32_t CoverageSize = CovHeader->getCoverageSize<Endian>();
> > -    assert((CovMapVersion)CovHeader->getVersion<Endian>() == Version);
> > -    Buf = reinterpret_cast<const char *>(CovHeader + 1);
> > -
> > -    // Skip past the function records, saving the start and end for
> later.
> > -    const char *FunBuf = Buf;
> > -    Buf += NRecords * sizeof(FuncRecordType);
> > -    const char *FunEnd = Buf;
> > -
> > -    // Get the filenames.
> > -    if (Buf + FilenamesSize > End)
> > -      return coveragemap_error::malformed;
> > -    size_t FilenamesBegin = Filenames.size();
> > -    RawCoverageFilenamesReader Reader(StringRef(Buf, FilenamesSize),
> Filenames);
> > -    if (auto Err = Reader.read())
> > -      return Err;
> > -    Buf += FilenamesSize;
> > -
> > -    // We'll read the coverage mapping records in the loop below.
> > -    const char *CovBuf = Buf;
> > -    Buf += CoverageSize;
> > -    const char *CovEnd = Buf;
> > -
> > -    if (Buf > End)
> > -      return coveragemap_error::malformed;
> > -    // Each coverage map has an alignment of 8, so we need to adjust
> alignment
> > -    // before reading the next map.
> > -    Buf += alignmentAdjustment(Buf, 8);
> > -
> > -    auto CFR = reinterpret_cast<const FuncRecordType *>(FunBuf);
> > -    while ((const char *)CFR < FunEnd) {
> > -      // Read the function information
> > -      uint32_t DataSize = CFR->template getDataSize<Endian>();
> > -      uint64_t FuncHash = CFR->template getFuncHash<Endian>();
> > -
> > -      // Now use that to read the coverage data.
> > -      if (CovBuf + DataSize > CovEnd)
> > -        return coveragemap_error::malformed;
> > -      auto Mapping = StringRef(CovBuf, DataSize);
> > -      CovBuf += DataSize;
> > -
> > -      // Ignore this record if we already have a record that points to
> the same
> > -      // function name. This is useful to ignore the redundant records
> for the
> > -      // functions with ODR linkage.
> > -      NameRefType NameRef = CFR->template getFuncNameRef<Endian>();
> > -      if (!UniqueFunctionMappingData.insert(NameRef).second) {
> > -        CFR++;
> > -        continue;
> > -      }
> > -
> > -      StringRef FuncName;
> > -      if (std::error_code EC =
> > -              CFR->template getFuncName<Endian>(ProfileNames, FuncName))
> > -        return EC;
> > -      Records.push_back(BinaryCoverageReader::ProfileMappingRecord(
> > -          Version, FuncName, FuncHash, Mapping, FilenamesBegin,
> > -          Filenames.size() - FilenamesBegin));
> > -      CFR++;
> > -    }
> > -    return std::error_code();
> > -  }
> > -};
> > -} // end anonymous namespace
> > -
> > -template <class IntPtrT, support::endianness Endian>
> > -std::unique_ptr<CovMapFuncRecordReader> CovMapFuncRecordReader::get(
> > -    coverage::CovMapVersion Version, InstrProfSymtab &P,
> > -    std::vector<BinaryCoverageReader::ProfileMappingRecord> &R,
> > -    std::vector<StringRef> &F) {
> > -  using namespace coverage;
> > -  switch (Version) {
> > -  case CovMapVersion::Version1:
> > -    return llvm::make_unique<VersionedCovMapFuncRecordReader<
> > -        CovMapVersion::Version1, IntPtrT, Endian>>(P, R, F);
> > -  case CovMapVersion::Version2:
> > -    // Decompress the name data.
> > -    P.create(P.getNameData());
> > -    return llvm::make_unique<VersionedCovMapFuncRecordReader<
> > -        CovMapVersion::Version2, IntPtrT, Endian>>(P, R, F);
> > -  }
> > -  llvm_unreachable("Unsupported version");
> > -}
> > -
> > -template <typename T, support::endianness Endian>
> > -static std::error_code readCoverageMappingData(
> > -    InstrProfSymtab &ProfileNames, StringRef Data,
> > -    std::vector<BinaryCoverageReader::ProfileMappingRecord> &Records,
> > -    std::vector<StringRef> &Filenames) {
> > -  using namespace coverage;
> > -  // Read the records in the coverage data section.
> > -  auto CovHeader =
> > -      reinterpret_cast<const coverage::CovMapHeader *>(Data.data());
> > -  CovMapVersion Version =
> (CovMapVersion)CovHeader->getVersion<Endian>();
> > -  if (Version > coverage::CovMapVersion::CurrentVersion)
> > -    return coveragemap_error::unsupported_version;
> > -  std::unique_ptr<CovMapFuncRecordReader> Reader =
> > -      CovMapFuncRecordReader::get<T, Endian>(Version, ProfileNames,
> Records,
> > -                                             Filenames);
> > -  for (const char *Buf = Data.data(), *End = Buf + Data.size(); Buf <
> End;) {
> > -    if (std::error_code EC = Reader->readFunctionRecords(Buf, End))
> > -      return EC;
> > -  }
> > -  return std::error_code();
> > -}
> > -static const char *TestingFormatMagic = "llvmcovmtestdata";
> > -
> > -static std::error_code loadTestingFormat(StringRef Data,
> > -                                         InstrProfSymtab &ProfileNames,
> > -                                         StringRef &CoverageMapping,
> > -                                         uint8_t &BytesInAddress,
> > -                                         support::endianness &Endian) {
> > -  BytesInAddress = 8;
> > -  Endian = support::endianness::little;
> > -
> > -  Data = Data.substr(StringRef(TestingFormatMagic).size());
> > -  if (Data.size() < 1)
> > -    return coveragemap_error::truncated;
> > -  unsigned N = 0;
> > -  auto ProfileNamesSize =
> > -      decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
> > -  if (N > Data.size())
> > -    return coveragemap_error::malformed;
> > -  Data = Data.substr(N);
> > -  if (Data.size() < 1)
> > -    return coveragemap_error::truncated;
> > -  N = 0;
> > -  uint64_t Address =
> > -      decodeULEB128(reinterpret_cast<const uint8_t *>(Data.data()), &N);
> > -  if (N > Data.size())
> > -    return coveragemap_error::malformed;
> > -  Data = Data.substr(N);
> > -  if (Data.size() < ProfileNamesSize)
> > -    return coveragemap_error::malformed;
> > -  ProfileNames.create(Data.substr(0, ProfileNamesSize), Address);
> > -  CoverageMapping = Data.substr(ProfileNamesSize);
> > -  return std::error_code();
> > -}
> > -
> > -static ErrorOr<SectionRef> lookupSection(ObjectFile &OF, StringRef
> Name) {
> > -  StringRef FoundName;
> > -  for (const auto &Section : OF.sections()) {
> > -    if (auto EC = Section.getName(FoundName))
> > -      return EC;
> > -    if (FoundName == Name)
> > -      return Section;
> > -  }
> > -  return coveragemap_error::no_data_found;
> > -}
> > -
> > -static std::error_code
> > -loadBinaryFormat(MemoryBufferRef ObjectBuffer, InstrProfSymtab
> &ProfileNames,
> > -                 StringRef &CoverageMapping, uint8_t &BytesInAddress,
> > -                 support::endianness &Endian, StringRef Arch) {
> > -  auto BinOrErr = object::createBinary(ObjectBuffer);
> > -  if (!BinOrErr)
> > -    return errorToErrorCode(BinOrErr.takeError());
> > -  auto Bin = std::move(BinOrErr.get());
> > -  std::unique_ptr<ObjectFile> OF;
> > -  if (auto *Universal =
> dyn_cast<object::MachOUniversalBinary>(Bin.get())) {
> > -    // If we have a universal binary, try to look up the object for the
> > -    // appropriate architecture.
> > -    auto ObjectFileOrErr = Universal->getObjectForArch(Arch);
> > -    if (std::error_code EC = ObjectFileOrErr.getError())
> > -      return EC;
> > -    OF = std::move(ObjectFileOrErr.get());
> > -  } else if (isa<object::ObjectFile>(Bin.get())) {
> > -    // For any other object file, upcast and take ownership.
> > -    OF.reset(cast<object::ObjectFile>(Bin.release()));
> > -    // If we've asked for a particular arch, make sure they match.
> > -    if (!Arch.empty() && OF->getArch() != Triple(Arch).getArch())
> > -      return object_error::arch_not_found;
> > -  } else
> > -    // We can only handle object files.
> > -    return coveragemap_error::malformed;
> > -
> > -  // The coverage uses native pointer sizes for the object it's written
> in.
> > -  BytesInAddress = OF->getBytesInAddress();
> > -  Endian = OF->isLittleEndian() ? support::endianness::little
> > -                                : support::endianness::big;
> > -
> > -  // Look for the sections that we are interested in.
> > -  auto NamesSection = lookupSection(*OF,
> getInstrProfNameSectionName(false));
> > -  if (auto EC = NamesSection.getError())
> > -    return EC;
> > -  auto CoverageSection =
> > -      lookupSection(*OF, getInstrProfCoverageSectionName(false));
> > -  if (auto EC = CoverageSection.getError())
> > -    return EC;
> > -
> > -  // Get the contents of the given sections.
> > -  if (std::error_code EC =
> CoverageSection->getContents(CoverageMapping))
> > -    return EC;
> > -  if (std::error_code EC = ProfileNames.create(*NamesSection))
> > -    return EC;
> > -
> > -  return std::error_code();
> > -}
> > -
> > -ErrorOr<std::unique_ptr<BinaryCoverageReader>>
> > -BinaryCoverageReader::create(std::unique_ptr<MemoryBuffer>
> &ObjectBuffer,
> > -                             StringRef Arch) {
> > -  std::unique_ptr<BinaryCoverageReader> Reader(new
> BinaryCoverageReader());
> > -
> > -  StringRef Coverage;
> > -  uint8_t BytesInAddress;
> > -  support::endianness Endian;
> > -  std::error_code EC;
> > -  if (ObjectBuffer->getBuffer().startswith(TestingFormatMagic))
> > -    // This is a special format used for testing.
> > -    EC = loadTestingFormat(ObjectBuffer->getBuffer(),
> Reader->ProfileNames,
> > -                           Coverage, BytesInAddress, Endian);
> > -  else
> > -    EC = loadBinaryFormat(ObjectBuffer->getMemBufferRef(),
> Reader->ProfileNames,
> > -                          Coverage, BytesInAddress, Endian, Arch);
> > -  if (EC)
> > -    return EC;
> > -
> > -  if (BytesInAddress == 4 && Endian == support::endianness::little)
> > -    EC = readCoverageMappingData<uint32_t, support::endianness::little>(
> > -        Reader->ProfileNames, Coverage, Reader->MappingRecords,
> > -        Reader->Filenames);
> > -  else if (BytesInAddress == 4 && Endian == support::endianness::big)
> > -    EC = readCoverageMappingData<uint32_t, support::endianness::big>(
> > -        Reader->ProfileNames, Coverage, Reader->MappingRecords,
> > -        Reader->Filenames);
> > -  else if (BytesInAddress == 8 && Endian == support::endianness::little)
> > -    EC = readCoverageMappingData<uint64_t, support::endianness::little>(
> > -        Reader->ProfileNames, Coverage, Reader->MappingRecords,
> > -        Reader->Filenames);
> > -  else if (BytesInAddress == 8 && Endian == support::endianness::big)
> > -    EC = readCoverageMappingData<uint64_t, support::endianness::big>(
> > -        Reader->ProfileNames, Coverage, Reader->MappingRecords,
> > -        Reader->Filenames);
> > -  else
> > -    return coveragemap_error::malformed;
> > -  if (EC)
> > -    return EC;
> > -  return std::move(Reader);
> > -}
> > -
> > -std::error_code
> > -BinaryCoverageReader::readNextRecord(CoverageMappingRecord &Record) {
> > -  if (CurrentRecord >= MappingRecords.size())
> > -    return coveragemap_error::eof;
> > -
> > -  FunctionsFilenames.clear();
> > -  Expressions.clear();
> > -  MappingRegions.clear();
> > -  auto &R = MappingRecords[CurrentRecord];
> > -  RawCoverageMappingReader Reader(
> > -      R.CoverageMapping,
> > -      makeArrayRef(Filenames).slice(R.FilenamesBegin, R.FilenamesSize),
> > -      FunctionsFilenames, Expressions, MappingRegions);
> > -  if (auto Err = Reader.read())
> > -    return Err;
> > -
> > -  Record.FunctionName = R.FunctionName;
> > -  Record.FunctionHash = R.FunctionHash;
> > -  Record.Filenames = FunctionsFilenames;
> > -  Record.Expressions = Expressions;
> > -  Record.MappingRegions = MappingRegions;
> > -
> > -  ++CurrentRecord;
> > -  return std::error_code();
> > -}
> > Index: lib/ProfileData/CoverageMapping.cpp
> > ===================================================================
> > --- lib/ProfileData/CoverageMapping.cpp
> > +++ lib/ProfileData/CoverageMapping.cpp
> > @@ -1,527 +0,0 @@
> > -//=-- CoverageMapping.cpp - Code coverage mapping support ---------*-
> C++ -*-=//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file contains support for clang's and llvm's instrumentation
> based
> > -// code coverage.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > -#include "llvm/ADT/DenseMap.h"
> > -#include "llvm/ADT/Optional.h"
> > -#include "llvm/ADT/SmallBitVector.h"
> > -#include "llvm/ProfileData/CoverageMappingReader.h"
> > -#include "llvm/ProfileData/InstrProfReader.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/Errc.h"
> > -#include "llvm/Support/ErrorHandling.h"
> > -#include "llvm/Support/ManagedStatic.h"
> > -#include "llvm/Support/Path.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -
> > -using namespace llvm;
> > -using namespace coverage;
> > -
> > -#define DEBUG_TYPE "coverage-mapping"
> > -
> > -Counter CounterExpressionBuilder::get(const CounterExpression &E) {
> > -  auto It = ExpressionIndices.find(E);
> > -  if (It != ExpressionIndices.end())
> > -    return Counter::getExpression(It->second);
> > -  unsigned I = Expressions.size();
> > -  Expressions.push_back(E);
> > -  ExpressionIndices[E] = I;
> > -  return Counter::getExpression(I);
> > -}
> > -
> > -void CounterExpressionBuilder::extractTerms(
> > -    Counter C, int Sign, SmallVectorImpl<std::pair<unsigned, int>>
> &Terms) {
> > -  switch (C.getKind()) {
> > -  case Counter::Zero:
> > -    break;
> > -  case Counter::CounterValueReference:
> > -    Terms.push_back(std::make_pair(C.getCounterID(), Sign));
> > -    break;
> > -  case Counter::Expression:
> > -    const auto &E = Expressions[C.getExpressionID()];
> > -    extractTerms(E.LHS, Sign, Terms);
> > -    extractTerms(E.RHS, E.Kind == CounterExpression::Subtract ? -Sign :
> Sign,
> > -                 Terms);
> > -    break;
> > -  }
> > -}
> > -
> > -Counter CounterExpressionBuilder::simplify(Counter ExpressionTree) {
> > -  // Gather constant terms.
> > -  llvm::SmallVector<std::pair<unsigned, int>, 32> Terms;
> > -  extractTerms(ExpressionTree, +1, Terms);
> > -
> > -  // If there are no terms, this is just a zero. The algorithm below
> assumes at
> > -  // least one term.
> > -  if (Terms.size() == 0)
> > -    return Counter::getZero();
> > -
> > -  // Group the terms by counter ID.
> > -  std::sort(Terms.begin(), Terms.end(),
> > -            [](const std::pair<unsigned, int> &LHS,
> > -               const std::pair<unsigned, int> &RHS) {
> > -    return LHS.first < RHS.first;
> > -  });
> > -
> > -  // Combine terms by counter ID to eliminate counters that sum to zero.
> > -  auto Prev = Terms.begin();
> > -  for (auto I = Prev + 1, E = Terms.end(); I != E; ++I) {
> > -    if (I->first == Prev->first) {
> > -      Prev->second += I->second;
> > -      continue;
> > -    }
> > -    ++Prev;
> > -    *Prev = *I;
> > -  }
> > -  Terms.erase(++Prev, Terms.end());
> > -
> > -  Counter C;
> > -  // Create additions. We do this before subtractions to avoid
> constructs like
> > -  // ((0 - X) + Y), as opposed to (Y - X).
> > -  for (auto Term : Terms) {
> > -    if (Term.second <= 0)
> > -      continue;
> > -    for (int I = 0; I < Term.second; ++I)
> > -      if (C.isZero())
> > -        C = Counter::getCounter(Term.first);
> > -      else
> > -        C = get(CounterExpression(CounterExpression::Add, C,
> > -                                  Counter::getCounter(Term.first)));
> > -  }
> > -
> > -  // Create subtractions.
> > -  for (auto Term : Terms) {
> > -    if (Term.second >= 0)
> > -      continue;
> > -    for (int I = 0; I < -Term.second; ++I)
> > -      C = get(CounterExpression(CounterExpression::Subtract, C,
> > -                                Counter::getCounter(Term.first)));
> > -  }
> > -  return C;
> > -}
> > -
> > -Counter CounterExpressionBuilder::add(Counter LHS, Counter RHS) {
> > -  return simplify(get(CounterExpression(CounterExpression::Add, LHS,
> RHS)));
> > -}
> > -
> > -Counter CounterExpressionBuilder::subtract(Counter LHS, Counter RHS) {
> > -  return simplify(
> > -      get(CounterExpression(CounterExpression::Subtract, LHS, RHS)));
> > -}
> > -
> > -void CounterMappingContext::dump(const Counter &C,
> > -                                 llvm::raw_ostream &OS) const {
> > -  switch (C.getKind()) {
> > -  case Counter::Zero:
> > -    OS << '0';
> > -    return;
> > -  case Counter::CounterValueReference:
> > -    OS << '#' << C.getCounterID();
> > -    break;
> > -  case Counter::Expression: {
> > -    if (C.getExpressionID() >= Expressions.size())
> > -      return;
> > -    const auto &E = Expressions[C.getExpressionID()];
> > -    OS << '(';
> > -    dump(E.LHS, OS);
> > -    OS << (E.Kind == CounterExpression::Subtract ? " - " : " + ");
> > -    dump(E.RHS, OS);
> > -    OS << ')';
> > -    break;
> > -  }
> > -  }
> > -  if (CounterValues.empty())
> > -    return;
> > -  ErrorOr<int64_t> Value = evaluate(C);
> > -  if (!Value)
> > -    return;
> > -  OS << '[' << *Value << ']';
> > -}
> > -
> > -ErrorOr<int64_t> CounterMappingContext::evaluate(const Counter &C)
> const {
> > -  switch (C.getKind()) {
> > -  case Counter::Zero:
> > -    return 0;
> > -  case Counter::CounterValueReference:
> > -    if (C.getCounterID() >= CounterValues.size())
> > -      return make_error_code(errc::argument_out_of_domain);
> > -    return CounterValues[C.getCounterID()];
> > -  case Counter::Expression: {
> > -    if (C.getExpressionID() >= Expressions.size())
> > -      return make_error_code(errc::argument_out_of_domain);
> > -    const auto &E = Expressions[C.getExpressionID()];
> > -    ErrorOr<int64_t> LHS = evaluate(E.LHS);
> > -    if (!LHS)
> > -      return LHS;
> > -    ErrorOr<int64_t> RHS = evaluate(E.RHS);
> > -    if (!RHS)
> > -      return RHS;
> > -    return E.Kind == CounterExpression::Subtract ? *LHS - *RHS : *LHS +
> *RHS;
> > -  }
> > -  }
> > -  llvm_unreachable("Unhandled CounterKind");
> > -}
> > -
> > -void FunctionRecordIterator::skipOtherFiles() {
> > -  while (Current != Records.end() && !Filename.empty() &&
> > -         Filename != Current->Filenames[0])
> > -    ++Current;
> > -  if (Current == Records.end())
> > -    *this = FunctionRecordIterator();
> > -}
> > -
> > -ErrorOr<std::unique_ptr<CoverageMapping>>
> > -CoverageMapping::load(CoverageMappingReader &CoverageReader,
> > -                      IndexedInstrProfReader &ProfileReader) {
> > -  auto Coverage = std::unique_ptr<CoverageMapping>(new
> CoverageMapping());
> > -
> > -  std::vector<uint64_t> Counts;
> > -  for (const auto &Record : CoverageReader) {
> > -    CounterMappingContext Ctx(Record.Expressions);
> > -
> > -    Counts.clear();
> > -    if (std::error_code EC = ProfileReader.getFunctionCounts(
> > -            Record.FunctionName, Record.FunctionHash, Counts)) {
> > -      if (EC == instrprof_error::hash_mismatch) {
> > -        Coverage->MismatchedFunctionCount++;
> > -        continue;
> > -      } else if (EC != instrprof_error::unknown_function)
> > -        return EC;
> > -      Counts.assign(Record.MappingRegions.size(), 0);
> > -    }
> > -    Ctx.setCounts(Counts);
> > -
> > -    assert(!Record.MappingRegions.empty() && "Function has no regions");
> > -
> > -    StringRef OrigFuncName = Record.FunctionName;
> > -    if (Record.Filenames.empty())
> > -      OrigFuncName = getFuncNameWithoutPrefix(OrigFuncName);
> > -    else
> > -      OrigFuncName =
> > -          getFuncNameWithoutPrefix(OrigFuncName, Record.Filenames[0]);
> > -    FunctionRecord Function(OrigFuncName, Record.Filenames);
> > -    for (const auto &Region : Record.MappingRegions) {
> > -      ErrorOr<int64_t> ExecutionCount = Ctx.evaluate(Region.Count);
> > -      if (!ExecutionCount)
> > -        break;
> > -      Function.pushRegion(Region, *ExecutionCount);
> > -    }
> > -    if (Function.CountedRegions.size() != Record.MappingRegions.size())
> {
> > -      Coverage->MismatchedFunctionCount++;
> > -      continue;
> > -    }
> > -
> > -    Coverage->Functions.push_back(std::move(Function));
> > -  }
> > -
> > -  return std::move(Coverage);
> > -}
> > -
> > -ErrorOr<std::unique_ptr<CoverageMapping>>
> > -CoverageMapping::load(StringRef ObjectFilename, StringRef
> ProfileFilename,
> > -                      StringRef Arch) {
> > -  auto CounterMappingBuff =
> MemoryBuffer::getFileOrSTDIN(ObjectFilename);
> > -  if (std::error_code EC = CounterMappingBuff.getError())
> > -    return EC;
> > -  auto CoverageReaderOrErr =
> > -      BinaryCoverageReader::create(CounterMappingBuff.get(), Arch);
> > -  if (std::error_code EC = CoverageReaderOrErr.getError())
> > -    return EC;
> > -  auto CoverageReader = std::move(CoverageReaderOrErr.get());
> > -  auto ProfileReaderOrErr =
> IndexedInstrProfReader::create(ProfileFilename);
> > -  if (auto EC = ProfileReaderOrErr.getError())
> > -    return EC;
> > -  auto ProfileReader = std::move(ProfileReaderOrErr.get());
> > -  return load(*CoverageReader, *ProfileReader);
> > -}
> > -
> > -namespace {
> > -/// \brief Distributes functions into instantiation sets.
> > -///
> > -/// An instantiation set is a collection of functions that have the
> same source
> > -/// code, ie, template functions specializations.
> > -class FunctionInstantiationSetCollector {
> > -  typedef DenseMap<std::pair<unsigned, unsigned>,
> > -                   std::vector<const FunctionRecord *>> MapT;
> > -  MapT InstantiatedFunctions;
> > -
> > -public:
> > -  void insert(const FunctionRecord &Function, unsigned FileID) {
> > -    auto I = Function.CountedRegions.begin(), E =
> Function.CountedRegions.end();
> > -    while (I != E && I->FileID != FileID)
> > -      ++I;
> > -    assert(I != E && "function does not cover the given file");
> > -    auto &Functions = InstantiatedFunctions[I->startLoc()];
> > -    Functions.push_back(&Function);
> > -  }
> > -
> > -  MapT::iterator begin() { return InstantiatedFunctions.begin(); }
> > -
> > -  MapT::iterator end() { return InstantiatedFunctions.end(); }
> > -};
> > -
> > -class SegmentBuilder {
> > -  std::vector<CoverageSegment> &Segments;
> > -  SmallVector<const CountedRegion *, 8> ActiveRegions;
> > -
> > -  SegmentBuilder(std::vector<CoverageSegment> &Segments) :
> Segments(Segments) {}
> > -
> > -  /// Start a segment with no count specified.
> > -  void startSegment(unsigned Line, unsigned Col) {
> > -    DEBUG(dbgs() << "Top level segment at " << Line << ":" << Col <<
> "\n");
> > -    Segments.emplace_back(Line, Col, /*IsRegionEntry=*/false);
> > -  }
> > -
> > -  /// Start a segment with the given Region's count.
> > -  void startSegment(unsigned Line, unsigned Col, bool IsRegionEntry,
> > -                    const CountedRegion &Region) {
> > -    if (Segments.empty())
> > -      Segments.emplace_back(Line, Col, IsRegionEntry);
> > -    CoverageSegment S = Segments.back();
> > -    // Avoid creating empty regions.
> > -    if (S.Line != Line || S.Col != Col) {
> > -      Segments.emplace_back(Line, Col, IsRegionEntry);
> > -      S = Segments.back();
> > -    }
> > -    DEBUG(dbgs() << "Segment at " << Line << ":" << Col);
> > -    // Set this region's count.
> > -    if (Region.Kind != coverage::CounterMappingRegion::SkippedRegion) {
> > -      DEBUG(dbgs() << " with count " << Region.ExecutionCount);
> > -      Segments.back().setCount(Region.ExecutionCount);
> > -    }
> > -    DEBUG(dbgs() << "\n");
> > -  }
> > -
> > -  /// Start a segment for the given region.
> > -  void startSegment(const CountedRegion &Region) {
> > -    startSegment(Region.LineStart, Region.ColumnStart, true, Region);
> > -  }
> > -
> > -  /// Pop the top region off of the active stack, starting a new
> segment with
> > -  /// the containing Region's count.
> > -  void popRegion() {
> > -    const CountedRegion *Active = ActiveRegions.back();
> > -    unsigned Line = Active->LineEnd, Col = Active->ColumnEnd;
> > -    ActiveRegions.pop_back();
> > -    if (ActiveRegions.empty())
> > -      startSegment(Line, Col);
> > -    else
> > -      startSegment(Line, Col, false, *ActiveRegions.back());
> > -  }
> > -
> > -  void buildSegmentsImpl(ArrayRef<CountedRegion> Regions) {
> > -    const CountedRegion *PrevRegion = nullptr;
> > -    for (const auto &Region : Regions) {
> > -      // Pop any regions that end before this one starts.
> > -      while (!ActiveRegions.empty() &&
> > -             ActiveRegions.back()->endLoc() <= Region.startLoc())
> > -        popRegion();
> > -      if (PrevRegion && PrevRegion->startLoc() == Region.startLoc() &&
> > -          PrevRegion->endLoc() == Region.endLoc()) {
> > -        if (Region.Kind == coverage::CounterMappingRegion::CodeRegion)
> > -          Segments.back().addCount(Region.ExecutionCount);
> > -      } else {
> > -        // Add this region to the stack.
> > -        ActiveRegions.push_back(&Region);
> > -        startSegment(Region);
> > -      }
> > -      PrevRegion = &Region;
> > -    }
> > -    // Pop any regions that are left in the stack.
> > -    while (!ActiveRegions.empty())
> > -      popRegion();
> > -  }
> > -
> > -public:
> > -  /// Build a list of CoverageSegments from a sorted list of Regions.
> > -  static std::vector<CoverageSegment>
> > -  buildSegments(ArrayRef<CountedRegion> Regions) {
> > -    std::vector<CoverageSegment> Segments;
> > -    SegmentBuilder Builder(Segments);
> > -    Builder.buildSegmentsImpl(Regions);
> > -    return Segments;
> > -  }
> > -};
> > -}
> > -
> > -std::vector<StringRef> CoverageMapping::getUniqueSourceFiles() const {
> > -  std::vector<StringRef> Filenames;
> > -  for (const auto &Function : getCoveredFunctions())
> > -    Filenames.insert(Filenames.end(), Function.Filenames.begin(),
> > -                     Function.Filenames.end());
> > -  std::sort(Filenames.begin(), Filenames.end());
> > -  auto Last = std::unique(Filenames.begin(), Filenames.end());
> > -  Filenames.erase(Last, Filenames.end());
> > -  return Filenames;
> > -}
> > -
> > -static SmallBitVector gatherFileIDs(StringRef SourceFile,
> > -                                    const FunctionRecord &Function) {
> > -  SmallBitVector FilenameEquivalence(Function.Filenames.size(), false);
> > -  for (unsigned I = 0, E = Function.Filenames.size(); I < E; ++I)
> > -    if (SourceFile == Function.Filenames[I])
> > -      FilenameEquivalence[I] = true;
> > -  return FilenameEquivalence;
> > -}
> > -
> > -/// Return the ID of the file where the definition of the function is
> located.
> > -static Optional<unsigned> findMainViewFileID(const FunctionRecord
> &Function) {
> > -  SmallBitVector IsNotExpandedFile(Function.Filenames.size(), true);
> > -  for (const auto &CR : Function.CountedRegions)
> > -    if (CR.Kind == CounterMappingRegion::ExpansionRegion)
> > -      IsNotExpandedFile[CR.ExpandedFileID] = false;
> > -  int I = IsNotExpandedFile.find_first();
> > -  if (I == -1)
> > -    return None;
> > -  return I;
> > -}
> > -
> > -/// Check if SourceFile is the file that contains the definition of
> > -/// the Function. Return the ID of the file in that case or None
> otherwise.
> > -static Optional<unsigned> findMainViewFileID(StringRef SourceFile,
> > -                                             const FunctionRecord
> &Function) {
> > -  Optional<unsigned> I = findMainViewFileID(Function);
> > -  if (I && SourceFile == Function.Filenames[*I])
> > -    return I;
> > -  return None;
> > -}
> > -
> > -/// Sort a nested sequence of regions from a single file.
> > -template <class It> static void sortNestedRegions(It First, It Last) {
> > -  std::sort(First, Last,
> > -            [](const CountedRegion &LHS, const CountedRegion &RHS) {
> > -    if (LHS.startLoc() == RHS.startLoc())
> > -      // When LHS completely contains RHS, we sort LHS first.
> > -      return RHS.endLoc() < LHS.endLoc();
> > -    return LHS.startLoc() < RHS.startLoc();
> > -  });
> > -}
> > -
> > -static bool isExpansion(const CountedRegion &R, unsigned FileID) {
> > -  return R.Kind == CounterMappingRegion::ExpansionRegion && R.FileID ==
> FileID;
> > -}
> > -
> > -CoverageData CoverageMapping::getCoverageForFile(StringRef Filename) {
> > -  CoverageData FileCoverage(Filename);
> > -  std::vector<coverage::CountedRegion> Regions;
> > -
> > -  for (const auto &Function : Functions) {
> > -    auto MainFileID = findMainViewFileID(Filename, Function);
> > -    auto FileIDs = gatherFileIDs(Filename, Function);
> > -    for (const auto &CR : Function.CountedRegions)
> > -      if (FileIDs.test(CR.FileID)) {
> > -        Regions.push_back(CR);
> > -        if (MainFileID && isExpansion(CR, *MainFileID))
> > -          FileCoverage.Expansions.emplace_back(CR, Function);
> > -      }
> > -  }
> > -
> > -  sortNestedRegions(Regions.begin(), Regions.end());
> > -  DEBUG(dbgs() << "Emitting segments for file: " << Filename << "\n");
> > -  FileCoverage.Segments = SegmentBuilder::buildSegments(Regions);
> > -
> > -  return FileCoverage;
> > -}
> > -
> > -std::vector<const FunctionRecord *>
> > -CoverageMapping::getInstantiations(StringRef Filename) {
> > -  FunctionInstantiationSetCollector InstantiationSetCollector;
> > -  for (const auto &Function : Functions) {
> > -    auto MainFileID = findMainViewFileID(Filename, Function);
> > -    if (!MainFileID)
> > -      continue;
> > -    InstantiationSetCollector.insert(Function, *MainFileID);
> > -  }
> > -
> > -  std::vector<const FunctionRecord *> Result;
> > -  for (const auto &InstantiationSet : InstantiationSetCollector) {
> > -    if (InstantiationSet.second.size() < 2)
> > -      continue;
> > -    Result.insert(Result.end(), InstantiationSet.second.begin(),
> > -                  InstantiationSet.second.end());
> > -  }
> > -  return Result;
> > -}
> > -
> > -CoverageData
> > -CoverageMapping::getCoverageForFunction(const FunctionRecord &Function)
> {
> > -  auto MainFileID = findMainViewFileID(Function);
> > -  if (!MainFileID)
> > -    return CoverageData();
> > -
> > -  CoverageData FunctionCoverage(Function.Filenames[*MainFileID]);
> > -  std::vector<coverage::CountedRegion> Regions;
> > -  for (const auto &CR : Function.CountedRegions)
> > -    if (CR.FileID == *MainFileID) {
> > -      Regions.push_back(CR);
> > -      if (isExpansion(CR, *MainFileID))
> > -        FunctionCoverage.Expansions.emplace_back(CR, Function);
> > -    }
> > -
> > -  sortNestedRegions(Regions.begin(), Regions.end());
> > -  DEBUG(dbgs() << "Emitting segments for function: " << Function.Name
> << "\n");
> > -  FunctionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
> > -
> > -  return FunctionCoverage;
> > -}
> > -
> > -CoverageData
> > -CoverageMapping::getCoverageForExpansion(const ExpansionRecord
> &Expansion) {
> > -  CoverageData ExpansionCoverage(
> > -      Expansion.Function.Filenames[Expansion.FileID]);
> > -  std::vector<coverage::CountedRegion> Regions;
> > -  for (const auto &CR : Expansion.Function.CountedRegions)
> > -    if (CR.FileID == Expansion.FileID) {
> > -      Regions.push_back(CR);
> > -      if (isExpansion(CR, Expansion.FileID))
> > -        ExpansionCoverage.Expansions.emplace_back(CR,
> Expansion.Function);
> > -    }
> > -
> > -  sortNestedRegions(Regions.begin(), Regions.end());
> > -  DEBUG(dbgs() << "Emitting segments for expansion of file " <<
> Expansion.FileID
> > -               << "\n");
> > -  ExpansionCoverage.Segments = SegmentBuilder::buildSegments(Regions);
> > -
> > -  return ExpansionCoverage;
> > -}
> > -
> > -namespace {
> > -class CoverageMappingErrorCategoryType : public std::error_category {
> > -  const char *name() const LLVM_NOEXCEPT override { return
> "llvm.coveragemap"; }
> > -  std::string message(int IE) const override {
> > -    auto E = static_cast<coveragemap_error>(IE);
> > -    switch (E) {
> > -    case coveragemap_error::success:
> > -      return "Success";
> > -    case coveragemap_error::eof:
> > -      return "End of File";
> > -    case coveragemap_error::no_data_found:
> > -      return "No coverage data found";
> > -    case coveragemap_error::unsupported_version:
> > -      return "Unsupported coverage format version";
> > -    case coveragemap_error::truncated:
> > -      return "Truncated coverage data";
> > -    case coveragemap_error::malformed:
> > -      return "Malformed coverage data";
> > -    }
> > -    llvm_unreachable("A value of coveragemap_error has no message.");
> > -  }
> > -};
> > -}
> > -
> > -static ManagedStatic<CoverageMappingErrorCategoryType> ErrorCategory;
> > -
> > -const std::error_category &llvm::coverage::coveragemap_category() {
> > -  return *ErrorCategory;
> > -}
> > Index: lib/ProfileData/Coverage/LLVMBuild.txt
> > ===================================================================
> > --- lib/ProfileData/Coverage/LLVMBuild.txt
> > +++ lib/ProfileData/Coverage/LLVMBuild.txt
> > @@ -0,0 +1,23 @@
> > +;===- ./lib/ProfileData/Coverage/LLVMBuild.txt -----------------*- Conf
> -*--===;
> > +;
> > +;                     The LLVM Compiler Infrastructure
> > +;
> > +; This file is distributed under the University of Illinois Open Source
> > +; License. See LICENSE.TXT for details.
> > +;
> >
> +;===------------------------------------------------------------------------===;
> > +;
> > +; This is an LLVMBuild description file for the components in this
> subdirectory.
> > +;
> > +; For more information on the LLVMBuild system, please see:
> > +;
> > +;   http://llvm.org/docs/LLVMBuild.html
> > +;
> >
> +;===------------------------------------------------------------------------===;
> > +
> > +[component_0]
> > +type = Library
> > +name = Coverage
> > +parent = ProfileData
> > +required_libraries = Core Object ProfileData Support
> > +
> > Index: lib/ProfileData/Coverage/CoverageMappingWriter.cpp
> > ===================================================================
> > --- lib/ProfileData/Coverage/CoverageMappingWriter.cpp
> > +++ lib/ProfileData/Coverage/CoverageMappingWriter.cpp
> > @@ -12,7 +12,7 @@
> >  //
> >
> //===----------------------------------------------------------------------===//
> >
> > -#include "llvm/ProfileData/CoverageMappingWriter.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMappingWriter.h"
> >  #include "llvm/Support/LEB128.h"
> >
> >  using namespace llvm;
> > Index: lib/ProfileData/Coverage/CoverageMappingReader.cpp
> > ===================================================================
> > --- lib/ProfileData/Coverage/CoverageMappingReader.cpp
> > +++ lib/ProfileData/Coverage/CoverageMappingReader.cpp
> > @@ -12,7 +12,7 @@
> >  //
> >
> //===----------------------------------------------------------------------===//
> >
> > -#include "llvm/ProfileData/CoverageMappingReader.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
> >  #include "llvm/ADT/DenseSet.h"
> >  #include "llvm/Object/MachOUniversal.h"
> >  #include "llvm/Object/ObjectFile.h"
> > Index: lib/ProfileData/Coverage/CoverageMapping.cpp
> > ===================================================================
> > --- lib/ProfileData/Coverage/CoverageMapping.cpp
> > +++ lib/ProfileData/Coverage/CoverageMapping.cpp
> > @@ -12,11 +12,11 @@
> >  //
> >
> //===----------------------------------------------------------------------===//
> >
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMapping.h"
> >  #include "llvm/ADT/DenseMap.h"
> >  #include "llvm/ADT/Optional.h"
> >  #include "llvm/ADT/SmallBitVector.h"
> > -#include "llvm/ProfileData/CoverageMappingReader.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMappingReader.h"
> >  #include "llvm/ProfileData/InstrProfReader.h"
> >  #include "llvm/Support/Debug.h"
> >  #include "llvm/Support/Errc.h"
> > Index: lib/ProfileData/Coverage/CMakeLists.txt
> > ===================================================================
> > --- lib/ProfileData/Coverage/CMakeLists.txt
> > +++ lib/ProfileData/Coverage/CMakeLists.txt
> > @@ -0,0 +1,11 @@
> > +add_llvm_library(LLVMCoverage
> > +  CoverageMapping.cpp
> > +  CoverageMappingWriter.cpp
> > +  CoverageMappingReader.cpp
> > +
> > +  ADDITIONAL_HEADER_DIRS
> > +  ${LLVM_MAIN_INCLUDE_DIR}/llvm/ProfileData/Coverage
> > +
> > +  DEPENDS
> > +  intrinsics_gen
> > +  )
> > Index: lib/ProfileData/CMakeLists.txt
> > ===================================================================
> > --- lib/ProfileData/CMakeLists.txt
> > +++ lib/ProfileData/CMakeLists.txt
> > @@ -2,9 +2,6 @@
> >    InstrProf.cpp
> >    InstrProfReader.cpp
> >    InstrProfWriter.cpp
> > -  CoverageMapping.cpp
> > -  CoverageMappingWriter.cpp
> > -  CoverageMappingReader.cpp
> >    ProfileSummary.cpp
> >    SampleProf.cpp
> >    SampleProfReader.cpp
> > @@ -16,3 +13,5 @@
> >    DEPENDS
> >    intrinsics_gen
> >    )
> > +
> > +add_subdirectory(Coverage)
> > Index: include/llvm/ProfileData/CoverageMappingWriter.h
> > ===================================================================
> > --- include/llvm/ProfileData/CoverageMappingWriter.h
> > +++ include/llvm/ProfileData/CoverageMappingWriter.h
> > @@ -1,63 +0,0 @@
> > -//=-- CoverageMappingWriter.h - Code coverage mapping writer ------*-
> C++ -*-=//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file contains support for writing coverage mapping data for
> > -// instrumentation based coverage.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#ifndef LLVM_PROFILEDATA_COVERAGEMAPPINGWRITER_H
> > -#define LLVM_PROFILEDATA_COVERAGEMAPPINGWRITER_H
> > -
> > -#include "llvm/ADT/ArrayRef.h"
> > -#include "llvm/ADT/StringMap.h"
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -
> > -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;
> > -  ArrayRef<CounterExpression> Expressions;
> > -  MutableArrayRef<CounterMappingRegion> MappingRegions;
> > -
> > -public:
> > -  CoverageMappingWriter(ArrayRef<unsigned> VirtualFileMapping,
> > -                        ArrayRef<CounterExpression> Expressions,
> > -                        MutableArrayRef<CounterMappingRegion>
> MappingRegions)
> > -      : VirtualFileMapping(VirtualFileMapping),
> Expressions(Expressions),
> > -        MappingRegions(MappingRegions) {}
> > -
> > -  CoverageMappingWriter(ArrayRef<CounterExpression> Expressions,
> > -                        MutableArrayRef<CounterMappingRegion>
> MappingRegions)
> > -      : Expressions(Expressions), MappingRegions(MappingRegions) {}
> > -
> > -  /// \brief Write encoded coverage mapping data to the given output
> stream.
> > -  void write(raw_ostream &OS);
> > -};
> > -
> > -} // end namespace coverage
> > -} // end namespace llvm
> > -
> > -#endif
> > Index: include/llvm/ProfileData/CoverageMappingReader.h
> > ===================================================================
> > --- include/llvm/ProfileData/CoverageMappingReader.h
> > +++ include/llvm/ProfileData/CoverageMappingReader.h
> > @@ -1,183 +0,0 @@
> > -//=-- CoverageMappingReader.h - Code coverage mapping reader ------*-
> C++ -*-=//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// This file contains support for reading coverage mapping data for
> > -// instrumentation based coverage.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#ifndef LLVM_PROFILEDATA_COVERAGEMAPPINGREADER_H
> > -#define LLVM_PROFILEDATA_COVERAGEMAPPINGREADER_H
> > -
> > -#include "llvm/ADT/ArrayRef.h"
> > -#include "llvm/ADT/StringRef.h"
> > -#include "llvm/ADT/Triple.h"
> > -#include "llvm/Object/ObjectFile.h"
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > -#include "llvm/ProfileData/InstrProf.h"
> > -#include "llvm/Support/FileSystem.h"
> > -#include "llvm/Support/MemoryBuffer.h"
> > -#include <iterator>
> > -
> > -namespace llvm {
> > -namespace coverage {
> > -
> > -class CoverageMappingReader;
> > -
> > -/// \brief Coverage mapping information for a single function.
> > -struct CoverageMappingRecord {
> > -  StringRef FunctionName;
> > -  uint64_t FunctionHash;
> > -  ArrayRef<StringRef> Filenames;
> > -  ArrayRef<CounterExpression> Expressions;
> > -  ArrayRef<CounterMappingRegion> MappingRegions;
> > -};
> > -
> > -/// \brief A file format agnostic iterator over coverage mapping data.
> > -class CoverageMappingIterator
> > -    : public std::iterator<std::input_iterator_tag,
> CoverageMappingRecord> {
> > -  CoverageMappingReader *Reader;
> > -  CoverageMappingRecord Record;
> > -
> > -  void increment();
> > -
> > -public:
> > -  CoverageMappingIterator() : Reader(nullptr) {}
> > -  CoverageMappingIterator(CoverageMappingReader *Reader) :
> Reader(Reader) {
> > -    increment();
> > -  }
> > -
> > -  CoverageMappingIterator &operator++() {
> > -    increment();
> > -    return *this;
> > -  }
> > -  bool operator==(const CoverageMappingIterator &RHS) {
> > -    return Reader == RHS.Reader;
> > -  }
> > -  bool operator!=(const CoverageMappingIterator &RHS) {
> > -    return Reader != RHS.Reader;
> > -  }
> > -  CoverageMappingRecord &operator*() { return Record; }
> > -  CoverageMappingRecord *operator->() { return &Record; }
> > -};
> > -
> > -class CoverageMappingReader {
> > -public:
> > -  virtual std::error_code readNextRecord(CoverageMappingRecord &Record)
> = 0;
> > -  CoverageMappingIterator begin() { return
> CoverageMappingIterator(this); }
> > -  CoverageMappingIterator end() { return CoverageMappingIterator(); }
> > -  virtual ~CoverageMappingReader() {}
> > -};
> > -
> > -/// \brief Base class for the raw coverage mapping and filenames data
> readers.
> > -class RawCoverageReader {
> > -protected:
> > -  StringRef Data;
> > -
> > -  RawCoverageReader(StringRef Data) : Data(Data) {}
> > -
> > -  std::error_code readULEB128(uint64_t &Result);
> > -  std::error_code readIntMax(uint64_t &Result, uint64_t MaxPlus1);
> > -  std::error_code readSize(uint64_t &Result);
> > -  std::error_code readString(StringRef &Result);
> > -};
> > -
> > -/// \brief Reader for the raw coverage filenames.
> > -class RawCoverageFilenamesReader : public RawCoverageReader {
> > -  std::vector<StringRef> &Filenames;
> > -
> > -  RawCoverageFilenamesReader(const RawCoverageFilenamesReader &) =
> delete;
> > -  RawCoverageFilenamesReader &
> > -  operator=(const RawCoverageFilenamesReader &) = delete;
> > -
> > -public:
> > -  RawCoverageFilenamesReader(StringRef Data, std::vector<StringRef>
> &Filenames)
> > -      : RawCoverageReader(Data), Filenames(Filenames) {}
> > -
> > -  std::error_code read();
> > -};
> > -
> > -/// \brief Reader for the raw coverage mapping data.
> > -class RawCoverageMappingReader : public RawCoverageReader {
> > -  ArrayRef<StringRef> TranslationUnitFilenames;
> > -  std::vector<StringRef> &Filenames;
> > -  std::vector<CounterExpression> &Expressions;
> > -  std::vector<CounterMappingRegion> &MappingRegions;
> > -
> > -  RawCoverageMappingReader(const RawCoverageMappingReader &) = delete;
> > -  RawCoverageMappingReader &
> > -  operator=(const RawCoverageMappingReader &) = delete;
> > -
> > -public:
> > -  RawCoverageMappingReader(StringRef MappingData,
> > -                           ArrayRef<StringRef> TranslationUnitFilenames,
> > -                           std::vector<StringRef> &Filenames,
> > -                           std::vector<CounterExpression> &Expressions,
> > -                           std::vector<CounterMappingRegion>
> &MappingRegions)
> > -      : RawCoverageReader(MappingData),
> > -        TranslationUnitFilenames(TranslationUnitFilenames),
> > -        Filenames(Filenames), Expressions(Expressions),
> > -        MappingRegions(MappingRegions) {}
> > -
> > -  std::error_code read();
> > -
> > -private:
> > -  std::error_code decodeCounter(unsigned Value, Counter &C);
> > -  std::error_code readCounter(Counter &C);
> > -  std::error_code
> > -  readMappingRegionsSubArray(std::vector<CounterMappingRegion>
> &MappingRegions,
> > -                             unsigned InferredFileID, size_t
> NumFileIDs);
> > -};
> > -
> > -/// \brief Reader for the coverage mapping data that is emitted by the
> > -/// frontend and stored in an object file.
> > -class BinaryCoverageReader : public CoverageMappingReader {
> > -public:
> > -  struct ProfileMappingRecord {
> > -    CovMapVersion Version;
> > -    StringRef FunctionName;
> > -    uint64_t FunctionHash;
> > -    StringRef CoverageMapping;
> > -    size_t FilenamesBegin;
> > -    size_t FilenamesSize;
> > -
> > -    ProfileMappingRecord(CovMapVersion Version, StringRef FunctionName,
> > -                         uint64_t FunctionHash, StringRef
> CoverageMapping,
> > -                         size_t FilenamesBegin, size_t FilenamesSize)
> > -        : Version(Version), FunctionName(FunctionName),
> > -          FunctionHash(FunctionHash), CoverageMapping(CoverageMapping),
> > -          FilenamesBegin(FilenamesBegin), FilenamesSize(FilenamesSize)
> {}
> > -  };
> > -
> > -private:
> > -  std::vector<StringRef> Filenames;
> > -  std::vector<ProfileMappingRecord> MappingRecords;
> > -  InstrProfSymtab ProfileNames;
> > -  size_t CurrentRecord;
> > -  std::vector<StringRef> FunctionsFilenames;
> > -  std::vector<CounterExpression> Expressions;
> > -  std::vector<CounterMappingRegion> MappingRegions;
> > -
> > -  BinaryCoverageReader(const BinaryCoverageReader &) = delete;
> > -  BinaryCoverageReader &operator=(const BinaryCoverageReader &) =
> delete;
> > -
> > -  BinaryCoverageReader() : CurrentRecord(0) {}
> > -
> > -public:
> > -  static ErrorOr<std::unique_ptr<BinaryCoverageReader>>
> > -  create(std::unique_ptr<MemoryBuffer> &ObjectBuffer,
> > -         StringRef Arch);
> > -
> > -  std::error_code readNextRecord(CoverageMappingRecord &Record)
> override;
> > -};
> > -
> > -} // end namespace coverage
> > -} // end namespace llvm
> > -
> > -#endif
> > Index: include/llvm/ProfileData/CoverageMapping.h
> > ===================================================================
> > --- include/llvm/ProfileData/CoverageMapping.h
> > +++ include/llvm/ProfileData/CoverageMapping.h
> > @@ -1,621 +0,0 @@
> > -//=-- CoverageMapping.h - Code coverage mapping support ---------*- C++
> -*-=//
> > -//
> > -//                     The LLVM Compiler Infrastructure
> > -//
> > -// This file is distributed under the University of Illinois Open Source
> > -// License. See LICENSE.TXT for details.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -//
> > -// Code coverage mapping data is generated by clang and read by
> > -// llvm-cov to show code coverage statistics for a file.
> > -//
> >
> -//===----------------------------------------------------------------------===//
> > -
> > -#ifndef LLVM_PROFILEDATA_COVERAGEMAPPING_H_
> > -#define LLVM_PROFILEDATA_COVERAGEMAPPING_H_
> > -
> > -#include "llvm/ADT/ArrayRef.h"
> > -#include "llvm/ADT/DenseMap.h"
> > -#include "llvm/ADT/Hashing.h"
> > -#include "llvm/ADT/Triple.h"
> > -#include "llvm/ADT/iterator.h"
> > -#include "llvm/ProfileData/InstrProf.h"
> > -#include "llvm/Support/Debug.h"
> > -#include "llvm/Support/Endian.h"
> > -#include "llvm/Support/ErrorOr.h"
> > -#include "llvm/Support/raw_ostream.h"
> > -#include <system_error>
> > -#include <tuple>
> > -
> > -namespace llvm {
> > -namespace coverage {
> > -enum class coveragemap_error {
> > -  success = 0,
> > -  eof,
> > -  no_data_found,
> > -  unsupported_version,
> > -  truncated,
> > -  malformed
> > -};
> > -} // end of coverage namespace.
> > -}
> > -
> > -namespace std {
> > -template <>
> > -struct is_error_code_enum<llvm::coverage::coveragemap_error> :
> std::true_type {
> > -};
> > -}
> > -
> > -namespace llvm {
> > -class IndexedInstrProfReader;
> > -namespace coverage {
> > -
> > -class CoverageMappingReader;
> > -
> > -class CoverageMapping;
> > -struct CounterExpressions;
> > -
> > -/// \brief A Counter is an abstract value that describes how to compute
> the
> > -/// execution count for a region of code using the collected profile
> count data.
> > -struct Counter {
> > -  enum CounterKind { Zero, CounterValueReference, Expression };
> > -  static const unsigned EncodingTagBits = 2;
> > -  static const unsigned EncodingTagMask = 0x3;
> > -  static const unsigned EncodingCounterTagAndExpansionRegionTagBits =
> > -      EncodingTagBits + 1;
> > -
> > -private:
> > -  CounterKind Kind;
> > -  unsigned ID;
> > -
> > -  Counter(CounterKind Kind, unsigned ID) : Kind(Kind), ID(ID) {}
> > -
> > -public:
> > -  Counter() : Kind(Zero), ID(0) {}
> > -
> > -  CounterKind getKind() const { return Kind; }
> > -
> > -  bool isZero() const { return Kind == Zero; }
> > -
> > -  bool isExpression() const { return Kind == Expression; }
> > -
> > -  unsigned getCounterID() const { return ID; }
> > -
> > -  unsigned getExpressionID() const { return ID; }
> > -
> > -  friend bool operator==(const Counter &LHS, const Counter &RHS) {
> > -    return LHS.Kind == RHS.Kind && LHS.ID == RHS.ID;
> > -  }
> > -
> > -  friend bool operator!=(const Counter &LHS, const Counter &RHS) {
> > -    return !(LHS == RHS);
> > -  }
> > -
> > -  friend bool operator<(const Counter &LHS, const Counter &RHS) {
> > -    return std::tie(LHS.Kind, LHS.ID) < std::tie(RHS.Kind, RHS.ID);
> > -  }
> > -
> > -  /// \brief Return the counter that represents the number zero.
> > -  static Counter getZero() { return Counter(); }
> > -
> > -  /// \brief Return the counter that corresponds to a specific profile
> counter.
> > -  static Counter getCounter(unsigned CounterId) {
> > -    return Counter(CounterValueReference, CounterId);
> > -  }
> > -
> > -  /// \brief Return the counter that corresponds to a specific
> > -  /// addition counter expression.
> > -  static Counter getExpression(unsigned ExpressionId) {
> > -    return Counter(Expression, ExpressionId);
> > -  }
> > -};
> > -
> > -/// \brief A Counter expression is a value that represents an arithmetic
> > -/// operation with two counters.
> > -struct CounterExpression {
> > -  enum ExprKind { Subtract, Add };
> > -  ExprKind Kind;
> > -  Counter LHS, RHS;
> > -
> > -  CounterExpression(ExprKind Kind, Counter LHS, Counter RHS)
> > -      : Kind(Kind), LHS(LHS), RHS(RHS) {}
> > -};
> > -
> > -/// \brief A Counter expression builder is used to construct the
> > -/// counter expressions. It avoids unnecessary duplication
> > -/// and simplifies algebraic expressions.
> > -class CounterExpressionBuilder {
> > -  /// \brief A list of all the counter expressions
> > -  std::vector<CounterExpression> Expressions;
> > -  /// \brief A lookup table for the index of a given expression.
> > -  llvm::DenseMap<CounterExpression, unsigned> ExpressionIndices;
> > -
> > -  /// \brief Return the counter which corresponds to the given
> expression.
> > -  ///
> > -  /// If the given expression is already stored in the builder, a
> counter
> > -  /// that references that expression is returned. Otherwise, the given
> > -  /// expression is added to the builder's collection of expressions.
> > -  Counter get(const CounterExpression &E);
> > -
> > -  /// \brief Gather the terms of the expression tree for processing.
> > -  ///
> > -  /// This collects each addition and subtraction referenced by the
> counter into
> > -  /// a sequence that can be sorted and combined to build a simplified
> counter
> > -  /// expression.
> > -  void extractTerms(Counter C, int Sign,
> > -                    SmallVectorImpl<std::pair<unsigned, int>> &Terms);
> > -
> > -  /// \brief Simplifies the given expression tree
> > -  /// by getting rid of algebraically redundant operations.
> > -  Counter simplify(Counter ExpressionTree);
> > -
> > -public:
> > -  ArrayRef<CounterExpression> getExpressions() const { return
> Expressions; }
> > -
> > -  /// \brief Return a counter that represents the expression
> > -  /// that adds LHS and RHS.
> > -  Counter add(Counter LHS, Counter RHS);
> > -
> > -  /// \brief Return a counter that represents the expression
> > -  /// that subtracts RHS from LHS.
> > -  Counter subtract(Counter LHS, Counter RHS);
> > -};
> > -
> > -/// \brief A Counter mapping region associates a source range with
> > -/// a specific counter.
> > -struct CounterMappingRegion {
> > -  enum RegionKind {
> > -    /// \brief A CodeRegion associates some code with a counter
> > -    CodeRegion,
> > -
> > -    /// \brief An ExpansionRegion represents a file expansion region
> that
> > -    /// associates a source range with the expansion of a virtual
> source file,
> > -    /// 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
> > -  };
> > -
> > -  Counter Count;
> > -  unsigned FileID, ExpandedFileID;
> > -  unsigned LineStart, ColumnStart, LineEnd, ColumnEnd;
> > -  RegionKind Kind;
> > -
> > -  CounterMappingRegion(Counter Count, unsigned FileID, unsigned
> ExpandedFileID,
> > -                       unsigned LineStart, unsigned ColumnStart,
> > -                       unsigned LineEnd, unsigned ColumnEnd, RegionKind
> Kind)
> > -      : Count(Count), FileID(FileID), ExpandedFileID(ExpandedFileID),
> > -        LineStart(LineStart), ColumnStart(ColumnStart),
> LineEnd(LineEnd),
> > -        ColumnEnd(ColumnEnd), Kind(Kind) {}
> > -
> > -  static CounterMappingRegion
> > -  makeRegion(Counter Count, unsigned FileID, unsigned LineStart,
> > -             unsigned ColumnStart, unsigned LineEnd, unsigned
> ColumnEnd) {
> > -    return CounterMappingRegion(Count, FileID, 0, LineStart,
> ColumnStart,
> > -                                LineEnd, ColumnEnd, CodeRegion);
> > -  }
> > -
> > -  static CounterMappingRegion
> > -  makeExpansion(unsigned FileID, unsigned ExpandedFileID, unsigned
> LineStart,
> > -                unsigned ColumnStart, unsigned LineEnd, unsigned
> ColumnEnd) {
> > -    return CounterMappingRegion(Counter(), FileID, ExpandedFileID,
> LineStart,
> > -                                ColumnStart, LineEnd, ColumnEnd,
> > -                                ExpansionRegion);
> > -  }
> > -
> > -  static CounterMappingRegion
> > -  makeSkipped(unsigned FileID, unsigned LineStart, unsigned ColumnStart,
> > -              unsigned LineEnd, unsigned ColumnEnd) {
> > -    return CounterMappingRegion(Counter(), FileID, 0, LineStart,
> ColumnStart,
> > -                                LineEnd, ColumnEnd, SkippedRegion);
> > -  }
> > -
> > -
> > -  inline std::pair<unsigned, unsigned> startLoc() const {
> > -    return std::pair<unsigned, unsigned>(LineStart, ColumnStart);
> > -  }
> > -
> > -  inline std::pair<unsigned, unsigned> endLoc() const {
> > -    return std::pair<unsigned, unsigned>(LineEnd, ColumnEnd);
> > -  }
> > -
> > -  bool operator<(const CounterMappingRegion &Other) const {
> > -    if (FileID != Other.FileID)
> > -      return FileID < Other.FileID;
> > -    return startLoc() < Other.startLoc();
> > -  }
> > -
> > -  bool contains(const CounterMappingRegion &Other) const {
> > -    if (FileID != Other.FileID)
> > -      return false;
> > -    if (startLoc() > Other.startLoc())
> > -      return false;
> > -    if (endLoc() < Other.endLoc())
> > -      return false;
> > -    return true;
> > -  }
> > -};
> > -
> > -/// \brief Associates a source range with an execution count.
> > -struct CountedRegion : public CounterMappingRegion {
> > -  uint64_t ExecutionCount;
> > -
> > -  CountedRegion(const CounterMappingRegion &R, uint64_t ExecutionCount)
> > -      : CounterMappingRegion(R), ExecutionCount(ExecutionCount) {}
> > -};
> > -
> > -/// \brief A Counter mapping context is used to connect the counters,
> > -/// expressions and the obtained counter values.
> > -class CounterMappingContext {
> > -  ArrayRef<CounterExpression> Expressions;
> > -  ArrayRef<uint64_t> CounterValues;
> > -
> > -public:
> > -  CounterMappingContext(ArrayRef<CounterExpression> Expressions,
> > -                        ArrayRef<uint64_t> CounterValues = None)
> > -      : Expressions(Expressions), CounterValues(CounterValues) {}
> > -
> > -  void setCounts(ArrayRef<uint64_t> Counts) { CounterValues = Counts; }
> > -
> > -  void dump(const Counter &C, llvm::raw_ostream &OS) const;
> > -  void dump(const Counter &C) const { dump(C, dbgs()); }
> > -
> > -  /// \brief Return the number of times that a region of code
> associated with
> > -  /// this counter was executed.
> > -  ErrorOr<int64_t> evaluate(const Counter &C) const;
> > -};
> > -
> > -/// \brief Code coverage information for a single function.
> > -struct FunctionRecord {
> > -  /// \brief Raw function name.
> > -  std::string Name;
> > -  /// \brief Associated files.
> > -  std::vector<std::string> Filenames;
> > -  /// \brief Regions in the function along with their counts.
> > -  std::vector<CountedRegion> CountedRegions;
> > -  /// \brief The number of times this function was executed.
> > -  uint64_t ExecutionCount;
> > -
> > -  FunctionRecord(StringRef Name, ArrayRef<StringRef> Filenames)
> > -      : Name(Name), Filenames(Filenames.begin(), Filenames.end()) {}
> > -
> > -  void pushRegion(CounterMappingRegion Region, uint64_t Count) {
> > -    if (CountedRegions.empty())
> > -      ExecutionCount = Count;
> > -    CountedRegions.emplace_back(Region, Count);
> > -  }
> > -};
> > -
> > -/// \brief Iterator over Functions, optionally filtered to a single
> file.
> > -class FunctionRecordIterator
> > -    : public iterator_facade_base<FunctionRecordIterator,
> > -                                  std::forward_iterator_tag,
> FunctionRecord> {
> > -  ArrayRef<FunctionRecord> Records;
> > -  ArrayRef<FunctionRecord>::iterator Current;
> > -  StringRef Filename;
> > -
> > -  /// \brief Skip records whose primary file is not \c Filename.
> > -  void skipOtherFiles();
> > -
> > -public:
> > -  FunctionRecordIterator(ArrayRef<FunctionRecord> Records_,
> > -                         StringRef Filename = "")
> > -      : Records(Records_), Current(Records.begin()), Filename(Filename)
> {
> > -    skipOtherFiles();
> > -  }
> > -
> > -  FunctionRecordIterator() : Current(Records.begin()) {}
> > -
> > -  bool operator==(const FunctionRecordIterator &RHS) const {
> > -    return Current == RHS.Current && Filename == RHS.Filename;
> > -  }
> > -
> > -  const FunctionRecord &operator*() const { return *Current; }
> > -
> > -  FunctionRecordIterator &operator++() {
> > -    assert(Current != Records.end() && "incremented past end");
> > -    ++Current;
> > -    skipOtherFiles();
> > -    return *this;
> > -  }
> > -};
> > -
> > -/// \brief Coverage information for a macro expansion or #included file.
> > -///
> > -/// When covered code has pieces that can be expanded for more detail,
> such as a
> > -/// preprocessor macro use and its definition, these are represented as
> > -/// expansions whose coverage can be looked up independently.
> > -struct ExpansionRecord {
> > -  /// \brief The abstract file this expansion covers.
> > -  unsigned FileID;
> > -  /// \brief The region that expands to this record.
> > -  const CountedRegion &Region;
> > -  /// \brief Coverage for the expansion.
> > -  const FunctionRecord &Function;
> > -
> > -  ExpansionRecord(const CountedRegion &Region,
> > -                  const FunctionRecord &Function)
> > -      : FileID(Region.ExpandedFileID), Region(Region),
> Function(Function) {}
> > -};
> > -
> > -/// \brief The execution count information starting at a point in a
> file.
> > -///
> > -/// A sequence of CoverageSegments gives execution counts for a file in
> format
> > -/// that's simple to iterate through for processing.
> > -struct CoverageSegment {
> > -  /// \brief The line where this segment begins.
> > -  unsigned Line;
> > -  /// \brief The column where this segment begins.
> > -  unsigned Col;
> > -  /// \brief The execution count, or zero if no count was recorded.
> > -  uint64_t Count;
> > -  /// \brief When false, the segment was uninstrumented or skipped.
> > -  bool HasCount;
> > -  /// \brief Whether this enters a new region or returns to a previous
> count.
> > -  bool IsRegionEntry;
> > -
> > -  CoverageSegment(unsigned Line, unsigned Col, bool IsRegionEntry)
> > -      : Line(Line), Col(Col), Count(0), HasCount(false),
> > -        IsRegionEntry(IsRegionEntry) {}
> > -
> > -  CoverageSegment(unsigned Line, unsigned Col, uint64_t Count,
> > -                  bool IsRegionEntry)
> > -      : Line(Line), Col(Col), Count(Count), HasCount(true),
> > -        IsRegionEntry(IsRegionEntry) {}
> > -
> > -  friend bool operator==(const CoverageSegment &L, const
> CoverageSegment &R) {
> > -    return std::tie(L.Line, L.Col, L.Count, L.HasCount,
> L.IsRegionEntry) ==
> > -           std::tie(R.Line, R.Col, R.Count, R.HasCount,
> R.IsRegionEntry);
> > -  }
> > -
> > -  void setCount(uint64_t NewCount) {
> > -    Count = NewCount;
> > -    HasCount = true;
> > -  }
> > -
> > -  void addCount(uint64_t NewCount) { setCount(Count + NewCount); }
> > -};
> > -
> > -/// \brief Coverage information to be processed or displayed.
> > -///
> > -/// This represents the coverage of an entire file, expansion, or
> function. It
> > -/// provides a sequence of CoverageSegments to iterate through, as well
> as the
> > -/// list of expansions that can be further processed.
> > -class CoverageData {
> > -  std::string Filename;
> > -  std::vector<CoverageSegment> Segments;
> > -  std::vector<ExpansionRecord> Expansions;
> > -  friend class CoverageMapping;
> > -
> > -public:
> > -  CoverageData() {}
> > -
> > -  CoverageData(StringRef Filename) : Filename(Filename) {}
> > -
> > -  CoverageData(CoverageData &&RHS)
> > -      : Filename(std::move(RHS.Filename)),
> Segments(std::move(RHS.Segments)),
> > -        Expansions(std::move(RHS.Expansions)) {}
> > -
> > -  /// \brief Get the name of the file this data covers.
> > -  StringRef getFilename() { return Filename; }
> > -
> > -  std::vector<CoverageSegment>::iterator begin() { return
> Segments.begin(); }
> > -  std::vector<CoverageSegment>::iterator end() { return Segments.end();
> }
> > -  bool empty() { return Segments.empty(); }
> > -
> > -  /// \brief Expansions that can be further processed.
> > -  std::vector<ExpansionRecord> getExpansions() { return Expansions; }
> > -};
> > -
> > -/// \brief The mapping of profile information to coverage data.
> > -///
> > -/// This is the main interface to get coverage information, using a
> profile to
> > -/// fill out execution counts.
> > -class CoverageMapping {
> > -  std::vector<FunctionRecord> Functions;
> > -  unsigned MismatchedFunctionCount;
> > -
> > -  CoverageMapping() : MismatchedFunctionCount(0) {}
> > -
> > -public:
> > -  /// \brief Load the coverage mapping using the given readers.
> > -  static ErrorOr<std::unique_ptr<CoverageMapping>>
> > -  load(CoverageMappingReader &CoverageReader,
> > -       IndexedInstrProfReader &ProfileReader);
> > -
> > -  /// \brief Load the coverage mapping from the given files.
> > -  static ErrorOr<std::unique_ptr<CoverageMapping>>
> > -  load(StringRef ObjectFilename, StringRef ProfileFilename,
> > -       StringRef Arch = StringRef());
> > -
> > -  /// \brief The number of functions that couldn't have their profiles
> mapped.
> > -  ///
> > -  /// This is a count of functions whose profile is out of date or
> otherwise
> > -  /// can't be associated with any coverage information.
> > -  unsigned getMismatchedCount() { return MismatchedFunctionCount; }
> > -
> > -  /// \brief Returns the list of files that are covered.
> > -  std::vector<StringRef> getUniqueSourceFiles() const;
> > -
> > -  /// \brief Get the coverage for a particular file.
> > -  ///
> > -  /// The given filename must be the name as recorded in the coverage
> > -  /// information. That is, only names returned from
> getUniqueSourceFiles will
> > -  /// yield a result.
> > -  CoverageData getCoverageForFile(StringRef Filename);
> > -
> > -  /// \brief Gets all of the functions covered by this profile.
> > -  iterator_range<FunctionRecordIterator> getCoveredFunctions() const {
> > -    return make_range(FunctionRecordIterator(Functions),
> > -                      FunctionRecordIterator());
> > -  }
> > -
> > -  /// \brief Gets all of the functions in a particular file.
> > -  iterator_range<FunctionRecordIterator>
> > -  getCoveredFunctions(StringRef Filename) const {
> > -    return make_range(FunctionRecordIterator(Functions, Filename),
> > -                      FunctionRecordIterator());
> > -  }
> > -
> > -  /// \brief Get the list of function instantiations in the file.
> > -  ///
> > -  /// Functions that are instantiated more than once, such as C++
> template
> > -  /// specializations, have distinct coverage records for each
> instantiation.
> > -  std::vector<const FunctionRecord *> getInstantiations(StringRef
> Filename);
> > -
> > -  /// \brief Get the coverage for a particular function.
> > -  CoverageData getCoverageForFunction(const FunctionRecord &Function);
> > -
> > -  /// \brief Get the coverage for an expansion within a coverage set.
> > -  CoverageData getCoverageForExpansion(const ExpansionRecord
> &Expansion);
> > -};
> > -
> > -const std::error_category &coveragemap_category();
> > -
> > -inline std::error_code make_error_code(coveragemap_error E) {
> > -  return std::error_code(static_cast<int>(E), coveragemap_category());
> > -}
> > -
> > -// Profile coverage map has the following layout:
> > -// [CoverageMapFileHeader]
> > -// [ArrayStart]
> > -//  [CovMapFunctionRecord]
> > -//  [CovMapFunctionRecord]
> > -//  ...
> > -// [ArrayEnd]
> > -// [Encoded Region Mapping Data]
> > -LLVM_PACKED_START
> > -template <class IntPtrT> struct CovMapFunctionRecordV1 {
> > -#define COVMAP_V1
> > -#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Type Name;
> > -#include "llvm/ProfileData/InstrProfData.inc"
> > -#undef COVMAP_V1
> > -
> > -  // Return the structural hash associated with the function.
> > -  template <support::endianness Endian> uint64_t getFuncHash() const {
> > -    return support::endian::byte_swap<uint64_t, Endian>(FuncHash);
> > -  }
> > -  // Return the coverage map data size for the funciton.
> > -  template <support::endianness Endian> uint32_t getDataSize() const {
> > -    return support::endian::byte_swap<uint32_t, Endian>(DataSize);
> > -  }
> > -  // Return function lookup key. The value is consider opaque.
> > -  template <support::endianness Endian> IntPtrT getFuncNameRef() const {
> > -    return support::endian::byte_swap<IntPtrT, Endian>(NamePtr);
> > -  }
> > -  // Return the PGO name of the function */
> > -  template <support::endianness Endian>
> > -  std::error_code getFuncName(InstrProfSymtab &ProfileNames,
> > -                              StringRef &FuncName) const {
> > -    IntPtrT NameRef = getFuncNameRef<Endian>();
> > -    uint32_t NameS = support::endian::byte_swap<uint32_t,
> Endian>(NameSize);
> > -    FuncName = ProfileNames.getFuncName(NameRef, NameS);
> > -    if (NameS && FuncName.empty())
> > -      return coveragemap_error::malformed;
> > -    return std::error_code();
> > -  }
> > -};
> > -
> > -struct CovMapFunctionRecord {
> > -#define COVMAP_FUNC_RECORD(Type, LLVMType, Name, Init) Type Name;
> > -#include "llvm/ProfileData/InstrProfData.inc"
> > -
> > -  // Return the structural hash associated with the function.
> > -  template <support::endianness Endian> uint64_t getFuncHash() const {
> > -    return support::endian::byte_swap<uint64_t, Endian>(FuncHash);
> > -  }
> > -  // Return the coverage map data size for the funciton.
> > -  template <support::endianness Endian> uint32_t getDataSize() const {
> > -    return support::endian::byte_swap<uint32_t, Endian>(DataSize);
> > -  }
> > -  // Return function lookup key. The value is consider opaque.
> > -  template <support::endianness Endian> uint64_t getFuncNameRef() const
> {
> > -    return support::endian::byte_swap<uint64_t, Endian>(NameRef);
> > -  }
> > -  // Return the PGO name of the function */
> > -  template <support::endianness Endian>
> > -  std::error_code getFuncName(InstrProfSymtab &ProfileNames,
> > -                              StringRef &FuncName) const {
> > -    uint64_t NameRef = getFuncNameRef<Endian>();
> > -    FuncName = ProfileNames.getFuncName(NameRef);
> > -    return std::error_code();
> > -  }
> > -};
> > -
> > -// Per module coverage mapping data header, i.e. CoverageMapFileHeader
> > -// documented above.
> > -struct CovMapHeader {
> > -#define COVMAP_HEADER(Type, LLVMType, Name, Init) Type Name;
> > -#include "llvm/ProfileData/InstrProfData.inc"
> > -  template <support::endianness Endian> uint32_t getNRecords() const {
> > -    return support::endian::byte_swap<uint32_t, Endian>(NRecords);
> > -  }
> > -  template <support::endianness Endian> uint32_t getFilenamesSize()
> const {
> > -    return support::endian::byte_swap<uint32_t, Endian>(FilenamesSize);
> > -  }
> > -  template <support::endianness Endian> uint32_t getCoverageSize()
> const {
> > -    return support::endian::byte_swap<uint32_t, Endian>(CoverageSize);
> > -  }
> > -  template <support::endianness Endian> uint32_t getVersion() const {
> > -    return support::endian::byte_swap<uint32_t, Endian>(Version);
> > -  }
> > -};
> > -
> > -LLVM_PACKED_END
> > -
> > -enum CovMapVersion {
> > -  Version1 = 0,
> > -  // Function's name reference from CovMapFuncRecord is changed from raw
> > -  // name string pointer to MD5 to support name section compression.
> Name
> > -  // section is also compressed.
> > -  Version2 = 1,
> > -  // The current version is Version2
> > -  CurrentVersion = INSTR_PROF_COVMAP_VERSION
> > -};
> > -
> > -template <int CovMapVersion, class IntPtrT> struct CovMapTraits {
> > -  typedef CovMapFunctionRecord CovMapFuncRecordType;
> > -  typedef uint64_t NameRefType;
> > -};
> > -
> > -template <class IntPtrT> struct CovMapTraits<CovMapVersion::Version1,
> IntPtrT> {
> > -  typedef CovMapFunctionRecordV1<IntPtrT> CovMapFuncRecordType;
> > -  typedef IntPtrT NameRefType;
> > -};
> > -
> > -} // end namespace coverage
> > -
> > -/// \brief Provide DenseMapInfo for CounterExpression
> > -template<> struct DenseMapInfo<coverage::CounterExpression> {
> > -  static inline coverage::CounterExpression getEmptyKey() {
> > -    using namespace coverage;
> > -    return CounterExpression(CounterExpression::ExprKind::Subtract,
> > -                             Counter::getCounter(~0U),
> > -                             Counter::getCounter(~0U));
> > -  }
> > -
> > -  static inline coverage::CounterExpression getTombstoneKey() {
> > -    using namespace coverage;
> > -    return CounterExpression(CounterExpression::ExprKind::Add,
> > -                             Counter::getCounter(~0U),
> > -                             Counter::getCounter(~0U));
> > -  }
> > -
> > -  static unsigned getHashValue(const coverage::CounterExpression &V) {
> > -    return static_cast<unsigned>(
> > -        hash_combine(V.Kind, V.LHS.getKind(), V.LHS.getCounterID(),
> > -                     V.RHS.getKind(), V.RHS.getCounterID()));
> > -  }
> > -
> > -  static bool isEqual(const coverage::CounterExpression &LHS,
> > -                      const coverage::CounterExpression &RHS) {
> > -    return LHS.Kind == RHS.Kind && LHS.LHS == RHS.LHS && LHS.RHS ==
> RHS.RHS;
> > -  }
> > -};
> > -
> > -} // end namespace llvm
> > -
> > -#endif // LLVM_PROFILEDATA_COVERAGEMAPPING_H_
> > Index: include/llvm/ProfileData/Coverage/CoverageMappingWriter.h
> > ===================================================================
> > --- include/llvm/ProfileData/Coverage/CoverageMappingWriter.h
> > +++ include/llvm/ProfileData/Coverage/CoverageMappingWriter.h
> > @@ -17,7 +17,7 @@
> >
> >  #include "llvm/ADT/ArrayRef.h"
> >  #include "llvm/ADT/StringMap.h"
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMapping.h"
> >  #include "llvm/Support/raw_ostream.h"
> >
> >  namespace llvm {
> > Index: include/llvm/ProfileData/Coverage/CoverageMappingReader.h
> > ===================================================================
> > --- include/llvm/ProfileData/Coverage/CoverageMappingReader.h
> > +++ include/llvm/ProfileData/Coverage/CoverageMappingReader.h
> > @@ -19,7 +19,7 @@
> >  #include "llvm/ADT/StringRef.h"
> >  #include "llvm/ADT/Triple.h"
> >  #include "llvm/Object/ObjectFile.h"
> > -#include "llvm/ProfileData/CoverageMapping.h"
> > +#include "llvm/ProfileData/Coverage/CoverageMapping.h"
> >  #include "llvm/ProfileData/InstrProf.h"
> >  #include "llvm/Support/FileSystem.h"
> >  #include "llvm/Support/MemoryBuffer.h"
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160422/ac1ce91b/attachment-0001.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: split_coverage.patch
Type: text/x-patch
Size: 200872 bytes
Desc: not available
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20160422/ac1ce91b/attachment-0001.bin>


More information about the llvm-commits mailing list