diff --git a/src/header/stdlib/mod.rs b/src/header/stdlib/mod.rs
index 220579ec331a267b0df686796df923fbbaae0759..f5c5ea6090210d0b8e309e36d968b20c5bb58936 100644
--- a/src/header/stdlib/mod.rs
+++ b/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
}
diff --git a/tests/stdlib/alloc.c b/tests/stdlib/alloc.c
index c2353fdefa57908b41879c1a52fc1e633f1dad09..0ed7d1e995e6c72b620955479286ab23cf48a18e 100644
--- a/tests/stdlib/alloc.c
+++ b/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);
}