pure_addressing.cpp

Go to the documentation of this file.

#include "barretenberg/vm2/simulation/standalone/pure_addressing.hpp"
 
#include <algorithm>
#include <cstdint>
#include <vector>
 
#include "barretenberg/common/bb_bench.hpp"
#include "barretenberg/numeric/uint128/uint128.hpp"
#include "barretenberg/vm2/common/addressing.hpp"
#include "barretenberg/vm2/common/memory_types.hpp"
#include "barretenberg/vm2/simulation/events/addressing_event.hpp"
#include "barretenberg/vm2/simulation/interfaces/addressing.hpp"
#include "barretenberg/vm2/simulation/interfaces/memory.hpp"
#include "barretenberg/vm2/simulation/lib/serialization.hpp"
 
namespace bb::avm2::simulation {
 
std::vector<Operand> PureAddressing::resolve(const Instruction& instruction, MemoryInterface& memory)
{
    BB_BENCH_NAME("PureAddressing::resolve");
 
    ExecutionOpCode exec_opcode = instruction_info_db.get(instruction.opcode).exec_opcode;
    const ExecInstructionSpec& spec = instruction_info_db.get(exec_opcode);
 
    assert(spec.num_addresses <= instruction.operands.size());
 
    std::optional<MemoryAddress> base_address;
    std::vector<Operand> resolved_operands = instruction.operands;
 
    for (size_t i = 0; i < spec.num_addresses; ++i) {
        Operand& operand = resolved_operands[i];
        const ValueTag tag = operand.get_tag();
 
        // We assume from serialization that the operand is <= the bits of a memory address.
        // We assert this here as it is a precondition.
        assert(get_tag_bits(tag) <= get_tag_bits(MemoryAddressTag));
        // Normalize possibly smaller sizes to MemoryAddress.
        if (tag != MemoryAddressTag) {
            operand = Operand::from(static_cast<MemoryAddress>(operand.to<MemoryAddress>()));
        }
 
        // Handle relative addressing
        if (is_operand_relative(instruction.indirect, i)) {
            if (!base_address) {
                MemoryValue maybe_base_address = memory.get(0);
                if (!memory.is_valid_address(maybe_base_address)) {
                    throw AddressingException(
                        format("Addressing error: Base address (mem[0]) is not a valid address (has tag ",
                               std::to_string(maybe_base_address.get_tag()),
                               ")"));
                }
                base_address = maybe_base_address.as<MemoryAddress>();
            }
            const uint64_t rel_offset = operand.as<MemoryAddress>();
            const uint64_t offset = rel_offset + *base_address;
            if (offset > AVM_HIGHEST_MEM_ADDRESS) {
                throw AddressingException(format("Addressing error: Relative address out of range. Base address ",
                                                 *base_address,
                                                 ", relative offset ",
                                                 rel_offset));
            }
            operand = Operand::from(static_cast<MemoryAddress>(offset));
        }
 
        // Handle indirection
        if (is_operand_indirect(instruction.indirect, i)) {
            const MemoryValue& indirect_value = memory.get(operand.as<MemoryAddress>());
            if (!memory.is_valid_address(indirect_value)) {
                throw AddressingException(
                    format("Addressing error: Address after indirection is not a valid address (address ",
                           operand.to_string(),
                           ") has tag ",
                           std::to_string(indirect_value.get_tag()),
                           ")"));
            }
            operand = indirect_value;
        }
    }
 
    return resolved_operands;
}
 
} // namespace bb::avm2::simulation