include/llvm/Object/StackMapParser.h

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