Class EncodingReader

lib/Bytecode/Reader/BytecodeReader.cpp:89–282

//===----------------------------------------------------------------------===//
namespace {
class EncodingReader {
public:
  EncodingReader(ArrayRef<uint8_t> data, MLIRContext &context)
      : data(data), offset(0), context(context) {}

  LogicalResult readVarInt(uint64_t &result, uint64_t max = 0) {
    if (offset >= data.size())
      return failure();
    result = 0;
    uint64_t shift = 0;
    uint8_t byte;
    do {
      if (offset >= data.size() || shift > 63)
        return failure();
      byte = data[offset++];
      uint64_t value = byte & 0x7F;
      result |= (value << shift);
      shift += 7;
    } while (byte & 0x80);
    if (max && result > max)
      return emitError() << "varint value exceeds maximum supported"
                         << " capacity. (expected value less than " << max
                         << ", got " << result << ").";
    return success();
  }

  /// Parse a signed variable length encoded integer from the byte stream. A
  /// signed varint is encoded as a normal varint with zigzag encoding applied,
  /// i.e. the low bit of the value is used to indicate the sign.
  LogicalResult readSignedVarInt(uint64_t &result) {
    if (failed(readVarInt(result)))
      return failure();
    // Essentially (but using unsigned): (x >> 1) ^ -(x & 1).
    result = (result >> 1) ^ (~(result & 1) + 1);
    return success();
  }

  template <typename T>
  std::enable_if_t<std::is_integral<T>::value, LogicalResult> readLE(T &value) {
    if (offset + sizeof(T) > data.size())
      return failure();
    value = 0;
    for (size_t i = 0; i < sizeof(T); ++i)
      value |= static_cast<T>(data[offset++]) << (8 * i);
    return success();
  }

  template <typename T>
  std::enable_if_t<std::is_integral<T>::value, T> readLE() {
    T value = 0;
    if (failed(readLE(value)))
      return 0;
    return value;
  }

  template <typename T>
  std::enable_if_t<std::is_integral<T>::value, LogicalResult>
  readLE(size_t count, SmallVectorImpl<T> &result) {