LCOV - code coverage report
Current view: top level - include/llvm/Object - StackMapParser.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 72 228 31.6 %
Date: 2018-10-17 09:37:48 Functions: 3 64 4.7 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- StackMapParser.h - StackMap Parsing Support --------------*- 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             : #ifndef LLVM_CODEGEN_STACKMAPPARSER_H
      11             : #define LLVM_CODEGEN_STACKMAPPARSER_H
      12             : 
      13             : #include "llvm/ADT/ArrayRef.h"
      14             : #include "llvm/ADT/iterator_range.h"
      15             : #include "llvm/Support/Endian.h"
      16             : #include <cassert>
      17             : #include <cstddef>
      18             : #include <cstdint>
      19             : #include <vector>
      20             : 
      21             : namespace llvm {
      22             : 
      23             : template <support::endianness Endianness>
      24             : class StackMapV2Parser {
      25             : public:
      26             :   template <typename AccessorT>
      27             :   class AccessorIterator {
      28             :   public:
      29             :     AccessorIterator(AccessorT A) : A(A) {}
      30             : 
      31           0 :     AccessorIterator& operator++() { A = A.next(); return *this; }
      32             :     AccessorIterator operator++(int) {
      33             :       auto tmp = *this;
      34             :       ++*this;
      35             :       return tmp;
      36             :     }
      37             : 
      38           0 :     bool operator==(const AccessorIterator &Other) {
      39           0 :       return A.P == Other.A.P;
      40             :     }
      41           0 : 
      42           0 :     bool operator!=(const AccessorIterator &Other) { return !(*this == Other); }
      43             : 
      44           0 :     AccessorT& operator*() { return A; }
      45           0 :     AccessorT* operator->() { return &A; }
      46             : 
      47           0 :   private:
      48           0 :     AccessorT A;
      49             :   };
      50           0 : 
      51           0 :   /// Accessor for function records.
      52             :   class FunctionAccessor {
      53           0 :     friend class StackMapV2Parser;
      54           0 : 
      55             :   public:
      56           0 :     /// Get the function address.
      57           0 :     uint64_t getFunctionAddress() const {
      58             :       return read<uint64_t>(P);
      59           0 :     }
      60           0 : 
      61             :     /// Get the function's stack size.
      62           0 :     uint64_t getStackSize() const {
      63           0 :       return read<uint64_t>(P + sizeof(uint64_t));
      64             :     }
      65           0 : 
      66           0 :     /// Get the number of callsite records.
      67             :     uint64_t getRecordCount() const {
      68           0 :       return read<uint64_t>(P + (2 * sizeof(uint64_t)));
      69           0 :     }
      70             : 
      71             :   private:
      72           0 :     FunctionAccessor(const uint8_t *P) : P(P) {}
      73             : 
      74             :     const static int FunctionAccessorSize = 3 * sizeof(uint64_t);
      75             : 
      76             :     FunctionAccessor next() const {
      77             :       return FunctionAccessor(P + FunctionAccessorSize);
      78             :     }
      79             : 
      80             :     const uint8_t *P;
      81             :   };
      82             : 
      83             :   /// Accessor for constants.
      84             :   class ConstantAccessor {
      85             :     friend class StackMapV2Parser;
      86             : 
      87           0 :   public:
      88           0 :     /// Return the value of this constant.
      89             :     uint64_t getValue() const { return read<uint64_t>(P); }
      90           0 : 
      91           0 :   private:
      92             :     ConstantAccessor(const uint8_t *P) : P(P) {}
      93           0 : 
      94           0 :     const static int ConstantAccessorSize = sizeof(uint64_t);
      95             : 
      96             :     ConstantAccessor next() const {
      97             :       return ConstantAccessor(P + ConstantAccessorSize);
      98           0 :     }
      99          16 : 
     100             :     const uint8_t *P;
     101           0 :   };
     102           0 : 
     103             :   enum class LocationKind : uint8_t {
     104           0 :     Register = 1, Direct = 2, Indirect = 3, Constant = 4, ConstantIndex = 5
     105           0 :   };
     106             : 
     107             :   /// Accessor for location records.
     108             :   class LocationAccessor {
     109           0 :     friend class StackMapV2Parser;
     110          16 :     friend class RecordAccessor;
     111             : 
     112           0 :   public:
     113           0 :     /// Get the Kind for this location.
     114             :     LocationKind getKind() const {
     115           0 :       return LocationKind(P[KindOffset]);
     116           0 :     }
     117             : 
     118             :     /// Get the Dwarf register number for this location.
     119             :     uint16_t getDwarfRegNum() const {
     120             :       return read<uint16_t>(P + DwarfRegNumOffset);
     121             :     }
     122             : 
     123             :     /// Get the small-constant for this location. (Kind must be Constant).
     124           0 :     uint32_t getSmallConstant() const {
     125          16 :       assert(getKind() == LocationKind::Constant && "Not a small constant.");
     126             :       return read<uint32_t>(P + SmallConstantOffset);
     127           0 :     }
     128           0 : 
     129             :     /// Get the constant-index for this location. (Kind must be ConstantIndex).
     130           0 :     uint32_t getConstantIndex() const {
     131           0 :       assert(getKind() == LocationKind::ConstantIndex &&
     132             :              "Not a constant-index.");
     133             :       return read<uint32_t>(P + SmallConstantOffset);
     134             :     }
     135             : 
     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);
     142             :     }
     143           0 : 
     144             :   private:
     145             :     LocationAccessor(const uint8_t *P) : P(P) {}
     146             : 
     147             :     LocationAccessor next() const {
     148             :       return LocationAccessor(P + LocationAccessorSize);
     149             :     }
     150           0 : 
     151           3 :     static const int KindOffset = 0;
     152             :     static const int DwarfRegNumOffset = KindOffset + sizeof(uint16_t);
     153           0 :     static const int SmallConstantOffset = DwarfRegNumOffset + sizeof(uint16_t);
     154           0 :     static const int LocationAccessorSize = sizeof(uint64_t);
     155             : 
     156           0 :     const uint8_t *P;
     157           0 :   };
     158             : 
     159             :   /// Accessor for stackmap live-out fields.
     160             :   class LiveOutAccessor {
     161             :     friend class StackMapV2Parser;
     162             :     friend class RecordAccessor;
     163             : 
     164             :   public:
     165             :     /// Get the Dwarf register number for this live-out.
     166             :     uint16_t getDwarfRegNum() const {
     167             :       return read<uint16_t>(P + DwarfRegNumOffset);
     168             :     }
     169             : 
     170             :     /// Get the size in bytes of live [sub]register.
     171             :     unsigned getSizeInBytes() const {
     172             :       return read<uint8_t>(P + SizeOffset);
     173             :     }
     174           0 : 
     175          66 :   private:
     176             :     LiveOutAccessor(const uint8_t *P) : P(P) {}
     177           0 : 
     178           0 :     LiveOutAccessor next() const {
     179             :       return LiveOutAccessor(P + LiveOutAccessorSize);
     180           0 :     }
     181           0 : 
     182             :     static const int DwarfRegNumOffset = 0;
     183             :     static const int SizeOffset =
     184             :       DwarfRegNumOffset + sizeof(uint16_t) + sizeof(uint8_t);
     185           0 :     static const int LiveOutAccessorSize = sizeof(uint32_t);
     186          53 : 
     187             :     const uint8_t *P;
     188           0 :   };
     189           0 : 
     190             :   /// Accessor for stackmap records.
     191           0 :   class RecordAccessor {
     192           0 :     friend class StackMapV2Parser;
     193             : 
     194             :   public:
     195             :     using location_iterator = AccessorIterator<LocationAccessor>;
     196           0 :     using liveout_iterator = AccessorIterator<LiveOutAccessor>;
     197             : 
     198          10 :     /// Get the patchpoint/stackmap ID for this record.
     199             :     uint64_t getID() const {
     200           0 :       return read<uint64_t>(P + PatchpointIDOffset);
     201             :     }
     202           0 : 
     203             :     /// Get the instruction offset (from the start of the containing function)
     204           0 :     /// for this record.
     205             :     uint32_t getInstructionOffset() const {
     206           0 :       return read<uint32_t>(P + InstructionOffsetOffset);
     207             :     }
     208             : 
     209             :     /// Get the number of locations contained in this record.
     210           0 :     uint16_t getNumLocations() const {
     211             :       return read<uint16_t>(P + NumLocationsOffset);
     212             :     }
     213           3 : 
     214             :     /// Get the location with the given index.
     215           0 :     LocationAccessor getLocation(unsigned LocationIndex) const {
     216             :       unsigned LocationOffset =
     217             :         LocationListOffset + LocationIndex * LocationSize;
     218           0 :       return LocationAccessor(P + LocationOffset);
     219             :     }
     220           0 : 
     221             :     /// Begin iterator for locations.
     222             :     location_iterator location_begin() const {
     223           0 :       return location_iterator(getLocation(0));
     224             :     }
     225             : 
     226             :     /// End iterator for locations.
     227           0 :     location_iterator location_end() const {
     228             :       return location_iterator(getLocation(getNumLocations()));
     229             :     }
     230             : 
     231          18 :     /// Iterator range for locations.
     232             :     iterator_range<location_iterator> locations() const {
     233           0 :       return make_range(location_begin(), location_end());
     234             :     }
     235             : 
     236             :     /// Get the number of liveouts contained in this record.
     237           0 :     uint16_t getNumLiveOuts() const {
     238             :       return read<uint16_t>(P + getNumLiveOutsOffset());
     239           0 :     }
     240             : 
     241             :     /// Get the live-out with the given index.
     242             :     LiveOutAccessor getLiveOut(unsigned LiveOutIndex) const {
     243           0 :       unsigned LiveOutOffset =
     244             :         getNumLiveOutsOffset() + sizeof(uint16_t) + LiveOutIndex * LiveOutSize;
     245             :       return LiveOutAccessor(P + LiveOutOffset);
     246             :     }
     247             : 
     248             :     /// Begin iterator for live-outs.
     249           0 :     liveout_iterator liveouts_begin() const {
     250          66 :       return liveout_iterator(getLiveOut(0));
     251             :     }
     252           0 : 
     253           0 :     /// End iterator for live-outs.
     254             :     liveout_iterator liveouts_end() const {
     255           0 :       return liveout_iterator(getLiveOut(getNumLiveOuts()));
     256           0 :     }
     257             : 
     258             :     /// Iterator range for live-outs.
     259             :     iterator_range<liveout_iterator> liveouts() const {
     260             :       return make_range(liveouts_begin(), liveouts_end());
     261             :     }
     262             : 
     263             :   private:
     264             :     RecordAccessor(const uint8_t *P) : P(P) {}
     265             : 
     266             :     unsigned getNumLiveOutsOffset() const {
     267             :       return LocationListOffset + LocationSize * getNumLocations() +
     268             :              sizeof(uint16_t);
     269             :     }
     270             : 
     271             :     unsigned getSizeInBytes() const {
     272             :       unsigned RecordSize =
     273             :         getNumLiveOutsOffset() + sizeof(uint16_t) + getNumLiveOuts() * LiveOutSize;
     274           0 :       return (RecordSize + 7) & ~0x7;
     275           0 :     }
     276             : 
     277           0 :     RecordAccessor next() const {
     278           0 :       return RecordAccessor(P + getSizeInBytes());
     279             :     }
     280           0 : 
     281           0 :     static const unsigned PatchpointIDOffset = 0;
     282             :     static const unsigned InstructionOffsetOffset =
     283             :       PatchpointIDOffset + sizeof(uint64_t);
     284             :     static const unsigned NumLocationsOffset =
     285           0 :       InstructionOffsetOffset + sizeof(uint32_t) + sizeof(uint16_t);
     286          10 :     static const unsigned LocationListOffset =
     287             :       NumLocationsOffset + sizeof(uint16_t);
     288           0 :     static const unsigned LocationSize = sizeof(uint64_t);
     289           0 :     static const unsigned LiveOutSize = sizeof(uint32_t);
     290             : 
     291           0 :     const uint8_t *P;
     292           0 :   };
     293             : 
     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           0 :     ConstantsListOffset = FunctionListOffset + getNumFunctions() * FunctionSize;
     299          10 : 
     300             :     assert(StackMapSection[0] == 2 &&
     301           0 :            "StackMapV2Parser can only parse version 2 stackmaps");
     302           0 : 
     303             :     unsigned CurrentRecordOffset =
     304           0 :       ConstantsListOffset + getNumConstants() * ConstantSize;
     305           0 : 
     306             :     for (unsigned I = 0, E = getNumRecords(); I != E; ++I) {
     307             :       StackMapRecordOffsets.push_back(CurrentRecordOffset);
     308             :       CurrentRecordOffset +=
     309             :         RecordAccessor(&StackMapSection[CurrentRecordOffset]).getSizeInBytes();
     310             :     }
     311             :   }
     312             : 
     313             :   using function_iterator = AccessorIterator<FunctionAccessor>;
     314             :   using constant_iterator = AccessorIterator<ConstantAccessor>;
     315             :   using record_iterator = AccessorIterator<RecordAccessor>;
     316             : 
     317             :   /// Get the version number of this stackmap. (Always returns 2).
     318             :   unsigned getVersion() const { return 2; }
     319             : 
     320             :   /// Get the number of functions in the stack map.
     321             :   uint32_t getNumFunctions() const {
     322             :     return read<uint32_t>(&StackMapSection[NumFunctionsOffset]);
     323             :   }
     324             : 
     325           0 :   /// Get the number of large constants in the stack map.
     326           0 :   uint32_t getNumConstants() const {
     327             :     return read<uint32_t>(&StackMapSection[NumConstantsOffset]);
     328           0 :   }
     329           0 : 
     330             :   /// Get the number of stackmap records in the stackmap.
     331           0 :   uint32_t getNumRecords() const {
     332           0 :     return read<uint32_t>(&StackMapSection[NumRecordsOffset]);
     333             :   }
     334             : 
     335             :   /// Return an FunctionAccessor for the given function index.
     336             :   FunctionAccessor getFunction(unsigned FunctionIndex) const {
     337           0 :     return FunctionAccessor(StackMapSection.data() +
     338          20 :                             getFunctionOffset(FunctionIndex));
     339             :   }
     340           0 : 
     341           0 :   /// Begin iterator for functions.
     342             :   function_iterator functions_begin() const {
     343           0 :     return function_iterator(getFunction(0));
     344           0 :   }
     345             : 
     346             :   /// End iterator for functions.
     347             :   function_iterator functions_end() const {
     348           0 :     return function_iterator(
     349          40 :              FunctionAccessor(StackMapSection.data() +
     350             :                               getFunctionOffset(getNumFunctions())));
     351           0 :   }
     352           0 : 
     353             :   /// Iterator range for functions.
     354           0 :   iterator_range<function_iterator> functions() const {
     355           0 :     return make_range(functions_begin(), functions_end());
     356             :   }
     357             : 
     358             :   /// Return the large constant at the given index.
     359           0 :   ConstantAccessor getConstant(unsigned ConstantIndex) const {
     360          20 :     return ConstantAccessor(StackMapSection.data() +
     361             :                             getConstantOffset(ConstantIndex));
     362          20 :   }
     363             : 
     364           0 :   /// Begin iterator for constants.
     365           0 :   constant_iterator constants_begin() const {
     366             :     return constant_iterator(getConstant(0));
     367           0 :   }
     368             : 
     369           0 :   /// End iterator for constants.
     370           0 :   constant_iterator constants_end() const {
     371             :     return constant_iterator(
     372           0 :              ConstantAccessor(StackMapSection.data() +
     373             :                               getConstantOffset(getNumConstants())));
     374             :   }
     375             : 
     376             :   /// Iterator range for constants.
     377             :   iterator_range<constant_iterator> constants() const {
     378             :     return make_range(constants_begin(), constants_end());
     379             :   }
     380             : 
     381             :   /// Return a RecordAccessor for the given record index.
     382          20 :   RecordAccessor getRecord(unsigned RecordIndex) const {
     383             :     std::size_t RecordOffset = StackMapRecordOffsets[RecordIndex];
     384             :     return RecordAccessor(StackMapSection.data() + RecordOffset);
     385             :   }
     386             : 
     387             :   /// Begin iterator for records.
     388             :   record_iterator records_begin() const {
     389             :     if (getNumRecords() == 0)
     390             :       return record_iterator(RecordAccessor(nullptr));
     391           0 :     return record_iterator(getRecord(0));
     392          81 :   }
     393             : 
     394           0 :   /// End iterator for records.
     395           0 :   record_iterator records_end() const {
     396             :     // Records need to be handled specially, since we cache the start addresses
     397           0 :     // for them: We can't just compute the 1-past-the-end address, we have to
     398           0 :     // 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());
     402             :   }
     403          40 : 
     404          20 :   /// Iterator range for records.
     405          40 :   iterator_range<record_iterator> records() const {
     406             :     return make_range(records_begin(), records_end());
     407             :   }
     408             : 
     409             : private:
     410             :   template <typename T>
     411             :   static T read(const uint8_t *P) {
     412             :     return support::endian::read<T, Endianness, 1>(P);
     413             :   }
     414           0 : 
     415          20 :   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           0 :   static const unsigned FunctionListOffset = NumRecordsOffset + sizeof(uint32_t);
     420           0 : 
     421             :   static const unsigned FunctionSize = 3 * sizeof(uint64_t);
     422             :   static const unsigned ConstantSize = sizeof(uint64_t);
     423             : 
     424           0 :   std::size_t getFunctionOffset(unsigned FunctionIndex) const {
     425             :     return FunctionListOffset + FunctionIndex * FunctionSize;
     426             :   }
     427          81 : 
     428          81 :   std::size_t getConstantOffset(unsigned ConstantIndex) const {
     429             :     return ConstantsListOffset + ConstantIndex * ConstantSize;
     430             :   }
     431           0 : 
     432             :   ArrayRef<uint8_t> StackMapSection;
     433          41 :   unsigned ConstantsListOffset;
     434          41 :   std::vector<unsigned> StackMapRecordOffsets;
     435             : };
     436             : 
     437           0 : } // end namespace llvm
     438          20 : 
     439             : #endif // LLVM_CODEGEN_STACKMAPPARSER_H

Generated by: LCOV version 1.13