[PATCH] D19333: Move coverage related code into a separate library
Justin Bogner via llvm-commits
llvm-commits at lists.llvm.org
Thu Apr 21 18:11:41 PDT 2016
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"
More information about the llvm-commits
mailing list