serialization.cpp

Go to the documentation of this file.

#include "barretenberg/vm2/simulation/lib/serialization.hpp"
 
#include <cassert>
#include <cstdint>
#include <iomanip>
#include <span>
#include <sstream>
#include <string>
#include <unordered_map>
#include <variant>
#include <vector>
 
#include "barretenberg/common/log.hpp"
#include "barretenberg/common/serialize.hpp"
#include "barretenberg/numeric/uint256/uint256.hpp"
#include "barretenberg/vm2/common/addressing.hpp"
#include "barretenberg/vm2/common/instruction_spec.hpp"
#include "barretenberg/vm2/common/opcodes.hpp"
#include "barretenberg/vm2/common/stringify.hpp"
 
namespace bb::avm2::simulation {
 
namespace {
const std::unordered_map<OperandType, uint32_t>& get_operand_type_size_bytes()
{
    static const std::unordered_map<OperandType, uint32_t> OPERAND_TYPE_SIZE_BYTES = {
        { OperandType::INDIRECT8, 1 }, { OperandType::INDIRECT16, 2 }, { OperandType::TAG, 1 },
        { OperandType::UINT8, 1 },     { OperandType::UINT16, 2 },     { OperandType::UINT32, 4 },
        { OperandType::UINT64, 8 },    { OperandType::UINT128, 16 },   { OperandType::FF, 32 }
    };
    return OPERAND_TYPE_SIZE_BYTES;
}
} // namespace
 
// Instruction wire formats.
const std::vector<OperandType> three_operand_format8 = {
    OperandType::INDIRECT8,
    OperandType::UINT8,
    OperandType::UINT8,
    OperandType::UINT8,
};
const std::vector<OperandType> three_operand_format16 = {
    OperandType::INDIRECT8,
    OperandType::UINT16,
    OperandType::UINT16,
    OperandType::UINT16,
};
const std::vector<OperandType> kernel_input_operand_format = { OperandType::INDIRECT8, OperandType::UINT16 };
 
const std::vector<OperandType> external_call_format = { OperandType::INDIRECT16,
                                                        /*l2GasOffset=*/OperandType::UINT16,
                                                        /*daGasOffset=*/OperandType::UINT16,
                                                        /*addrOffset=*/OperandType::UINT16,
                                                        /*argsOffset=*/OperandType::UINT16,
                                                        /*argsSizeOffset=*/OperandType::UINT16 };
 
namespace {
// Contrary to TS, the format does not contain the WireOpCode byte which prefixes any instruction.
// Entries are ordered to match WireOpCode enum.
const std::unordered_map<WireOpCode, std::vector<OperandType>>& get_wire_opcode_wire_format()
{
    static const std::unordered_map<WireOpCode, std::vector<OperandType>> WireOpCode_WIRE_FORMAT = {
        // Compute
        // Compute - Arithmetic
        { WireOpCode::ADD_8, three_operand_format8 },
        { WireOpCode::ADD_16, three_operand_format16 },
        { WireOpCode::SUB_8, three_operand_format8 },
        { WireOpCode::SUB_16, three_operand_format16 },
        { WireOpCode::MUL_8, three_operand_format8 },
        { WireOpCode::MUL_16, three_operand_format16 },
        { WireOpCode::DIV_8, three_operand_format8 },
        { WireOpCode::DIV_16, three_operand_format16 },
        { WireOpCode::FDIV_8, three_operand_format8 },
        { WireOpCode::FDIV_16, three_operand_format16 },
        // Compute - Comparison
        { WireOpCode::EQ_8, three_operand_format8 },
        { WireOpCode::EQ_16, three_operand_format16 },
        { WireOpCode::LT_8, three_operand_format8 },
        { WireOpCode::LT_16, three_operand_format16 },
        { WireOpCode::LTE_8, three_operand_format8 },
        { WireOpCode::LTE_16, three_operand_format16 },
        // Compute - Bitwise
        { WireOpCode::AND_8, three_operand_format8 },
        { WireOpCode::AND_16, three_operand_format16 },
        { WireOpCode::OR_8, three_operand_format8 },
        { WireOpCode::OR_16, three_operand_format16 },
        { WireOpCode::XOR_8, three_operand_format8 },
        { WireOpCode::XOR_16, three_operand_format16 },
        { WireOpCode::NOT_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::UINT8 } },
        { WireOpCode::NOT_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
        { WireOpCode::SHL_8, three_operand_format8 },
        { WireOpCode::SHL_16, three_operand_format16 },
        { WireOpCode::SHR_8, three_operand_format8 },
        { WireOpCode::SHR_16, three_operand_format16 },
        // Compute - Type Conversions
        { WireOpCode::CAST_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::UINT8, OperandType::TAG } },
        { WireOpCode::CAST_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::TAG } },
 
        // Execution Environment - Globals
        { WireOpCode::GETENVVAR_16,
          {
              OperandType::INDIRECT8,
              OperandType::UINT16,
              OperandType::UINT8, // var idx
          } },
 
        // Execution Environment - Calldata
        { WireOpCode::CALLDATACOPY,
          { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
        { WireOpCode::SUCCESSCOPY, { OperandType::INDIRECT8, OperandType::UINT16 } },
        { WireOpCode::RETURNDATASIZE, { OperandType::INDIRECT8, OperandType::UINT16 } },
        { WireOpCode::RETURNDATACOPY,
          { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
 
        // Machine State - Internal Control Flow
        { WireOpCode::JUMP_32, { OperandType::UINT32 } },
        { WireOpCode::JUMPI_32, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT32 } },
        { WireOpCode::INTERNALCALL, { OperandType::UINT32 } },
        { WireOpCode::INTERNALRETURN, {} },
 
        // Machine State - Memory
        { WireOpCode::SET_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::TAG, OperandType::UINT8 } },
        { WireOpCode::SET_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::UINT16 } },
        { WireOpCode::SET_32, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::UINT32 } },
        { WireOpCode::SET_64, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::UINT64 } },
        { WireOpCode::SET_128,
          { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::UINT128 } },
        { WireOpCode::SET_FF, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::TAG, OperandType::FF } },
        { WireOpCode::MOV_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::UINT8 } },
        { WireOpCode::MOV_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
 
        // Side Effects - Public Storage
        { WireOpCode::SLOAD, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
        { WireOpCode::SSTORE, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
        // Side Effects - Notes, Nullfiers, Logs, Messages
        { WireOpCode::NOTEHASHEXISTS,
          { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
 
        { WireOpCode::EMITNOTEHASH,
          {
              OperandType::INDIRECT8,
              OperandType::UINT16,
          } },
        { WireOpCode::NULLIFIEREXISTS,
          { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
        { WireOpCode::EMITNULLIFIER,
          {
              OperandType::INDIRECT8,
              OperandType::UINT16,
          } },
        { WireOpCode::L1TOL2MSGEXISTS,
          { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
        { WireOpCode::GETCONTRACTINSTANCE,
          { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT8 } },
        { WireOpCode::EMITUNENCRYPTEDLOG,
          {
              OperandType::INDIRECT8,
              OperandType::UINT16,
              OperandType::UINT16,
          } },
        { WireOpCode::SENDL2TOL1MSG, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
 
        // Control Flow - Contract Calls
        { WireOpCode::CALL, external_call_format },
        { WireOpCode::STATICCALL, external_call_format },
        { WireOpCode::RETURN, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
        // REVERT,
        { WireOpCode::REVERT_8, { OperandType::INDIRECT8, OperandType::UINT8, OperandType::UINT8 } },
        { WireOpCode::REVERT_16, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
 
        // Misc
        { WireOpCode::DEBUGLOG,
          { OperandType::INDIRECT8,
            OperandType::UINT16,
            OperandType::UINT16,
            OperandType::UINT16,
            OperandType::UINT16,
            OperandType::UINT16 } },
 
        // Gadgets
        // Gadgets - Hashing
        { WireOpCode::POSEIDON2PERM, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
        { WireOpCode::SHA256COMPRESSION,
          { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16, OperandType::UINT16 } },
        { WireOpCode::KECCAKF1600, { OperandType::INDIRECT8, OperandType::UINT16, OperandType::UINT16 } },
        // TEMP ECADD without relative memory
        { WireOpCode::ECADD,
          { OperandType::INDIRECT16,
            OperandType::UINT16,     // lhs.x
            OperandType::UINT16,     // lhs.y
            OperandType::UINT16,     // lhs.is_infinite
            OperandType::UINT16,     // rhs.x
            OperandType::UINT16,     // rhs.y
            OperandType::UINT16,     // rhs.is_infinite
            OperandType::UINT16 } }, // dst_offset
        // Gadget - Conversion
        { WireOpCode::TORADIXBE,
          { OperandType::INDIRECT16,
            OperandType::UINT16,
            OperandType::UINT16,
            OperandType::UINT16,
            OperandType::UINT16,
            OperandType::UINT16 } },
    };
    return WireOpCode_WIRE_FORMAT;
}
} // namespace
 
namespace testonly {
 
const std::unordered_map<WireOpCode, std::vector<OperandType>>& get_instruction_wire_formats()
{
    return get_wire_opcode_wire_format();
}
 
const std::unordered_map<OperandType, uint32_t>& get_operand_type_sizes()
{
    return get_operand_type_size_bytes();
}
 
} // namespace testonly
 
namespace {
 
bool is_wire_opcode_valid(uint8_t w_opcode)
{
    return w_opcode < static_cast<uint8_t>(WireOpCode::LAST_OPCODE_SENTINEL);
}
 
} // namespace
 
Instruction deserialize_instruction(std::span<const uint8_t> bytecode, size_t pos)
{
    const auto bytecode_length = bytecode.size();
 
    if (pos >= bytecode_length) {
        std::string error_msg = format("Invalid program counter ", pos, ", max is ", bytecode_length - 1);
        vinfo(error_msg);
        throw InstrDeserializationError(InstrDeserializationEventError::PC_OUT_OF_RANGE, error_msg);
    }
 
    const uint8_t opcode_byte = bytecode[pos];
 
    if (!is_wire_opcode_valid(opcode_byte)) {
        std::string error_msg = format("Opcode ",
                                       static_cast<uint32_t>(opcode_byte),
                                       " (0x",
                                       to_hex(opcode_byte),
                                       ") value is not in the range of valid opcodes (at PC ",
                                       pos,
                                       ").");
        vinfo(error_msg);
        throw InstrDeserializationError(InstrDeserializationEventError::OPCODE_OUT_OF_RANGE, error_msg);
    }
 
    const auto opcode = static_cast<WireOpCode>(opcode_byte);
    const auto iter = get_wire_opcode_wire_format().find(opcode);
    assert(iter != get_wire_opcode_wire_format().end());
    const auto& inst_format = iter->second;
 
    const uint32_t instruction_size = get_wire_instruction_spec().at(opcode).size_in_bytes;
 
    // We know we will encounter a parsing error, but continue processing because
    // we need the partial instruction to be parsed for witness generation.
    if (pos + instruction_size > bytecode_length) {
        std::string error_msg = format("Instruction at PC ",
                                       pos,
                                       " does not fit in bytecode (instruction size: ",
                                       instruction_size,
                                       ", remaining: ",
                                       bytecode_length - pos,
                                       ")");
        vinfo(error_msg);
        throw InstrDeserializationError(InstrDeserializationEventError::INSTRUCTION_OUT_OF_RANGE, error_msg);
    }
 
    pos++; // move after opcode byte
 
    uint16_t indirect = 0;
    std::vector<Operand> operands;
    for (const OperandType op_type : inst_format) {
        const auto operand_size = get_operand_type_size_bytes().at(op_type);
        assert(pos + operand_size <= bytecode_length); // Guaranteed to hold due to
                                                       //  pos + instruction_size <= bytecode_length
 
        switch (op_type) {
        case OperandType::TAG:
        case OperandType::UINT8: {
            operands.emplace_back(Operand::from<uint8_t>(bytecode[pos]));
            break;
        }
        case OperandType::INDIRECT8: {
            indirect = bytecode[pos];
            break;
        }
        case OperandType::INDIRECT16: {
            uint16_t operand_u16 = 0;
            uint8_t const* pos_ptr = &bytecode[pos];
            serialize::read(pos_ptr, operand_u16);
            indirect = operand_u16;
            break;
        }
        case OperandType::UINT16: {
            uint16_t operand_u16 = 0;
            uint8_t const* pos_ptr = &bytecode[pos];
            serialize::read(pos_ptr, operand_u16);
            operands.emplace_back(Operand::from<uint16_t>(operand_u16));
            break;
        }
        case OperandType::UINT32: {
            uint32_t operand_u32 = 0;
            uint8_t const* pos_ptr = &bytecode[pos];
            serialize::read(pos_ptr, operand_u32);
            operands.emplace_back(Operand::from<uint32_t>(operand_u32));
            break;
        }
        case OperandType::UINT64: {
            uint64_t operand_u64 = 0;
            uint8_t const* pos_ptr = &bytecode[pos];
            serialize::read(pos_ptr, operand_u64);
            operands.emplace_back(Operand::from<uint64_t>(operand_u64));
            break;
        }
        case OperandType::UINT128: {
            uint128_t operand_u128 = 0;
            uint8_t const* pos_ptr = &bytecode[pos];
            serialize::read(pos_ptr, operand_u128);
            operands.emplace_back(Operand::from<uint128_t>(operand_u128));
            break;
        }
        case OperandType::FF: {
            FF operand_ff;
            uint8_t const* pos_ptr = &bytecode[pos];
            read(pos_ptr, operand_ff);
            operands.emplace_back(Operand::from<FF>(operand_ff));
        }
        }
        pos += operand_size;
    }
 
    return {
        .opcode = opcode,
        .indirect = indirect,
        .operands = std::move(operands),
    };
};
 
std::string Instruction::to_string() const
{
    std::ostringstream oss;
    oss << opcode << " ";
    for (size_t operand_pos = 0; operand_pos < operands.size(); ++operand_pos) {
        const auto& operand = operands[operand_pos];
        oss << std::to_string(operand);
        if (is_operand_relative(indirect, static_cast<uint8_t>(operand_pos))) {
            oss << "R";
        }
        if (is_operand_indirect(indirect, static_cast<uint8_t>(operand_pos))) {
            oss << "I";
        }
        oss << " ";
    }
    return oss.str();
}
 
size_t Instruction::size_in_bytes() const
{
    assert(get_wire_instruction_spec().contains(opcode));
    return get_wire_instruction_spec().at(opcode).size_in_bytes;
}
 
ExecutionOpCode Instruction::get_exec_opcode() const
{
    assert(get_wire_instruction_spec().contains(opcode));
    return get_wire_instruction_spec().at(opcode).exec_opcode;
}
 
std::vector<uint8_t> Instruction::serialize() const
{
    std::vector<uint8_t> output;
    output.reserve(get_wire_instruction_spec().at(opcode).size_in_bytes);
    output.emplace_back(static_cast<uint8_t>(opcode));
    size_t operand_pos = 0;
 
    for (const auto& operand_type : get_wire_opcode_wire_format().at(opcode)) {
        switch (operand_type) {
        case OperandType::INDIRECT8:
            output.emplace_back(static_cast<uint8_t>(indirect));
            break;
        case OperandType::INDIRECT16: {
            const auto indirect_vec = to_buffer(indirect);
            output.insert(output.end(),
                          std::make_move_iterator(indirect_vec.begin()),
                          std::make_move_iterator(indirect_vec.end()));
        } break;
        case OperandType::TAG:
        case OperandType::UINT8:
            output.emplace_back(operands.at(operand_pos++).as<uint8_t>());
            break;
        case OperandType::UINT16: {
            const auto operand_vec = to_buffer(operands.at(operand_pos++).as<uint16_t>());
            output.insert(
                output.end(), std::make_move_iterator(operand_vec.begin()), std::make_move_iterator(operand_vec.end()));
        } break;
        case OperandType::UINT32: {
            const auto operand_vec = to_buffer(operands.at(operand_pos++).as<uint32_t>());
            output.insert(
                output.end(), std::make_move_iterator(operand_vec.begin()), std::make_move_iterator(operand_vec.end()));
        } break;
        case OperandType::UINT64: {
            const auto operand_vec = to_buffer(operands.at(operand_pos++).as<uint64_t>());
            output.insert(
                output.end(), std::make_move_iterator(operand_vec.begin()), std::make_move_iterator(operand_vec.end()));
        } break;
        case OperandType::UINT128: {
            const auto operand_vec = to_buffer(operands.at(operand_pos++).as<uint128_t>());
            output.insert(
                output.end(), std::make_move_iterator(operand_vec.begin()), std::make_move_iterator(operand_vec.end()));
        } break;
        case OperandType::FF: {
            const auto operand_vec = to_buffer(operands.at(operand_pos++).as<FF>());
            output.insert(
                output.end(), std::make_move_iterator(operand_vec.begin()), std::make_move_iterator(operand_vec.end()));
        } break;
        }
    }
    return output;
}
 
bool check_tag(const Instruction& instruction)
{
    if (instruction.opcode == WireOpCode::LAST_OPCODE_SENTINEL) {
        vinfo("Instruction does not contain a valid wire opcode.");
        return false;
    }
 
    const auto& wire_format = get_wire_opcode_wire_format().at(instruction.opcode);
 
    size_t pos = 0; // Position in instruction operands
 
    for (size_t i = 0; i < wire_format.size(); i++) {
        if (wire_format[i] == OperandType::INDIRECT8 || wire_format[i] == OperandType::INDIRECT16) {
            continue; // No pos increment
        }
 
        if (wire_format[i] == OperandType::TAG) {
            if (pos >= instruction.operands.size()) {
                vinfo("Instruction operands size is too small. Tag position: ",
                      pos,
                      " size: ",
                      instruction.operands.size(),
                      " WireOpCode: ",
                      instruction.opcode);
                return false;
            }
 
            try {
                uint8_t tag = instruction.operands.at(pos).as<uint8_t>(); // Cast to uint8_t might throw
 
                if (tag > static_cast<uint8_t>(MemoryTag::MAX)) {
                    vinfo("Instruction tag operand at position: ",
                          pos,
                          " is invalid.",
                          " Tag value: ",
                          tag,
                          " WireOpCode: ",
                          instruction.opcode);
                    return false;
                }
 
            } catch (const std::runtime_error&) {
                vinfo("Instruction operand at position: ",
                      pos,
                      " is longer than a byte.",
                      " WireOpCode: ",
                      instruction.opcode);
                return false;
            }
        }
 
        pos++;
    }
    return true;
}
 
} // namespace bb::avm2::simulation