Malloc implementation using the global allocator (#19)

* add malloc, realloc, calloc and free support

Author: gmmyung

.gitignore

@@ -1,3 +1,4 @@
 /target
 **/*.rs.bk
-Cargo.lock
+Cargo.lock
+/.vscode

Cargo.toml

@@ -10,6 +10,9 @@ repository = "https://github.com/thejpster/tinyrlibc"
 
 [dependencies]
 
+[dev-dependencies]
+static-alloc = "0.2.4"
+
 [build-dependencies]
 cc = "1.0"
 
@@ -38,6 +41,7 @@ all = [
     "isdigit",
     "isalpha",
     "isupper",
+    "alloc",
 ]
 abs = []
 strcmp = []
@@ -61,3 +65,4 @@ isspace = []
 isdigit = []
 isalpha = []
 isupper = []
+alloc = []

README.md

@@ -30,6 +30,11 @@ This crate basically came about so that the [nrfxlib](https://github.com/NordicP
 * strchr
 * snprintf
 * vsnprintf
+* alloc (optional)
+    * malloc
+    * calloc
+    * realloc
+    * free
 
 ## Non-standard helper functions
 

src/ctype.rs

@@ -10,6 +10,9 @@
 /// `void`
 pub type CVoid = ::core::ffi::c_void;
 
+/// `size_t`
+pub type CSizeT = usize;
+
 /// `long long int`
 pub type CLongLong = ::core::ffi::c_longlong;
 

src/lib.rs

@@ -9,12 +9,27 @@
 
 #![cfg_attr(not(test), no_std)]
 #![allow(clippy::missing_safety_doc)]
+#![allow(unused_imports)]
 
-#[cfg(test)]
-#[allow(unused_imports)]
-use std as core;
+#[cfg(feature = "alloc")]
+mod malloc;
+#[cfg(feature = "alloc")]
+pub use self::malloc::{calloc, free, malloc, realloc};
+
+// A new global allocator is required for the tests, but not for the library itself.
+// This is because the default alloc crate uses the system allocator, collides with
+// the one in this crate, and causes a link error.
+#[cfg(all(feature = "alloc", test))]
+use static_alloc::Bump;
+#[cfg(all(feature = "alloc", test))]
+#[global_allocator]
+static ALLOCATOR: Bump<[u8; 1024 * 1024]> = Bump::uninit();
 
 mod itoa;
+#[cfg(feature = "itoa")]
+pub use self::itoa::itoa;
+#[cfg(feature = "utoa")]
+pub use self::itoa::utoa;
 
 mod abs;
 #[cfg(feature = "abs")]

src/malloc.rs

@@ -0,0 +1,145 @@
+//! Rust implementation of C library function `malloc`, `calloc`, `realloc`, and `free`.
+//!
+//! Copyright (c) Gyungmin Myung <[email protected]>
+//! This file is licensed under the Blue Oak Model Licence 1.0.0
+
+extern crate alloc;
+use crate::CSizeT;
+
+// The maximum alignment of any fundamental type. Equivalent to max_align_t
+const MAX_ALIGN: usize = 16;
+
+/// Rust implementation of C library function `malloc`
+///
+/// See [malloc](https://linux.die.net/man/3/malloc) for alignment details.
+#[no_mangle]
+pub unsafe extern "C" fn malloc(size: CSizeT) -> *mut u8 {
+	// size + MAX_ALIGN for to store the size of the allocated memory.
+	let layout = alloc::alloc::Layout::from_size_align(size + MAX_ALIGN, MAX_ALIGN).unwrap();
+	let ptr = unsafe { alloc::alloc::alloc(layout) };
+	if ptr.is_null() {
+		return ptr;
+	}
+	unsafe {
+		*(ptr as *mut CSizeT) = size;
+	}
+	unsafe { ptr.add(MAX_ALIGN) }
+}
+
+/// Rust implementation of C library function `calloc`
+///
+/// See [calloc](https://linux.die.net/man/3/calloc) for alignment details.
+#[no_mangle]
+pub unsafe extern "C" fn calloc(nmemb: CSizeT, size: CSizeT) -> *mut u8 {
+	let total_size = nmemb * size;
+	let layout = alloc::alloc::Layout::from_size_align(total_size + MAX_ALIGN, MAX_ALIGN).unwrap();
+	let ptr = unsafe { alloc::alloc::alloc_zeroed(layout) };
+	if ptr.is_null() {
+		return ptr;
+	}
+	unsafe {
+		*(ptr as *mut CSizeT) = total_size;
+	}
+	unsafe { ptr.add(MAX_ALIGN) }
+}
+
+/// Rust implementation of C library function `realloc`
+///
+/// See [realloc](https://linux.die.net/man/3/realloc) for alignment details.
+#[no_mangle]
+pub unsafe extern "C" fn realloc(ptr: *mut u8, size: CSizeT) -> *mut u8 {
+	if ptr.is_null() {
+		return malloc(size);
+	}
+	let old_size = unsafe { *(ptr.sub(MAX_ALIGN) as *mut CSizeT) };
+	let layout = alloc::alloc::Layout::from_size_align(old_size + MAX_ALIGN, MAX_ALIGN).unwrap();
+	let new_ptr = unsafe { alloc::alloc::realloc(ptr.sub(MAX_ALIGN), layout, size + MAX_ALIGN) };
+	if new_ptr.is_null() {
+		return new_ptr;
+	}
+	unsafe {
+		*(new_ptr as *mut CSizeT) = size;
+	}
+	unsafe { new_ptr.add(MAX_ALIGN) }
+}
+
+/// Rust implementation of C library function `free`
+#[no_mangle]
+pub unsafe extern "C" fn free(ptr: *mut u8) {
+	if ptr.is_null() {
+		return;
+	}
+	let old_size = unsafe { *(ptr.sub(MAX_ALIGN) as *mut CSizeT) };
+	let layout = alloc::alloc::Layout::from_size_align(old_size + MAX_ALIGN, MAX_ALIGN).unwrap();
+	unsafe { alloc::alloc::dealloc(ptr.sub(MAX_ALIGN), layout) };
+}
+
+#[cfg(test)]
+mod test {
+	use super::*;
+
+	#[test]
+	fn test_malloc() {
+		let ptr = unsafe { malloc(10) };
+		assert!(!ptr.is_null());
+		unsafe {
+			assert_eq!(*(ptr.sub(MAX_ALIGN) as *mut CSizeT), 10);
+			(0..10).for_each(|i| {
+				*ptr.add(i) = i as u8;
+			});
+			(0..10).for_each(|i| {
+				assert_eq!(*ptr.add(i), i as u8);
+			});
+		}
+		unsafe { free(ptr) };
+	}
+
+	#[test]
+	fn test_calloc() {
+		let ptr = unsafe { calloc(10, 10) };
+		assert!(!ptr.is_null());
+		unsafe {
+			assert_eq!(*(ptr.sub(MAX_ALIGN) as *mut CSizeT), 100);
+			(0..100).for_each(|i| {
+				assert_eq!(*ptr.add(i), 0);
+			});
+			(0..100).for_each(|i| {
+				*ptr.add(i) = i as u8;
+			});
+			(0..100).for_each(|i| {
+				assert_eq!(*ptr.add(i), i as u8);
+			});
+		}
+		unsafe { free(ptr) };
+	}
+
+	#[test]
+	fn test_realloc() {
+		let ptr = unsafe { malloc(10) };
+		assert!(!ptr.is_null());
+		unsafe {
+			assert_eq!(*(ptr.sub(MAX_ALIGN) as *mut CSizeT), 10);
+			(0..10).for_each(|i| {
+				*ptr.add(i) = i as u8;
+			});
+			(0..10).for_each(|i| {
+				assert_eq!(*ptr.add(i), i as u8);
+			});
+		}
+		let ptr = unsafe { realloc(ptr, 20) };
+		assert!(!ptr.is_null());
+		unsafe {
+			assert_eq!(*(ptr.sub(MAX_ALIGN) as *mut CSizeT), 20);
+			(0..10).for_each(|i| {
+				assert_eq!(*ptr.add(i), i as u8);
+			});
+			(10..20).for_each(|i| {
+				*ptr.add(i) = i as u8;
+			});
+			(10..20).for_each(|i| {
+				assert_eq!(*ptr.add(i), i as u8);
+			});
+		}
+		unsafe { free(ptr) };
+	}
+}