Function parseTypeSection

lib/Bytecode/Reader/BytecodeReader.cpp:609–648

Parses the type section and initializes the lazy type table

/// Parses the type section and initializes the lazy type table
static LogicalResult parseTypeSection(ArrayRef<uint8_t> payload,
                                      LazyTypeTable &types,
                                      MLIRContext &context,
                                      const BytecodeVersion &bytecodeVersion) {
  EncodingReader reader(payload, context);
  uint64_t numTypes;
  if (failed(reader.readVarInt(numTypes)))
    return failure();

  // Handle empty type table case.
  if (numTypes == 0) {
    types.initialize(ArrayRef<uint8_t>(), ArrayRef<uint32_t>(),
                     bytecodeVersion);
    return success();
  }

  if (numTypes > (payload.size() - reader.currentOffset()) / sizeof(uint32_t)) {
    return reader.emitError()
           << "number of types (" << numTypes << ") exceeds the maximum of "
           << (payload.size() - reader.currentOffset()) / sizeof(uint32_t)
           << " that can fit in the remaining payload of "
           << (payload.size() - reader.currentOffset()) << " bytes.";
  }

  // Ensure 4-byte alignment for the start indices array
  if (failed(reader.skipPadding(alignof(uint32_t))))
    return failure();
  // Read type start indices as a contiguous array
  const uint32_t *startIndicesPtr =
      reinterpret_cast<const uint32_t *>(reader.getCurrentPtr());
  if (!startIndicesPtr)
    return failure();
  ArrayRef<uint32_t> typeStartIndices(startIndicesPtr, numTypes);
  if (failed(reader.skip(numTypes * sizeof(uint32_t))))
    return failure();
  // Initialize the lazy type table with the payload and indices
  ArrayRef<uint8_t> typeData = payload.slice(reader.currentOffset());
  types.initialize(typeData, typeStartIndices, bytecodeVersion);
  return success();
}

//===----------------------------------------------------------------------===//
// Constant Section