program_block.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cstdint>
#include <map>
#include <optional>
#include <vector>
 
#include "barretenberg/avm_fuzzer/fuzz_lib/instruction.hpp"
#include "barretenberg/avm_fuzzer/fuzz_lib/memory_manager.hpp"
#include "barretenberg/vm2/common/memory_types.hpp"
#include "barretenberg/vm2/simulation/lib/serialization.hpp"
 
enum class TerminatorType {
    RETURN,
    JUMP,
    JUMP_IF,
    NONE,
};
 
class ProgramBlock {
  private:
    MemoryManager memory_manager;
    std::vector<bb::avm2::simulation::Instruction> instructions;
 
    uint16_t condition_offset_index = 0;
 
    // At first we insert INTERNALCALL instruction with 0 offset, because we don't know the resulting block offsets
    // when we insert instruction. On the step 3 of build bytecode we calculate the actual offsets, which will be used
    // for step 4 to patch the INTERNALCALL instruction with the actual offset.
    std::map<size_t, ProgramBlock*> internal_call_instruction_indicies_to_patch;
 
    void preprocess_memory_addresses(AddressRef address, uint32_t actual_address);
    void preprocess_memory_addresses(ResultAddressRef address, uint32_t actual_address);
 
    void process_add_8_instruction(ADD_8_Instruction instruction);
    void process_sub_8_instruction(SUB_8_Instruction instruction);
    void process_mul_8_instruction(MUL_8_Instruction instruction);
    void process_div_8_instruction(DIV_8_Instruction instruction);
    void process_eq_8_instruction(EQ_8_Instruction instruction);
    void process_lt_8_instruction(LT_8_Instruction instruction);
    void process_lte_8_instruction(LTE_8_Instruction instruction);
    void process_and_8_instruction(AND_8_Instruction instruction);
    void process_or_8_instruction(OR_8_Instruction instruction);
    void process_xor_8_instruction(XOR_8_Instruction instruction);
    void process_shl_8_instruction(SHL_8_Instruction instruction);
    void process_shr_8_instruction(SHR_8_Instruction instruction);
    void process_set_8_instruction(SET_8_Instruction instruction);
    void process_set_16_instruction(SET_16_Instruction instruction);
    void process_set_32_instruction(SET_32_Instruction instruction);
    void process_set_64_instruction(SET_64_Instruction instruction);
    void process_set_128_instruction(SET_128_Instruction instruction);
    void process_set_ff_instruction(SET_FF_Instruction instruction);
    void process_mov_8_instruction(MOV_8_Instruction instruction);
    void process_mov_16_instruction(MOV_16_Instruction instruction);
    void process_not_8_instruction(NOT_8_Instruction instruction);
    void process_fdiv_8_instruction(FDIV_8_Instruction instruction);
    void process_add_16_instruction(ADD_16_Instruction instruction);
    void process_sub_16_instruction(SUB_16_Instruction instruction);
    void process_mul_16_instruction(MUL_16_Instruction instruction);
    void process_div_16_instruction(DIV_16_Instruction instruction);
    void process_fdiv_16_instruction(FDIV_16_Instruction instruction);
    void process_eq_16_instruction(EQ_16_Instruction instruction);
    void process_lt_16_instruction(LT_16_Instruction instruction);
    void process_lte_16_instruction(LTE_16_Instruction instruction);
    void process_and_16_instruction(AND_16_Instruction instruction);
    void process_or_16_instruction(OR_16_Instruction instruction);
    void process_xor_16_instruction(XOR_16_Instruction instruction);
    void process_not_16_instruction(NOT_16_Instruction instruction);
    void process_shl_16_instruction(SHL_16_Instruction instruction);
    void process_shr_16_instruction(SHR_16_Instruction instruction);
    void process_cast_8_instruction(CAST_8_Instruction instruction);
    void process_cast_16_instruction(CAST_16_Instruction instruction);
    void process_sstore_instruction(SSTORE_Instruction instruction);
    void process_sload_instruction(SLOAD_Instruction instruction);
    void process_getenvvar_instruction(GETENVVAR_Instruction instruction);
    void process_emitnulifier_instruction(EMITNULLIFIER_Instruction instruction);
    void process_nullifierexists_instruction(NULLIFIEREXISTS_Instruction instruction);
    void process_emitnotehash_instruction(EMITNOTEHASH_Instruction instruction);
    void process_notehashexists_instruction(NOTEHASHEXISTS_Instruction instruction);
    void process_calldatacopy_instruction(CALLDATACOPY_Instruction instruction);
 
  public:
    std::vector<ProgramBlock*> successors;
    std::vector<ProgramBlock*> predecessors;
 
    ProgramBlock* caller = nullptr;
    TerminatorType terminator_type = TerminatorType::NONE;
    int offset = -1;
 
    ProgramBlock() = default;
    void process_instruction(FuzzInstruction instruction);
 
    void finalize_with_return(uint8_t return_size,
                              MemoryTagWrapper return_value_tag,
                              uint16_t return_value_offset_index);
 
    void finalize_with_jump(ProgramBlock* target_block, bool copy_memory_manager = true);
 
    void finalize_with_jump_if(ProgramBlock* target_then_block,
                               ProgramBlock* target_else_block,
                               uint16_t condition_offset,
                               bool copy_memory_manager = true);
 
    void insert_internal_call(ProgramBlock* target_block);
 
    std::optional<uint16_t> get_terminating_condition_value();
    std::vector<bb::avm2::simulation::Instruction> get_instructions();
 
    bool is_memory_address_set(uint16_t address);
 
    void patch_internal_calls();
};