Delete elem_byte_size

Author: lucic71

libcc2rs/src/rc.rs

@@ -16,13 +16,6 @@ use crate::reinterpret::{ByteRepr, OriginalAlloc, SingleOriginalAlloc, SliceOrig
 
 pub type Value<T> = Rc<RefCell<T>>;
 
-struct ReinterpretedView {
-    // Pointer to the source of reinterpret
-    alloc: Rc<dyn OriginalAlloc>,
-    // C++ size of the reinterpreted view
-    elem_byte_size: usize,
-}
-
 #[derive(Default)]
 enum PtrKind<T> {
     #[default]
@@ -32,7 +25,7 @@ enum PtrKind<T> {
     HeapSingle(Weak<RefCell<T>>),
     HeapArray(Weak<RefCell<Box<[T]>>>),
     Vec(Weak<RefCell<Vec<T>>>),
-    Reinterpreted(Rc<ReinterpretedView>),
+    Reinterpreted(Rc<dyn OriginalAlloc>),
 }
 
 pub enum StrongPtr<T> {
@@ -84,8 +77,8 @@ impl<T> fmt::Debug for PtrKind<T> {
             PtrKind::HeapSingle(w) => write!(f, "HeapSingle({:?})", w.as_ptr()),
             PtrKind::StackArray(w) => write!(f, "StackArray({:?})", w.as_ptr()),
             PtrKind::HeapArray(w) => write!(f, "HeapArray({:?})", w.as_ptr()),
-            PtrKind::Reinterpreted(view) => {
-                write!(f, "Reinterpreted(0x{:x})", view.alloc.address())
+            PtrKind::Reinterpreted(alloc) => {
+                write!(f, "Reinterpreted(0x{:x})", alloc.address())
             }
         }
     }
@@ -100,7 +93,7 @@ impl<T> Clone for PtrKind<T> {
             PtrKind::HeapSingle(weak) => PtrKind::HeapSingle(weak.clone()),
             PtrKind::StackArray(weak) => PtrKind::StackArray(weak.clone()),
             PtrKind::HeapArray(weak) => PtrKind::HeapArray(weak.clone()),
-            PtrKind::Reinterpreted(view) => PtrKind::Reinterpreted(Rc::clone(view)),
+            PtrKind::Reinterpreted(alloc) => PtrKind::Reinterpreted(Rc::clone(alloc)),
         }
     }
 }
@@ -112,7 +105,7 @@ impl<T> PtrKind<T> {
             PtrKind::StackSingle(w) | PtrKind::HeapSingle(w) => w.as_ptr() as usize,
             PtrKind::Vec(w) => w.as_ptr() as usize,
             PtrKind::StackArray(w) | PtrKind::HeapArray(w) => w.as_ptr() as usize,
-            PtrKind::Reinterpreted(view) => view.alloc.address(),
+            PtrKind::Reinterpreted(alloc) => alloc.address(),
         }
     }
 }
@@ -256,23 +249,29 @@ impl<T> Ptr<T> {
     // Ptr::offset is in elements (step = 1). This helper converts between
     // user-facing element counts and the internal offset units.
     #[inline]
-    fn elem_step(&self) -> usize {
+    fn elem_step(&self) -> usize
+    where
+        T: ByteRepr,
+    {
         match &self.kind {
-            PtrKind::Reinterpreted(view) => view.elem_byte_size,
+            PtrKind::Reinterpreted(_) => T::byte_size(),
             _ => 1,
         }
     }
 
     #[inline]
-    pub fn len(&self) -> usize {
+    pub fn len(&self) -> usize
+    where
+        T: ByteRepr,
+    {
         match &self.kind {
             PtrKind::Null => 0,
             PtrKind::StackSingle(_) | PtrKind::HeapSingle(_) => 1,
             PtrKind::Vec(weak) => weak.upgrade().expect("ub: dangling pointer").borrow().len(),
             PtrKind::StackArray(weak) | PtrKind::HeapArray(weak) => {
                 weak.upgrade().expect("ub: dangling pointer").borrow().len()
             }
-            PtrKind::Reinterpreted(view) => view.alloc.total_byte_len() / view.elem_byte_size,
+            PtrKind::Reinterpreted(alloc) => alloc.total_byte_len() / T::byte_size(),
         }
     }
 
@@ -291,12 +290,15 @@ impl<T> Ptr<T> {
                 .expect("ub: dangling pointer")
                 .borrow()
                 .is_empty(),
-            PtrKind::Reinterpreted(view) => self.offset >= view.alloc.total_byte_len(),
+            PtrKind::Reinterpreted(alloc) => self.offset >= alloc.total_byte_len(),
         }
     }
 
     #[inline]
-    pub fn offset(&self, offset: isize) -> Self {
+    pub fn offset(&self, offset: isize) -> Self
+    where
+        T: ByteRepr,
+    {
         let step = self.elem_step();
         Self {
             kind: self.kind.clone(),
@@ -307,20 +309,29 @@ impl<T> Ptr<T> {
     }
 
     #[inline]
-    pub fn get_offset(&self) -> usize {
+    pub fn get_offset(&self) -> usize
+    where
+        T: ByteRepr,
+    {
         self.offset / self.elem_step()
     }
 
     #[inline]
-    pub fn to_last(&self) -> Self {
+    pub fn to_last(&self) -> Self
+    where
+        T: ByteRepr,
+    {
         Self {
             kind: self.kind.clone(),
             offset: self.len().wrapping_sub(1).wrapping_mul(self.elem_step()),
         }
     }
 
     #[inline]
-    pub fn to_end(&self) -> Self {
+    pub fn to_end(&self) -> Self
+    where
+        T: ByteRepr,
+    {
         Self {
             kind: self.kind.clone(),
             offset: self.len().wrapping_mul(self.elem_step()),
@@ -346,8 +357,8 @@ impl<T> Ptr<T> {
                 rc: weak.upgrade().expect("ub: dangling pointer"),
                 offset: self.offset,
             },
-            PtrKind::Reinterpreted(view) => StrongPtr::Reinterpreted {
-                alloc: Rc::clone(&view.alloc),
+            PtrKind::Reinterpreted(alloc) => StrongPtr::Reinterpreted {
+                alloc: Rc::clone(alloc),
                 byte_offset: self.offset,
                 cell: RefCell::new(None),
             },
@@ -372,10 +383,10 @@ impl<T> Ptr<T> {
                 let rc = weak.upgrade().expect("ub: dangling pointer");
                 rc.borrow_mut()[self.offset] = value;
             }
-            PtrKind::Reinterpreted(view) => {
+            PtrKind::Reinterpreted(alloc) => {
                 let mut buf = vec![0u8; T::byte_size()];
                 value.to_bytes(&mut buf);
-                view.alloc.write_bytes(self.offset, &buf);
+                alloc.write_bytes(self.offset, &buf);
             }
         }
     }
@@ -417,15 +428,12 @@ impl<T> Ptr<T> {
                 Rc::new(SliceOriginalAlloc { weak: weak.clone() }),
                 src_byte_off,
             ),
-            PtrKind::Reinterpreted(view) => (Rc::clone(&view.alloc), self.offset),
+            PtrKind::Reinterpreted(alloc) => (Rc::clone(alloc), self.offset),
         };
 
         Ptr {
             offset: abs_byte_off,
-            kind: PtrKind::Reinterpreted(Rc::new(ReinterpretedView {
-                alloc,
-                elem_byte_size: U::byte_size(),
-            })),
+            kind: PtrKind::Reinterpreted(alloc),
         }
     }
 }
@@ -452,13 +460,13 @@ impl<T> Ptr<T> {
                 let mut borrow = rc.borrow_mut();
                 f(&mut borrow[self.offset])
             }
-            PtrKind::Reinterpreted(view) => {
+            PtrKind::Reinterpreted(alloc) => {
                 let mut buf = vec![0u8; T::byte_size()];
-                view.alloc.read_bytes(self.offset, &mut buf);
+                alloc.read_bytes(self.offset, &mut buf);
                 let mut val = T::from_bytes(&buf);
                 let ret = f(&mut val);
                 val.to_bytes(&mut buf);
-                view.alloc.write_bytes(self.offset, &buf);
+                alloc.write_bytes(self.offset, &buf);
                 ret
             }
         }
@@ -485,9 +493,9 @@ impl<T> Ptr<T> {
                 let borrow = rc.borrow();
                 f(&borrow[self.offset])
             }
-            PtrKind::Reinterpreted(view) => {
+            PtrKind::Reinterpreted(alloc) => {
                 let mut buf = vec![0u8; T::byte_size()];
-                view.alloc.read_bytes(self.offset, &mut buf);
+                alloc.read_bytes(self.offset, &mut buf);
                 let val = T::from_bytes(&buf);
                 f(&val)
             }
@@ -512,9 +520,9 @@ impl<T: Clone + ByteRepr> Ptr<T> {
             PtrKind::StackArray(ref weak) | PtrKind::HeapArray(ref weak) => {
                 weak.upgrade().expect("ub: dangling pointer").borrow()[self.offset].clone()
             }
-            PtrKind::Reinterpreted(ref view) => {
+            PtrKind::Reinterpreted(ref alloc) => {
                 let mut buf = vec![0u8; T::byte_size()];
-                view.alloc.read_bytes(self.offset, &mut buf);
+                alloc.read_bytes(self.offset, &mut buf);
                 T::from_bytes(&buf)
             }
         }
@@ -531,7 +539,7 @@ impl<T: std::io::Write + ByteRepr> Ptr<T> {
     }
 }
 
-impl<T: std::cmp::Ord> Ptr<T> {
+impl<T: std::cmp::Ord + ByteRepr> Ptr<T> {
     pub fn sort(&self, last: usize) {
         match self.kind {
             PtrKind::Null => panic!("ub: dereference of null pointer"),
@@ -553,7 +561,7 @@ impl<T: std::cmp::Ord> Ptr<T> {
     }
 }
 
-impl<T: Clone> Ptr<T> {
+impl<T: Clone + ByteRepr> Ptr<T> {
     pub fn sort_with_cmp<F>(&self, last: usize, mut cmp: F)
     where
         F: FnMut(Ptr<T>, Ptr<T>) -> bool,
@@ -600,7 +608,7 @@ impl<T: Clone> Ptr<T> {
 
 impl<T> IntoIterator for &Ptr<T>
 where
-    T: Clone,
+    T: Clone + ByteRepr,
 {
     type Item = Ptr<T>;
     type IntoIter = Ptr<T>;
@@ -610,7 +618,7 @@ where
     }
 }
 
-impl<T> Iterator for Ptr<T> {
+impl<T: ByteRepr> Iterator for Ptr<T> {
     type Item = Ptr<T>;
     fn next(&mut self) -> Option<Self::Item> {
         if self.get_offset() < self.len() {
@@ -664,7 +672,7 @@ pub struct StringIterator<T> {
     ptr: Ptr<T>,
 }
 
-impl<T> Iterator for StringIterator<T> {
+impl<T: ByteRepr> Iterator for StringIterator<T> {
     type Item = Ptr<T>;
     fn next(&mut self) -> Option<Self::Item> {
         // stop before the null terminator at the last position
@@ -696,7 +704,7 @@ impl Iterator for CStringIterator {
     }
 }
 
-impl<T> Sub for Ptr<T> {
+impl<T: ByteRepr> Sub for Ptr<T> {
     type Output = isize;
     fn sub(self, other: Self) -> Self::Output {
         assert!(self.kind == other.kind, "ub: invalid subtraction");
@@ -706,7 +714,7 @@ impl<T> Sub for Ptr<T> {
 
 macro_rules! impl_ptr_add_sub_assign {
     ($($rhs:ty),+) => { $(
-        impl<T> std::ops::AddAssign<$rhs> for Ptr<T> {
+        impl<T: ByteRepr> std::ops::AddAssign<$rhs> for Ptr<T> {
             #[inline]
             fn add_assign(&mut self, other: $rhs) {
                 let step = self.elem_step();
@@ -715,7 +723,7 @@ macro_rules! impl_ptr_add_sub_assign {
                 );
             }
         }
-        impl<T> std::ops::SubAssign<$rhs> for Ptr<T> {
+        impl<T: ByteRepr> std::ops::SubAssign<$rhs> for Ptr<T> {
             #[inline]
             fn sub_assign(&mut self, other: $rhs) {
                 let step = self.elem_step();
@@ -730,22 +738,22 @@ impl_ptr_add_sub_assign!(i32, u32, u64, isize, usize);
 
 macro_rules! impl_ptr_add_sub {
     ($($rhs:ty),+) => { $(
-        impl<T> std::ops::Add<$rhs> for &Ptr<T> {
+        impl<T: ByteRepr> std::ops::Add<$rhs> for &Ptr<T> {
             type Output = Ptr<T>;
             #[inline]
             fn add(self, other: $rhs) -> Ptr<T> { let mut r = self.clone(); r += other; r }
         }
-        impl<T> std::ops::Sub<$rhs> for &Ptr<T> {
+        impl<T: ByteRepr> std::ops::Sub<$rhs> for &Ptr<T> {
             type Output = Ptr<T>;
             #[inline]
             fn sub(self, other: $rhs) -> Ptr<T> { let mut r = self.clone(); r += -(other as isize); r }
         }
-        impl<T> std::ops::Add<$rhs> for Ptr<T> {
+        impl<T: ByteRepr> std::ops::Add<$rhs> for Ptr<T> {
             type Output = Self;
             #[inline]
             fn add(mut self, other: $rhs) -> Self { self += other; self }
         }
-        impl<T> std::ops::Sub<$rhs> for Ptr<T> {
+        impl<T: ByteRepr> std::ops::Sub<$rhs> for Ptr<T> {
             type Output = Self;
             #[inline]
             fn sub(mut self, other: $rhs) -> Self { self += -(other as isize); self }
@@ -754,7 +762,7 @@ macro_rules! impl_ptr_add_sub {
 }
 impl_ptr_add_sub!(i32, u32, u64, isize, usize);
 
-impl<T> PostfixInc for Ptr<T> {
+impl<T: ByteRepr> PostfixInc for Ptr<T> {
     #[inline]
     fn postfix_inc(&mut self) -> Self {
         let ret = self.clone();
@@ -763,7 +771,7 @@ impl<T> PostfixInc for Ptr<T> {
     }
 }
 
-impl<T> PostfixDec for Ptr<T> {
+impl<T: ByteRepr> PostfixDec for Ptr<T> {
     #[inline]
     fn postfix_dec(&mut self) -> Self {
         let ret = self.clone();
@@ -772,15 +780,15 @@ impl<T> PostfixDec for Ptr<T> {
     }
 }
 
-impl<T> PrefixInc for Ptr<T> {
+impl<T: ByteRepr> PrefixInc for Ptr<T> {
     #[inline]
     fn prefix_inc(&mut self) -> Self {
         self.offset = self.offset.wrapping_add(self.elem_step());
         self.clone()
     }
 }
 
-impl<T> PrefixDec for Ptr<T> {
+impl<T: ByteRepr> PrefixDec for Ptr<T> {
     #[inline]
     fn prefix_dec(&mut self) -> Self {
         self.offset = self.offset.wrapping_sub(self.elem_step());
@@ -909,7 +917,7 @@ impl<T> fmt::Debug for Ptr<T> {
                 (Weak::as_ptr(w) as usize).wrapping_add(self.byte_offset())
             }
             PtrKind::Vec(w) => (Weak::as_ptr(w) as usize).wrapping_add(self.byte_offset()),
-            PtrKind::Reinterpreted(view) => view.alloc.address().wrapping_add(self.byte_offset()),
+            PtrKind::Reinterpreted(alloc) => alloc.address().wrapping_add(self.byte_offset()),
         };
         write!(f, "0x{:x}", addr)
     }
@@ -1005,9 +1013,9 @@ impl Ptr<u8> {
                 let raw = strong.borrow();
                 raw[start..end].to_vec()
             }
-            PtrKind::Reinterpreted(ref view) => {
+            PtrKind::Reinterpreted(ref alloc) => {
                 let mut buf = vec![0u8; end.wrapping_sub(start)];
-                view.alloc.read_bytes(start, &mut buf);
+                alloc.read_bytes(start, &mut buf);
                 buf
             }
         }