1 //===- StackMapParser.h - StackMap Parsing Support --------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLVM_CODEGEN_STACKMAPPARSER_H
11 #define LLVM_CODEGEN_STACKMAPPARSER_H
13 #include "llvm/ADT/ArrayRef.h"
14 #include "llvm/ADT/iterator_range.h"
15 #include "llvm/Support/Endian.h"
23 template <support::endianness Endianness>
24 class StackMapV2Parser {
26 template <typename AccessorT>
27 class AccessorIterator {
29 AccessorIterator(AccessorT A) : A(A) {}
31 AccessorIterator& operator++() { A = A.next(); return *this; }
32 AccessorIterator operator++(int) {
38 bool operator==(const AccessorIterator &Other) {
39 return A.P == Other.A.P;
42 bool operator!=(const AccessorIterator &Other) { return !(*this == Other); }
44 AccessorT& operator*() { return A; }
45 AccessorT* operator->() { return &A; }
51 /// Accessor for function records.
52 class FunctionAccessor {
53 friend class StackMapV2Parser;
56 /// Get the function address.
57 uint64_t getFunctionAddress() const {
58 return read<uint64_t>(P);
61 /// Get the function's stack size.
62 uint64_t getStackSize() const {
63 return read<uint64_t>(P + sizeof(uint64_t));
66 /// Get the number of callsite records.
67 uint64_t getRecordCount() const {
68 return read<uint64_t>(P + (2 * sizeof(uint64_t)));
72 FunctionAccessor(const uint8_t *P) : P(P) {}
74 const static int FunctionAccessorSize = 3 * sizeof(uint64_t);
76 FunctionAccessor next() const {
77 return FunctionAccessor(P + FunctionAccessorSize);
83 /// Accessor for constants.
84 class ConstantAccessor {
85 friend class StackMapV2Parser;
88 /// Return the value of this constant.
89 uint64_t getValue() const { return read<uint64_t>(P); }
92 ConstantAccessor(const uint8_t *P) : P(P) {}
94 const static int ConstantAccessorSize = sizeof(uint64_t);
96 ConstantAccessor next() const {
97 return ConstantAccessor(P + ConstantAccessorSize);
103 enum class LocationKind : uint8_t {
104 Register = 1, Direct = 2, Indirect = 3, Constant = 4, ConstantIndex = 5
107 /// Accessor for location records.
108 class LocationAccessor {
109 friend class StackMapV2Parser;
110 friend class RecordAccessor;
113 /// Get the Kind for this location.
114 LocationKind getKind() const {
115 return LocationKind(P[KindOffset]);
118 /// Get the Dwarf register number for this location.
119 uint16_t getDwarfRegNum() const {
120 return read<uint16_t>(P + DwarfRegNumOffset);
123 /// Get the small-constant for this location. (Kind must be Constant).
124 uint32_t getSmallConstant() const {
125 assert(getKind() == LocationKind::Constant && "Not a small constant.");
126 return read<uint32_t>(P + SmallConstantOffset);
129 /// Get the constant-index for this location. (Kind must be ConstantIndex).
130 uint32_t getConstantIndex() const {
131 assert(getKind() == LocationKind::ConstantIndex &&
132 "Not a constant-index.");
133 return read<uint32_t>(P + SmallConstantOffset);
136 /// Get the offset for this location. (Kind must be Direct or Indirect).
137 int32_t getOffset() const {
138 assert((getKind() == LocationKind::Direct ||
139 getKind() == LocationKind::Indirect) &&
140 "Not direct or indirect.");
141 return read<int32_t>(P + SmallConstantOffset);
145 LocationAccessor(const uint8_t *P) : P(P) {}
147 LocationAccessor next() const {
148 return LocationAccessor(P + LocationAccessorSize);
151 static const int KindOffset = 0;
152 static const int DwarfRegNumOffset = KindOffset + sizeof(uint16_t);
153 static const int SmallConstantOffset = DwarfRegNumOffset + sizeof(uint16_t);
154 static const int LocationAccessorSize = sizeof(uint64_t);
159 /// Accessor for stackmap live-out fields.
160 class LiveOutAccessor {
161 friend class StackMapV2Parser;
162 friend class RecordAccessor;
165 /// Get the Dwarf register number for this live-out.
166 uint16_t getDwarfRegNum() const {
167 return read<uint16_t>(P + DwarfRegNumOffset);
170 /// Get the size in bytes of live [sub]register.
171 unsigned getSizeInBytes() const {
172 return read<uint8_t>(P + SizeOffset);
176 LiveOutAccessor(const uint8_t *P) : P(P) {}
178 LiveOutAccessor next() const {
179 return LiveOutAccessor(P + LiveOutAccessorSize);
182 static const int DwarfRegNumOffset = 0;
183 static const int SizeOffset =
184 DwarfRegNumOffset + sizeof(uint16_t) + sizeof(uint8_t);
185 static const int LiveOutAccessorSize = sizeof(uint32_t);
190 /// Accessor for stackmap records.
191 class RecordAccessor {
192 friend class StackMapV2Parser;
195 using location_iterator = AccessorIterator<LocationAccessor>;
196 using liveout_iterator = AccessorIterator<LiveOutAccessor>;
198 /// Get the patchpoint/stackmap ID for this record.
199 uint64_t getID() const {
200 return read<uint64_t>(P + PatchpointIDOffset);
203 /// Get the instruction offset (from the start of the containing function)
205 uint32_t getInstructionOffset() const {
206 return read<uint32_t>(P + InstructionOffsetOffset);
209 /// Get the number of locations contained in this record.
210 uint16_t getNumLocations() const {
211 return read<uint16_t>(P + NumLocationsOffset);
214 /// Get the location with the given index.
215 LocationAccessor getLocation(unsigned LocationIndex) const {
216 unsigned LocationOffset =
217 LocationListOffset + LocationIndex * LocationSize;
218 return LocationAccessor(P + LocationOffset);
221 /// Begin iterator for locations.
222 location_iterator location_begin() const {
223 return location_iterator(getLocation(0));
226 /// End iterator for locations.
227 location_iterator location_end() const {
228 return location_iterator(getLocation(getNumLocations()));
231 /// Iterator range for locations.
232 iterator_range<location_iterator> locations() const {
233 return make_range(location_begin(), location_end());
236 /// Get the number of liveouts contained in this record.
237 uint16_t getNumLiveOuts() const {
238 return read<uint16_t>(P + getNumLiveOutsOffset());
241 /// Get the live-out with the given index.
242 LiveOutAccessor getLiveOut(unsigned LiveOutIndex) const {
243 unsigned LiveOutOffset =
244 getNumLiveOutsOffset() + sizeof(uint16_t) + LiveOutIndex * LiveOutSize;
245 return LiveOutAccessor(P + LiveOutOffset);
248 /// Begin iterator for live-outs.
249 liveout_iterator liveouts_begin() const {
250 return liveout_iterator(getLiveOut(0));
253 /// End iterator for live-outs.
254 liveout_iterator liveouts_end() const {
255 return liveout_iterator(getLiveOut(getNumLiveOuts()));
258 /// Iterator range for live-outs.
259 iterator_range<liveout_iterator> liveouts() const {
260 return make_range(liveouts_begin(), liveouts_end());
264 RecordAccessor(const uint8_t *P) : P(P) {}
266 unsigned getNumLiveOutsOffset() const {
267 return LocationListOffset + LocationSize * getNumLocations() +
271 unsigned getSizeInBytes() const {
272 unsigned RecordSize =
273 getNumLiveOutsOffset() + sizeof(uint16_t) + getNumLiveOuts() * LiveOutSize;
274 return (RecordSize + 7) & ~0x7;
277 RecordAccessor next() const {
278 return RecordAccessor(P + getSizeInBytes());
281 static const unsigned PatchpointIDOffset = 0;
282 static const unsigned InstructionOffsetOffset =
283 PatchpointIDOffset + sizeof(uint64_t);
284 static const unsigned NumLocationsOffset =
285 InstructionOffsetOffset + sizeof(uint32_t) + sizeof(uint16_t);
286 static const unsigned LocationListOffset =
287 NumLocationsOffset + sizeof(uint16_t);
288 static const unsigned LocationSize = sizeof(uint64_t);
289 static const unsigned LiveOutSize = sizeof(uint32_t);
294 /// Construct a parser for a version-2 stackmap. StackMap data will be read
295 /// from the given array.
296 StackMapV2Parser(ArrayRef<uint8_t> StackMapSection)
297 : StackMapSection(StackMapSection) {
298 ConstantsListOffset = FunctionListOffset + getNumFunctions() * FunctionSize;
300 assert(StackMapSection[0] == 2 &&
301 "StackMapV2Parser can only parse version 2 stackmaps");
303 unsigned CurrentRecordOffset =
304 ConstantsListOffset + getNumConstants() * ConstantSize;
306 for (unsigned I = 0, E = getNumRecords(); I != E; ++I) {
307 StackMapRecordOffsets.push_back(CurrentRecordOffset);
308 CurrentRecordOffset +=
309 RecordAccessor(&StackMapSection[CurrentRecordOffset]).getSizeInBytes();
313 using function_iterator = AccessorIterator<FunctionAccessor>;
314 using constant_iterator = AccessorIterator<ConstantAccessor>;
315 using record_iterator = AccessorIterator<RecordAccessor>;
317 /// Get the version number of this stackmap. (Always returns 2).
318 unsigned getVersion() const { return 2; }
320 /// Get the number of functions in the stack map.
321 uint32_t getNumFunctions() const {
322 return read<uint32_t>(&StackMapSection[NumFunctionsOffset]);
325 /// Get the number of large constants in the stack map.
326 uint32_t getNumConstants() const {
327 return read<uint32_t>(&StackMapSection[NumConstantsOffset]);
330 /// Get the number of stackmap records in the stackmap.
331 uint32_t getNumRecords() const {
332 return read<uint32_t>(&StackMapSection[NumRecordsOffset]);
335 /// Return an FunctionAccessor for the given function index.
336 FunctionAccessor getFunction(unsigned FunctionIndex) const {
337 return FunctionAccessor(StackMapSection.data() +
338 getFunctionOffset(FunctionIndex));
341 /// Begin iterator for functions.
342 function_iterator functions_begin() const {
343 return function_iterator(getFunction(0));
346 /// End iterator for functions.
347 function_iterator functions_end() const {
348 return function_iterator(
349 FunctionAccessor(StackMapSection.data() +
350 getFunctionOffset(getNumFunctions())));
353 /// Iterator range for functions.
354 iterator_range<function_iterator> functions() const {
355 return make_range(functions_begin(), functions_end());
358 /// Return the large constant at the given index.
359 ConstantAccessor getConstant(unsigned ConstantIndex) const {
360 return ConstantAccessor(StackMapSection.data() +
361 getConstantOffset(ConstantIndex));
364 /// Begin iterator for constants.
365 constant_iterator constants_begin() const {
366 return constant_iterator(getConstant(0));
369 /// End iterator for constants.
370 constant_iterator constants_end() const {
371 return constant_iterator(
372 ConstantAccessor(StackMapSection.data() +
373 getConstantOffset(getNumConstants())));
376 /// Iterator range for constants.
377 iterator_range<constant_iterator> constants() const {
378 return make_range(constants_begin(), constants_end());
381 /// Return a RecordAccessor for the given record index.
382 RecordAccessor getRecord(unsigned RecordIndex) const {
383 std::size_t RecordOffset = StackMapRecordOffsets[RecordIndex];
384 return RecordAccessor(StackMapSection.data() + RecordOffset);
387 /// Begin iterator for records.
388 record_iterator records_begin() const {
389 if (getNumRecords() == 0)
390 return record_iterator(RecordAccessor(nullptr));
391 return record_iterator(getRecord(0));
394 /// End iterator for records.
395 record_iterator records_end() const {
396 // Records need to be handled specially, since we cache the start addresses
397 // for them: We can't just compute the 1-past-the-end address, we have to
398 // look at the last record and use the 'next' method.
399 if (getNumRecords() == 0)
400 return record_iterator(RecordAccessor(nullptr));
401 return record_iterator(getRecord(getNumRecords() - 1).next());
404 /// Iterator range for records.
405 iterator_range<record_iterator> records() const {
406 return make_range(records_begin(), records_end());
410 template <typename T>
411 static T read(const uint8_t *P) {
412 return support::endian::read<T, Endianness, 1>(P);
415 static const unsigned HeaderOffset = 0;
416 static const unsigned NumFunctionsOffset = HeaderOffset + sizeof(uint32_t);
417 static const unsigned NumConstantsOffset = NumFunctionsOffset + sizeof(uint32_t);
418 static const unsigned NumRecordsOffset = NumConstantsOffset + sizeof(uint32_t);
419 static const unsigned FunctionListOffset = NumRecordsOffset + sizeof(uint32_t);
421 static const unsigned FunctionSize = 3 * sizeof(uint64_t);
422 static const unsigned ConstantSize = sizeof(uint64_t);
424 std::size_t getFunctionOffset(unsigned FunctionIndex) const {
425 return FunctionListOffset + FunctionIndex * FunctionSize;
428 std::size_t getConstantOffset(unsigned ConstantIndex) const {
429 return ConstantsListOffset + ConstantIndex * ConstantSize;
432 ArrayRef<uint8_t> StackMapSection;
433 unsigned ConstantsListOffset;
434 std::vector<unsigned> StackMapRecordOffsets;
437 } // end namespace llvm
439 #endif // LLVM_CODEGEN_STACKMAPPARSER_H