Class InstructionParser

lib/Bytecode/Reader/BytecodeReader.cpp:1131–1882

// above.

class InstructionParser {
  //===----------------------------------------------------------------------===//
  // Helper for Operation Creation and Result Handling
  //===----------------------------------------------------------------------===//
  /// Creates an operation using OperationState and pushes its results to the
  /// valueIndexList. The numResultsForValueIndex parameter controls how many
  /// results are added to valueIndexList.
  static LogicalResult createOperationGeneric(
      OpBuilder &builder, Location loc, StringRef opNameStr,
      ArrayRef<Type> resultTypes, ArrayRef<Value> operands,
      ArrayRef<NamedAttribute> attributes, std::vector<Value> &valueIndexList,
      SmallVectorImpl<std::unique_ptr<Region>> &parsedRegions,
      std::optional<size_t> numResultsForValueIndex = std::nullopt) {
    OperationState state(loc, opNameStr, operands, resultTypes, attributes);

    // Add parsed regions to the operation state.
    for (auto &region_ptr : parsedRegions)
      state.addRegion(std::move(region_ptr));

    Operation *op = builder.create(state);
    // Operation creation using OperationState can fail if verification fails.
    // Emit an error noting the failure.
    if (!op)
      return ::emitError(loc) << "failed to create operation '" << opNameStr
                              << "'due to verification error.";
    // Add results to the value index list. Only add numResultsForValueIndex
    // results if specified (for backward compat with older bytecode that
    // didn't have newer results).
    size_t numToAdd = numResultsForValueIndex.value_or(op->getNumResults());
    for (size_t i = 0; i < numToAdd; ++i)
      valueIndexList.push_back(op->getResult(i));

    return success();
  }

  /// Parses operand indices and returns the corresponding Values from the
  /// valueIndexList. If numOperandsToRead is std::nullopt, it first reads the
  /// number of operands as a VarInt. Otherwise, it uses the provided count.
  static LogicalResult
  parseOperands(EncodingReader &reader, Location loc,
                ArrayRef<Value> valueIndexList, SmallVectorImpl<Value> &results,
                std::optional<uint64_t> numOperandsToRead = std::nullopt) {
    uint64_t numOperands;
    if (numOperandsToRead.has_value())
      numOperands = *numOperandsToRead;
    else if (failed(reader.readVarInt(
                 numOperands, std::numeric_limits<uint32_t>::max() - 1)))
      return reader.emitError() << "failed to read operand count";

    results.reserve(numOperands);
    for (uint64_t i = 0; i < numOperands; ++i) {
      uint64_t operandIdx;
      if (failed(reader.readVarInt(operandIdx)))
        return reader.emitError() << "failed to read operand index " << i;
      if (operandIdx >= valueIndexList.size())
        return reader.emitError()
               << "operand index " << operandIdx
               << " out of bounds (size=" << valueIndexList.size()