Move malloc,free,realloc,calloc,strdup in libcc2rs

lucic71 · lucic71 · commit 175fa732fa31 · 2026-05-21T14:49:04.000+01:00
diff --git a/libcc2rs/src/alloc.rs b/libcc2rs/src/alloc.rs
@@ -0,0 +1,47 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+use std::ffi::{c_char, c_void};
+
+unsafe extern "C" {
+    fn malloc(size: usize) -> *mut c_void;
+    fn free(ptr: *mut c_void);
+    fn realloc(ptr: *mut c_void, size: usize) -> *mut c_void;
+    fn calloc(nmemb: usize, size: usize) -> *mut c_void;
+    fn strdup(s: *const c_char) -> *mut c_char;
+}
+
+/// # Safety
+///
+/// Same contract as C's `malloc`.
+pub unsafe fn malloc_unsafe(a0: u64) -> *mut c_void {
+    unsafe { malloc(a0 as usize) }
+}
+
+/// # Safety
+///
+/// Same contract as C's `free`.
+pub unsafe fn free_unsafe(a0: *mut c_void) {
+    unsafe { free(a0) }
+}
+
+/// # Safety
+///
+/// Same contract as C's `realloc`.
+pub unsafe fn realloc_unsafe(a0: *mut c_void, a1: u64) -> *mut c_void {
+    unsafe { realloc(a0, a1 as usize) }
+}
+
+/// # Safety
+///
+/// Same contract as C's `calloc`.
+pub unsafe fn calloc_unsafe(a0: u64, a1: u64) -> *mut c_void {
+    unsafe { calloc(a0 as usize, a1 as usize) }
+}
+
+/// # Safety
+///
+/// Same contract as C's `strdup`.
+pub unsafe fn strdup_unsafe(a0: *const u8) -> *mut u8 {
+    unsafe { strdup(a0 as *const c_char) as *mut u8 }
+}
diff --git a/libcc2rs/src/lib.rs b/libcc2rs/src/lib.rs
@@ -22,6 +22,9 @@ pub use rules::*;
 mod io;
 pub use io::*;
 
+mod alloc;
+pub use alloc::*;
+
 mod iterators;
 pub use iterators::*;
 
diff --git a/rules/cstdlib/ir_unsafe.json b/rules/cstdlib/ir_unsafe.json
@@ -9,7 +9,7 @@
   "f2": {
     "body": [
       {
-        "text": "libc::free("
+        "text": "libcc2rs::free_unsafe("
       },
       {
         "placeholder": {
@@ -31,7 +31,7 @@
   "f3": {
     "body": [
       {
-        "text": "libc::malloc("
+        "text": "libcc2rs::malloc_unsafe("
       },
       {
         "placeholder": {
@@ -40,7 +40,7 @@
         }
       },
       {
-        "text": " as ::libc::size_t)"
+        "text": ")"
       }
     ],
     "params": {
@@ -56,7 +56,7 @@
   "f4": {
     "body": [
       {
-        "text": "libc::realloc("
+        "text": "libcc2rs::realloc_unsafe("
       },
       {
         "placeholder": {
@@ -74,7 +74,7 @@
         }
       },
       {
-        "text": " as ::libc::size_t)"
+        "text": ")"
       }
     ],
     "params": {
@@ -94,7 +94,7 @@
   "f5": {
     "body": [
       {
-        "text": "libc::calloc("
+        "text": "libcc2rs::calloc_unsafe("
       },
       {
         "placeholder": {
@@ -103,7 +103,7 @@
         }
       },
       {
-        "text": " as ::libc::size_t, "
+        "text": ", "
       },
       {
         "placeholder": {
@@ -112,7 +112,7 @@
         }
       },
       {
-        "text": " as ::libc::size_t)"
+        "text": ")"
       }
     ],
     "params": {
diff --git a/rules/cstdlib/tgt_unsafe.rs b/rules/cstdlib/tgt_unsafe.rs
@@ -6,19 +6,19 @@ unsafe fn f1() {
 }
 
 unsafe fn f2(a0: *mut ::libc::c_void) {
-    libc::free(a0)
+    libcc2rs::free_unsafe(a0)
 }
 
 unsafe fn f3(a0: u64) -> *mut ::libc::c_void {
-    libc::malloc(a0 as ::libc::size_t)
+    libcc2rs::malloc_unsafe(a0)
 }
 
 unsafe fn f4(a0: *mut ::libc::c_void, a1: u64) -> *mut ::libc::c_void {
-    libc::realloc(a0, a1 as ::libc::size_t)
+    libcc2rs::realloc_unsafe(a0, a1)
 }
 
 unsafe fn f5(a0: u64, a1: u64) -> *mut ::libc::c_void {
-    libc::calloc(a0 as ::libc::size_t, a1 as ::libc::size_t)
+    libcc2rs::calloc_unsafe(a0, a1)
 }
 
 unsafe fn f6(a0: *const u8) -> *mut u8 {
diff --git a/rules/cstring/ir_unsafe.json b/rules/cstring/ir_unsafe.json
@@ -283,7 +283,7 @@
   "f15": {
     "body": [
       {
-        "text": "libc::strdup("
+        "text": "libcc2rs::strdup_unsafe("
       },
       {
         "placeholder": {
@@ -292,7 +292,7 @@
         }
       },
       {
-        "text": " as *const i8) as *mut u8"
+        "text": ")"
       }
     ],
     "params": {
diff --git a/rules/cstring/tgt_unsafe.rs b/rules/cstring/tgt_unsafe.rs
@@ -77,7 +77,7 @@ unsafe fn f14(a0: *mut u8, a1: i32) -> *mut u8 {
 }
 
 unsafe fn f15(a0: *const u8) -> *mut u8 {
-    libc::strdup(a0 as *const i8) as *mut u8
+    libcc2rs::strdup_unsafe(a0)
 }
 
 unsafe fn f16(a0: *const u8, a1: *const u8) -> u64 {
diff --git a/tests/unit/out/unsafe/cstring.rs b/tests/unit/out/unsafe/cstring.rs
@@ -267,30 +267,30 @@ pub unsafe fn test_strrchr_9() {
     );
 }
 pub unsafe fn test_strdup_10() {
-    let mut d: *mut u8 = libc::strdup(b"hello\0".as_ptr() as *const i8) as *mut u8;
+    let mut d: *mut u8 = libcc2rs::strdup_unsafe(b"hello\0".as_ptr());
     assert!(!((d).is_null()));
     assert!(
         ((libc::strcmp(
             (d).cast_const() as *const i8,
             b"hello\0".as_ptr() as *const i8
         )) == (0))
     );
-    libc::free((d as *mut u8 as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d as *mut u8 as *mut ::libc::c_void));
     let mut p: *const u8 = b"world\0".as_ptr();
     let mut buf: [u8; 4] = [('a' as u8), ('b' as u8), ('c' as u8), ('\0' as u8)];
-    let mut d2: *mut u8 = libc::strdup(p as *const i8) as *mut u8;
+    let mut d2: *mut u8 = libcc2rs::strdup_unsafe(p);
     assert!(!((d2).is_null()));
     assert!(((libc::strcmp((d2).cast_const() as *const i8, p as *const i8)) == (0)));
-    libc::free((d2 as *mut u8 as *mut ::libc::c_void));
-    let mut d3: *mut u8 = libc::strdup((buf.as_mut_ptr()).cast_const() as *const i8) as *mut u8;
+    libcc2rs::free_unsafe((d2 as *mut u8 as *mut ::libc::c_void));
+    let mut d3: *mut u8 = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
     assert!(!((d3).is_null()));
     assert!(
         ((libc::strcmp(
             (d3).cast_const() as *const i8,
             (buf.as_mut_ptr()).cast_const() as *const i8
         )) == (0))
     );
-    libc::free((d3 as *mut u8 as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d3 as *mut u8 as *mut ::libc::c_void));
 }
 pub unsafe fn test_strcspn_11() {
     assert!(
diff --git a/tests/unit/out/unsafe/errno.rs b/tests/unit/out/unsafe/errno.rs
@@ -17,11 +17,10 @@ pub unsafe fn test_errno_0() {
 }
 pub unsafe fn test_errno_preserved_across_strdup_1() {
     (*libcc2rs::cpp2rust_errno()) = 99;
-    let mut d: *mut u8 =
-        libc::strdup((b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8) as *mut u8;
+    let mut d: *mut u8 = libcc2rs::strdup_unsafe((b"hello\0".as_ptr().cast_mut()).cast_const());
     assert!((((!((d).is_null())) as i32) != 0));
     assert!(((((*libcc2rs::cpp2rust_errno()) == (99)) as i32) != 0));
-    libc::free((d as *mut u8 as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d as *mut u8 as *mut ::libc::c_void));
     (*libcc2rs::cpp2rust_errno()) = 0;
 }
 pub unsafe fn test_errno_from_fseek_2() {
diff --git a/tests/unit/out/unsafe/malloc_realloc_free.rs b/tests/unit/out/unsafe/malloc_realloc_free.rs
@@ -13,46 +13,44 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut p: *mut i32 =
-        (libc::malloc(::std::mem::size_of::<i32>() as u64 as ::libc::size_t) as *mut i32);
+        (libcc2rs::malloc_unsafe(::std::mem::size_of::<i32>() as u64) as *mut i32);
     (*p) = 42;
     assert!(((((*p) == (42)) as i32) != 0));
-    libc::free((p as *mut i32 as *mut ::libc::c_void));
-    let mut arr: *mut i32 = (libc::malloc(
-        (4_u64).wrapping_mul(::std::mem::size_of::<i32>() as u64 as u64) as ::libc::size_t,
-    ) as *mut i32);
+    libcc2rs::free_unsafe((p as *mut i32 as *mut ::libc::c_void));
+    let mut arr: *mut i32 =
+        (libcc2rs::malloc_unsafe((4_u64).wrapping_mul(::std::mem::size_of::<i32>() as u64 as u64))
+            as *mut i32);
     let mut i: i32 = 0;
     'loop_: while ((((i) < (4)) as i32) != 0) {
         (*arr.offset((i) as isize)) = ((i) * (10));
         i.postfix_inc();
     }
     assert!(((((*arr.offset((0) as isize)) == (0)) as i32) != 0));
     assert!(((((*arr.offset((3) as isize)) == (30)) as i32) != 0));
-    libc::free((arr as *mut i32 as *mut ::libc::c_void));
-    let mut grow: *mut i32 = (libc::malloc(
-        (2_u64).wrapping_mul(::std::mem::size_of::<i32>() as u64 as u64) as ::libc::size_t,
-    ) as *mut i32);
+    libcc2rs::free_unsafe((arr as *mut i32 as *mut ::libc::c_void));
+    let mut grow: *mut i32 =
+        (libcc2rs::malloc_unsafe((2_u64).wrapping_mul(::std::mem::size_of::<i32>() as u64 as u64))
+            as *mut i32);
     (*grow.offset((0) as isize)) = 1;
     (*grow.offset((1) as isize)) = 2;
-    grow = (libc::realloc(
+    grow = (libcc2rs::realloc_unsafe(
         (grow as *mut i32 as *mut ::libc::c_void),
-        (4_u64).wrapping_mul(::std::mem::size_of::<i32>() as u64 as u64) as ::libc::size_t,
+        (4_u64).wrapping_mul(::std::mem::size_of::<i32>() as u64 as u64),
     ) as *mut i32);
     (*grow.offset((2) as isize)) = 3;
     (*grow.offset((3) as isize)) = 4;
     assert!(((((*grow.offset((0) as isize)) == (1)) as i32) != 0));
     assert!(((((*grow.offset((1) as isize)) == (2)) as i32) != 0));
     assert!(((((*grow.offset((2) as isize)) == (3)) as i32) != 0));
     assert!(((((*grow.offset((3) as isize)) == (4)) as i32) != 0));
-    libc::free((grow as *mut i32 as *mut ::libc::c_void));
-    let mut zeros: *mut i32 = (libc::calloc(
-        4_u64 as ::libc::size_t,
-        ::std::mem::size_of::<i32>() as u64 as ::libc::size_t,
-    ) as *mut i32);
+    libcc2rs::free_unsafe((grow as *mut i32 as *mut ::libc::c_void));
+    let mut zeros: *mut i32 =
+        (libcc2rs::calloc_unsafe(4_u64, ::std::mem::size_of::<i32>() as u64) as *mut i32);
     let mut i: i32 = 0;
     'loop_: while ((((i) < (4)) as i32) != 0) {
         assert!(((((*zeros.offset((i) as isize)) == (0)) as i32) != 0));
         i.postfix_inc();
     }
-    libc::free((zeros as *mut i32 as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((zeros as *mut i32 as *mut ::libc::c_void));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/string_h.rs b/tests/unit/out/unsafe/string_h.rs
@@ -338,8 +338,7 @@ pub unsafe fn test_strrchr_9() {
     );
 }
 pub unsafe fn test_strdup_10() {
-    let mut d: *mut u8 =
-        libc::strdup((b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8) as *mut u8;
+    let mut d: *mut u8 = libcc2rs::strdup_unsafe((b"hello\0".as_ptr().cast_mut()).cast_const());
     assert!((((!((d).is_null())) as i32) != 0));
     assert!(
         ((((libc::strcmp(
@@ -348,21 +347,21 @@ pub unsafe fn test_strdup_10() {
         )) == (0)) as i32)
             != 0)
     );
-    libc::free((d as *mut u8 as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d as *mut u8 as *mut ::libc::c_void));
     let mut p: *const u8 = (b"world\0".as_ptr().cast_mut()).cast_const();
     let mut buf: [u8; 4] = [
         (('a' as i32) as u8),
         (('b' as i32) as u8),
         (('c' as i32) as u8),
         (('\0' as i32) as u8),
     ];
-    let mut d2: *mut u8 = libc::strdup(p as *const i8) as *mut u8;
+    let mut d2: *mut u8 = libcc2rs::strdup_unsafe(p);
     assert!((((!((d2).is_null())) as i32) != 0));
     assert!(
         ((((libc::strcmp((d2).cast_const() as *const i8, p as *const i8)) == (0)) as i32) != 0)
     );
-    libc::free((d2 as *mut u8 as *mut ::libc::c_void));
-    let mut d3: *mut u8 = libc::strdup((buf.as_mut_ptr()).cast_const() as *const i8) as *mut u8;
+    libcc2rs::free_unsafe((d2 as *mut u8 as *mut ::libc::c_void));
+    let mut d3: *mut u8 = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
     assert!((((!((d3).is_null())) as i32) != 0));
     assert!(
         ((((libc::strcmp(
@@ -371,7 +370,7 @@ pub unsafe fn test_strdup_10() {
         )) == (0)) as i32)
             != 0)
     );
-    libc::free((d3 as *mut u8 as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d3 as *mut u8 as *mut ::libc::c_void));
 }
 pub unsafe fn test_strcspn_11() {
     assert!(

Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@`
`9`	`9`	`"f2": {`
`10`	`10`	`"body": [`
`11`	`11`	`{`
`12`		`- "text": "libc::free("`
	`12`	`+ "text": "libcc2rs::free_unsafe("`
`13`	`13`	`},`
`14`	`14`	`{`
`15`	`15`	`"placeholder": {`
`@@ -31,7 +31,7 @@`
`31`	`31`	`"f3": {`
`32`	`32`	`"body": [`
`33`	`33`	`{`
`34`		`- "text": "libc::malloc("`
	`34`	`+ "text": "libcc2rs::malloc_unsafe("`
`35`	`35`	`},`
`36`	`36`	`{`
`37`	`37`	`"placeholder": {`
`@@ -40,7 +40,7 @@`
`40`	`40`	`}`
`41`	`41`	`},`
`42`	`42`	`{`
`43`		`- "text": " as ::libc::size_t)"`
	`43`	`+ "text": ")"`
`44`	`44`	`}`
`45`	`45`	`],`
`46`	`46`	`"params": {`
`@@ -56,7 +56,7 @@`
`56`	`56`	`"f4": {`
`57`	`57`	`"body": [`
`58`	`58`	`{`
`59`		`- "text": "libc::realloc("`
	`59`	`+ "text": "libcc2rs::realloc_unsafe("`
`60`	`60`	`},`
`61`	`61`	`{`
`62`	`62`	`"placeholder": {`
`@@ -74,7 +74,7 @@`
`74`	`74`	`}`
`75`	`75`	`},`
`76`	`76`	`{`
`77`		`- "text": " as ::libc::size_t)"`
	`77`	`+ "text": ")"`
`78`	`78`	`}`
`79`	`79`	`],`
`80`	`80`	`"params": {`
`@@ -94,7 +94,7 @@`
`94`	`94`	`"f5": {`
`95`	`95`	`"body": [`
`96`	`96`	`{`
`97`		`- "text": "libc::calloc("`
	`97`	`+ "text": "libcc2rs::calloc_unsafe("`
`98`	`98`	`},`
`99`	`99`	`{`
`100`	`100`	`"placeholder": {`
`@@ -103,7 +103,7 @@`
`103`	`103`	`}`
`104`	`104`	`},`
`105`	`105`	`{`
`106`		`- "text": " as ::libc::size_t, "`
	`106`	`+ "text": ", "`
`107`	`107`	`},`
`108`	`108`	`{`
`109`	`109`	`"placeholder": {`
`@@ -112,7 +112,7 @@`
`112`	`112`	`}`
`113`	`113`	`},`
`114`	`114`	`{`
`115`		`- "text": " as ::libc::size_t)"`
	`115`	`+ "text": ")"`
`116`	`116`	`}`
`117`	`117`	`],`
`118`	`118`	`"params": {`
Original file line number	Diff line number	Diff line change
`@@ -6,19 +6,19 @@ unsafe fn f1() {`
`6`	`6`	`}`
`7`	`7`
`8`	`8`	`unsafe fn f2(a0: *mut ::libc::c_void) {`
`9`		`- libc::free(a0)`
	`9`	`+ libcc2rs::free_unsafe(a0)`
`10`	`10`	`}`
`11`	`11`
`12`	`12`	`unsafe fn f3(a0: u64) -> *mut ::libc::c_void {`
`13`		`- libc::malloc(a0 as ::libc::size_t)`
	`13`	`+ libcc2rs::malloc_unsafe(a0)`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`unsafe fn f4(a0: mut ::libc::c_void, a1: u64) -> mut ::libc::c_void {`
`17`		`- libc::realloc(a0, a1 as ::libc::size_t)`
	`17`	`+ libcc2rs::realloc_unsafe(a0, a1)`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`unsafe fn f5(a0: u64, a1: u64) -> *mut ::libc::c_void {`
`21`		`- libc::calloc(a0 as ::libc::size_t, a1 as ::libc::size_t)`
	`21`	`+ libcc2rs::calloc_unsafe(a0, a1)`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`unsafe fn f6(a0: const u8) -> mut u8 {`
Original file line number	Diff line number	Diff line change
`@@ -283,7 +283,7 @@`
`283`	`283`	`"f15": {`
`284`	`284`	`"body": [`
`285`	`285`	`{`
`286`		`- "text": "libc::strdup("`
	`286`	`+ "text": "libcc2rs::strdup_unsafe("`
`287`	`287`	`},`
`288`	`288`	`{`
`289`	`289`	`"placeholder": {`
`@@ -292,7 +292,7 @@`
`292`	`292`	`}`
`293`	`293`	`},`
`294`	`294`	`{`
`295`		`- "text": " as const i8) as mut u8"`
	`295`	`+ "text": ")"`
`296`	`296`	`}`
`297`	`297`	`],`
`298`	`298`	`"params": {`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ unsafe fn f14(a0: mut u8, a1: i32) -> mut u8 {`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`unsafe fn f15(a0: const u8) -> mut u8 {`
`80`		`- libc::strdup(a0 as const i8) as mut u8`
	`80`	`+ libcc2rs::strdup_unsafe(a0)`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`unsafe fn f16(a0: const u8, a1: const u8) -> u64 {`
Original file line number	Diff line number	Diff line change
`@@ -17,11 +17,10 @@ pub unsafe fn test_errno_0() {`
`17`	`17`	`}`
`18`	`18`	`pub unsafe fn test_errno_preserved_across_strdup_1() {`
`19`	`19`	`(*libcc2rs::cpp2rust_errno()) = 99;`
`20`		`- let mut d: *mut u8 =`
`21`		`- libc::strdup((b"hello\0".as_ptr().cast_mut()).cast_const() as const i8) as mut u8;`
	`20`	`+ let mut d: *mut u8 = libcc2rs::strdup_unsafe((b"hello\0".as_ptr().cast_mut()).cast_const());`
`22`	`21`	`assert!((((!((d).is_null())) as i32) != 0));`
`23`	`22`	`assert!(((((*libcc2rs::cpp2rust_errno()) == (99)) as i32) != 0));`
`24`		`- libc::free((d as mut u8 as mut ::libc::c_void));`
	`23`	`+ libcc2rs::free_unsafe((d as mut u8 as mut ::libc::c_void));`
`25`	`24`	`(*libcc2rs::cpp2rust_errno()) = 0;`
`26`	`25`	`}`
`27`	`26`	`pub unsafe fn test_errno_from_fseek_2() {`