freestanding: small fixes (#9760)

vlib/builtin/linux_bare/libc_impl.v

@@ -1,72 +1,76 @@
 module builtin
 
 [unsafe]
-pub fn memcpy(dest &byte, src &byte, n int) &byte {
+pub fn memcpy(dest &C.void, src &C.void, n size_t) &C.void {
+	dest_ := unsafe { &byte(dest) }
+	src_ := unsafe { &byte(src) }
 	unsafe {
-		for i in 0 .. n {
-			dest[i] = src[i]
+		for i in 0 .. int(n) {
+			dest_[i] = src_[i]
 		}
-		return dest
 	}
+	return dest
 }
 
 [export: 'malloc']
 [unsafe]
-fn __malloc(n int) &byte {
-	return unsafe { malloc(n) }
+fn __malloc(n size_t) &C.void {
+	return unsafe { malloc(int(n)) }
 }
 
 [unsafe]
-fn strlen(s &byte) int {
+fn strlen(_s &C.void) size_t {
+	s := unsafe { &byte(_s) }
 	mut i := 0
 	for ; unsafe { s[i] } != 0; i++ {}
-	return i
+	return size_t(i)
 }
 
 [unsafe]
-fn realloc(old_area &byte, new_size int) &byte {
+fn realloc(old_area &C.void, new_size size_t) &C.void {
 	if old_area == 0 {
-		return unsafe { malloc(new_size) }
+		return unsafe { malloc(int(new_size)) }
 	}
-	if new_size == 0 {
+	if new_size == size_t(0) {
 		unsafe { free(old_area) }
 		return 0
 	}
 	old_size := unsafe { *(&u64(old_area - sizeof(u64))) }
-	if new_size <= old_size {
+	if u64(new_size) <= old_size {
 		return old_area
 	} else {
-		new_area := unsafe { malloc(new_size) }
-		unsafe { memmove(new_area, old_area, int(old_size)) }
+		new_area := unsafe { malloc(int(new_size)) }
+		unsafe { memmove(new_area, old_area, size_t(old_size)) }
 		unsafe { free(old_area) }
 		return new_area
 	}
 }
 
 [unsafe]
-fn memset(_s &byte, _c int, n int) &byte {
-	c := char(_c)
-	mut s := unsafe { &char(_s) }
+fn memset(s &C.void, c int, n size_t) &C.void {
+	mut s_ := unsafe { &char(s) }
 	for i in 0 .. int(n) {
 		unsafe {
-			s[i] = c
+			s_[i] = char(c)
 		}
 	}
 	return s
 }
 
 [unsafe]
-fn memmove(dest &byte, src &byte, n int) &byte {
-	mut temp_buf := unsafe { malloc(n) }
+fn memmove(dest &C.void, src &C.void, n size_t) &C.void {
+	dest_ := unsafe { &byte(dest) }
+	src_ := unsafe { &byte(src) }
+	mut temp_buf := unsafe { malloc(int(n)) }
 	for i in 0 .. int(n) {
 		unsafe {
-			temp_buf[i] = src[i]
+			temp_buf[i] = src_[i]
 		}
 	}
 
 	for i in 0 .. int(n) {
 		unsafe {
-			dest[i] = temp_buf[i]
+			dest_[i] = temp_buf[i]
 		}
 	}
 	unsafe { free(temp_buf) }
@@ -75,23 +79,25 @@ fn memmove(dest &byte, src &byte, n int) &byte {
 
 [export: 'calloc']
 [unsafe]
-fn __calloc(nmemb int, size int) &byte {
-	new_area := unsafe { malloc(nmemb * size) }
+fn __calloc(nmemb size_t, size size_t) &C.void {
+	new_area := unsafe { malloc(int(nmemb) * int(size)) }
 	unsafe { memset(new_area, 0, nmemb * size) }
 	return new_area
 }
 
 fn getchar() int {
 	x := byte(0)
-	sys_read(C.stdin, &x, 1)
+	sys_read(0, &x, 1)
 	return int(x)
 }
 
-fn memcmp(a &byte, b &byte, n int) int {
+fn memcmp(a &C.void, b &C.void, n size_t) int {
+	a_ := unsafe { &byte(a) }
+	b_ := unsafe { &byte(b) }
 	for i in 0 .. int(n) {
-		if unsafe { a[i] != b[i] } {
+		if unsafe { a_[i] != b_[i] } {
 			unsafe {
-				return a[i] - b[i]
+				return a_[i] - b_[i]
 			}
 		}
 	}
@@ -100,7 +106,7 @@ fn memcmp(a &byte, b &byte, n int) int {
 
 [export: 'free']
 [unsafe]
-fn __free(ptr &byte) {
+fn __free(ptr &C.void) {
 	err := mm_free(ptr)
 	if err != .enoerror {
 		eprintln('free error:')
@@ -112,7 +118,7 @@ fn vsprintf(str &char, format &char, ap &byte) int {
 	panic('vsprintf(): string interpolation is not supported in `-freestanding`')
 }
 
-fn vsnprintf(str &char, size int, format &char, ap &byte) int {
+fn vsnprintf(str &char, size size_t, format &char, ap &byte) int {
 	panic('vsnprintf(): string interpolation is not supported in `-freestanding`')
 }
 
@@ -128,3 +134,17 @@ fn bare_print(buf &byte, len u64) {
 fn bare_eprint(buf &byte, len u64) {
 	sys_write(2, buf, len)
 }
+
+fn bare_panic(msg string) {
+	println('V panic' + msg)
+	exit(1)
+}
+
+fn bare_backtrace() string {
+	return 'backtraces are not available with `-freestanding`'
+}
+
+[export: 'exit']
+fn __exit(code int) {
+	sys_exit(code)
+}