Add malloc/calloc/free implementations

Author: lucic71

libcc2rs/src/alloc.rs

@@ -3,24 +3,36 @@
 
 use crate::rc::{AnyPtr, Ptr};
 
-pub fn malloc_refcount(_a0: usize) -> AnyPtr {
-    todo!("malloc_refcount")
+pub fn malloc_refcount(a0: usize) -> AnyPtr {
+    Ptr::alloc_array(vec![0u8; a0].into_boxed_slice()).to_any()
 }
 
-pub fn free_refcount(_a0: AnyPtr) {
-    todo!("free_refcount")
+pub fn free_refcount(a0: AnyPtr) {
+    if a0.is_null() {
+        return;
+    }
+    a0.reinterpret_cast::<u8>().delete_array();
 }
 
-pub fn realloc_refcount(_a0: AnyPtr, _a1: usize) -> AnyPtr {
-    todo!("realloc_refcount")
+pub fn realloc_refcount(a0: AnyPtr, a1: usize) -> AnyPtr {
+    if a0.is_null() {
+        return malloc_refcount(a1);
+    }
+    let __new = Ptr::alloc_array(vec![0u8; a1].into_boxed_slice()).to_any();
+    let __n = a1.min(a0.reinterpret_cast::<u8>().len());
+    __new.memcpy(&a0, __n);
+    a0.reinterpret_cast::<u8>().delete_array();
+    __new
 }
 
-pub fn calloc_refcount(_a0: usize, _a1: usize) -> AnyPtr {
-    todo!("calloc_refcount")
+pub fn calloc_refcount(a0: usize, a1: usize) -> AnyPtr {
+    Ptr::alloc_array(vec![0u8; a0.wrapping_mul(a1)].into_boxed_slice()).to_any()
 }
 
-pub fn strdup_refcount(_a0: Ptr<u8>) -> Ptr<u8> {
-    todo!("strdup_refcount")
+pub fn strdup_refcount(a0: Ptr<u8>) -> Ptr<u8> {
+    let mut bytes: Vec<u8> = a0.to_c_string_iterator().collect();
+    bytes.push(0);
+    Ptr::alloc_array(bytes.into_boxed_slice())
 }
 
 /// # Safety

libcc2rs/src/rc.rs

@@ -210,32 +210,38 @@ impl<T> Ptr<T> {
 
     #[inline]
     pub fn delete(&self) {
-        assert_eq!(self.offset, 0, "ub: invalid delete");
-        let weak = match self.kind {
-            PtrKind::HeapSingle(ref weak) => weak,
+        match &self.kind {
+            PtrKind::HeapSingle(weak) => {
+                assert_eq!(self.offset, 0, "ub: invalid delete");
+                assert_eq!(Weak::strong_count(weak), 1, "ub: invalid delete");
+                unsafe {
+                    let strong = weak.upgrade().expect("ub: dangling pointer");
+                    Rc::from_raw(Rc::as_ptr(&strong));
+                }
+                assert_eq!(Weak::strong_count(weak), 0, "ub: double free");
+            }
+            PtrKind::Reinterpreted(data) => data.alloc.delete(),
+            PtrKind::Null => {}
             _ => panic!("ub: invalid delete"),
-        };
-        assert_eq!(Weak::strong_count(weak), 1, "ub: invalid delete");
-        unsafe {
-            let strong = weak.upgrade().expect("ub: dangling pointer");
-            Rc::from_raw(Rc::as_ptr(&strong));
         }
-        assert_eq!(Weak::strong_count(weak), 0, "ub: strong count is not zero");
     }
 
     #[inline]
     pub fn delete_array(&self) {
-        assert_eq!(self.offset, 0, "ub: invalid delete");
-        let weak = match self.kind {
-            PtrKind::HeapArray(ref weak) => weak,
+        match &self.kind {
+            PtrKind::HeapArray(weak) => {
+                assert_eq!(self.offset, 0, "ub: invalid delete");
+                assert_eq!(Weak::strong_count(weak), 1, "ub: invalid delete");
+                unsafe {
+                    let strong = weak.upgrade().expect("ub: dangling pointer");
+                    Rc::from_raw(Rc::as_ptr(&strong));
+                }
+                assert_eq!(Weak::strong_count(weak), 0, "ub: double free");
+            }
+            PtrKind::Reinterpreted(data) => data.alloc.delete(),
+            PtrKind::Null => {}
             _ => panic!("ub: invalid delete"),
-        };
-        assert_eq!(Weak::strong_count(weak), 1, "ub: invalid delete");
-        unsafe {
-            let strong = weak.upgrade().expect("ub: dangling pointer");
-            Rc::from_raw(Rc::as_ptr(&strong));
         }
-        assert_eq!(Weak::strong_count(weak), 0, "ub: strong count is not zero");
     }
 
     #[inline]

libcc2rs/src/reinterpret.rs

@@ -1,7 +1,10 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use std::{cell::RefCell, rc::Weak};
+use std::{
+    cell::RefCell,
+    rc::{Rc, Weak},
+};
 
 pub trait ByteRepr: 'static {
     fn byte_size() -> usize
@@ -100,6 +103,7 @@ pub trait OriginalAlloc {
     fn total_byte_len(&self) -> usize;
     // Stable address used for pointer equality across PtrKind variants.
     fn address(&self) -> usize;
+    fn delete(&self);
 }
 
 // Read bytes starting at `byte_offset` from a slice of S elements into `buf`.
@@ -165,6 +169,15 @@ impl<T: ByteRepr> OriginalAlloc for SingleOriginalAlloc<T> {
     fn address(&self) -> usize {
         self.weak.as_ptr() as usize
     }
+
+    fn delete(&self) {
+        assert_eq!(Weak::strong_count(&self.weak), 1, "ub: invalid delete");
+        unsafe {
+            let strong = self.weak.upgrade().expect("ub: dangling pointer");
+            Rc::from_raw(Rc::as_ptr(&strong));
+        }
+        assert_eq!(Weak::strong_count(&self.weak), 0, "ub: double free");
+    }
 }
 
 pub(crate) trait AsSlice {
@@ -219,4 +232,13 @@ impl<T: AsSlice + 'static> OriginalAlloc for SliceOriginalAlloc<T> {
     fn address(&self) -> usize {
         self.weak.as_ptr() as usize
     }
+
+    fn delete(&self) {
+        assert_eq!(Weak::strong_count(&self.weak), 1, "ub: invalid delete");
+        unsafe {
+            let strong = self.weak.upgrade().expect("ub: dangling pointer");
+            Rc::from_raw(Rc::as_ptr(&strong));
+        }
+        assert_eq!(Weak::strong_count(&self.weak), 0, "ub: double free");
+    }
 }