serialization.hpp

Go to the documentation of this file.

#pragma once
 
#include "barretenberg/vm2/common/memory_types.hpp"
#include "barretenberg/vm2/common/opcodes.hpp"
#include "barretenberg/vm2/common/tagged_value.hpp"
 
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
namespace bb::avm2::simulation {
 
// Possible types for an instruction's operand in its wire format.
// The counterpart TS file is: avm/serialization/instruction_serialization.ts.
// INDIRECT is parsed as UINT8 where the bits represent the operands that have indirect mem access.
enum class OperandType : uint8_t { INDIRECT8, INDIRECT16, TAG, UINT8, UINT16, UINT32, UINT64, UINT128, FF };
 
namespace testonly {
 
const std::unordered_map<WireOpCode, std::vector<OperandType>>& get_instruction_wire_formats();
const std::unordered_map<OperandType, uint32_t>& get_operand_type_sizes();
 
} // namespace testonly
 
using Operand = TaggedValue;
 
struct Instruction {
    WireOpCode opcode = WireOpCode::LAST_OPCODE_SENTINEL;
    uint16_t addressing_mode = 0;
    std::vector<Operand> operands;
 
    std::string to_string() const;
 
    // Serialize the instruction according to the specification from OPCODE_WIRE_FORMAT.
    // There is no validation that the instructions operands comply to the format. Namely,
    // they are casted according to the operand variant specified in format (throw only in
    // truncation case). If the number of operands is larger than specified in format,
    // no error will be thrown neither.
    std::vector<uint8_t> serialize() const;
 
    size_t size_in_bytes() const;
    ExecutionOpCode get_exec_opcode() const;
 
    bool operator==(const Instruction& other) const = default;
};
 
enum class InstrDeserializationEventError : uint8_t {
    PC_OUT_OF_RANGE,
    OPCODE_OUT_OF_RANGE,
    INSTRUCTION_OUT_OF_RANGE,
    TAG_OUT_OF_RANGE,
};
 
struct InstrDeserializationError {
    InstrDeserializationEventError type;
    std::optional<std::string> message;
 
    // Constructor from error type only
    InstrDeserializationError(InstrDeserializationEventError t)
        : type(t)
        , message(std::nullopt)
    {}
 
    // Constructor with error type and message
    InstrDeserializationError(InstrDeserializationEventError t, const std::string& msg)
        : type(t)
        , message(msg)
    {}
 
    bool operator==(const InstrDeserializationError& other) const = default;
};
 
Instruction deserialize_instruction(std::span<const uint8_t> bytecode, size_t pos);
 
bool check_tag(const Instruction& instruction);
 
} // namespace bb::avm2::simulation