1//===- CoverageMappingReader.h - Code coverage mapping reader ---*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains support for reading coverage mapping data for
10// instrumentation based coverage.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPINGREADER_H
15#define LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPINGREADER_H
16
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/StringRef.h"
19#include "llvm/ProfileData/Coverage/CoverageMapping.h"
20#include "llvm/ProfileData/InstrProf.h"
21#include "llvm/Support/Error.h"
22#include "llvm/Support/MemoryBuffer.h"
23#include <cstddef>
24#include <cstdint>
25#include <iterator>
26#include <memory>
27#include <vector>
28
29namespace llvm {
30namespace coverage {
31
32class CoverageMappingReader;
33
34/// Coverage mapping information for a single function.
35struct CoverageMappingRecord {
36  StringRef FunctionName;
37  uint64_t FunctionHash;
38  ArrayRef<StringRef> Filenames;
39  ArrayRef<CounterExpression> Expressions;
40  ArrayRef<CounterMappingRegion> MappingRegions;
41};
42
43/// A file format agnostic iterator over coverage mapping data.
44class CoverageMappingIterator
45    : public std::iterator<std::input_iterator_tag, CoverageMappingRecord> {
46  CoverageMappingReader *Reader;
47  CoverageMappingRecord Record;
48  coveragemap_error ReadErr;
49
50  void increment();
51
52public:
53  CoverageMappingIterator()
54      : Reader(nullptr), Record(), ReadErr(coveragemap_error::success) {}
55
56  CoverageMappingIterator(CoverageMappingReader *Reader)
57      : Reader(Reader), Record(), ReadErr(coveragemap_error::success) {
58    increment();
59  }
60
61  ~CoverageMappingIterator() {
62    if (ReadErr != coveragemap_error::success)
63      llvm_unreachable("Unexpected error in coverage mapping iterator");
64  }
65
66  CoverageMappingIterator &operator++() {
67    increment();
68    return *this;
69  }
70  bool operator==(const CoverageMappingIterator &RHS) {
71    return Reader == RHS.Reader;
72  }
73  bool operator!=(const CoverageMappingIterator &RHS) {
74    return Reader != RHS.Reader;
75  }
76  Expected<CoverageMappingRecord &> operator*() {
77    if (ReadErr != coveragemap_error::success) {
78      auto E = make_error<CoverageMapError>(ReadErr);
79      ReadErr = coveragemap_error::success;
80      return std::move(E);
81    }
82    return Record;
83  }
84  Expected<CoverageMappingRecord *> operator->() {
85    if (ReadErr != coveragemap_error::success) {
86      auto E = make_error<CoverageMapError>(ReadErr);
87      ReadErr = coveragemap_error::success;
88      return std::move(E);
89    }
90    return &Record;
91  }
92};
93
94class CoverageMappingReader {
95public:
96  virtual ~CoverageMappingReader() = default;
97
98  virtual Error readNextRecord(CoverageMappingRecord &Record) = 0;
99  CoverageMappingIterator begin() { return CoverageMappingIterator(this); }
100  CoverageMappingIterator end() { return CoverageMappingIterator(); }
101};
102
103/// Base class for the raw coverage mapping and filenames data readers.
104class RawCoverageReader {
105protected:
106  StringRef Data;
107
108  RawCoverageReader(StringRef Data) : Data(Data) {}
109
110  Error readULEB128(uint64_t &Result);
111  Error readIntMax(uint64_t &Result, uint64_t MaxPlus1);
112  Error readSize(uint64_t &Result);
113  Error readString(StringRef &Result);
114};
115
116/// Reader for the raw coverage filenames.
117class RawCoverageFilenamesReader : public RawCoverageReader {
118  std::vector<StringRef> &Filenames;
119
120public:
121  RawCoverageFilenamesReader(StringRef Data, std::vector<StringRef> &Filenames)
122      : RawCoverageReader(Data), Filenames(Filenames) {}
123  RawCoverageFilenamesReader(const RawCoverageFilenamesReader &) = delete;
124  RawCoverageFilenamesReader &
125  operator=(const RawCoverageFilenamesReader &) = delete;
126
127  Error read();
128};
129
130/// Checks if the given coverage mapping data is exported for
131/// an unused function.
132class RawCoverageMappingDummyChecker : public RawCoverageReader {
133public:
134  RawCoverageMappingDummyChecker(StringRef MappingData)
135      : RawCoverageReader(MappingData) {}
136
137  Expected<bool> isDummy();
138};
139
140/// Reader for the raw coverage mapping data.
141class RawCoverageMappingReader : public RawCoverageReader {
142  ArrayRef<StringRef> TranslationUnitFilenames;
143  std::vector<StringRef> &Filenames;
144  std::vector<CounterExpression> &Expressions;
145  std::vector<CounterMappingRegion> &MappingRegions;
146
147public:
148  RawCoverageMappingReader(StringRef MappingData,
149                           ArrayRef<StringRef> TranslationUnitFilenames,
150                           std::vector<StringRef> &Filenames,
151                           std::vector<CounterExpression> &Expressions,
152                           std::vector<CounterMappingRegion> &MappingRegions)
153      : RawCoverageReader(MappingData),
154        TranslationUnitFilenames(TranslationUnitFilenames),
155        Filenames(Filenames), Expressions(Expressions),
156        MappingRegions(MappingRegions) {}
157  RawCoverageMappingReader(const RawCoverageMappingReader &) = delete;
158  RawCoverageMappingReader &
159  operator=(const RawCoverageMappingReader &) = delete;
160
161  Error read();
162
163private:
164  Error decodeCounter(unsigned Value, Counter &C);
165  Error readCounter(Counter &C);
166  Error
167  readMappingRegionsSubArray(std::vector<CounterMappingRegion> &MappingRegions,
168                             unsigned InferredFileID, size_t NumFileIDs);
169};
170
171/// Reader for the coverage mapping data that is emitted by the
172/// frontend and stored in an object file.
173class BinaryCoverageReader : public CoverageMappingReader {
174public:
175  struct ProfileMappingRecord {
176    CovMapVersion Version;
177    StringRef FunctionName;
178    uint64_t FunctionHash;
179    StringRef CoverageMapping;
180    size_t FilenamesBegin;
181    size_t FilenamesSize;
182
183    ProfileMappingRecord(CovMapVersion Version, StringRef FunctionName,
184                         uint64_t FunctionHash, StringRef CoverageMapping,
185                         size_t FilenamesBegin, size_t FilenamesSize)
186        : Version(Version), FunctionName(FunctionName),
187          FunctionHash(FunctionHash), CoverageMapping(CoverageMapping),
188          FilenamesBegin(FilenamesBegin), FilenamesSize(FilenamesSize) {}
189  };
190
191private:
192  std::vector<StringRef> Filenames;
193  std::vector<ProfileMappingRecord> MappingRecords;
194  InstrProfSymtab ProfileNames;
195  size_t CurrentRecord = 0;
196  std::vector<StringRef> FunctionsFilenames;
197  std::vector<CounterExpression> Expressions;
198  std::vector<CounterMappingRegion> MappingRegions;
199
200  BinaryCoverageReader() = default;
201
202public:
203  BinaryCoverageReader(const BinaryCoverageReader &) = delete;
204  BinaryCoverageReader &operator=(const BinaryCoverageReader &) = delete;
205
206  static Expected<std::vector<std::unique_ptr<BinaryCoverageReader>>>
207  create(MemoryBufferRef ObjectBuffer, StringRef Arch,
208         SmallVectorImpl<std::unique_ptr<MemoryBuffer>> &ObjectFileBuffers);
209
210  static Expected<std::unique_ptr<BinaryCoverageReader>>
211  createCoverageReaderFromBuffer(StringRef Coverage,
212                                 InstrProfSymtab &&ProfileNames,
213                                 uint8_t BytesInAddress,
214                                 support::endianness Endian);
215
216  Error readNextRecord(CoverageMappingRecord &Record) override;
217};
218
219} // end namespace coverage
220} // end namespace llvm
221
222#endif // LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPINGREADER_H
223