Struct cairo_vm::vm::vm_core::VirtualMachine

pub struct VirtualMachine { /* private fields */ }

Implementations

impl VirtualMachine

pub fn new(trace_enabled: bool) -> VirtualMachine

pub fn compute_segments_effective_sizes(&mut self)

pub fn step_hint( &mut self, hint_executor: &mut dyn HintProcessor, exec_scopes: &mut ExecutionScopes, hint_data_dictionary: &HashMap<usize, Vec<Box<dyn Any>>>, constants: &HashMap<String, Felt252> ) -> Result<(), VirtualMachineError>

pub fn step_instruction(&mut self) -> Result<(), VirtualMachineError>

pub fn step( &mut self, hint_executor: &mut dyn HintProcessor, exec_scopes: &mut ExecutionScopes, hint_data_dictionary: &HashMap<usize, Vec<Box<dyn Any>>>, constants: &HashMap<String, Felt252> ) -> Result<(), VirtualMachineError>

pub fn compute_operands( &self, instruction: &Instruction ) -> Result<(Operands, OperandsAddresses, DeducedOperands), VirtualMachineError>

Compute operands and result, trying to deduce them if normal memory access returns a None value.

pub fn verify_auto_deductions(&self) -> Result<(), VirtualMachineError>

Makes sure that all assigned memory cells are consistent with their auto deduction rules.

pub fn verify_auto_deductions_for_addr( &self, addr: Relocatable, builtin: &BuiltinRunner ) -> Result<(), VirtualMachineError>

pub fn end_run( &mut self, exec_scopes: &ExecutionScopes ) -> Result<(), VirtualMachineError>

pub fn mark_address_range_as_accessed( &mut self, base: Relocatable, len: usize ) -> Result<(), VirtualMachineError>

pub fn add_memory_segment(&mut self) -> Relocatable

Adds a new segment and to the memory and returns its starting location as a Relocatable value.

pub fn get_ap(&self) -> Relocatable

pub fn get_fp(&self) -> Relocatable

pub fn get_pc(&self) -> Relocatable

pub fn get_integer( &self, key: Relocatable ) -> Result<Cow<'_, Felt252>, MemoryError>

Gets the integer value corresponding to the Relocatable address

pub fn get_relocatable( &self, key: Relocatable ) -> Result<Relocatable, MemoryError>

Gets the relocatable value corresponding to the Relocatable address

pub fn get_maybe<'a, 'b: 'a, K: 'a>( &'b self, key: &'a K ) -> Option<MaybeRelocatable>where Relocatable: TryFrom<&'a K>,

Gets a MaybeRelocatable value from memory indicated by a generic address

pub fn get_builtin_runners(&self) -> &Vec<BuiltinRunner>

Returns a reference to the vector with all builtins present in the virtual machine

pub fn get_builtin_runners_as_mut(&mut self) -> &mut Vec<BuiltinRunner>

Returns a mutable reference to the vector with all builtins present in the virtual machine

pub fn insert_value<T: Into<MaybeRelocatable>>( &mut self, key: Relocatable, val: T ) -> Result<(), MemoryError>

Inserts a value into a memory address given by a Relocatable value

pub fn load_data( &mut self, ptr: Relocatable, data: &Vec<MaybeRelocatable> ) -> Result<Relocatable, MemoryError>

Writes data into the memory from address ptr and returns the first address after the data.

pub fn write_arg( &mut self, ptr: Relocatable, arg: &dyn Any ) -> Result<MaybeRelocatable, MemoryError>

Writes args into the memory from address ptr and returns the first address after the data.

pub fn memcmp( &self, lhs: Relocatable, rhs: Relocatable, len: usize ) -> (Ordering, usize)

pub fn get_return_values( &self, n_ret: usize ) -> Result<Vec<MaybeRelocatable>, MemoryError>

Gets n_ret return values from memory

pub fn get_range( &self, addr: Relocatable, size: usize ) -> Vec<Option<Cow<'_, MaybeRelocatable>>>

Gets n elements from memory starting from addr (n being size)

pub fn get_continuous_range( &self, addr: Relocatable, size: usize ) -> Result<Vec<MaybeRelocatable>, MemoryError>

Gets n elements from memory starting from addr (n being size)

pub fn get_integer_range( &self, addr: Relocatable, size: usize ) -> Result<Vec<Cow<'_, Felt252>>, MemoryError>

Gets n integer values from memory starting from addr (n being size),

pub fn get_range_check_builtin( &self ) -> Result<&RangeCheckBuiltinRunner, VirtualMachineError>

pub fn get_signature_builtin( &mut self ) -> Result<&mut SignatureBuiltinRunner, VirtualMachineError>

pub fn disable_trace(&mut self)

pub fn get_segment_used_size(&self, index: usize) -> Option<usize>

pub fn get_segment_size(&self, index: usize) -> Option<usize>

pub fn add_temporary_segment(&mut self) -> Relocatable

pub fn add_relocation_rule( &mut self, src_ptr: Relocatable, dst_ptr: Relocatable ) -> Result<(), MemoryError>

Add a new relocation rule.

Will return an error if any of the following conditions are not met:

• Source address’s segment must be negative (temporary).
• Source address’s offset must be zero.
• There shouldn’t already be relocation at the source segment.

pub fn gen_arg( &mut self, arg: &dyn Any ) -> Result<MaybeRelocatable, MemoryError>

pub fn write_output( &mut self, writer: &mut impl Write ) -> Result<(), VirtualMachineError>

Write the values hosted in the output builtin’s segment. Does nothing if the output builtin is not present in the program.

pub fn relocate_trace( &mut self, relocation_table: &[usize] ) -> Result<(), TraceError>

Relocates the VM’s trace, turning relocatable registers to numbered ones

pub fn get_relocated_trace(&self) -> Result<&Vec<TraceEntry>, TraceError>