fcntl/build.rs

-extern crate cbindgen;
-
-use std::{env, fs};
-
-fn main() {
-    let crate_dir = env::var("CARGO_MANIFEST_DIR").expect("CARGO_MANIFEST_DIR not set");
-    fs::create_dir_all("../target/include").expect("failed to create include directory");
-    cbindgen::generate(crate_dir)
-      .expect("failed to generate bindings")
-      .write_to_file("../target/include/fcntl.h");
-}

fcntl/src/lib.rs

-//! fcntl implementation for Redox, following http://pubs.opengroup.org/onlinepubs/7908799/xsh/fcntl.h.html
-
-#![no_std]
-
-extern crate platform;
-
-use platform::types::*;
-
-pub use sys::*;
-
-#[cfg(target_os = "linux")]
-#[path="linux.rs"]
-pub mod sys;
-
-#[cfg(target_os = "redox")]
-#[path="redox.rs"]
-pub mod sys;
-
-pub const F_DUPFD: c_int = 0;
-pub const F_GETFD: c_int = 1;
-pub const F_SETFD: c_int = 2;
-pub const F_GETFL: c_int = 3;
-pub const F_SETFL: c_int = 4;
-pub const F_GETLK: c_int = 5;
-pub const F_SETLK: c_int = 6;
-pub const F_SETLKW: c_int = 7;
-
-pub const FD_CLOEXEC: c_int = 0x0100_0000;
-
-pub const F_RDLCK: c_int = 0;
-pub const F_WRLCK: c_int = 1;
-pub const F_UNLCK: c_int = 2;
-
-#[no_mangle]
-pub extern "C" fn creat(path: *const c_char, mode: mode_t) -> c_int {
-    open(path, O_WRONLY | O_CREAT | O_TRUNC, mode)
-}
-
-#[no_mangle]
-pub extern "C" fn fcntl(fildes: c_int, cmd: c_int, arg: c_int) -> c_int {
-    unimplemented!();
-}
-
-#[no_mangle]
-pub extern "C" fn open(path: *const c_char, oflag: c_int, mode: mode_t) -> c_int {
-    platform::open(path, oflag, mode)
-}
-
-/*
-#[no_mangle]
-pub extern "C" fn func(args) -> c_int {
-    unimplemented!();
-}
-*/

fcntl/src/linux.rs

-use platform::types::*;
-
-pub const O_RDONLY: c_int =     0x0000;
-pub const O_WRONLY: c_int =     0x0001;
-pub const O_RDWR: c_int =       0x0002;
-pub const O_CREAT: c_int =      0x0040;
-pub const O_TRUNC: c_int =      0x0200;
-pub const O_ACCMODE: c_int = O_RDONLY | O_WRONLY | O_RDWR;

fcntl/src/redox.rs

-use platform::types::*;
-
-pub const O_RDONLY: c_int =     0x0001_0000;
-pub const O_WRONLY: c_int =     0x0002_0000;
-pub const O_RDWR: c_int =       0x0003_0000;
-pub const O_NONBLOCK: c_int =   0x0004_0000;
-pub const O_APPEND: c_int =     0x0008_0000;
-pub const O_SHLOCK: c_int =     0x0010_0000;
-pub const O_EXLOCK: c_int =     0x0020_0000;
-pub const O_ASYNC: c_int =      0x0040_0000;
-pub const O_FSYNC: c_int =      0x0080_0000;
-pub const O_CLOEXEC: c_int =    0x0100_0000;
-pub const O_CREAT: c_int =      0x0200_0000;
-pub const O_TRUNC: c_int =      0x0400_0000;
-pub const O_EXCL: c_int =       0x0800_0000;
-pub const O_DIRECTORY: c_int =  0x1000_0000;
-pub const O_STAT: c_int =       0x2000_0000;
-pub const O_SYMLINK: c_int =    0x4000_0000;
-pub const O_NOFOLLOW: c_int =   0x8000_0000;
-pub const O_ACCMODE: c_int = O_RDONLY | O_WRONLY | O_RDWR;

fmt.sh

+#!/usr/bin/env bash
+
+cargo fmt --package relibc --package crt0 --package redox-rt "$@"

generic-rt/Cargo.toml

+[package]
+name = "generic-rt"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

generic-rt/src/lib.rs

+#![no_std]
+#![feature(core_intrinsics)]
+
+use core::{
+    arch::asm,
+    mem::{self, offset_of},
+};
+
+#[derive(Debug)]
+#[repr(C)]
+pub struct GenericTcb<Os> {
+    /// Pointer to the end of static TLS. Must be the first member
+    pub tls_end: *mut u8,
+    /// Size of the memory allocated for the static TLS in bytes (multiple of page size)
+    pub tls_len: usize,
+    /// Pointer to this structure
+    pub tcb_ptr: *mut Self,
+    /// Size of the memory allocated for this structure in bytes (should be same as page size)
+    pub tcb_len: usize,
+    pub os_specific: Os,
+}
+impl<Os> GenericTcb<Os> {
+    /// Architecture specific code to read a usize from the TCB - aarch64
+    #[inline(always)]
+    #[cfg(target_arch = "aarch64")]
+    pub unsafe fn arch_read(offset: usize) -> usize {
+        let abi_ptr: usize;
+        asm!(
+            "mrs {}, tpidr_el0",
+            out(reg) abi_ptr,
+        );
+
+        let tcb_ptr = *(abi_ptr as *const usize);
+        *((tcb_ptr + offset) as *const usize)
+    }
+
+    /// Architecture specific code to read a usize from the TCB - x86
+    #[inline(always)]
+    #[cfg(target_arch = "x86")]
+    pub unsafe fn arch_read(offset: usize) -> usize {
+        let value;
+        asm!(
+            "
+            mov {}, gs:[{}]
+            ",
+            out(reg) value,
+            in(reg) offset,
+        );
+        value
+    }
+
+    /// Architecture specific code to read a usize from the TCB - x86_64
+    #[inline(always)]
+    #[cfg(target_arch = "x86_64")]
+    pub unsafe fn arch_read(offset: usize) -> usize {
+        let value;
+        asm!(
+            "
+            mov {}, fs:[{}]
+            ",
+            out(reg) value,
+            in(reg) offset,
+        );
+        value
+    }
+
+    /// Architecture specific code to read a usize from the TCB - riscv64
+    #[inline(always)]
+    #[cfg(target_arch = "riscv64")]
+    unsafe fn arch_read(offset: usize) -> usize {
+        let value;
+        asm!(
+            "ld {value}, -8(tp)", // TCB
+            "add {value}, {value}, {offset}",
+            "ld {value}, 0({value})",
+            value = out(reg) value,
+            offset = in(reg) offset,
+        );
+        value
+    }
+
+    pub unsafe fn current_ptr() -> Option<*mut Self> {
+        let tcb_ptr = Self::arch_read(offset_of!(Self, tcb_ptr)) as *mut Self;
+        let tcb_len = Self::arch_read(offset_of!(Self, tcb_len));
+        if tcb_ptr.is_null() || tcb_len < mem::size_of::<Self>() {
+            None
+        } else {
+            Some(tcb_ptr)
+        }
+    }
+    pub unsafe fn current() -> Option<&'static mut Self> {
+        Some(&mut *Self::current_ptr()?)
+    }
+}
+pub fn panic_notls(msg: impl core::fmt::Display) -> ! {
+    //eprintln!("panicked in ld.so: {}", msg);
+
+    core::intrinsics::abort();
+}
+
+pub trait ExpectTlsFree {
+    type Unwrapped;
+
+    fn expect_notls(self, msg: &str) -> Self::Unwrapped;
+}
+impl<T, E: core::fmt::Debug> ExpectTlsFree for Result<T, E> {
+    type Unwrapped = T;
+
+    fn expect_notls(self, msg: &str) -> T {
+        match self {
+            Ok(t) => t,
+            Err(err) => panic_notls(format_args!(
+                "{}: expect failed for Result with err: {:?}",
+                msg, err
+            )),
+        }
+    }
+}
+impl<T> ExpectTlsFree for Option<T> {
+    type Unwrapped = T;
+
+    fn expect_notls(self, msg: &str) -> T {
+        match self {
+            Some(t) => t,
+            None => panic_notls(format_args!("{}: expect failed for Option", msg)),
+        }
+    }
+}

grp/lib.rs

-/* automatically generated by rust-bindgen */
-#[repr(C)]
-#[derive(Debug, Copy)]
-pub struct group {
-    pub gr_name: *mut libc::c_char,
-    pub gr_passwd: *mut libc::c_char,
-    pub gr_gid: gid_t,
-    pub gr_mem: *mut *mut libc::c_char,
-}
-impl Clone for group {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[no_mangle]
-pub extern "C" fn getgrgid(gid: gid_t) -> *mut group {
-    unimplemented!();
-}
-
-#[no_mangle]
-pub extern "C" fn getgrnam(name: *const libc::c_char) -> *mut group {
-    unimplemented!();
-}
-
-#[no_mangle]
-pub extern "C" fn getgrgid_r(
-    gid: gid_t,
-    grp: *mut group,
-    buffer: *mut libc::c_char,
-    bufsize: usize,
-    result: *mut *mut group,
-) -> libc::c_int {
-    unimplemented!();
-}
-
-#[no_mangle]
-pub extern "C" fn getgrnam_r(
-    name: *const libc::c_char,
-    grp: *mut group,
-    buffer: *mut libc::c_char,
-    bufsize: usize,
-    result: *mut *mut group,
-) -> libc::c_int {
-    unimplemented!();
-}
-
-#[no_mangle]
-pub extern "C" fn getgrent() -> *mut group {
-    unimplemented!();
-}
-
-#[no_mangle]
-pub extern "C" fn endgrent() {
-    unimplemented!();
-}
-
-#[no_mangle]
-pub extern "C" fn setgrent() {
-    unimplemented!();
-}

include/alloca.h

+#ifndef _ALLOCA_H
+#define _ALLOCA_H
+
+#define alloca(size) __builtin_alloca (size)
+
+#endif /* _ALLOCA_H */

include/bits/assert.h

+// Do not use include guard, to ensure assert is always defined
+#ifdef assert
+#undef assert
+#endif
+
+#ifdef NDEBUG
+# define assert(cond) (void) 0
+#else
+# define assert(cond) \
+  ((void)((cond) || (__assert_fail(__func__, __FILE__, __LINE__, #cond), 0)))
+#endif

include/bits/ctype.h

+#ifndef _BITS_CTYPE_H
+#define _BITS_CTYPE_H
+
+#define _tolower(c) tolower(c)
+#define _toupper(c) toupper(c)
+
+#endif /* _BITS_CTYPE_H */

include/bits/dirent.h

+#ifndef _BITS_DIRENT_H
+#define _BITS_DIRENT_H
+
+// Shamelessly stolen from musl
+#define DT_UNKNOWN 0
+#define DT_FIFO 1
+#define DT_CHR 2
+#define DT_DIR 4
+#define DT_BLK 6
+#define DT_REG 8
+#define DT_LNK 10
+#define DT_SOCK 12
+#define DT_WHT 14
+#define IFTODT(x) ((x)>>12 & 017)
+#define DTTOIF(x) ((x)<<12)
+
+#endif /* _BITS_DIRENT_H */

include/bits/elf.h

+#ifndef _BITS_ELF_H                                                          
+#define _BITS_ELF_H
+#define ELF32_ST_BIND(val)		(((unsigned char) (val)) >> 4)
+#define ELF32_ST_TYPE(val)		((val) & 0xf)
+#define ELF32_ST_INFO(bind, type)	(((bind) << 4) + ((type) & 0xf))
+
+#define ELF64_ST_BIND(val)		ELF32_ST_BIND (val)
+#define ELF64_ST_TYPE(val)		ELF32_ST_TYPE (val)
+#define ELF64_ST_INFO(bind, type)	ELF32_ST_INFO ((bind), (type))
+
+
+#define ELF32_ST_VISIBILITY(o)	((o) & 0x03)
+#define ELF64_ST_VISIBILITY(o)	ELF32_ST_VISIBILITY (o)
+
+#define ELF32_R_SYM(val)		((val) >> 8)
+#define ELF32_R_TYPE(val)		((val) & 0xff)
+#define ELF32_R_INFO(sym, type)		(((sym) << 8) + ((type) & 0xff))
+
+#define ELF64_R_SYM(i)			((i) >> 32)
+#define ELF64_R_TYPE(i)			((i) & 0xffffffff)
+#define ELF64_R_INFO(sym,type)		((((Elf64_Xword) (sym)) << 32) + (type))
+
+#define DT_VALRNGHI	0x6ffffdff
+#define DT_VALTAGIDX(tag)	(DT_VALRNGHI - (tag))
+
+#define DT_ADDRRNGHI	0x6ffffeff
+#define DT_ADDRTAGIDX(tag)	(DT_ADDRRNGHI - (tag))
+
+#define	DT_VERNEEDNUM	0x6fffffff
+#define DT_VERSIONTAGIDX(tag)	(DT_VERNEEDNUM - (tag))
+
+#define ELF32_M_SYM(info)	((info) >> 8)
+#define ELF32_M_SIZE(info)	((unsigned char) (info))
+#define ELF32_M_INFO(sym, size)	(((sym) << 8) + (unsigned char) (size))
+
+#define ELF64_M_SYM(info)	ELF32_M_SYM (info)
+#define ELF64_M_SIZE(info)	ELF32_M_SIZE (info)
+#define ELF64_M_INFO(sym, size)	ELF32_M_INFO (sym, size)
+
+#endif /* ifdef _BITS_ELF_H*/

include/bits/errno.h

+#ifndef _BITS_ERRNO_H
+#define _BITS_ERRNO_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define errno (*__errno_location())
+#define program_invocation_name (*__program_invocation_name())
+#define program_invocation_short_name (*__program_invocation_short_name())
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* _BITS_ERRNO_H */

include/bits/fcntl.h

+#ifndef _BITS_FCNTL_H
+#define _BITS_FCNTL_H
+
+#endif

include/bits/float.h

+#ifndef _BITS_FLOAT_H
+#define _BITS_FLOAT_H
+
+#define FLT_ROUNDS (flt_rounds())
+
+// Shamelessly copy pasted from musl:
+
+#define FLT_TRUE_MIN 1.40129846432481707092e-45F
+#define FLT_MIN 1.17549435082228750797e-38F
+#define FLT_MAX 3.40282346638528859812e+38F
+#define FLT_EPSILON 1.1920928955078125e-07F
+
+#define FLT_MANT_DIG 24
+#define FLT_MIN_EXP (-125)
+#define FLT_MAX_EXP 128
+#define FLT_HAS_SUBNORM 1
+
+#define FLT_DIG 6
+#define FLT_DECIMAL_DIG 9
+#define FLT_MIN_10_EXP (-37)
+#define FLT_MAX_10_EXP 38
+
+#define DBL_TRUE_MIN 4.94065645841246544177e-324
+#define DBL_MIN 2.22507385850720138309e-308
+#define DBL_MAX 1.79769313486231570815e+308
+#define DBL_EPSILON 2.22044604925031308085e-16
+
+#define DBL_MANT_DIG 53
+#define DBL_MIN_EXP (-1021)
+#define DBL_MAX_EXP 1024
+#define DBL_HAS_SUBNORM 1
+
+#define DBL_DIG 15
+#define DBL_DECIMAL_DIG 17
+#define DBL_MIN_10_EXP (-307)
+#define DBL_MAX_10_EXP 308
+
+#define LDBL_HAS_SUBNORM 1
+#define LDBL_DECIMAL_DIG DECIMAL_DIG
+
+// TODO: Support more architectures than x86_64 here:
+#define LDBL_TRUE_MIN 3.6451995318824746025e-4951L
+#define LDBL_MIN     3.3621031431120935063e-4932L
+#define LDBL_MAX     1.1897314953572317650e+4932L
+#define LDBL_EPSILON 1.0842021724855044340e-19L
+
+#define LDBL_MANT_DIG 64
+#define LDBL_MIN_EXP (-16381)
+#define LDBL_MAX_EXP 16384
+
+#endif

include/bits/inttypes.h

+#ifndef _BITS_INTTYPE_H
+#define _BITS_INTTYPE_H
+
+#define PRId8  "hhd"
+#define PRId16 "hd"
+#define PRId32 "d"
+#define PRId64 "ld"
+
+#define PRIdLEAST8  "hhd"
+#define PRIdLEAST16 "hd"
+#define PRIdLEAST32 "d"
+#define PRIdLEAST64 "ld"
+
+#define PRIdFAST8  "hhd"
+#define PRIdFAST16 "hd"
+#define PRIdFAST32 "d"
+#define PRIdFAST64 "ld"
+
+#define PRIi8  "hhi"
+#define PRIi16 "hi"
+#define PRIi32 "i"
+#define PRIi64 "li"
+
+#define PRIiLEAST8  "hhi"
+#define PRIiLEAST16 "hi"
+#define PRIiLEAST32 "i"
+#define PRIiLEAST64 "li"
+
+#define PRIiFAST8  "hhi"
+#define PRIiFAST16 "hi"
+#define PRIiFAST32 "i"
+#define PRIiFAST64 "li"
+
+#define PRIo8  "hho"
+#define PRIo16 "ho"
+#define PRIo32 "o"
+#define PRIo64 "lo"
+
+#define PRIoLEAST8  "hho"
+#define PRIoLEAST16 "ho"
+#define PRIoLEAST32 "o"
+#define PRIoLEAST64 "lo"
+
+#define PRIoFAST8  "hho"
+#define PRIoFAST16 "ho"
+#define PRIoFAST32 "o"
+#define PRIoFAST64 "lo"
+
+#define PRIu8  "hhu"
+#define PRIu16 "hu"
+#define PRIu32 "u"
+#define PRIu64 "lu"
+
+#define PRIuLEAST8  "hhu"
+#define PRIuLEAST16 "hu"
+#define PRIuLEAST32 "u"
+#define PRIuLEAST64 "lu"
+
+#define PRIuFAST8  "hhu"
+#define PRIuFAST16 "hu"
+#define PRIuFAST32 "u"
+#define PRIuFAST64 "lu"
+
+#define PRIx8  "hhx"
+#define PRIx16 "hx"
+#define PRIx32 "x"
+#define PRIx64 "lx"
+
+#define PRIxLEAST8  "hhx"
+#define PRIxLEAST16 "hx"
+#define PRIxLEAST32 "x"
+#define PRIxLEAST64 "lx"
+
+#define PRIxFAST8  "hhx"
+#define PRIxFAST16 "hx"
+#define PRIxFAST32 "x"
+#define PRIxFAST64 "lx"
+
+#define PRIX8  "hhX"
+#define PRIX16 "hX"
+#define PRIX32 "X"
+#define PRIX64 "lX"
+
+#define PRIXLEAST8  "hhX"
+#define PRIXLEAST16 "hX"
+#define PRIXLEAST32 "X"
+#define PRIXLEAST64 "lX"
+
+#define PRIXFAST8  "hhX"
+#define PRIXFAST16 "hX"
+#define PRIXFAST32 "X"
+#define PRIXFAST64 "lX"
+
+#define PRIdMAX "jd"
+#define PRIiMAX "ji"
+#define PRIoMAX "jo"
+#define PRIuMAX "ju"
+#define PRIxMAX "jx"
+#define PRIXMAX "jX"
+
+#define PRIdPTR "td"
+#define PRIiPTR "ti"
+#define PRIoPTR "to"
+#define PRIuPTR "tu"
+#define PRIxPTR "tx"
+#define PRIXPTR "tX"
+
+#define SCNd8  PRId8
+#define SCNd16 PRId16
+#define SCNd32 PRId32
+#define SCNd64 PRId64
+
+#define SCNdLEAST8  PRIdLEAST8
+#define SCNdLEAST16 PRIdLEAST16
+#define SCNdLEAST32 PRIdLEAST32
+#define SCNdLEAST64 PRIdLEAST64
+
+#define SCNdFAST8  PRIdFAST8
+#define SCNdFAST16 PRIdFAST16
+#define SCNdFAST32 PRIdFAST32
+#define SCNdFAST64 PRIdFAST64
+
+#define SCNi8  PRIi8
+#define SCNi16 PRIi16
+#define SCNi32 PRIi32
+#define SCNi64 PRIi64
+
+#define SCNiLEAST8  PRIiLEAST8
+#define SCNiLEAST16 PRIiLEAST16
+#define SCNiLEAST32 PRIiLEAST32
+#define SCNiLEAST64 PRIiLEAST64
+
+#define SCNiFAST8  PRIiFAST8
+#define SCNiFAST16 PRIiFAST16
+#define SCNiFAST32 PRIiFAST32
+#define SCNiFAST64 PRIiFAST64
+
+#define SCNo8  PRIo8
+#define SCNo16 PRIo16
+#define SCNo32 PRIo32
+#define SCNo64 PRIo64
+
+#define SCNoLEAST8  PRIoLEAST8
+#define SCNoLEAST16 PRIoLEAST16
+#define SCNoLEAST32 PRIoLEAST32
+#define SCNoLEAST64 PRIoLEAST64
+
+#define SCNoFAST8  PRIoFAST8
+#define SCNoFAST16 PRIoFAST16
+#define SCNoFAST32 PRIoFAST32
+#define SCNoFAST64 PRIoFAST64
+
+#define SCNu8  PRIu8
+#define SCNu16 PRIu16
+#define SCNu32 PRIu32
+#define SCNu64 PRIu64
+
+#define SCNuLEAST8  PRIuLEAST8
+#define SCNuLEAST16 PRIuLEAST16
+#define SCNuLEAST32 PRIuLEAST32
+#define SCNuLEAST64 PRIuLEAST64
+
+#define SCNuFAST8  PRIuFAST8
+#define SCNuFAST16 PRIuFAST16
+#define SCNuFAST32 PRIuFAST32
+#define SCNuFAST64 PRIuFAST64
+
+#define SCNx8  PRIx8
+#define SCNx16 PRIx16
+#define SCNx32 PRIx32
+#define SCNx64 PRIx64
+
+#define SCNxLEAST8  PRIxLEAST8
+#define SCNxLEAST16 PRIxLEAST16
+#define SCNxLEAST32 PRIxLEAST32
+#define SCNxLEAST64 PRIxLEAST64
+
+#define SCNxFAST8  PRIxFAST8
+#define SCNxFAST16 PRIxFAST16
+#define SCNxFAST32 PRIxFAST32
+#define SCNxFAST64 PRIxFAST64
+
+#define SCNdMAX PRIdMAX
+#define SCNiMAX PRIiMAX
+#define SCNoMAX PRIoMAX
+#define SCNuMAX PRIuMAX
+#define SCNxMAX PRIxMAX
+
+#define SCNdPTR PRIdPTR
+#define SCNiPTR PRIiPTR
+#define SCNoPTR PRIoPTR
+#define SCNuPTR PRIuPTR
+#define SCNxPTR PRIxPTR
+
+#endif

include/bits/limits.h

+#ifndef _BITS_LIMIT_H
+#define _BITS_LIMIT_H
+
+#define CHAR_BIT __CHAR_BIT__
+#ifdef __CHAR_MAX__
+# define CHAR_MAX __CHAR_MAX__
+#else
+# define CHAR_MAX 0xFF
+#endif
+#define CHAR_MIN 0
+#define INT_MAX __INT_MAX__
+#define INT_MIN (-INT_MAX - 1)
+#define LLONG_MAX __LONG_LONG_MAX__
+#define LLONG_MIN (-LLONG_MAX - 1)
+#define LONG_BIT __LONG_WIDTH__
+#define LONG_MAX __LONG_MAX__
+#define LONG_MIN (-LONG_MAX - 1)
+#define SCHAR_MAX __SCHAR_MAX__
+#define SCHAR_MIN (-SCHAR_MAX - 1)
+#define SHRT_MAX __SHRT_MAX__
+#define SHRT_MIN (-SHRT_MAX - 1)
+
+// TODO: These might not be accurate on all platforms
+#define SSIZE_MAX 0x7fffffffffffffff
+#define UCHAR_MAX 255
+#define UINT_MAX 0xffffffff
+#define ULLONG_MAX 0xffffffffffffffff
+#define ULONG_MAX 0xffffffffffffffff
+#define USHRT_MAX 0xffff
+#define WORD_BIT 32
+
+#endif

include/bits/locale.h

+#define LC_ALL 0
+#define LC_COLLATE 1
+#define LC_CTYPE 2
+#define LC_MESSAGES 3
+#define LC_MONETARY 4
+#define LC_NUMERIC 5
+#define LC_TIME 6

include/bits/malloc.h

+#ifndef _BITS_MALLOC_H
+#define _BITS_MALLOC_H
+
+#include <stddef.h>
+
+// Generated from:
+// `grep "malloc\|calloc\|realloc\|free\|valloc\|memalign" target/include/stdlib.h`
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void *calloc(size_t nelem, size_t elsize);
+void free(void *ptr);
+void *malloc(size_t size);
+void *memalign(size_t alignment, size_t size);
+void *realloc(void *ptr, size_t size);
+void *valloc(size_t size);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif