Snapshot/write-back the entire region between offset and end of original alloc

Author: lucic71

libcc2rs/src/rc.rs

@@ -43,10 +43,27 @@ pub enum StrongPtr<T> {
         byte_offset: usize,
         // Local buffer for deref(). None until first access.
         // Read-through: refreshed from alloc on every deref() call.
-        cell: RefCell<Option<T>>,
+        cell: RefCell<Option<Vec<T>>>,
     },
 }
 
+fn read_reinterpreted_region<T: ByteRepr>(
+    data: &dyn OriginalAlloc,
+    offset: usize,
+) -> (Vec<u8>, Vec<T>) {
+    let elem_size = std::mem::size_of::<T>();
+    let num_elems = data
+        .total_byte_len()
+        .saturating_sub(offset)
+        .checked_div(elem_size)
+        .unwrap_or(0);
+    assert!(num_elems > 0, "ub: dereference out of bounds");
+    let mut buf = vec![0u8; num_elems * elem_size];
+    data.read_bytes(offset, &mut buf);
+    let vals = buf.chunks_exact(elem_size).map(T::from_bytes).collect();
+    (buf, vals)
+}
+
 impl<T: ByteRepr> StrongPtr<T> {
     pub fn deref(&self) -> Ref<'_, T> {
         match self {
@@ -59,10 +76,9 @@ impl<T: ByteRepr> StrongPtr<T> {
                 cell,
             } => {
                 // Read-through: always re-read from the original allocation.
-                let mut buf = vec![0u8; std::mem::size_of::<T>()];
-                alloc.read_bytes(*byte_offset, &mut buf);
-                *cell.borrow_mut() = Some(T::from_bytes(&buf));
-                Ref::map(cell.borrow(), |opt| opt.as_ref().unwrap())
+                let (_, vals) = read_reinterpreted_region::<T>(&**alloc, *byte_offset);
+                *cell.borrow_mut() = Some(vals);
+                Ref::map(cell.borrow(), |opt| &opt.as_ref().unwrap()[0])
             }
         }
     }
@@ -442,11 +458,12 @@ impl<T> Ptr<T> {
                 f(&mut borrow[self.offset])
             }
             PtrKind::Reinterpreted(data) => {
-                let mut buf = vec![0u8; std::mem::size_of::<T>()];
-                data.read_bytes(self.offset, &mut buf);
-                let mut val = T::from_bytes(&buf);
-                let ret = f(&mut val);
-                val.to_bytes(&mut buf);
+                let (mut buf, mut vals) = read_reinterpreted_region::<T>(&**data, self.offset);
+                let elem_size = std::mem::size_of::<T>();
+                let ret = f(&mut vals[0]);
+                for (i, val) in vals.iter().enumerate() {
+                    val.to_bytes(&mut buf[i * elem_size..(i + 1) * elem_size]);
+                }
                 data.write_bytes(self.offset, &buf);
                 ret
             }
@@ -475,10 +492,8 @@ impl<T> Ptr<T> {
                 f(&borrow[self.offset])
             }
             PtrKind::Reinterpreted(data) => {
-                let mut buf = vec![0u8; std::mem::size_of::<T>()];
-                data.read_bytes(self.offset, &mut buf);
-                let val = T::from_bytes(&buf);
-                f(&val)
+                let (_, vals) = read_reinterpreted_region::<T>(&**data, self.offset);
+                f(&vals[0])
             }
         }
     }