vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

Merge branch 'master' of https://gitlab.redox-os.org/redox-os/relibc

Browse Source
This commit is contained in:
Jeremy Soller
2019-04-27 19:57:35 -06:00
parent 6a16275817 6074616857
commit 5a34907033
9 changed files with 763 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include.sh
+15 -3
View File
@@ -1,5 +1,7 @@
#!/usr/bin/env bash
SUPRESS_ALL_THE_ERRORS=yes
set -e
include="$(realpath "$1")"
@@ -7,6 +9,10 @@ include="$(realpath "$1")"
cargo build --release --manifest-path cbindgen/Cargo.toml
cbindgen="$(realpath target/release/cbindgen)"
if [ "$SUPRESS_ALL_THE_ERRORS" = "yes" ]; then
echo -e "\e[91mNote: Warnings by cbindgen are suppressed in include.sh.\e[0m"
fi
jobs=()
for config in src/header/*/cbindgen.toml
do
@@ -15,10 +21,16 @@ do
if [ "${name:0:1}" != "_" ]
then
header="$include/${name/_//}.h"
pushd "$dir"
"$cbindgen" -c cbindgen.toml -o "$header" mod.rs &
pushd "$dir" > /dev/null
echo "$dir"
cbindgen_cmd='"$cbindgen" -c cbindgen.toml -o "$header" mod.rs'
if [ "$SUPRESS_ALL_THE_ERRORS" = "yes" ]; then
eval "$cbindgen_cmd" 2>&1 | (grep "^ERROR" -A 3 || true) &
else
eval "$cbindgen_cmd" &
fi
jobs+=($!)
popd
popd > /dev/null
fi
done
src/header/stdio/printf.rs
+577 -352
View File
File diff suppressed because it is too large Load Diff
src/header/stdlib/mod.rs
+39 -8
View File
@@ -78,11 +78,15 @@ pub extern "C" fn abs(i: c_int) -> c_int {
#[no_mangle]
pub unsafe extern "C" fn aligned_alloc(alignment: size_t, size: size_t) -> *mut c_void {
if size % alignment != 0 {
return ptr::null_mut();
if size % alignment == 0 {
/* The size-is-multiple-of-alignment requirement is the only
* difference between aligned_alloc() and memalign(). */
memalign(alignment, size)
}
else {
platform::errno = errno::EINVAL;
ptr::null_mut()
}
memalign(alignment, size)
}
#[no_mangle]
@@ -190,13 +194,19 @@ pub unsafe extern "C" fn calloc(nelem: size_t, elsize: size_t) -> *mut c_void {
let size_result = nelem.checked_mul(elsize);
match size_result {
Some(size) => {
/* If allocation fails here, errno setting will be handled
* by malloc() */
let ptr = malloc(size);
if !ptr.is_null() {
intrinsics::write_bytes(ptr as *mut u8, 0, size);
}
ptr
},
None => {
// For overflowing multiplication, we have to set errno here
platform::errno = errno::ENOMEM;
ptr::null_mut()
}
None => core::ptr::null_mut(),
}
}
@@ -403,12 +413,29 @@ pub extern "C" fn lrand48() -> c_long {
#[no_mangle]
pub unsafe extern "C" fn malloc(size: size_t) -> *mut c_void {
platform::alloc(size)
let ptr = platform::alloc(size);
if ptr.is_null() {
platform::errno = errno::ENOMEM;
}
ptr
}
#[no_mangle]
pub unsafe extern "C" fn memalign(alignment: size_t, size: size_t) -> *mut c_void {
platform::alloc_align(size, alignment)
/* 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 {
let ptr = platform::alloc_align(size, alignment);
if ptr.is_null() {
platform::errno = errno::ENOMEM;
}
ptr
}
else {
platform::errno = errno::EINVAL;
ptr::null_mut()
}
}
#[no_mangle]
@@ -613,7 +640,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 {
platform::realloc(ptr, size)
let ptr = platform::realloc(ptr, size);
if ptr.is_null() {
platform::errno = errno::ENOMEM;
}
ptr
}
#[no_mangle]
src/header/string/mod.rs
+4 -2
View File
@@ -235,8 +235,10 @@ pub unsafe extern "C" fn strerror_r(errnum: c_int, buf: *mut c_char, buflen: siz
let len = strlen(msg);
if len >= buflen {
memcpy(buf as *mut c_void, msg as *const c_void, buflen - 1);
*buf.add(buflen - 1) = 0;
if buflen != 0 {
memcpy(buf as *mut c_void, msg as *const c_void, buflen - 1);
*buf.add(buflen - 1) = 0;
}
return ERANGE as c_int;
}
memcpy(buf as *mut c_void, msg as *const c_void, len + 1);
tests/error.c
+4
View File
@@ -19,4 +19,8 @@ int main(void) {
char buf2[3];
int ret2 = strerror_r(err, buf2, 3);
printf("errno: %d = %s, return: %d\n", err, buf2, ret2);
char buf3[256];
int ret3 = strerror_r(err, buf3, 0);
printf("errno: %d = %s, return: %d\n", err, buf3, ret3);
}
tests/expected/error.stdout
+1
View File
@@ -1,3 +1,4 @@
errno: 2 = No such file or directory
errno: 2 = No such file or directory, return: 0
errno: 2 = No, return: 34
errno: 2 = , return: 34
tests/expected/stdio/printf.stdout
+3
View File
@@ -26,6 +26,9 @@ Positional madness:
4 3 2
00002
|Fiz |Buz | Fiz| Tot|
int: 5 double: 0.100000 0.200000 0.300000 0.400000
-1717986918 0.100000
-1717986918 0.200000
Float madness:
1.234568e+02
tests/stdio/printf.c
+4 -2
View File
@@ -1,7 +1,5 @@
#include <stdio.h>
#include "test_helpers.h"
int main(void) {
int sofar = 0;
int len = printf(
@@ -35,6 +33,10 @@ int main(void) {
printf("%3$d %2$d %1$d\n", 2, 3, 4);
printf("%.*3$d\n", 2, 0, 5);
printf("|%-*6$.*5$s|%-*6$.*5$s|%*6$.*5$s|%*6$.*5$s|\n", "Fizz", "Buzz", "FizzBuzz", "TotalBuzz", 3, 8);
printf("int: %*6$d double: %lf %lf %lf %lf\n", 5, 0.1, 0.2, 0.3, 0.4, 10);
printf("%1$d %1$lf\n", 5, 0.1);
printf("%1$d %lf\n", 5, 0.2);
//printf("int: %*6$d no info on middle types\n", 5, 0.1, 0.2, 0.3, 0.4, 10);
puts("\nFloat madness:");
printf("%20e\n", 123.456789123);
tests/stdlib/alloc.c
+116 -21
View File
@@ -1,34 +1,129 @@
#include <malloc.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h> /* for size_t */
#include <stdint.h> /* for SIZE_MAX */
#include "test_helpers.h"
int main(void) {
char * ptr = (char *)malloc(256);
printf("malloc %p\n", ptr);
size_t sample_alloc_size = 256;
size_t sample_realloc_size = sample_alloc_size + 1;
/* ensure values are mapped to variables */
size_t max_size = SIZE_MAX;
size_t aligned_alloc_alignment = 128;
size_t aligned_alloc_goodsize = 256;
size_t aligned_alloc_badsize = 257;
int i;
for(i = 0; i < 256; i++) {
ptr[i] = (char)i;
errno = 0;
char * ptr_malloc = (char *)malloc(sample_alloc_size);
int malloc_errno = errno;
printf("malloc : %p, errno: %d = %s\n",
ptr_malloc, malloc_errno, strerror(malloc_errno));
for(i = 0; i < sample_alloc_size; i++) {
ptr_malloc[i] = (char)i;
}
free(ptr);
char * ptrc = (char *)calloc(256, 1);
printf("calloc %p\n", ptrc);
for(i = 0; i < 256; i++) {
ptrc[i] = (char)i;
free(ptr_malloc);
errno = 0;
char * ptr_malloc_maxsize = (char *)malloc(max_size);
int malloc_maxsize_errno = errno;
printf("malloc (SIZE_MAX) : %p, errno: %d = %s\n",
ptr_malloc_maxsize, malloc_maxsize_errno,
strerror(malloc_maxsize_errno));
free(ptr_malloc_maxsize);
errno = 0;
char * ptr_calloc = (char *)calloc(sample_alloc_size, 1);
int calloc_errno = errno;
printf("calloc : %p, errno: %d = %s\n", ptr_calloc,
calloc_errno, strerror(calloc_errno));
for(i = 0; i < sample_alloc_size; i++) {
ptr_calloc[i] = (char)i;
}
free(ptrc);
char * ptrco = (char *)calloc(SIZE_MAX, SIZE_MAX);
printf("calloc (overflowing) %p\n", ptrco);
free(ptrco); /* clean up correctly even if overflow is not handled */
char * ptra = (char *)memalign(256, 256);
printf("memalign %p\n", ptra);
for(i = 0; i < 256; i++) {
ptra[i] = (char)i;
free(ptr_calloc);
errno = 0;
char * ptr_calloc_overflow = (char *)calloc(max_size, max_size);
int calloc_overflow_errno = errno;
printf("calloc (overflowing) : %p, errno: %d = %s\n",
ptr_calloc_overflow, calloc_overflow_errno,
strerror(calloc_overflow_errno));
free(ptr_calloc_overflow); /* clean up correctly even if overflow is not handled */
char * ptr_realloc = (char *)malloc(sample_alloc_size);
errno = 0;
ptr_realloc = (char *)realloc(ptr_realloc, sample_realloc_size);
int realloc_errno = errno;
printf("realloc : %p, errno: %d = %s\n",
ptr_realloc, realloc_errno, strerror(realloc_errno));
for(i = 0; i < sample_realloc_size; i++) {
ptr_realloc[i] = (char)i;
}
free(ptra);
free(ptr_realloc);
char * ptr_realloc_maxsize = (char *)malloc(sample_alloc_size);
errno = 0;
ptr_realloc_maxsize = (char *)realloc(ptr_realloc_maxsize, max_size);
int realloc_maxsize_errno = errno;
printf("realloc (SIZE_MAX) : %p, errno: %d = %s\n",
ptr_realloc_maxsize, realloc_maxsize_errno,
strerror(realloc_maxsize_errno));
free(ptr_realloc_maxsize);
errno = 0;
char * ptr_memalign = (char *)memalign(256, sample_alloc_size);
int memalign_errno = errno;
printf("memalign : %p, errno: %d = %s\n", ptr_memalign,
memalign_errno, strerror(memalign_errno));
for(i = 0; i < sample_alloc_size; i++) {
ptr_memalign[i] = (char)i;
}
free(ptr_memalign);
errno = 0;
char * ptr_memalign_maxsize = (char *)memalign(256, max_size);
int memalign_maxsize_errno = errno;
printf("memalign (SIZE_MAX) : %p, errno: %d = %s\n",
ptr_memalign_maxsize, memalign_maxsize_errno,
strerror(memalign_maxsize_errno));
free(ptr_memalign_maxsize);
errno = 0;
char * ptr_memalign_align0 = (char *)memalign(0, sample_alloc_size);
int memalign_align0_errno = errno;
printf("memalign (alignment 0): %p, errno: %d = %s\n",
ptr_memalign_align0, memalign_align0_errno,
strerror(memalign_align0_errno));
free(ptr_memalign_align0);
errno = 0;
char * ptr_memalign_align3 = (char *)memalign(3, sample_alloc_size);
int memalign_align3_errno = errno;
printf("memalign (alignment 3): %p, errno: %d = %s\n",
ptr_memalign_align3, memalign_align3_errno,
strerror(memalign_align3_errno));
free(ptr_memalign_align3);
errno = 0;
char * ptr_aligned_alloc_goodsize = (char *)aligned_alloc(aligned_alloc_alignment, aligned_alloc_goodsize);
int aligned_alloc_goodsize_errno = errno;
printf("aligned_alloc (size %% alignment == 0):\n");
printf(" %p, errno: %d = %s\n",
ptr_aligned_alloc_goodsize, aligned_alloc_goodsize_errno,
strerror(aligned_alloc_goodsize_errno));
free(ptr_aligned_alloc_goodsize);
errno = 0;
char * ptr_aligned_alloc_badsize = (char *)aligned_alloc(aligned_alloc_alignment, aligned_alloc_badsize);
int aligned_alloc_badsize_errno = errno;
printf("aligned_alloc (size %% alignment != 0):\n");
printf(" %p, errno: %d = %s\n",
ptr_aligned_alloc_badsize, aligned_alloc_badsize_errno,
strerror(aligned_alloc_badsize_errno));
free(ptr_aligned_alloc_badsize);
}