internal_call_stack_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <vector>
 
#include "barretenberg/vm2/common/aztec_types.hpp"
#include "barretenberg/vm2/simulation/events/event_emitter.hpp"
#include "barretenberg/vm2/simulation/events/internal_call_stack_event.hpp"
#include "barretenberg/vm2/simulation/interfaces/internal_call_stack_manager.hpp"
 
namespace bb::avm2::simulation {
 
struct InternalCallPtr {
    InternalCallId return_call_id;
    PC caller_pc;
    PC return_pc;
};
 
// This contains the context_id due to circuit requirements similar to memory (i.e. it is used in the event emitter)
// There might be a way to avoid this by emitting in the context / execution itself.
class InternalCallStackManager : public InternalCallStackManagerInterface {
  public:
    InternalCallStackManager(uint32_t context_id, EventEmitterInterface<InternalCallStackEvent>& emitter)
        : context_id(context_id)
        , internal_call_stack_events(emitter)
    {}
 
    void push(PC caller_pc, PC return_pc) override;
    PC pop() override;
    InternalCallId get_next_call_id() const override;
    InternalCallId get_call_id() const override;
    InternalCallId get_return_call_id() const override;
    std::vector<PC> get_current_call_stack() const override;
 
  private:
    InternalCallId next_call_id = 2;   // does not start at 0
    InternalCallId call_id = 1;        // does not start at 0
    InternalCallId return_call_id = 0; // this is the return id of the current call
 
    uint32_t context_id;
 
    // NOTE: Using vector because we need iterators.
    std::vector<InternalCallPtr> internal_call_stack;
    EventEmitterInterface<InternalCallStackEvent>& internal_call_stack_events;
};
 
class InternalCallStackManagerProvider : public InternalCallStackManagerProviderInterface {
  public:
    InternalCallStackManagerProvider(EventEmitterInterface<InternalCallStackEvent>& event_emitter)
        : events(event_emitter)
    {}
 
    std::unique_ptr<InternalCallStackManagerInterface> make_internal_call_stack_manager(uint32_t context_id) override
    {
        return std::make_unique<InternalCallStackManager>(context_id, events);
    }
 
  private:
    EventEmitterInterface<InternalCallStackEvent>& events;
};
 
} // namespace bb::avm2::simulation