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 
29 namespace llvm {
30 namespace coverage {
31 
32 class CoverageMappingReader;
33 
34 /// Coverage mapping information for a single function.
35 struct 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.
44 class CoverageMappingIterator {
45   CoverageMappingReader *Reader;
46   CoverageMappingRecord Record;
47   coveragemap_error ReadErr;
48 
49   void increment();
50 
51 public:
52   using iterator_category = std::input_iterator_tag;
53   using value_type = CoverageMappingRecord;
54   using difference_type = std::ptrdiff_t;
55   using pointer = value_type *;
56   using reference = value_type &;
57 
58   CoverageMappingIterator()
59       : Reader(nullptr), Record(), ReadErr(coveragemap_error::success) {}
60 
61   CoverageMappingIterator(CoverageMappingReader *Reader)
62       : Reader(Reader), Record(), ReadErr(coveragemap_error::success) {
63     increment();
64   }
65 
66   ~CoverageMappingIterator() {
67     if (ReadErr != coveragemap_error::success)
68       llvm_unreachable("Unexpected error in coverage mapping iterator");
69   }
70 
71   CoverageMappingIterator &operator++() {
72     increment();
73     return *this;
74   }
75   bool operator==(const CoverageMappingIterator &RHS) const {
76     return Reader == RHS.Reader;
77   }
78   bool operator!=(const CoverageMappingIterator &RHS) const {
79     return Reader != RHS.Reader;
80   }
81   Expected<CoverageMappingRecord &> operator*() {
82     if (ReadErr != coveragemap_error::success) {
83       auto E = make_error<CoverageMapError>(ReadErr);
84       ReadErr = coveragemap_error::success;
85       return std::move(E);
86     }
87     return Record;
88   }
89   Expected<CoverageMappingRecord *> operator->() {
90     if (ReadErr != coveragemap_error::success) {
91       auto E = make_error<CoverageMapError>(ReadErr);
92       ReadErr = coveragemap_error::success;
93       return std::move(E);
94     }
95     return &Record;
96   }
97 };
98 
99 class CoverageMappingReader {
100 public:
101   virtual ~CoverageMappingReader() = default;
102 
103   virtual Error readNextRecord(CoverageMappingRecord &Record) = 0;
104   CoverageMappingIterator begin() { return CoverageMappingIterator(this); }
105   CoverageMappingIterator end() { return CoverageMappingIterator(); }
106 };
107 
108 /// Base class for the raw coverage mapping and filenames data readers.
109 class RawCoverageReader {
110 protected:
111   StringRef Data;
112 
113   RawCoverageReader(StringRef Data) : Data(Data) {}
114 
115   Error readULEB128(uint64_t &Result);
116   Error readIntMax(uint64_t &Result, uint64_t MaxPlus1);
117   Error readSize(uint64_t &Result);
118   Error readString(StringRef &Result);
119 };
120 
121 /// Checks if the given coverage mapping data is exported for
122 /// an unused function.
123 class RawCoverageMappingDummyChecker : public RawCoverageReader {
124 public:
125   RawCoverageMappingDummyChecker(StringRef MappingData)
126       : RawCoverageReader(MappingData) {}
127 
128   Expected<bool> isDummy();
129 };
130 
131 /// Reader for the raw coverage mapping data.
132 class RawCoverageMappingReader : public RawCoverageReader {
133   ArrayRef<std::string> &TranslationUnitFilenames;
134   std::vector<StringRef> &Filenames;
135   std::vector<CounterExpression> &Expressions;
136   std::vector<CounterMappingRegion> &MappingRegions;
137 
138 public:
139   RawCoverageMappingReader(StringRef MappingData,
140                            ArrayRef<std::string> &TranslationUnitFilenames,
141                            std::vector<StringRef> &Filenames,
142                            std::vector<CounterExpression> &Expressions,
143                            std::vector<CounterMappingRegion> &MappingRegions)
144       : RawCoverageReader(MappingData),
145         TranslationUnitFilenames(TranslationUnitFilenames),
146         Filenames(Filenames), Expressions(Expressions),
147         MappingRegions(MappingRegions) {}
148   RawCoverageMappingReader(const RawCoverageMappingReader &) = delete;
149   RawCoverageMappingReader &
150   operator=(const RawCoverageMappingReader &) = delete;
151 
152   Error read();
153 
154 private:
155   Error decodeCounter(unsigned Value, Counter &C);
156   Error readCounter(Counter &C);
157   Error
158   readMappingRegionsSubArray(std::vector<CounterMappingRegion> &MappingRegions,
159                              unsigned InferredFileID, size_t NumFileIDs);
160 };
161 
162 /// Reader for the coverage mapping data that is emitted by the
163 /// frontend and stored in an object file.
164 class BinaryCoverageReader : public CoverageMappingReader {
165 public:
166   struct ProfileMappingRecord {
167     CovMapVersion Version;
168     StringRef FunctionName;
169     uint64_t FunctionHash;
170     StringRef CoverageMapping;
171     size_t FilenamesBegin;
172     size_t FilenamesSize;
173 
174     ProfileMappingRecord(CovMapVersion Version, StringRef FunctionName,
175                          uint64_t FunctionHash, StringRef CoverageMapping,
176                          size_t FilenamesBegin, size_t FilenamesSize)
177         : Version(Version), FunctionName(FunctionName),
178           FunctionHash(FunctionHash), CoverageMapping(CoverageMapping),
179           FilenamesBegin(FilenamesBegin), FilenamesSize(FilenamesSize) {}
180   };
181 
182   using FuncRecordsStorage = std::unique_ptr<MemoryBuffer>;
183 
184 private:
185   std::vector<std::string> Filenames;
186   std::vector<ProfileMappingRecord> MappingRecords;
187   InstrProfSymtab ProfileNames;
188   size_t CurrentRecord = 0;
189   std::vector<StringRef> FunctionsFilenames;
190   std::vector<CounterExpression> Expressions;
191   std::vector<CounterMappingRegion> MappingRegions;
192 
193   // Used to tie the lifetimes of coverage function records to the lifetime of
194   // this BinaryCoverageReader instance. Needed to support the format change in
195   // D69471, which can split up function records into multiple sections on ELF.
196   FuncRecordsStorage FuncRecords;
197 
198   BinaryCoverageReader(FuncRecordsStorage &&FuncRecords)
199       : FuncRecords(std::move(FuncRecords)) {}
200 
201 public:
202   BinaryCoverageReader(const BinaryCoverageReader &) = delete;
203   BinaryCoverageReader &operator=(const BinaryCoverageReader &) = delete;
204 
205   static Expected<std::vector<std::unique_ptr<BinaryCoverageReader>>>
206   create(MemoryBufferRef ObjectBuffer, StringRef Arch,
207          SmallVectorImpl<std::unique_ptr<MemoryBuffer>> &ObjectFileBuffers,
208          StringRef CompilationDir = "");
209 
210   static Expected<std::unique_ptr<BinaryCoverageReader>>
211   createCoverageReaderFromBuffer(StringRef Coverage,
212                                  FuncRecordsStorage &&FuncRecords,
213                                  InstrProfSymtab &&ProfileNames,
214                                  uint8_t BytesInAddress,
215                                  support::endianness Endian,
216                                  StringRef CompilationDir = "");
217 
218   Error readNextRecord(CoverageMappingRecord &Record) override;
219 };
220 
221 /// Reader for the raw coverage filenames.
222 class RawCoverageFilenamesReader : public RawCoverageReader {
223   std::vector<std::string> &Filenames;
224   StringRef CompilationDir;
225 
226   // Read an uncompressed sequence of filenames.
227   Error readUncompressed(CovMapVersion Version, uint64_t NumFilenames);
228 
229 public:
230   RawCoverageFilenamesReader(StringRef Data,
231                              std::vector<std::string> &Filenames,
232                              StringRef CompilationDir = "")
233       : RawCoverageReader(Data), Filenames(Filenames),
234         CompilationDir(CompilationDir) {}
235   RawCoverageFilenamesReader(const RawCoverageFilenamesReader &) = delete;
236   RawCoverageFilenamesReader &
237   operator=(const RawCoverageFilenamesReader &) = delete;
238 
239   Error read(CovMapVersion Version);
240 };
241 
242 } // end namespace coverage
243 } // end namespace llvm
244 
245 #endif // LLVM_PROFILEDATA_COVERAGE_COVERAGEMAPPINGREADER_H
246