include/llvm/ProfileData/CoverageMappingReader.h

   1 //=-- CoverageMappingReader.h - Code coverage mapping reader ------*- C++ -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for reading coverage mapping data for
  11 // instrumentation based coverage.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_PROFILEDATA_COVERAGEMAPPINGREADER_H
  16 #define LLVM_PROFILEDATA_COVERAGEMAPPINGREADER_H
  17
  18 #include "llvm/ADT/ArrayRef.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/ADT/Triple.h"
  21 #include "llvm/Object/ObjectFile.h"
  22 #include "llvm/ProfileData/CoverageMapping.h"
  23 #include "llvm/ProfileData/InstrProf.h"
  24 #include "llvm/Support/FileSystem.h"
  25 #include "llvm/Support/MemoryBuffer.h"
  26 #include <iterator>
  27
  28 namespace llvm {
  29 namespace coverage {
  30
  31 class CoverageMappingReader;
  32
  33 /// \brief Coverage mapping information for a single function.
  34 struct CoverageMappingRecord {
  35   StringRef FunctionName;
  36   uint64_t FunctionHash;
  37   ArrayRef<StringRef> Filenames;
  38   ArrayRef<CounterExpression> Expressions;
  39   ArrayRef<CounterMappingRegion> MappingRegions;
  40 };
  41
  42 /// \brief A file format agnostic iterator over coverage mapping data.
  43 class CoverageMappingIterator
  44     : public std::iterator<std::input_iterator_tag, CoverageMappingRecord> {
  45   CoverageMappingReader *Reader;
  46   CoverageMappingRecord Record;
  47
  48   void increment();
  49
  50 public:
  51   CoverageMappingIterator() : Reader(nullptr) {}
  52   CoverageMappingIterator(CoverageMappingReader *Reader) : Reader(Reader) {
  53     increment();
  54   }
  55
  56   CoverageMappingIterator &operator++() {
  57     increment();
  58     return *this;
  59   }
  60   bool operator==(const CoverageMappingIterator &RHS) {
  61     return Reader == RHS.Reader;
  62   }
  63   bool operator!=(const CoverageMappingIterator &RHS) {
  64     return Reader != RHS.Reader;
  65   }
  66   CoverageMappingRecord &operator*() { return Record; }
  67   CoverageMappingRecord *operator->() { return &Record; }
  68 };
  69
  70 class CoverageMappingReader {
  71 public:
  72   virtual std::error_code readNextRecord(CoverageMappingRecord &Record) = 0;
  73   CoverageMappingIterator begin() { return CoverageMappingIterator(this); }
  74   CoverageMappingIterator end() { return CoverageMappingIterator(); }
  75   virtual ~CoverageMappingReader() {}
  76 };
  77
  78 /// \brief Base class for the raw coverage mapping and filenames data readers.
  79 class RawCoverageReader {
  80 protected:
  81   StringRef Data;
  82
  83   /// \brief Return the error code.
  84   std::error_code error(std::error_code EC) { return EC; }
  85
  86   /// \brief Clear the current error code and return a successful one.
  87   std::error_code success() { return error(instrprof_error::success); }
  88
  89   RawCoverageReader(StringRef Data) : Data(Data) {}
  90
  91   std::error_code readULEB128(uint64_t &Result);
  92   std::error_code readIntMax(uint64_t &Result, uint64_t MaxPlus1);
  93   std::error_code readSize(uint64_t &Result);
  94   std::error_code readString(StringRef &Result);
  95 };
  96
  97 /// \brief Reader for the raw coverage filenames.
  98 class RawCoverageFilenamesReader : public RawCoverageReader {
  99   std::vector<StringRef> &Filenames;
 100
 101   RawCoverageFilenamesReader(const RawCoverageFilenamesReader &) = delete;
 102   RawCoverageFilenamesReader &
 103   operator=(const RawCoverageFilenamesReader &) = delete;
 104
 105 public:
 106   RawCoverageFilenamesReader(StringRef Data, std::vector<StringRef> &Filenames)
 107       : RawCoverageReader(Data), Filenames(Filenames) {}
 108
 109   std::error_code read();
 110 };
 111
 112 /// \brief Reader for the raw coverage mapping data.
 113 class RawCoverageMappingReader : public RawCoverageReader {
 114   ArrayRef<StringRef> TranslationUnitFilenames;
 115   std::vector<StringRef> &Filenames;
 116   std::vector<CounterExpression> &Expressions;
 117   std::vector<CounterMappingRegion> &MappingRegions;
 118
 119   RawCoverageMappingReader(const RawCoverageMappingReader &) = delete;
 120   RawCoverageMappingReader &
 121   operator=(const RawCoverageMappingReader &) = delete;
 122
 123 public:
 124   RawCoverageMappingReader(StringRef MappingData,
 125                            ArrayRef<StringRef> TranslationUnitFilenames,
 126                            std::vector<StringRef> &Filenames,
 127                            std::vector<CounterExpression> &Expressions,
 128                            std::vector<CounterMappingRegion> &MappingRegions)
 129       : RawCoverageReader(MappingData),
 130         TranslationUnitFilenames(TranslationUnitFilenames),
 131         Filenames(Filenames), Expressions(Expressions),
 132         MappingRegions(MappingRegions) {}
 133
 134   std::error_code read();
 135
 136 private:
 137   std::error_code decodeCounter(unsigned Value, Counter &C);
 138   std::error_code readCounter(Counter &C);
 139   std::error_code
 140   readMappingRegionsSubArray(std::vector<CounterMappingRegion> &MappingRegions,
 141                              unsigned InferredFileID, size_t NumFileIDs);
 142 };
 143
 144 /// \brief Reader for the coverage mapping data that is emitted by the
 145 /// frontend and stored in an object file.
 146 class BinaryCoverageReader : public CoverageMappingReader {
 147 public:
 148   struct ProfileMappingRecord {
 149     CoverageMappingVersion Version;
 150     StringRef FunctionName;
 151     uint64_t FunctionHash;
 152     StringRef CoverageMapping;
 153     size_t FilenamesBegin;
 154     size_t FilenamesSize;
 155
 156     ProfileMappingRecord(CoverageMappingVersion Version, StringRef FunctionName,
 157                          uint64_t FunctionHash, StringRef CoverageMapping,
 158                          size_t FilenamesBegin, size_t FilenamesSize)
 159         : Version(Version), FunctionName(FunctionName),
 160           FunctionHash(FunctionHash), CoverageMapping(CoverageMapping),
 161           FilenamesBegin(FilenamesBegin), FilenamesSize(FilenamesSize) {}
 162   };
 163
 164 private:
 165   std::vector<StringRef> Filenames;
 166   std::vector<ProfileMappingRecord> MappingRecords;
 167   size_t CurrentRecord;
 168   std::vector<StringRef> FunctionsFilenames;
 169   std::vector<CounterExpression> Expressions;
 170   std::vector<CounterMappingRegion> MappingRegions;
 171
 172   BinaryCoverageReader(const BinaryCoverageReader &) = delete;
 173   BinaryCoverageReader &operator=(const BinaryCoverageReader &) = delete;
 174
 175   BinaryCoverageReader() : CurrentRecord(0) {}
 176
 177 public:
 178   static ErrorOr<std::unique_ptr<BinaryCoverageReader>>
 179   create(std::unique_ptr<MemoryBuffer> &ObjectBuffer,
 180          Triple::ArchType Arch = Triple::ArchType::UnknownArch);
 181
 182   std::error_code readNextRecord(CoverageMappingRecord &Record) override;
 183 };
 184
 185 } // end namespace coverage
 186 } // end namespace llvm
 187
 188 #endif