fix

Author: nunoplopes

cpp2rust/converter/models/converter_refcount.cpp

@@ -73,6 +73,23 @@ static bool IsValueField(clang::ASTContext &ctx,
   return type->isConstantArrayType() || IsBoxedType(ctx, type);
 }
 
+// Whether `expr` is an array field whose elements are accessed through
+// array_field_ptr!, such that they are found in the memory of the struct when
+// the struct is reinterpreted from other memory.
+static bool IsArrayFieldPtr(clang::ASTContext &ctx, const clang::Expr *expr) {
+  auto *member =
+      clang::dyn_cast<clang::MemberExpr>(expr->IgnoreParenImpCasts());
+  auto *field =
+      member ? clang::dyn_cast<clang::FieldDecl>(member->getMemberDecl())
+             : nullptr;
+  if (!field || field->getParent()->isUnion() ||
+      Mapper::Contains(ctx, member)) {
+    return false;
+  }
+  auto *type = field->getType()->getAsArrayTypeUnsafe();
+  return type && !type->getElementType()->isArrayType();
+}
+
 static bool IsPointerType(clang::ASTContext &ctx, clang::QualType type) {
   return type->isPointerType() || GetStrongestIteratorCategory(ctx, type) ==
                                       IteratorCategory::Contiguous;
@@ -421,7 +438,7 @@ bool ConverterRefCount::VisitArraySubscriptExpr(
     clang::ArraySubscriptExpr *expr) {
   auto *base = expr->getBase();
   if (base->IgnoreCasts()->getType()->isPointerType() ||
-      IsUnionArrayMember(base) ||
+      IsUnionArrayMember(base) || IsArrayFieldPtr(ctx_, base) ||
       (IsReferenceType(base) &&
        base->IgnoreCasts()->getType()->isArrayType())) {
     ConvertPointerSubscript(expr);
@@ -1542,8 +1559,23 @@ bool ConverterRefCount::VisitExplicitCastExpr(clang::ExplicitCastExpr *expr) {
     } else if (expr->getSubExpr()->getType()->isPointerType() &&
                !expr->getSubExpr()->isNullPointerConstant(
                    ctx_, clang::Expr::NPC_ValueDependentIsNull)) {
-      StrCat(std::format("{}.reinterpret_cast::<{}>()",
-                         ToString(expr->getSubExpr()),
+      auto sub_expr = expr->getSubExpr();
+      if (auto *array_type =
+              ctx_.getAsArrayType(sub_expr->getType()->getPointeeType())) {
+        // A pointer to an array is a pointer to its first element.
+        auto element_type = array_type->getElementType();
+        PushConversionKind push(*this, ConversionKind::Unboxed);
+        StrCat(std::format("({} as Ptr<{}>)", ToString(sub_expr),
+                           ToString(element_type)));
+        if (!ctx_.hasSameUnqualifiedType(
+                element_type, expr->getType()->getPointeeType())) {
+          StrCat(std::format(".reinterpret_cast::<{}>()",
+                             ConvertPointeeType(expr->getType())));
+        }
+        computed_expr_type_ = ComputedExprType::FreshPointer;
+        return false;
+      }
+      StrCat(std::format("{}.reinterpret_cast::<{}>()", ToString(sub_expr),
                          ConvertPointeeType(expr->getType())));
       computed_expr_type_ = ComputedExprType::FreshPointer;
       return false;
@@ -1848,6 +1880,13 @@ bool ConverterRefCount::VisitMemberExpr(clang::MemberExpr *expr) {
     return false;
   }
 
+  if (isAddrOf() && IsArrayFieldPtr(ctx_, expr)) {
+    StrCat(std::format("array_field_ptr!({}, {})", ConvertRecordPtr(expr),
+                       GetNamedDeclAsString(member)));
+    computed_expr_type_ = ComputedExprType::FreshPointer;
+    return false;
+  }
+
   std::string str;
   if (known) {
     str = GetMappedAsString(expr);
@@ -1893,18 +1932,7 @@ void ConverterRefCount::ConvertInlineField(clang::MemberExpr *expr) {
   auto *base = expr->getBase();
   if (isAddrOf()) {
     // A pointer to the struct, offset to the field.
-    std::string ptr;
-    {
-      Buffer buf(*this);
-      PushExprKind push(*this, ExprKind::AddrOf);
-      if (expr->isArrow()) {
-        ConvertArrow(base);
-      } else {
-        Convert(base);
-      }
-      ptr = std::move(buf).str();
-    }
-    StrCat(std::format("field_ptr!({}, {})", ptr, name));
+    StrCat(std::format("field_ptr!({}, {})", ConvertRecordPtr(expr), name));
     computed_expr_type_ = ComputedExprType::FreshPointer;
     return;
   }
@@ -1939,6 +1967,17 @@ void ConverterRefCount::ConvertInlineField(clang::MemberExpr *expr) {
   SetValueFreshness(type);
 }
 
+std::string ConverterRefCount::ConvertRecordPtr(clang::MemberExpr *expr) {
+  Buffer buf(*this);
+  PushExprKind push(*this, ExprKind::AddrOf);
+  if (expr->isArrow()) {
+    ConvertArrow(expr->getBase());
+  } else {
+    Convert(expr->getBase());
+  }
+  return std::move(buf).str();
+}
+
 std::string ConverterRefCount::ReadField(clang::MemberExpr *expr) {
   // Unless the struct is reached through a pointer, in which case the field
   // is read in a closure, the borrow of the struct ends at the end of the

cpp2rust/converter/models/converter_refcount.h

@@ -152,6 +152,9 @@ class ConverterRefCount final : public Converter {
   // Converts an access to a field that is stored inline in its struct.
   void ConvertInlineField(clang::MemberExpr *expr);
 
+  // A pointer to the struct whose field `expr` accesses.
+  std::string ConvertRecordPtr(clang::MemberExpr *expr);
+
   // Copies the value of the field `expr` out of its struct, such that the
   // struct doesn't stay borrowed.
   std::string ReadField(clang::MemberExpr *expr);

docs/src/codegen/types/pointers.md

@@ -52,7 +52,9 @@ and `&p->field` is `field_ptr!(p, field)`: a pointer to the field of the struct,
 made from the `Value` or the `Ptr` of the struct (see
 [Pointers to fields](../../runtime/rc.md#pointers-to-fields)). An array decays
 with `arr.as_pointer() as Ptr<T>`, a `Ptr` to element 0 of the whole array, and
-`&arr[i]` is that pointer offset by `i`.
+`&arr[i]` is that pointer offset by `i`. An array field decays with
+`array_field_ptr!(p, arr)`, and `p->arr[i]` is read and written through that
+pointer offset by `i`.
 
 Both models push the address down to the innermost place expression:
 `&(cond ? x : y)` becomes `if cond { &mut x } else { &mut y }` in the unsafe

docs/src/runtime/rc.md

@@ -127,6 +127,15 @@ elements are ordinary array pointers, and pointers to the fields of those have
 the array or vector as their root. A field pointer hence always points to a
 single object, which is why it needs no element index.
 
+`array_field_ptr!(p, arr)` is a pointer to element 0 of the array field `arr`,
+and is how the elements of an array field are accessed. It is an ordinary array
+pointer into the array's `Value`, except when `p` is a reinterpreted pointer: the
+array then lives in the bytes of the original allocation, so the result is a
+reinterpreted pointer to those bytes, at the offset of the field. Writes to the
+elements hence reach the original allocation, and the pointer can go past the
+end of the struct, as C code does with a trailing `char name[1]` in an
+over-allocated struct.
+
 Reading a field through a pointer borrows the struct only for the duration of a
 closure, e.g., `p.with(|s| s.y)`, so that the borrow ends before the rest of the
 statement runs. `field!(p, y)` is the place of the field, which is read and

libcc2rs/src/field.rs

@@ -122,6 +122,18 @@ pub trait FieldPtr<S: Record> {
         field: fn(&S) -> &T,
         offset: fn(&S::Offsets) -> usize,
     ) -> Ptr<T>;
+
+    // A pointer to the first element of the array field `field`, at
+    // `offset(S::OFFSETS)`. The array is in a Value of its own, unless the
+    // struct is reinterpreted memory, in which case the pointer points into
+    // that memory.
+    fn array_field_ptr<T>(
+        &self,
+        field: fn(&S) -> &Value<Box<[T]>>,
+        offset: fn(&S::Offsets) -> usize,
+    ) -> Ptr<T>
+    where
+        T: ByteRepr;
 }
 
 impl<S: Record> FieldPtr<S> for Ptr<S> {
@@ -150,6 +162,22 @@ impl<S: Record> FieldPtr<S> for Ptr<S> {
             kind: PtrKind::Field(root),
         }
     }
+
+    #[inline]
+    fn array_field_ptr<T>(
+        &self,
+        field: fn(&S) -> &Value<Box<[T]>>,
+        offset: fn(&S::Offsets) -> usize,
+    ) -> Ptr<T>
+    where
+        T: ByteRepr,
+    {
+        if let PtrKind::Reinterpreted(_) = &self.kind {
+            let (alloc, byte_offset) = self.original_alloc().unwrap();
+            return Ptr::from_original_alloc(alloc, byte_offset.wrapping_add(offset(&S::OFFSETS)));
+        }
+        self.with(|s| field(s).as_pointer())
+    }
 }
 
 impl<S: Record> FieldPtr<S> for Value<S> {
@@ -161,6 +189,18 @@ impl<S: Record> FieldPtr<S> for Value<S> {
     ) -> Ptr<T> {
         self.as_pointer().field_ptr(field, offset)
     }
+
+    #[inline]
+    fn array_field_ptr<T>(
+        &self,
+        field: fn(&S) -> &Value<Box<[T]>>,
+        _offset: fn(&S::Offsets) -> usize,
+    ) -> Ptr<T>
+    where
+        T: ByteRepr,
+    {
+        field(&self.borrow()).as_pointer()
+    }
 }
 
 // A pointer to field `field` of the struct that a Ptr or a Value holds,
@@ -173,6 +213,16 @@ macro_rules! field_ptr {
     }};
 }
 
+// A pointer to the first element of array field `field` of the struct that a
+// Ptr or a Value holds, e.g., `array_field_ptr!(p, arr)`.
+#[macro_export]
+macro_rules! array_field_ptr {
+    ($base:expr, $field:ident) => {{
+        use $crate::FieldPtr as _;
+        ($base).array_field_ptr(|__s| &__s.$field, |__o| __o.$field)
+    }};
+}
+
 // Something that is read and written in place, like the object a pointer
 // points to.
 pub trait Place: Clone {
@@ -515,6 +565,51 @@ mod tests {
         raw.delete();
     }
 
+    #[derive(Record)]
+    struct Masked {
+        #[offset(0)]
+        n: i32,
+        #[offset(4)]
+        mask: Value<Box<[u8]>>,
+    }
+
+    impl ByteRepr for Masked {
+        fn byte_size() -> usize {
+            8
+        }
+        fn to_bytes(&self, buf: &mut [u8]) {
+            self.n.to_bytes(&mut buf[0..4]);
+            self.mask.borrow().to_bytes(&mut buf[4..8]);
+        }
+        fn from_bytes(buf: &[u8]) -> Self {
+            Self {
+                n: i32::from_bytes(&buf[0..4]),
+                mask: Rc::new(RefCell::new(<Box<[u8]>>::from_bytes(&buf[4..8]))),
+            }
+        }
+    }
+
+    #[test]
+    fn array_field() {
+        let s: Value<Masked> = Rc::new(RefCell::new(Masked::from_bytes(&[0; 8])));
+        let m = array_field_ptr!(s, mask);
+        m.offset(2).write(5);
+        assert_eq!(s.borrow().mask.borrow()[2], 5);
+        assert_eq!(array_field_ptr!(s.as_pointer(), mask), m);
+        // The array field of a reinterpreted struct is in its memory, which
+        // the pointer can go past the end of the struct in.
+        let raw: Ptr<u8> = Ptr::alloc_array(vec![0u8; 12].into_boxed_slice());
+        let view: Ptr<Masked> = raw.reinterpret_cast();
+        let m = array_field_ptr!(view, mask);
+        m.offset(1).write(7);
+        assert_eq!(raw.offset(5).read(), 7);
+        m.offset(6).write(9);
+        assert_eq!(raw.offset(10).read(), 9);
+        field_ptr!(view, n).write(3);
+        assert_eq!(m.offset(1).read(), 7);
+        raw.delete();
+    }
+
     #[test]
     fn field_place() {
         let s = outer();

tests/multi-file/defaulted_move_cross_tu/out/refcount/defaulted_move_cross_tu.rs

@@ -56,9 +56,13 @@ pub fn sum_0(s: Ptr<S>) -> i32 {
     return {
         let _lhs = {
             let _lhs = ((*s.with(|__s| __s.v.clone()).borrow()).len() as i32);
-            _lhs + (*s.with(|__s| __s.n.clone()).borrow())[(0) as usize]
+            _lhs + ((array_field_ptr!(s, n) as Ptr<i32>)
+                .offset((0) as isize)
+                .read())
         };
-        _lhs + (*s.with(|__s| __s.n.clone()).borrow())[(1) as usize]
+        _lhs + ((array_field_ptr!(s, n) as Ptr<i32>)
+            .offset((1) as isize)
+            .read())
     };
 }
 pub fn main() {
@@ -90,13 +94,13 @@ impl SImpl for Ptr<S> {
             &mut (*{ (*_a0.upgrade().deref()).v.clone() }.borrow_mut()),
         ));
         {
-            (((*self).with(|__s| __s.n.clone()).as_pointer()) as Ptr<i32>)
+            ((array_field_ptr!((*self), n)) as Ptr<i32>)
                 .to_any()
                 .memcpy(
-                    &(({ (*_a0.upgrade().deref()).n.clone() }.as_pointer()) as Ptr<i32>).to_any(),
+                    &((array_field_ptr!(_a0, n)) as Ptr<i32>).to_any(),
                     8_usize as usize,
                 );
-            (((*self).with(|__s| __s.n.clone()).as_pointer()) as Ptr<i32>).to_any()
+            ((array_field_ptr!((*self), n)) as Ptr<i32>).to_any()
         };
         return (*self).clone();
     }

tests/unit/array_field_addr.c

@@ -1,4 +1,3 @@
-// no-compile: refcount
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>

tests/unit/container_field_addr.cpp

@@ -6,20 +6,15 @@
 struct S {
   int tag;
   std::vector<int> v;
-  std::map<int, int> m;
 };
 
 static void add(std::vector<int> *v, int k) { v->push_back(k); }
 
-static void put(std::map<int, int> *m, int k, int v) { (*m)[k] = v; }
-
 static void run(S *h) {
   add(&h->v, h->tag);
-  put(&h->m, h->tag, 2);
   std::vector<int> *pv = &h->v;
   pv->push_back((int)pv->size());
   assert(h->v.size() == 2 && h->v[0] == 7 && h->v[1] == 1);
-  assert(h->m[7] == 2);
   assert(h->tag == 7);
 }
 

tests/unit/field_aliasing.c

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

tests/unit/flex_array_member_sibling_write.c

@@ -1,4 +1,3 @@
-// panic: refcount
 #include <assert.h>
 #include <stdlib.h>
 #include <string.h>