Method writeBlock

lib/Bytecode/Writer/BytecodeWriter.cpp:1444–1477

Handles writing blocks. block-bytecode =: numArgs[varint] argTypeIndex[varint]* // Type indices for each block argument. numOps[varint] instruction* // Bytecode for each operation in the block.

  ///   numOps[varint]
  ///   instruction*           // Bytecode for each operation in the block.
  LogicalResult writeBlock(Block &block, EncodingWriter &writer) {
    // Record the current nextValueIndex. This will be restored after processing
    // the block, effectively rolling back the indices used within this block.
    uint64_t originalNextValueIndex = nextValueIndex;

    // Process block arguments.
    writer.writeVarInt(block.getNumArguments());
    for (BlockArgument arg : block.getArguments()) {
      if (failed(typeMgr.writeTypeIndex(arg.getType(), writer)))
        return failure();
      // Assign a new index to the block argument.
      // Block arguments are always new values in this scope.
      assert(!valueIndexMap.count(arg) &&
             "block argument encountered that is already in valueIndexMap for "
             "this scope");
      valueIndexMap[arg] = nextValueIndex++;
    }

    // Write number of operations in the block.
    writer.writeVarInt(block.getOperations().size());
    // Process operations in the block.
    for (Operation &op : block)
      if (failed(writeOperation(&op, writer)))
        return failure();

    // Remove all of the entries added during parsing of this block.
    for (uint64_t i = 0, e = nextValueIndex - originalNextValueIndex; i < e;
         ++i)
      valueIndexMap.pop_back();

    // Restore nextValueIndex to what it was before this block.
    nextValueIndex = originalNextValueIndex;
    return success();
  }

private:
  llvm::MapVector<Value, uint64_t> valueIndexMap;