diff --git a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs index a12c20c0d8..44e847b3f7 100644 --- a/src/hint_processor/builtin_hint_processor/blake2s_utils.rs +++ b/src/hint_processor/builtin_hint_processor/blake2s_utils.rs @@ -43,16 +43,15 @@ Computes the blake2s compress function and fills the value in the right position output_ptr should point to the middle of an instance, right after initial_state, message, t, f, which should all have a value at this point, and right before the output portion which will be written by this function.*/ -fn compute_blake2s_func(vm: &mut VirtualMachine, output_rel: Relocatable) -> Result<(), HintError> { - let h = get_fixed_size_u32_array::<8>(&vm.get_integer_range(output_rel.sub_usize(26)?, 8)?)?; +fn compute_blake2s_func(vm: &mut VirtualMachine, output_ptr: Relocatable) -> Result<(), HintError> { + let h = get_fixed_size_u32_array::<8>(&vm.get_integer_range(output_ptr.sub_usize(26)?, 8)?)?; let message = - get_fixed_size_u32_array::<16>(&vm.get_integer_range(output_rel.sub_usize(18)?, 16)?)?; - let t = felt_to_u32(vm.get_integer(output_rel.sub_usize(2)?)?.as_ref())?; - let f = felt_to_u32(vm.get_integer(output_rel.sub_usize(1)?)?.as_ref())?; + get_fixed_size_u32_array::<16>(&vm.get_integer_range(output_ptr.sub_usize(18)?, 16)?)?; + let t = felt_to_u32(vm.get_integer(output_ptr.sub_usize(2)?)?.as_ref())?; + let f = felt_to_u32(vm.get_integer(output_ptr.sub_usize(1)?)?.as_ref())?; let new_state = get_maybe_relocatable_array_from_u32(&blake2s_compress(&h, &message, t, 0, f, 0)); - let output_ptr = MaybeRelocatable::RelocatableValue(output_rel); - vm.load_data(&output_ptr, &new_state) + vm.load_data(output_ptr, &new_state) .map_err(HintError::Memory)?; Ok(()) } @@ -113,7 +112,7 @@ pub fn finalize_blake2s( full_padding.extend_from_slice(padding); } let data = get_maybe_relocatable_array_from_u32(&full_padding); - vm.load_data(&MaybeRelocatable::RelocatableValue(blake2s_ptr_end), &data) + vm.load_data(blake2s_ptr_end, &data) .map_err(HintError::Memory)?; Ok(()) } @@ -148,8 +147,7 @@ pub fn blake2s_add_uint256( } //Insert first batch of data let data = get_maybe_relocatable_array_from_felt(&inner_data); - vm.load_data(&MaybeRelocatable::RelocatableValue(data_ptr), &data) - .map_err(HintError::Memory)?; + vm.load_data(data_ptr, &data).map_err(HintError::Memory)?; //Build second batch of data let mut inner_data = Vec::::new(); for i in 0..4 { @@ -157,11 +155,8 @@ pub fn blake2s_add_uint256( } //Insert second batch of data let data = get_maybe_relocatable_array_from_felt(&inner_data); - vm.load_data( - &MaybeRelocatable::RelocatableValue(data_ptr).add_usize(4), - &data, - ) - .map_err(HintError::Memory)?; + vm.load_data(data_ptr + 4, &data) + .map_err(HintError::Memory)?; Ok(()) } @@ -195,8 +190,7 @@ pub fn blake2s_add_uint256_bigend( } //Insert first batch of data let data = get_maybe_relocatable_array_from_felt(&inner_data); - vm.load_data(&MaybeRelocatable::RelocatableValue(data_ptr), &data) - .map_err(HintError::Memory)?; + vm.load_data(data_ptr, &data).map_err(HintError::Memory)?; //Build second batch of data let mut inner_data = Vec::::new(); for i in 0..4 { @@ -204,11 +198,8 @@ pub fn blake2s_add_uint256_bigend( } //Insert second batch of data let data = get_maybe_relocatable_array_from_felt(&inner_data); - vm.load_data( - &MaybeRelocatable::RelocatableValue(data_ptr).add_usize(4), - &data, - ) - .map_err(HintError::Memory)?; + vm.load_data(data_ptr + 4, &data) + .map_err(HintError::Memory)?; Ok(()) } diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index fc3268ee2a..44a35e6c93 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -328,15 +328,12 @@ impl CairoRunner { }; self.initial_pc = Some(initial_pc); vm.segments - .load_data( - &MaybeRelocatable::RelocatableValue(prog_base), - &self.program.data, - ) + .load_data(prog_base, &self.program.data) .map_err(RunnerError::MemoryInitializationError)?; } if let Some(exec_base) = self.execution_base { vm.segments - .load_data(&MaybeRelocatable::RelocatableValue(exec_base), &stack) + .load_data(exec_base, &stack) .map_err(RunnerError::MemoryInitializationError)?; } else { return Err(RunnerError::NoProgBase); diff --git a/src/vm/vm_core.rs b/src/vm/vm_core.rs index 2f3da0c991..c2ba44d3f7 100644 --- a/src/vm/vm_core.rs +++ b/src/vm/vm_core.rs @@ -825,9 +825,9 @@ impl VirtualMachine { ///Writes data into the memory at address ptr and returns the first address after the data. pub fn load_data( &mut self, - ptr: &MaybeRelocatable, + ptr: Relocatable, data: &Vec, - ) -> Result { + ) -> Result { self.segments.load_data(ptr, data) } @@ -4005,7 +4005,7 @@ mod tests { let segment = vm.segments.add(); vm.load_data( - &segment.into(), + segment, &vec![ mayberelocatable!(1), mayberelocatable!(2), diff --git a/src/vm/vm_memory/memory_segments.rs b/src/vm/vm_memory/memory_segments.rs index 72f9d0e8a3..21834efbf6 100644 --- a/src/vm/vm_memory/memory_segments.rs +++ b/src/vm/vm_memory/memory_segments.rs @@ -56,13 +56,13 @@ impl MemorySegmentManager { ///Writes data into the memory at address ptr and returns the first address after the data. pub fn load_data( &mut self, - ptr: &MaybeRelocatable, + ptr: Relocatable, data: &Vec, - ) -> Result { + ) -> Result { for (num, value) in data.iter().enumerate() { - self.memory.insert(&ptr.add_usize(num), value)?; + self.memory.insert(&(ptr + num), value)?; } - Ok(ptr.add_usize(data.len())) + Ok(ptr + data.len()) } pub fn new() -> MemorySegmentManager { @@ -138,7 +138,7 @@ impl MemorySegmentManager { CairoArg::Single(value) => Ok(value.clone()), CairoArg::Array(values) => { let base = self.add(); - self.load_data(&base.into(), values)?; + self.load_data(base, values)?; Ok(base.into()) } CairoArg::Composed(cairo_args) => { @@ -147,7 +147,7 @@ impl MemorySegmentManager { .map(|cairo_arg| self.gen_cairo_arg(cairo_arg)) .collect::, VirtualMachineError>>()?; let base = self.add(); - self.load_data(&base.into(), &args)?; + self.load_data(base, &args)?; Ok(base.into()) } } @@ -159,16 +159,10 @@ impl MemorySegmentManager { arg: &dyn Any, ) -> Result { if let Some(vector) = arg.downcast_ref::>() { - self.load_data( - &MaybeRelocatable::from((ptr.segment_index, ptr.offset)), - vector, - ) + self.load_data(ptr, vector).map(Into::into) } else if let Some(vector) = arg.downcast_ref::>() { let data = &vector.iter().map(|value| value.into()).collect(); - self.load_data( - &MaybeRelocatable::from((ptr.segment_index, ptr.offset)), - data, - ) + self.load_data(ptr, data).map(Into::into) } else { Err(MemoryError::WriteArg) } @@ -317,20 +311,20 @@ mod tests { #[test] fn load_data_empty() { let data = Vec::new(); - let ptr = MaybeRelocatable::from((0, 3)); + let ptr = Relocatable::from((0, 3)); let mut segments = MemorySegmentManager::new(); - let current_ptr = segments.load_data(&ptr, &data).unwrap(); - assert_eq!(current_ptr, MaybeRelocatable::from((0, 3))); + let current_ptr = segments.load_data(ptr, &data).unwrap(); + assert_eq!(current_ptr, Relocatable::from((0, 3))); } #[test] fn load_data_one_element() { let data = vec![MaybeRelocatable::from(Felt::new(4))]; - let ptr = MaybeRelocatable::from((0, 0)); + let ptr = Relocatable::from((0, 0)); let mut segments = MemorySegmentManager::new(); segments.add(); - let current_ptr = segments.load_data(&ptr, &data).unwrap(); - assert_eq!(current_ptr, MaybeRelocatable::from((0, 1))); + let current_ptr = segments.load_data(ptr, &data).unwrap(); + assert_eq!(current_ptr, Relocatable::from((0, 1))); assert_eq!( segments.memory.get(&ptr).unwrap().as_ref(), &MaybeRelocatable::from(Felt::new(4)) @@ -344,11 +338,11 @@ mod tests { MaybeRelocatable::from(Felt::new(5)), MaybeRelocatable::from(Felt::new(6)), ]; - let ptr = MaybeRelocatable::from((0, 0)); + let ptr = Relocatable::from((0, 0)); let mut segments = MemorySegmentManager::new(); segments.add(); - let current_ptr = segments.load_data(&ptr, &data).unwrap(); - assert_eq!(current_ptr, MaybeRelocatable::from((0, 3))); + let current_ptr = segments.load_data(ptr, &data).unwrap(); + assert_eq!(current_ptr, Relocatable::from((0, 3))); assert_eq!( segments.memory.get(&ptr).unwrap().as_ref(),