libcc2rs: fix pointer comparison of adjacent fields in the same allocation

Author: nunoplopes

libcc2rs/src/field.rs

@@ -274,7 +274,7 @@ impl<S: Record> FieldPtr<S> for Ptr<S> {
             PtrKind::Field(_, _, FieldShape::Single) => {
                 self.field_ptr(get, get_mut, offset).decay()
             }
-            _ => self.elems_of(get, get_mut, offset(&S::OFFSETS)),
+            _ => self.elems_of(get, get_mut, offset(&S::OFFSETS), true),
         }
     }
 }
@@ -290,7 +290,8 @@ impl<S: Record> Ptr<S> {
     // A pointer to the first element of the array or vector that `get` gives
     // in the struct that self points to, which is at byte `offset` of the
     // struct. The pointer reaches the array or vector through the Value that
-    // holds the struct, or else through self.
+    // holds the struct, or else through self. `inline` tells if the elements
+    // are in the memory of the struct, as those of an array are.
     // The projection of an array of structs takes the array as a Box, the
     // contents of its Value.
     #[allow(clippy::borrowed_box)]
@@ -300,6 +301,7 @@ impl<S: Record> Ptr<S> {
         get: impl Fn(&S) -> &C + 'static,
         get_mut: impl Fn(&mut S) -> &mut C + 'static,
         offset: usize,
+        inline: bool,
     ) -> Ptr<T>
     where
         C: AsRef<[T]> + AsMut<[T]> + 'static,
@@ -318,18 +320,21 @@ impl<S: Record> Ptr<S> {
                 move |s: &S| get(s).as_ref(),
                 move |s: &mut S| get_mut(s).as_mut(),
                 address(w.as_ptr() as *const ()),
+                inline,
             )),
             PtrKind::StackArray(w) | PtrKind::HeapArray(w) => Rc::new(InValue::new(
                 w,
                 move |a: &Box<[S]>| get(&a[idx]).as_ref(),
                 move |a: &mut Box<[S]>| get_mut(&mut a[idx]).as_mut(),
                 address(w.as_ptr() as *const ()),
+                inline,
             )),
             PtrKind::StackVec(w) | PtrKind::HeapVec(w) => Rc::new(InValue::new(
                 w,
                 move |v: &Vec<S>| get(&v[idx]).as_ref(),
                 move |v: &mut Vec<S>| get_mut(&mut v[idx]).as_mut(),
                 address(w.as_ptr() as *const ()),
+                inline,
             )),
             _ => Rc::new(FieldOf::new(
                 self.clone(),
@@ -355,11 +360,13 @@ struct InValue<R, G, M> {
     get_mut: M,
     // The address of the field, for comparisons.
     address: usize,
+    // Whether the elements are in the memory of the struct.
+    inline: bool,
 }
 
 impl<R, G, M> InValue<R, G, M> {
     #[inline]
-    fn new<T>(root: &Weak<RefCell<R>>, get: G, get_mut: M, address: usize) -> Self
+    fn new<T>(root: &Weak<RefCell<R>>, get: G, get_mut: M, address: usize, inline: bool) -> Self
     where
         G: Fn(&R) -> &[T],
         M: Fn(&mut R) -> &mut [T],
@@ -369,6 +376,7 @@ impl<R, G, M> InValue<R, G, M> {
             get,
             get_mut,
             address,
+            inline,
         }
     }
 }
@@ -404,6 +412,11 @@ where
     fn address(&self) -> usize {
         self.address
     }
+
+    fn struct_root(&self) -> Option<usize> {
+        self.inline
+            .then_some(self.root.as_ptr() as *const () as usize)
+    }
 }
 
 // A field of a struct, as returned by field_ref!, which is made a pointer to
@@ -445,7 +458,7 @@ where
                 .decay(),
             _ => self
                 .base
-                .elems_of(self.get, self.get_mut, (self.offset)(&S::OFFSETS)),
+                .elems_of(self.get, self.get_mut, (self.offset)(&S::OFFSETS), false),
         }
     }
 }
@@ -1586,6 +1599,70 @@ mod tests {
         assert_eq!(v.offset(1).read(), 6);
     }
 
+    #[derive(Clone, Default, Record, ByteRepr)]
+    #[byte_size(44)]
+    struct Adjacent {
+        #[offset(0)]
+        #[byte_size(8)]
+        a: Box<[i32]>,
+        #[offset(8)]
+        #[byte_size(8)]
+        b: Box<[i32]>,
+        #[offset(16)]
+        #[byte_size(24)]
+        v: Vec<i32>,
+        #[offset(40)]
+        c: i32,
+    }
+
+    #[derive(Default, Record, ByteRepr)]
+    #[byte_size(48)]
+    struct HoldsAdjacent {
+        #[offset(0)]
+        n: i32,
+        #[offset(4)]
+        #[byte_size(44)]
+        adj: Adjacent,
+    }
+
+    fn adjacent() -> Adjacent {
+        Adjacent {
+            a: vec![1, 2].into_boxed_slice(),
+            b: vec![3, 4].into_boxed_slice(),
+            v: vec![5, 6, 7, 8, 9, 10],
+            c: 11,
+        }
+    }
+
+    fn check_adjacent(s: Ptr<Adjacent>) {
+        // One past the end of an array field is the next field.
+        let a: Ptr<i32> = array_field_ptr!(s, a);
+        let b: Ptr<i32> = array_field_ptr!(s, b);
+        assert_eq!(a.offset(2), b);
+        assert!(a.offset(2) <= b && a.offset(2) >= b);
+        assert!(a.offset(1) < b && b < a.offset(3));
+        assert_ne!(a.offset(1), b);
+        assert_eq!(b.offset(-2), a);
+        // The elements of a vector are not in the struct.
+        let v: Ptr<i32> = field_ref!(s, v).as_pointer();
+        assert_ne!(v.offset(6), field_ptr!(s, c));
+    }
+
+    #[test]
+    fn adjacent_array_fields() {
+        let s: Value<Adjacent> = Rc::new(RefCell::new(adjacent()));
+        check_adjacent(s.as_pointer());
+        let held: Value<HoldsAdjacent> = Rc::new(RefCell::new(HoldsAdjacent {
+            n: 0,
+            adj: adjacent(),
+        }));
+        check_adjacent(field_ptr!(held, adj));
+        // Fields of different structs are not equal.
+        let other: Value<Adjacent> = Rc::new(RefCell::new(adjacent()));
+        let a: Ptr<i32> = array_field_ptr!(s, a);
+        assert_ne!(a.offset(2), array_field_ptr!(other, b));
+    }
+
     #[test]
     fn pointer_size() {
         // Pointers to elements of fields are no larger than other pointers.

libcc2rs/src/rc.rs

@@ -51,6 +51,12 @@ pub trait SliceParent<T> {
     fn borrow_slice_mut<'a>(&self, root: &'a SliceRoot) -> RefMut<'a, [T]>;
     fn address(&self) -> usize;
 
+    // The address of the allocation of the struct that the elements are in,
+    // if they are in its memory, as the elements of an array field are.
+    fn struct_root(&self) -> Option<usize> {
+        None
+    }
+
     // Calls `f` with element `idx`.
     fn with_elem(&self, idx: usize, f: &mut dyn FnMut(&T)) {
         let root = self.root();
@@ -342,6 +348,27 @@ impl<T> PtrKind<T> {
             PtrKind::Reinterpreted(data) => data.alloc.address(),
         }
     }
+
+    // The address of the allocation of the struct that the pointer points
+    // into, if it points to a field or to an element of an array field, which
+    // are at their address in the struct.
+    fn struct_root(&self) -> Option<usize> {
+        match self {
+            PtrKind::Field(root, _, FieldShape::Single | FieldShape::Array) => {
+                Some(root.as_ptr() as *const () as usize)
+            }
+            PtrKind::Nested(parent) => parent.struct_root(),
+            _ => None,
+        }
+    }
+
+    // Whether both pointers point into the same struct, where they are
+    // compared by their address, e.g., one past the end of an array field is
+    // the next field.
+    fn in_same_struct(&self, other: &Self) -> bool {
+        self.struct_root()
+            .is_some_and(|root| other.struct_root() == Some(root))
+    }
 }
 
 impl<T> Eq for PtrKind<T> {}
@@ -390,7 +417,13 @@ impl<T> Clone for Ptr<T> {
 
 impl<T> PartialEq for Ptr<T> {
     fn eq(&self, other: &Self) -> bool {
-        self.byte_offset() == other.byte_offset() && self.kind == other.kind
+        if self.byte_offset() == other.byte_offset() {
+            return self.kind == other.kind;
+        }
+        match (&self.kind, &other.kind) {
+            (PtrKind::Nested(a), PtrKind::Nested(b)) if Rc::ptr_eq(a, b) => false,
+            (a, b) => a.in_same_struct(b) && self.address() == other.address(),
+        }
     }
 }
 
@@ -400,6 +433,9 @@ impl<T> Ord for Ptr<T> {
     fn cmp(&self, other: &Self) -> std::cmp::Ordering {
         match self.kind.partial_cmp(&other.kind) {
             Some(std::cmp::Ordering::Equal) | None => self.byte_offset().cmp(&other.byte_offset()),
+            Some(_) if self.kind.in_same_struct(&other.kind) => {
+                self.address().cmp(&other.address())
+            }
             Some(ord) => ord,
         }
     }

tests/unit/struct_member_array_adjacency.c

@@ -1,4 +1,3 @@
-// panic: refcount
 #include <assert.h>
 
 struct pair {