109467b48Spatrick //===- StackMapParser.h - StackMap Parsing Support --------------*- C++ -*-===// 209467b48Spatrick // 309467b48Spatrick // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 409467b48Spatrick // See https://llvm.org/LICENSE.txt for license information. 509467b48Spatrick // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 609467b48Spatrick // 709467b48Spatrick //===----------------------------------------------------------------------===// 809467b48Spatrick 9*73471bf0Spatrick #ifndef LLVM_OBJECT_STACKMAPPARSER_H 10*73471bf0Spatrick #define LLVM_OBJECT_STACKMAPPARSER_H 1109467b48Spatrick 1209467b48Spatrick #include "llvm/ADT/ArrayRef.h" 1309467b48Spatrick #include "llvm/ADT/iterator_range.h" 14*73471bf0Spatrick #include "llvm/Object/ELF.h" 1509467b48Spatrick #include "llvm/Support/Endian.h" 1609467b48Spatrick #include <cassert> 1709467b48Spatrick #include <cstddef> 1809467b48Spatrick #include <cstdint> 1909467b48Spatrick #include <vector> 2009467b48Spatrick 2109467b48Spatrick namespace llvm { 2209467b48Spatrick 2309467b48Spatrick /// A parser for the latest stackmap format. At the moment, latest=V3. 2409467b48Spatrick template <support::endianness Endianness> 2509467b48Spatrick class StackMapParser { 2609467b48Spatrick public: 2709467b48Spatrick template <typename AccessorT> 2809467b48Spatrick class AccessorIterator { 2909467b48Spatrick public: AccessorIterator(AccessorT A)3009467b48Spatrick AccessorIterator(AccessorT A) : A(A) {} 3109467b48Spatrick 3209467b48Spatrick AccessorIterator& operator++() { A = A.next(); return *this; } 3309467b48Spatrick AccessorIterator operator++(int) { 3409467b48Spatrick auto tmp = *this; 3509467b48Spatrick ++*this; 3609467b48Spatrick return tmp; 3709467b48Spatrick } 3809467b48Spatrick 39*73471bf0Spatrick bool operator==(const AccessorIterator &Other) const { 4009467b48Spatrick return A.P == Other.A.P; 4109467b48Spatrick } 4209467b48Spatrick 43*73471bf0Spatrick bool operator!=(const AccessorIterator &Other) const { 44*73471bf0Spatrick return !(*this == Other); 45*73471bf0Spatrick } 4609467b48Spatrick 4709467b48Spatrick AccessorT& operator*() { return A; } 4809467b48Spatrick AccessorT* operator->() { return &A; } 4909467b48Spatrick 5009467b48Spatrick private: 5109467b48Spatrick AccessorT A; 5209467b48Spatrick }; 5309467b48Spatrick 5409467b48Spatrick /// Accessor for function records. 5509467b48Spatrick class FunctionAccessor { 5609467b48Spatrick friend class StackMapParser; 5709467b48Spatrick 5809467b48Spatrick public: 5909467b48Spatrick /// Get the function address. getFunctionAddress()6009467b48Spatrick uint64_t getFunctionAddress() const { 6109467b48Spatrick return read<uint64_t>(P); 6209467b48Spatrick } 6309467b48Spatrick 6409467b48Spatrick /// Get the function's stack size. getStackSize()6509467b48Spatrick uint64_t getStackSize() const { 6609467b48Spatrick return read<uint64_t>(P + sizeof(uint64_t)); 6709467b48Spatrick } 6809467b48Spatrick 6909467b48Spatrick /// Get the number of callsite records. getRecordCount()7009467b48Spatrick uint64_t getRecordCount() const { 7109467b48Spatrick return read<uint64_t>(P + (2 * sizeof(uint64_t))); 7209467b48Spatrick } 7309467b48Spatrick 7409467b48Spatrick private: FunctionAccessor(const uint8_t * P)7509467b48Spatrick FunctionAccessor(const uint8_t *P) : P(P) {} 7609467b48Spatrick 7709467b48Spatrick const static int FunctionAccessorSize = 3 * sizeof(uint64_t); 7809467b48Spatrick next()7909467b48Spatrick FunctionAccessor next() const { 8009467b48Spatrick return FunctionAccessor(P + FunctionAccessorSize); 8109467b48Spatrick } 8209467b48Spatrick 8309467b48Spatrick const uint8_t *P; 8409467b48Spatrick }; 8509467b48Spatrick 8609467b48Spatrick /// Accessor for constants. 8709467b48Spatrick class ConstantAccessor { 8809467b48Spatrick friend class StackMapParser; 8909467b48Spatrick 9009467b48Spatrick public: 9109467b48Spatrick /// Return the value of this constant. getValue()9209467b48Spatrick uint64_t getValue() const { return read<uint64_t>(P); } 9309467b48Spatrick 9409467b48Spatrick private: ConstantAccessor(const uint8_t * P)9509467b48Spatrick ConstantAccessor(const uint8_t *P) : P(P) {} 9609467b48Spatrick 9709467b48Spatrick const static int ConstantAccessorSize = sizeof(uint64_t); 9809467b48Spatrick next()9909467b48Spatrick ConstantAccessor next() const { 10009467b48Spatrick return ConstantAccessor(P + ConstantAccessorSize); 10109467b48Spatrick } 10209467b48Spatrick 10309467b48Spatrick const uint8_t *P; 10409467b48Spatrick }; 10509467b48Spatrick 10609467b48Spatrick enum class LocationKind : uint8_t { 10709467b48Spatrick Register = 1, Direct = 2, Indirect = 3, Constant = 4, ConstantIndex = 5 10809467b48Spatrick }; 10909467b48Spatrick 11009467b48Spatrick /// Accessor for location records. 11109467b48Spatrick class LocationAccessor { 11209467b48Spatrick friend class StackMapParser; 11309467b48Spatrick friend class RecordAccessor; 11409467b48Spatrick 11509467b48Spatrick public: 11609467b48Spatrick /// Get the Kind for this location. getKind()11709467b48Spatrick LocationKind getKind() const { 11809467b48Spatrick return LocationKind(P[KindOffset]); 11909467b48Spatrick } 12009467b48Spatrick 12109467b48Spatrick /// Get the Size for this location. getSizeInBytes()12209467b48Spatrick unsigned getSizeInBytes() const { 12309467b48Spatrick return read<uint16_t>(P + SizeOffset); 12409467b48Spatrick 12509467b48Spatrick } 12609467b48Spatrick 12709467b48Spatrick /// Get the Dwarf register number for this location. getDwarfRegNum()12809467b48Spatrick uint16_t getDwarfRegNum() const { 12909467b48Spatrick return read<uint16_t>(P + DwarfRegNumOffset); 13009467b48Spatrick } 13109467b48Spatrick 13209467b48Spatrick /// Get the small-constant for this location. (Kind must be Constant). getSmallConstant()13309467b48Spatrick uint32_t getSmallConstant() const { 13409467b48Spatrick assert(getKind() == LocationKind::Constant && "Not a small constant."); 13509467b48Spatrick return read<uint32_t>(P + SmallConstantOffset); 13609467b48Spatrick } 13709467b48Spatrick 13809467b48Spatrick /// Get the constant-index for this location. (Kind must be ConstantIndex). getConstantIndex()13909467b48Spatrick uint32_t getConstantIndex() const { 14009467b48Spatrick assert(getKind() == LocationKind::ConstantIndex && 14109467b48Spatrick "Not a constant-index."); 14209467b48Spatrick return read<uint32_t>(P + SmallConstantOffset); 14309467b48Spatrick } 14409467b48Spatrick 14509467b48Spatrick /// Get the offset for this location. (Kind must be Direct or Indirect). getOffset()14609467b48Spatrick int32_t getOffset() const { 14709467b48Spatrick assert((getKind() == LocationKind::Direct || 14809467b48Spatrick getKind() == LocationKind::Indirect) && 14909467b48Spatrick "Not direct or indirect."); 15009467b48Spatrick return read<int32_t>(P + SmallConstantOffset); 15109467b48Spatrick } 15209467b48Spatrick 15309467b48Spatrick private: LocationAccessor(const uint8_t * P)15409467b48Spatrick LocationAccessor(const uint8_t *P) : P(P) {} 15509467b48Spatrick next()15609467b48Spatrick LocationAccessor next() const { 15709467b48Spatrick return LocationAccessor(P + LocationAccessorSize); 15809467b48Spatrick } 15909467b48Spatrick 16009467b48Spatrick static const int KindOffset = 0; 16109467b48Spatrick static const int SizeOffset = KindOffset + sizeof(uint16_t); 16209467b48Spatrick static const int DwarfRegNumOffset = SizeOffset + sizeof(uint16_t); 16309467b48Spatrick static const int SmallConstantOffset = DwarfRegNumOffset + sizeof(uint32_t); 16409467b48Spatrick static const int LocationAccessorSize = sizeof(uint64_t) + sizeof(uint32_t); 16509467b48Spatrick 16609467b48Spatrick const uint8_t *P; 16709467b48Spatrick }; 16809467b48Spatrick 16909467b48Spatrick /// Accessor for stackmap live-out fields. 17009467b48Spatrick class LiveOutAccessor { 17109467b48Spatrick friend class StackMapParser; 17209467b48Spatrick friend class RecordAccessor; 17309467b48Spatrick 17409467b48Spatrick public: 17509467b48Spatrick /// Get the Dwarf register number for this live-out. getDwarfRegNum()17609467b48Spatrick uint16_t getDwarfRegNum() const { 17709467b48Spatrick return read<uint16_t>(P + DwarfRegNumOffset); 17809467b48Spatrick } 17909467b48Spatrick 18009467b48Spatrick /// Get the size in bytes of live [sub]register. getSizeInBytes()18109467b48Spatrick unsigned getSizeInBytes() const { 18209467b48Spatrick return read<uint8_t>(P + SizeOffset); 18309467b48Spatrick } 18409467b48Spatrick 18509467b48Spatrick private: LiveOutAccessor(const uint8_t * P)18609467b48Spatrick LiveOutAccessor(const uint8_t *P) : P(P) {} 18709467b48Spatrick next()18809467b48Spatrick LiveOutAccessor next() const { 18909467b48Spatrick return LiveOutAccessor(P + LiveOutAccessorSize); 19009467b48Spatrick } 19109467b48Spatrick 19209467b48Spatrick static const int DwarfRegNumOffset = 0; 19309467b48Spatrick static const int SizeOffset = 19409467b48Spatrick DwarfRegNumOffset + sizeof(uint16_t) + sizeof(uint8_t); 19509467b48Spatrick static const int LiveOutAccessorSize = sizeof(uint32_t); 19609467b48Spatrick 19709467b48Spatrick const uint8_t *P; 19809467b48Spatrick }; 19909467b48Spatrick 20009467b48Spatrick /// Accessor for stackmap records. 20109467b48Spatrick class RecordAccessor { 20209467b48Spatrick friend class StackMapParser; 20309467b48Spatrick 20409467b48Spatrick public: 20509467b48Spatrick using location_iterator = AccessorIterator<LocationAccessor>; 20609467b48Spatrick using liveout_iterator = AccessorIterator<LiveOutAccessor>; 20709467b48Spatrick 20809467b48Spatrick /// Get the patchpoint/stackmap ID for this record. getID()20909467b48Spatrick uint64_t getID() const { 21009467b48Spatrick return read<uint64_t>(P + PatchpointIDOffset); 21109467b48Spatrick } 21209467b48Spatrick 21309467b48Spatrick /// Get the instruction offset (from the start of the containing function) 21409467b48Spatrick /// for this record. getInstructionOffset()21509467b48Spatrick uint32_t getInstructionOffset() const { 21609467b48Spatrick return read<uint32_t>(P + InstructionOffsetOffset); 21709467b48Spatrick } 21809467b48Spatrick 21909467b48Spatrick /// Get the number of locations contained in this record. getNumLocations()22009467b48Spatrick uint16_t getNumLocations() const { 22109467b48Spatrick return read<uint16_t>(P + NumLocationsOffset); 22209467b48Spatrick } 22309467b48Spatrick 22409467b48Spatrick /// Get the location with the given index. getLocation(unsigned LocationIndex)22509467b48Spatrick LocationAccessor getLocation(unsigned LocationIndex) const { 22609467b48Spatrick unsigned LocationOffset = 22709467b48Spatrick LocationListOffset + LocationIndex * LocationSize; 22809467b48Spatrick return LocationAccessor(P + LocationOffset); 22909467b48Spatrick } 23009467b48Spatrick 23109467b48Spatrick /// Begin iterator for locations. location_begin()23209467b48Spatrick location_iterator location_begin() const { 23309467b48Spatrick return location_iterator(getLocation(0)); 23409467b48Spatrick } 23509467b48Spatrick 23609467b48Spatrick /// End iterator for locations. location_end()23709467b48Spatrick location_iterator location_end() const { 23809467b48Spatrick return location_iterator(getLocation(getNumLocations())); 23909467b48Spatrick } 24009467b48Spatrick 24109467b48Spatrick /// Iterator range for locations. locations()24209467b48Spatrick iterator_range<location_iterator> locations() const { 24309467b48Spatrick return make_range(location_begin(), location_end()); 24409467b48Spatrick } 24509467b48Spatrick 24609467b48Spatrick /// Get the number of liveouts contained in this record. getNumLiveOuts()24709467b48Spatrick uint16_t getNumLiveOuts() const { 24809467b48Spatrick return read<uint16_t>(P + getNumLiveOutsOffset()); 24909467b48Spatrick } 25009467b48Spatrick 25109467b48Spatrick /// Get the live-out with the given index. getLiveOut(unsigned LiveOutIndex)25209467b48Spatrick LiveOutAccessor getLiveOut(unsigned LiveOutIndex) const { 25309467b48Spatrick unsigned LiveOutOffset = 25409467b48Spatrick getNumLiveOutsOffset() + sizeof(uint16_t) + LiveOutIndex * LiveOutSize; 25509467b48Spatrick return LiveOutAccessor(P + LiveOutOffset); 25609467b48Spatrick } 25709467b48Spatrick 25809467b48Spatrick /// Begin iterator for live-outs. liveouts_begin()25909467b48Spatrick liveout_iterator liveouts_begin() const { 26009467b48Spatrick return liveout_iterator(getLiveOut(0)); 26109467b48Spatrick } 26209467b48Spatrick 26309467b48Spatrick /// End iterator for live-outs. liveouts_end()26409467b48Spatrick liveout_iterator liveouts_end() const { 26509467b48Spatrick return liveout_iterator(getLiveOut(getNumLiveOuts())); 26609467b48Spatrick } 26709467b48Spatrick 26809467b48Spatrick /// Iterator range for live-outs. liveouts()26909467b48Spatrick iterator_range<liveout_iterator> liveouts() const { 27009467b48Spatrick return make_range(liveouts_begin(), liveouts_end()); 27109467b48Spatrick } 27209467b48Spatrick 27309467b48Spatrick private: RecordAccessor(const uint8_t * P)27409467b48Spatrick RecordAccessor(const uint8_t *P) : P(P) {} 27509467b48Spatrick getNumLiveOutsOffset()27609467b48Spatrick unsigned getNumLiveOutsOffset() const { 27709467b48Spatrick unsigned LocOffset = 27809467b48Spatrick ((LocationListOffset + LocationSize * getNumLocations()) + 7) & ~0x7; 27909467b48Spatrick return LocOffset + sizeof(uint16_t); 28009467b48Spatrick } 28109467b48Spatrick getSizeInBytes()28209467b48Spatrick unsigned getSizeInBytes() const { 28309467b48Spatrick unsigned RecordSize = 28409467b48Spatrick getNumLiveOutsOffset() + sizeof(uint16_t) + getNumLiveOuts() * LiveOutSize; 28509467b48Spatrick return (RecordSize + 7) & ~0x7; 28609467b48Spatrick } 28709467b48Spatrick next()28809467b48Spatrick RecordAccessor next() const { 28909467b48Spatrick return RecordAccessor(P + getSizeInBytes()); 29009467b48Spatrick } 29109467b48Spatrick 29209467b48Spatrick static const unsigned PatchpointIDOffset = 0; 29309467b48Spatrick static const unsigned InstructionOffsetOffset = 29409467b48Spatrick PatchpointIDOffset + sizeof(uint64_t); 29509467b48Spatrick static const unsigned NumLocationsOffset = 29609467b48Spatrick InstructionOffsetOffset + sizeof(uint32_t) + sizeof(uint16_t); 29709467b48Spatrick static const unsigned LocationListOffset = 29809467b48Spatrick NumLocationsOffset + sizeof(uint16_t); 29909467b48Spatrick static const unsigned LocationSize = sizeof(uint64_t) + sizeof(uint32_t); 30009467b48Spatrick static const unsigned LiveOutSize = sizeof(uint32_t); 30109467b48Spatrick 30209467b48Spatrick const uint8_t *P; 30309467b48Spatrick }; 30409467b48Spatrick 30509467b48Spatrick /// Construct a parser for a version-3 stackmap. StackMap data will be read 30609467b48Spatrick /// from the given array. StackMapParser(ArrayRef<uint8_t> StackMapSection)30709467b48Spatrick StackMapParser(ArrayRef<uint8_t> StackMapSection) 30809467b48Spatrick : StackMapSection(StackMapSection) { 30909467b48Spatrick ConstantsListOffset = FunctionListOffset + getNumFunctions() * FunctionSize; 31009467b48Spatrick 31109467b48Spatrick assert(StackMapSection[0] == 3 && 31209467b48Spatrick "StackMapParser can only parse version 3 stackmaps"); 31309467b48Spatrick 31409467b48Spatrick unsigned CurrentRecordOffset = 31509467b48Spatrick ConstantsListOffset + getNumConstants() * ConstantSize; 31609467b48Spatrick 31709467b48Spatrick for (unsigned I = 0, E = getNumRecords(); I != E; ++I) { 31809467b48Spatrick StackMapRecordOffsets.push_back(CurrentRecordOffset); 31909467b48Spatrick CurrentRecordOffset += 32009467b48Spatrick RecordAccessor(&StackMapSection[CurrentRecordOffset]).getSizeInBytes(); 32109467b48Spatrick } 32209467b48Spatrick } 32309467b48Spatrick 324*73471bf0Spatrick /// Validates the header of the specified stack map section. validateHeader(ArrayRef<uint8_t> StackMapSection)325*73471bf0Spatrick static Error validateHeader(ArrayRef<uint8_t> StackMapSection) { 326*73471bf0Spatrick // See the comment for StackMaps::emitStackmapHeader(). 327*73471bf0Spatrick if (StackMapSection.size() < 16) 328*73471bf0Spatrick return object::createError( 329*73471bf0Spatrick "the stack map section size (" + Twine(StackMapSection.size()) + 330*73471bf0Spatrick ") is less than the minimum possible size of its header (16)"); 331*73471bf0Spatrick 332*73471bf0Spatrick unsigned Version = StackMapSection[0]; 333*73471bf0Spatrick if (Version != 3) 334*73471bf0Spatrick return object::createError( 335*73471bf0Spatrick "the version (" + Twine(Version) + 336*73471bf0Spatrick ") of the stack map section is unsupported, the " 337*73471bf0Spatrick "supported version is 3"); 338*73471bf0Spatrick return Error::success(); 339*73471bf0Spatrick } 340*73471bf0Spatrick 34109467b48Spatrick using function_iterator = AccessorIterator<FunctionAccessor>; 34209467b48Spatrick using constant_iterator = AccessorIterator<ConstantAccessor>; 34309467b48Spatrick using record_iterator = AccessorIterator<RecordAccessor>; 34409467b48Spatrick 34509467b48Spatrick /// Get the version number of this stackmap. (Always returns 3). getVersion()34609467b48Spatrick unsigned getVersion() const { return 3; } 34709467b48Spatrick 34809467b48Spatrick /// Get the number of functions in the stack map. getNumFunctions()34909467b48Spatrick uint32_t getNumFunctions() const { 35009467b48Spatrick return read<uint32_t>(&StackMapSection[NumFunctionsOffset]); 35109467b48Spatrick } 35209467b48Spatrick 35309467b48Spatrick /// Get the number of large constants in the stack map. getNumConstants()35409467b48Spatrick uint32_t getNumConstants() const { 35509467b48Spatrick return read<uint32_t>(&StackMapSection[NumConstantsOffset]); 35609467b48Spatrick } 35709467b48Spatrick 35809467b48Spatrick /// Get the number of stackmap records in the stackmap. getNumRecords()35909467b48Spatrick uint32_t getNumRecords() const { 36009467b48Spatrick return read<uint32_t>(&StackMapSection[NumRecordsOffset]); 36109467b48Spatrick } 36209467b48Spatrick 36309467b48Spatrick /// Return an FunctionAccessor for the given function index. getFunction(unsigned FunctionIndex)36409467b48Spatrick FunctionAccessor getFunction(unsigned FunctionIndex) const { 36509467b48Spatrick return FunctionAccessor(StackMapSection.data() + 36609467b48Spatrick getFunctionOffset(FunctionIndex)); 36709467b48Spatrick } 36809467b48Spatrick 36909467b48Spatrick /// Begin iterator for functions. functions_begin()37009467b48Spatrick function_iterator functions_begin() const { 37109467b48Spatrick return function_iterator(getFunction(0)); 37209467b48Spatrick } 37309467b48Spatrick 37409467b48Spatrick /// End iterator for functions. functions_end()37509467b48Spatrick function_iterator functions_end() const { 37609467b48Spatrick return function_iterator( 37709467b48Spatrick FunctionAccessor(StackMapSection.data() + 37809467b48Spatrick getFunctionOffset(getNumFunctions()))); 37909467b48Spatrick } 38009467b48Spatrick 38109467b48Spatrick /// Iterator range for functions. functions()38209467b48Spatrick iterator_range<function_iterator> functions() const { 38309467b48Spatrick return make_range(functions_begin(), functions_end()); 38409467b48Spatrick } 38509467b48Spatrick 38609467b48Spatrick /// Return the large constant at the given index. getConstant(unsigned ConstantIndex)38709467b48Spatrick ConstantAccessor getConstant(unsigned ConstantIndex) const { 38809467b48Spatrick return ConstantAccessor(StackMapSection.data() + 38909467b48Spatrick getConstantOffset(ConstantIndex)); 39009467b48Spatrick } 39109467b48Spatrick 39209467b48Spatrick /// Begin iterator for constants. constants_begin()39309467b48Spatrick constant_iterator constants_begin() const { 39409467b48Spatrick return constant_iterator(getConstant(0)); 39509467b48Spatrick } 39609467b48Spatrick 39709467b48Spatrick /// End iterator for constants. constants_end()39809467b48Spatrick constant_iterator constants_end() const { 39909467b48Spatrick return constant_iterator( 40009467b48Spatrick ConstantAccessor(StackMapSection.data() + 40109467b48Spatrick getConstantOffset(getNumConstants()))); 40209467b48Spatrick } 40309467b48Spatrick 40409467b48Spatrick /// Iterator range for constants. constants()40509467b48Spatrick iterator_range<constant_iterator> constants() const { 40609467b48Spatrick return make_range(constants_begin(), constants_end()); 40709467b48Spatrick } 40809467b48Spatrick 40909467b48Spatrick /// Return a RecordAccessor for the given record index. getRecord(unsigned RecordIndex)41009467b48Spatrick RecordAccessor getRecord(unsigned RecordIndex) const { 41109467b48Spatrick std::size_t RecordOffset = StackMapRecordOffsets[RecordIndex]; 41209467b48Spatrick return RecordAccessor(StackMapSection.data() + RecordOffset); 41309467b48Spatrick } 41409467b48Spatrick 41509467b48Spatrick /// Begin iterator for records. records_begin()41609467b48Spatrick record_iterator records_begin() const { 41709467b48Spatrick if (getNumRecords() == 0) 41809467b48Spatrick return record_iterator(RecordAccessor(nullptr)); 41909467b48Spatrick return record_iterator(getRecord(0)); 42009467b48Spatrick } 42109467b48Spatrick 42209467b48Spatrick /// End iterator for records. records_end()42309467b48Spatrick record_iterator records_end() const { 42409467b48Spatrick // Records need to be handled specially, since we cache the start addresses 42509467b48Spatrick // for them: We can't just compute the 1-past-the-end address, we have to 42609467b48Spatrick // look at the last record and use the 'next' method. 42709467b48Spatrick if (getNumRecords() == 0) 42809467b48Spatrick return record_iterator(RecordAccessor(nullptr)); 42909467b48Spatrick return record_iterator(getRecord(getNumRecords() - 1).next()); 43009467b48Spatrick } 43109467b48Spatrick 43209467b48Spatrick /// Iterator range for records. records()43309467b48Spatrick iterator_range<record_iterator> records() const { 43409467b48Spatrick return make_range(records_begin(), records_end()); 43509467b48Spatrick } 43609467b48Spatrick 43709467b48Spatrick private: 43809467b48Spatrick template <typename T> read(const uint8_t * P)43909467b48Spatrick static T read(const uint8_t *P) { 44009467b48Spatrick return support::endian::read<T, Endianness, 1>(P); 44109467b48Spatrick } 44209467b48Spatrick 44309467b48Spatrick static const unsigned HeaderOffset = 0; 44409467b48Spatrick static const unsigned NumFunctionsOffset = HeaderOffset + sizeof(uint32_t); 44509467b48Spatrick static const unsigned NumConstantsOffset = NumFunctionsOffset + sizeof(uint32_t); 44609467b48Spatrick static const unsigned NumRecordsOffset = NumConstantsOffset + sizeof(uint32_t); 44709467b48Spatrick static const unsigned FunctionListOffset = NumRecordsOffset + sizeof(uint32_t); 44809467b48Spatrick 44909467b48Spatrick static const unsigned FunctionSize = 3 * sizeof(uint64_t); 45009467b48Spatrick static const unsigned ConstantSize = sizeof(uint64_t); 45109467b48Spatrick getFunctionOffset(unsigned FunctionIndex)45209467b48Spatrick std::size_t getFunctionOffset(unsigned FunctionIndex) const { 45309467b48Spatrick return FunctionListOffset + FunctionIndex * FunctionSize; 45409467b48Spatrick } 45509467b48Spatrick getConstantOffset(unsigned ConstantIndex)45609467b48Spatrick std::size_t getConstantOffset(unsigned ConstantIndex) const { 45709467b48Spatrick return ConstantsListOffset + ConstantIndex * ConstantSize; 45809467b48Spatrick } 45909467b48Spatrick 46009467b48Spatrick ArrayRef<uint8_t> StackMapSection; 46109467b48Spatrick unsigned ConstantsListOffset; 46209467b48Spatrick std::vector<unsigned> StackMapRecordOffsets; 46309467b48Spatrick }; 46409467b48Spatrick 46509467b48Spatrick } // end namespace llvm 46609467b48Spatrick 467*73471bf0Spatrick #endif // LLVM_OBJECT_STACKMAPPARSER_H 468