From 7546d3026dddaf5fcfb70d9df75c525837499842 Mon Sep 17 00:00:00 2001 From: Michael Mueller Date: Wed, 19 Jun 2019 17:41:02 +0200 Subject: [PATCH] Move buffer param into function Needed for thread-safe mode, otherwise there will be borrow problems with trying to borrow immutably, while already borrowed mutably. --- src/memory.rs | 67 +++++++++++++++++++++------------------------------ 1 file changed, 28 insertions(+), 39 deletions(-) diff --git a/src/memory.rs b/src/memory.rs index 048720d..a1cbbb8 100644 --- a/src/memory.rs +++ b/src/memory.rs @@ -204,9 +204,10 @@ impl MemoryInstance { /// Get value from memory at given offset. pub fn get_value(&self, offset: u32) -> Result { - let mut buffer = self.buffer.borrow_mut(); let region = - self.checked_region(&mut buffer, offset as usize, ::core::mem::size_of::())?; + self.checked_region(offset as usize, ::core::mem::size_of::())?; + + let buffer = self.buffer.borrow(); Ok(T::from_little_endian(&buffer[region.range()]).expect("Slice size is checked")) } @@ -217,9 +218,9 @@ impl MemoryInstance { /// /// [`get_into`]: #method.get_into pub fn get(&self, offset: u32, size: usize) -> Result, Error> { - let mut buffer = self.buffer.borrow_mut(); - let region = self.checked_region(&mut buffer, offset as usize, size)?; + let region = self.checked_region(offset as usize, size)?; + let buffer = self.buffer.borrow(); Ok(buffer[region.range()].to_vec()) } @@ -229,9 +230,9 @@ impl MemoryInstance { /// /// Returns `Err` if the specified region is out of bounds. pub fn get_into(&self, offset: u32, target: &mut [u8]) -> Result<(), Error> { - let mut buffer = self.buffer.borrow_mut(); - let region = self.checked_region(&mut buffer, offset as usize, target.len())?; + let region = self.checked_region(offset as usize, target.len())?; + let buffer = self.buffer.borrow(); target.copy_from_slice(&buffer[region.range()]); Ok(()) @@ -239,14 +240,14 @@ impl MemoryInstance { /// Copy data in the memory at given offset. pub fn set(&self, offset: u32, value: &[u8]) -> Result<(), Error> { - let mut buffer = self.buffer.borrow_mut(); let range = self - .checked_region(&mut buffer, offset as usize, value.len())? + .checked_region(offset as usize, value.len())? .range(); if offset < self.lowest_used.get() { self.lowest_used.set(offset); } + let mut buffer = self.buffer.borrow_mut(); buffer[range].copy_from_slice(value); Ok(()) @@ -254,13 +255,13 @@ impl MemoryInstance { /// Copy value in the memory at given offset. pub fn set_value(&self, offset: u32, value: T) -> Result<(), Error> { - let mut buffer = self.buffer.borrow_mut(); let range = self - .checked_region(&mut buffer, offset as usize, ::core::mem::size_of::())? + .checked_region(offset as usize, ::core::mem::size_of::())? .range(); if offset < self.lowest_used.get() { self.lowest_used.set(offset); } + let mut buffer = self.buffer.borrow_mut(); value.into_little_endian(&mut buffer[range]); Ok(()) } @@ -299,15 +300,12 @@ impl MemoryInstance { Ok(size_before_grow) } - fn checked_region( + fn checked_region( &self, - buffer: &mut B, offset: usize, size: usize, - ) -> Result - where - B: ::core::ops::DerefMut>, - { + ) -> Result { + let mut buffer = self.buffer.borrow_mut(); let end = offset.checked_add(size).ok_or_else(|| { Error::Memory(format!( "trying to access memory block of size {} from offset {}", @@ -334,17 +332,13 @@ impl MemoryInstance { }) } - fn checked_region_pair( + fn checked_region_pair( &self, - buffer: &mut B, offset1: usize, size1: usize, offset2: usize, size2: usize, - ) -> Result<(CheckedRegion, CheckedRegion), Error> - where - B: ::core::ops::DerefMut>, - { + ) -> Result<(CheckedRegion, CheckedRegion), Error> { let end1 = offset1.checked_add(size1).ok_or_else(|| { Error::Memory(format!( "trying to access memory block of size {} from offset {}", @@ -359,6 +353,7 @@ impl MemoryInstance { )) })?; + let mut buffer = self.buffer.borrow_mut(); let max = cmp::max(end1, end2); if max <= self.current_size.get() && buffer.len() < max { buffer.resize(max, 0); @@ -402,15 +397,14 @@ impl MemoryInstance { /// /// Returns `Err` if either of specified regions is out of bounds. pub fn copy(&self, src_offset: usize, dst_offset: usize, len: usize) -> Result<(), Error> { - let mut buffer = self.buffer.borrow_mut(); - let (read_region, write_region) = - self.checked_region_pair(&mut buffer, src_offset, len, dst_offset, len)?; + self.checked_region_pair(src_offset, len, dst_offset, len)?; if dst_offset < self.lowest_used.get() as usize { self.lowest_used.set(dst_offset as u32); } + let mut buffer = self.buffer.borrow_mut(); unsafe { ::core::ptr::copy( buffer[read_region.range()].as_ptr(), @@ -439,10 +433,8 @@ impl MemoryInstance { dst_offset: usize, len: usize, ) -> Result<(), Error> { - let mut buffer = self.buffer.borrow_mut(); - let (read_region, write_region) = - self.checked_region_pair(&mut buffer, src_offset, len, dst_offset, len)?; + self.checked_region_pair(src_offset, len, dst_offset, len)?; if read_region.intersects(&write_region) { return Err(Error::Memory(format!( @@ -454,6 +446,7 @@ impl MemoryInstance { self.lowest_used.set(dst_offset as u32); } + let mut buffer = self.buffer.borrow_mut(); unsafe { ::core::ptr::copy_nonoverlapping( buffer[read_region.range()].as_ptr(), @@ -475,28 +468,25 @@ impl MemoryInstance { dst_offset: usize, len: usize, ) -> Result<(), Error> { - if Rc::ptr_eq(&src.0, &dst.0) { + if ::MyRc::ptr_eq(&src.0, &dst.0) { // `transfer` is invoked with with same source and destination. Let's assume that regions may // overlap and use `copy`. return src.copy(src_offset, dst_offset, len); } - // Because memory references point to different memory instances, it is safe to `borrow_mut` - // both buffers at once (modulo `with_direct_access_mut`). - let mut src_buffer = src.buffer.borrow_mut(); - let mut dst_buffer = dst.buffer.borrow_mut(); - let src_range = src - .checked_region(&mut src_buffer, src_offset, len)? + .checked_region(src_offset, len)? .range(); let dst_range = dst - .checked_region(&mut dst_buffer, dst_offset, len)? + .checked_region(dst_offset, len)? .range(); if dst_offset < dst.lowest_used.get() as usize { dst.lowest_used.set(dst_offset as u32); } + let mut dst_buffer = dst.buffer.borrow_mut(); + let src_buffer = src.buffer.borrow(); dst_buffer[dst_range].copy_from_slice(&src_buffer[src_range]); Ok(()) @@ -510,14 +500,13 @@ impl MemoryInstance { /// /// Returns `Err` if the specified region is out of bounds. pub fn clear(&self, offset: usize, new_val: u8, len: usize) -> Result<(), Error> { - let mut buffer = self.buffer.borrow_mut(); - - let range = self.checked_region(&mut buffer, offset, len)?.range(); + let range = self.checked_region(offset, len)?.range(); if offset < self.lowest_used.get() as usize { self.lowest_used.set(offset as u32); } + let mut buffer = self.buffer.borrow_mut(); for val in &mut buffer[range] { *val = new_val }