Alloc functions cleanup

src/header/stdlib/mod.rs

@@ -92,7 +92,7 @@ pub unsafe extern "C" fn aligned_alloc(alignment: size_t, size: size_t) -> *mut
          * difference between aligned_alloc() and memalign(). */
         memalign(alignment, size)
     } else {
-        platform::errno = errno::EINVAL;
+        platform::errno = EINVAL;
         ptr::null_mut()
     }
 }
@@ -199,8 +199,7 @@ pub unsafe extern "C" fn bsearch(
 #[no_mangle]
 pub unsafe extern "C" fn calloc(nelem: size_t, elsize: size_t) -> *mut c_void {
     //Handle possible integer overflow in size calculation
-    let size_result = nelem.checked_mul(elsize);
-    match size_result {
+    match nelem.checked_mul(elsize) {
         Some(size) => {
             /* If allocation fails here, errno setting will be handled
              * by malloc() */
@@ -212,7 +211,7 @@ pub unsafe extern "C" fn calloc(nelem: size_t, elsize: size_t) -> *mut c_void {
         }
         None => {
             // For overflowing multiplication, we have to set errno here
-            platform::errno = errno::ENOMEM;
+            platform::errno = ENOMEM;
             ptr::null_mut()
         }
     }
@@ -463,24 +462,21 @@ pub unsafe extern "C" fn lrand48() -> c_long {
 pub unsafe extern "C" fn malloc(size: size_t) -> *mut c_void {
     let ptr = platform::alloc(size);
     if ptr.is_null() {
-        platform::errno = errno::ENOMEM;
+        platform::errno = ENOMEM;
     }
     ptr
 }
 
 #[no_mangle]
 pub unsafe extern "C" fn memalign(alignment: size_t, size: size_t) -> *mut c_void {
-    /* Check if alignment is a (positive) power of two. The second
-     * expression will never underflow, due to Rust's lazy boolean
-     * operators. */
-    if alignment > 0 && (alignment & (alignment - 1)) == 0 {
+    if alignment.is_power_of_two() {
         let ptr = platform::alloc_align(size, alignment);
         if ptr.is_null() {
-            platform::errno = errno::ENOMEM;
+            platform::errno = ENOMEM;
         }
         ptr
     } else {
-        platform::errno = errno::EINVAL;
+        platform::errno = EINVAL;
         ptr::null_mut()
     }
 }
@@ -726,11 +722,11 @@ pub extern "C" fn random() -> c_long {
 
 #[no_mangle]
 pub unsafe extern "C" fn realloc(ptr: *mut c_void, size: size_t) -> *mut c_void {
-    let ptr = platform::realloc(ptr, size);
-    if ptr.is_null() {
-        platform::errno = errno::ENOMEM;
+    let new_ptr = platform::realloc(ptr, size);
+    if new_ptr.is_null() {
+        platform::errno = ENOMEM;
     }
-    ptr
+    new_ptr
 }
 
 #[no_mangle]
@@ -1101,7 +1097,7 @@ pub unsafe extern "C" fn valloc(size: size_t) -> *mut c_void {
              * EINVAL, hence no call to memalign(). */
             let ptr = platform::alloc_align(size, page_size);
             if ptr.is_null() {
-                platform::errno = errno::ENOMEM;
+                platform::errno = ENOMEM;
             }
             ptr
         }

tests/stdlib/alloc.c

@@ -12,7 +12,7 @@ int main(void) {
     size_t sample_realloc_size = sample_alloc_size + 1;
     
     /* ensure values are mapped to variables */
-    size_t zero = 0;
+    size_t zero_size = 0;
     size_t max_size = SIZE_MAX;
     size_t aligned_alloc_alignment = 128;
     size_t aligned_alloc_goodsize = 256;
@@ -22,6 +22,14 @@ int main(void) {
     
     int i;
     
+    errno = 0;
+    char * ptr_zerosize_malloc = (char *)malloc(zero_size);
+    int malloc_zerosize_errno = errno;
+    printf("malloc (size 0)       : %p, errno: %d = %s\n",
+        ptr_zerosize_malloc, malloc_zerosize_errno,
+        strerror(malloc_zerosize_errno));
+    free(ptr_zerosize_malloc);
+    
     errno = 0;
     char * ptr_malloc = (char *)malloc(sample_alloc_size);
     int malloc_errno = errno;
@@ -40,6 +48,14 @@ int main(void) {
         strerror(malloc_maxsize_errno));
     free(ptr_malloc_maxsize);
     
+    errno = 0;
+    char * ptr_zerosize_calloc = (char *)calloc(zero_size, 1);
+    int calloc_zerosize_errno = errno;
+    printf("calloc (size 0)       : %p, errno: %d = %s\n",
+        ptr_zerosize_calloc,
+        calloc_zerosize_errno, strerror(calloc_zerosize_errno));
+    free(ptr_zerosize_calloc);
+    
     errno = 0;
     char * ptr_calloc = (char *)calloc(sample_alloc_size, 1);
     int calloc_errno = errno;
@@ -58,6 +74,15 @@ int main(void) {
         strerror(calloc_overflow_errno));
     free(ptr_calloc_overflow); /* clean up correctly even if overflow is not handled */
     
+    char * ptr_realloc_size0 = (char *)malloc(sample_alloc_size);
+    errno = 0;
+    ptr_realloc_size0 = (char *)realloc(ptr_realloc_size0, zero_size);
+    int realloc_size0_errno = errno;
+    printf("realloc (size 0)      : %p, errno: %d = %s\n",
+        ptr_realloc_size0, realloc_size0_errno,
+        strerror(realloc_size0_errno));
+    free(ptr_realloc_size0);
+    
     char * ptr_realloc = (char *)malloc(sample_alloc_size);
     errno = 0;
     ptr_realloc = (char *)realloc(ptr_realloc, sample_realloc_size);
@@ -78,6 +103,14 @@ int main(void) {
         strerror(realloc_maxsize_errno));
     free(ptr_realloc_maxsize);
     
+    errno = 0;
+    char * ptr_memalign_size0 = (char *)memalign(256, zero_size);
+    int memalign_size0_errno = errno;
+    printf("memalign (size 0)     : %p, errno: %d = %s\n",
+        ptr_memalign_size0, memalign_size0_errno,
+        strerror(memalign_size0_errno));
+    free(ptr_memalign_size0);
+    
     errno = 0;
     char * ptr_memalign = (char *)memalign(256, sample_alloc_size);
     int memalign_errno = errno;
@@ -130,11 +163,20 @@ int main(void) {
         strerror(aligned_alloc_badsize_errno));
     free(ptr_aligned_alloc_badsize);
     
+    errno = 0;
+    char * ptr_valloc_size0 = (char *)valloc(zero_size);
+    int valloc_size0_errno = errno;
+    printf("valloc (size 0)       : %p, errno: %d = %s\n",
+        ptr_valloc_size0, valloc_size0_errno,
+        strerror(valloc_size0_errno));
+    free(ptr_valloc_size0);
+    
     errno = 0;
     char * ptr_valloc = (char *)valloc(sample_alloc_size);
     int valloc_errno = errno;
     printf("valloc                : %p, errno: %d = %s\n",
         ptr_valloc, valloc_errno, strerror(valloc_errno));
+    free(ptr_valloc);
     
     errno = 0;
     char * ptr_valloc_maxsize = (char *)valloc(max_size);
@@ -142,6 +184,7 @@ int main(void) {
     printf("valloc (SIZE_MAX)     : %p, errno: %d = %s\n",
         ptr_valloc_maxsize, valloc_maxsize_errno,
         strerror(valloc_maxsize_errno));
+    free(ptr_valloc_maxsize);
     
     errno = 0;
     void * ptr_posix_memalign = NULL;
@@ -156,20 +199,21 @@ int main(void) {
     printf("                        errno: %d = %s\n",
         posix_memalign_errno,
         strerror(posix_memalign_errno));
+    free(ptr_posix_memalign);
     
     errno = 0;
     void * ptr_posix_memalign_align0 = NULL;
-    int posix_memalign_align0_return = posix_memalign(&ptr_posix_memalign_align0, zero, sample_alloc_size);
+    int posix_memalign_align0_return = posix_memalign(&ptr_posix_memalign_align0, zero_size, sample_alloc_size);
     int posix_memalign_align0_errno = errno;
     printf("posix_memalign (alignment 0):\n");
     printf("                        %p, return value: %d = %s,\n",
         ptr_posix_memalign_align0,
         posix_memalign_align0_return,
         strerror(posix_memalign_align0_return));
-    
     printf("                        errno: %d = %s\n",
         posix_memalign_align0_errno,
         strerror(posix_memalign_align0_errno));
+    free(ptr_posix_memalign_align0);
     
     errno = 0;
     void * ptr_posix_memalign_nonpow2mul = NULL;
@@ -180,24 +224,24 @@ int main(void) {
         ptr_posix_memalign_nonpow2mul,
         posix_memalign_nonpow2mul_return,
         strerror(posix_memalign_nonpow2mul_return));
-    
     printf("                        errno: %d = %s\n",
         posix_memalign_nonpow2mul_errno,
         strerror(posix_memalign_nonpow2mul_errno));
+    free(ptr_posix_memalign_nonpow2mul);
     
     errno = 0;
     void * ptr_posix_memalign_size0 = NULL;
-    int posix_memalign_size0_return = posix_memalign(&ptr_posix_memalign_size0, pow2_mul_voidptr_size, zero);
+    int posix_memalign_size0_return = posix_memalign(&ptr_posix_memalign_size0, pow2_mul_voidptr_size, zero_size);
     int posix_memalign_size0_errno = errno;
     printf("posix_memalign (size 0):\n");
     printf("                        %p, return value: %d = %s,\n",
         ptr_posix_memalign_size0,
         posix_memalign_size0_return,
         strerror(posix_memalign_size0_return));
-    
     printf("                        errno: %d = %s\n",
         posix_memalign_size0_errno,
         strerror(posix_memalign_size0_errno));
+    free(ptr_posix_memalign_size0);
     
     errno = 0;
     void * ptr_posix_memalign_maxsize = NULL;
@@ -208,8 +252,8 @@ int main(void) {
         ptr_posix_memalign_maxsize,
         posix_memalign_maxsize_return,
         strerror(posix_memalign_maxsize_return));
-    
     printf("                        errno: %d = %s\n",
         posix_memalign_maxsize_errno,
         strerror(posix_memalign_maxsize_errno));
+    free(ptr_posix_memalign_maxsize);
 }