Class LazyTypeTable

lib/Bytecode/Reader/BytecodeReader.cpp:481–605

//
namespace {
class LazyTypeTable {
public:
  LazyTypeTable(MLIRContext &context) : context(context) {}

  void initialize(ArrayRef<uint8_t> payloadData, ArrayRef<uint32_t> indices,
                  const BytecodeVersion &version) {
    payload = payloadData;
    typeStartIndices = indices;
    typeCache.resize(indices.size());
    fileVersion = version;
  }

  Type getType(uint64_t typeIndex) {
    if (typeIndex >= typeCache.size())
      return Type();
    if (typeCache[typeIndex])
      return typeCache[typeIndex];

    // Check for recursion.
    if (currentlyParsing.count(typeIndex))
      return Type();
    // Mark this type as currently being parsed.
    currentlyParsing.insert(typeIndex);
    [[maybe_unused]] llvm::scope_exit removeIndex(
        [&] { currentlyParsing.erase(typeIndex); });
    // Calculate the boundaries for the type data.
    uint32_t start = typeStartIndices[typeIndex];
    uint32_t end = (typeIndex + 1 < typeStartIndices.size())
                       ? typeStartIndices[typeIndex + 1]
                       : payload.size();
    if (end < start || end > payload.size())
      return Type();
    // Parse the type from its specific byte slice.
    EncodingReader typeReader(payload.slice(start, end - start), context);
    uint64_t typeTag;
    if (failed(typeReader.readVarInt(typeTag)))
      return nullptr;
    ArrayRef<uint8_t> payloadBytes;
    if (typeReader.remaining() > 0)
      payloadBytes = typeReader.readBytes(typeReader.remaining());
    Type parsedType;
    if (failed(parseTypeImpl(typeTag, payloadBytes, parsedType)))
      return Type();

    // Cache the result.
    typeCache[typeIndex] = parsedType;
    return parsedType;
  }

  size_t size() const { return typeStartIndices.size(); }

  /// Returns the bytecode file version.
  BytecodeVersion getFileVersion() const { return fileVersion; }

  /// Reads a type index using the provided reader and retrieves the
  /// corresponding Type. Emits an error and returns a null Type on failure.
  Type readAndGetType(EncodingReader &reader) {
    uint64_t typeIndex;