[unsafe] Allow taking the address of malloc, free, realloc, calloc, strdup (#136)

lucic71 · web-flow · commit 2611835f63c9 · 2026-05-22T08:06:16.000+01:00
diff --git a/libcc2rs/src/alloc.rs b/libcc2rs/src/alloc.rs
@@ -0,0 +1,37 @@
+// Copyright (c) 2022-present INESC-ID.
+// Distributed under the MIT license that can be found in the LICENSE file.
+
+/// # Safety
+///
+/// Same contract as C's `malloc`.
+pub unsafe fn malloc_unsafe(a0: u64) -> *mut libc::c_void {
+    unsafe { libc::malloc(a0 as libc::size_t) }
+}
+
+/// # Safety
+///
+/// Same contract as C's `free`.
+pub unsafe fn free_unsafe(a0: *mut libc::c_void) {
+    unsafe { libc::free(a0) }
+}
+
+/// # Safety
+///
+/// Same contract as C's `realloc`.
+pub unsafe fn realloc_unsafe(a0: *mut libc::c_void, a1: u64) -> *mut libc::c_void {
+    unsafe { libc::realloc(a0, a1 as libc::size_t) }
+}
+
+/// # Safety
+///
+/// Same contract as C's `calloc`.
+pub unsafe fn calloc_unsafe(a0: u64, a1: u64) -> *mut libc::c_void {
+    unsafe { libc::calloc(a0 as libc::size_t, a1 as libc::size_t) }
+}
+
+/// # Safety
+///
+/// Same contract as C's `strdup`.
+pub unsafe fn strdup_unsafe(a0: *const u8) -> *mut u8 {
+    unsafe { libc::strdup(a0 as *const libc::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/malloc_realloc_free.c b/tests/unit/malloc_realloc_free.c
@@ -2,37 +2,49 @@
 #include <assert.h>
 #include <stdlib.h>
 
-int main() {
-  int *p = (int *)malloc(sizeof(int));
-  *p = 42;
-  assert(*p == 42);
-  free(p);
+#define ALLOC_TESTS(MALLOC, FREE, REALLOC, CALLOC)                             \
+  do {                                                                         \
+    int *p = (int *)MALLOC(sizeof(int));                                       \
+    *p = 42;                                                                   \
+    assert(*p == 42);                                                          \
+    FREE(p);                                                                   \
+                                                                               \
+    int *arr = (int *)MALLOC(4 * sizeof(int));                                 \
+    for (int i = 0; i < 4; i++) {                                              \
+      arr[i] = i * 10;                                                         \
+    }                                                                          \
+    assert(arr[0] == 0);                                                       \
+    assert(arr[3] == 30);                                                      \
+    FREE(arr);                                                                 \
+                                                                               \
+    int *grow = (int *)MALLOC(2 * sizeof(int));                                \
+    grow[0] = 1;                                                               \
+    grow[1] = 2;                                                               \
+    grow = (int *)REALLOC(grow, 4 * sizeof(int));                              \
+    grow[2] = 3;                                                               \
+    grow[3] = 4;                                                               \
+    assert(grow[0] == 1);                                                      \
+    assert(grow[1] == 2);                                                      \
+    assert(grow[2] == 3);                                                      \
+    assert(grow[3] == 4);                                                      \
+    FREE(grow);                                                                \
+                                                                               \
+    int *zeros = (int *)CALLOC(4, sizeof(int));                                \
+    for (int i = 0; i < 4; i++) {                                              \
+      assert(zeros[i] == 0);                                                   \
+    }                                                                          \
+    FREE(zeros);                                                               \
+  } while (0)
 
-  int *arr = (int *)malloc(4 * sizeof(int));
-  for (int i = 0; i < 4; i++) {
-    arr[i] = i * 10;
-  }
-  assert(arr[0] == 0);
-  assert(arr[3] == 30);
-  free(arr);
+int main() {
+  ALLOC_TESTS(malloc, free, realloc, calloc);
 
-  int *grow = (int *)malloc(2 * sizeof(int));
-  grow[0] = 1;
-  grow[1] = 2;
-  grow = (int *)realloc(grow, 4 * sizeof(int));
-  grow[2] = 3;
-  grow[3] = 4;
-  assert(grow[0] == 1);
-  assert(grow[1] == 2);
-  assert(grow[2] == 3);
-  assert(grow[3] == 4);
-  free(grow);
+  void *(*pmalloc)(size_t) = malloc;
+  void (*pfree)(void *) = free;
+  void *(*prealloc)(void *, size_t) = realloc;
+  void *(*pcalloc)(size_t, size_t) = calloc;
 
-  int *zeros = (int *)calloc(4, sizeof(int));
-  for (int i = 0; i < 4; i++) {
-    assert(zeros[i] == 0);
-  }
-  free(zeros);
+  ALLOC_TESTS(pmalloc, pfree, prealloc, pcalloc);
 
   return 0;
 }
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
diff --git a/tests/unit/out/unsafe/string_h.rs b/tests/unit/out/unsafe/string_h.rs

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() {`