include/assert.h

-#ifndef _ASSERT_H
-#define _ASSERT_H
-
-#ifdef NDEBUG
-# define assert(cond)
-#else
-# include <stdio.h>
-# define assert(cond) if (!(cond)) { \
-    fprintf(stderr, "%s: %s:%d: Assertion `%s` failed.\n", __func__, __FILE__, __LINE__, #cond); \
-    abort(); \
-    }
-#endif
-
-#endif

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
 
-//TODO extern __thread int errno;
-extern int errno;
+#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
 
-int open(const char* filename, int flags, ...);
-int fcntl(int fildes, int cmd, ...);
-
 #endif

include/bits/float.h

@@ -5,8 +5,6 @@
 
 // Shamelessly copy pasted from musl:
 
-#define FLT_RADIX 2
-
 #define FLT_TRUE_MIN 1.40129846432481707092e-45F
 #define FLT_MIN 1.17549435082228750797e-38F
 #define FLT_MAX 3.40282346638528859812e+38F

include/bits/inttypes.h

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

-#define MB_LEN_MAX 4 // unicode
+#ifndef _BITS_LIMIT_H
+#define _BITS_LIMIT_H
 
 #define CHAR_BIT __CHAR_BIT__
-#define CHAR_MAX __CHAR_MAX__
+#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_BIT__
+#define LONG_BIT __LONG_WIDTH__
 #define LONG_MAX __LONG_MAX__
 #define LONG_MIN (-LONG_MAX - 1)
 #define SCHAR_MAX __SCHAR_MAX__
@@ -16,12 +21,12 @@
 #define SHRT_MIN (-SHRT_MAX - 1)
 
 // TODO: These might not be accurate on all platforms
-#define SSIZE_MAX ((1 << 64 - 1) - 1)
+#define SSIZE_MAX 0x7fffffffffffffff
 #define UCHAR_MAX 255
-#define UINT_MAX ((1 << 32) - 1)
-#define ULLONG_MAX ((1 << 64) - 1)
-#define ULONG_MAX ((1 << 64) - 1)
-#define USHRT_MAX ((1 << 16) - 1)
+#define UINT_MAX 0xffffffff
+#define ULLONG_MAX 0xffffffffffffffff
+#define ULONG_MAX 0xffffffffffffffff
+#define USHRT_MAX 0xffff
 #define WORD_BIT 32
 
-#define PATH_MAX 4096
+#endif

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

include/bits/netdb.h

+#ifndef _BITS_NETDB_H
+#define _BITS_NETDB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define h_errno (*__h_errno_location())
+# define        h_addr  h_addr_list[0] /* Address, for backward compatibility.*/
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* _BITS_NETDB_H */

include/bits/netinet/in.h

+#ifndef _BITS_NETINET_IN_H
+#define _BITS_NETINET_IN_H
+
+extern const struct in6_addr in6addr_any;
+extern const struct in6_addr in6addr_loopback;
+#define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
+#define IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
+
+// from musl {
+#define IN6_IS_ADDR_UNSPECIFIED(a) \
+        (((uint32_t *) (a))[0] == 0 && ((uint32_t *) (a))[1] == 0 && \
+         ((uint32_t *) (a))[2] == 0 && ((uint32_t *) (a))[3] == 0)
+
+#define IN6_IS_ADDR_LOOPBACK(a) \
+        (((uint32_t *) (a))[0] == 0 && ((uint32_t *) (a))[1] == 0 && \
+         ((uint32_t *) (a))[2] == 0 && \
+         ((uint8_t *) (a))[12] == 0 && ((uint8_t *) (a))[13] == 0 && \
+         ((uint8_t *) (a))[14] == 0 && ((uint8_t *) (a))[15] == 1 )
+
+#define IN6_IS_ADDR_MULTICAST(a) (((uint8_t *) (a))[0] == 0xff)
+
+#define IN6_IS_ADDR_LINKLOCAL(a) \
+        ((((uint8_t *) (a))[0]) == 0xfe && (((uint8_t *) (a))[1] & 0xc0) == 0x80)
+
+#define IN6_IS_ADDR_SITELOCAL(a) \
+        ((((uint8_t *) (a))[0]) == 0xfe && (((uint8_t *) (a))[1] & 0xc0) == 0xc0)
+
+#define IN6_IS_ADDR_V4MAPPED(a) \
+        (((uint32_t *) (a))[0] == 0 && ((uint32_t *) (a))[1] == 0 && \
+         ((uint8_t *) (a))[8] == 0 && ((uint8_t *) (a))[9] == 0 && \
+         ((uint8_t *) (a))[10] == 0xff && ((uint8_t *) (a))[11] == 0xff)
+
+#define IN6_IS_ADDR_V4COMPAT(a) \
+        (((uint32_t *) (a))[0] == 0 && ((uint32_t *) (a))[1] == 0 && \
+         ((uint32_t *) (a))[2] == 0 && ((uint8_t *) (a))[15] > 1)
+
+#define IN6_IS_ADDR_MC_NODELOCAL(a) \
+        (IN6_IS_ADDR_MULTICAST(a) && ((((uint8_t *) (a))[1] & 0xf) == 0x1))
+
+#define IN6_IS_ADDR_MC_LINKLOCAL(a) \
+        (IN6_IS_ADDR_MULTICAST(a) && ((((uint8_t *) (a))[1] & 0xf) == 0x2))
+
+#define IN6_IS_ADDR_MC_SITELOCAL(a) \
+        (IN6_IS_ADDR_MULTICAST(a) && ((((uint8_t *) (a))[1] & 0xf) == 0x5))
+
+#define IN6_IS_ADDR_MC_ORGLOCAL(a) \
+        (IN6_IS_ADDR_MULTICAST(a) && ((((uint8_t *) (a))[1] & 0xf) == 0x8))
+
+#define IN6_IS_ADDR_MC_GLOBAL(a) \
+        (IN6_IS_ADDR_MULTICAST(a) && ((((uint8_t *) (a))[1] & 0xf) == 0xe))
+
+#define __ARE_4_EQUAL(a,b) \
+	(!( (0[a]-0[b]) | (1[a]-1[b]) | (2[a]-2[b]) | (3[a]-3[b]) ))
+#define IN6_ARE_ADDR_EQUAL(a,b) \
+	__ARE_4_EQUAL((const uint32_t *)(a), (const uint32_t *)(b))
+
+#define	IN_CLASSA(a)		((((in_addr_t)(a)) & 0x80000000) == 0)
+#define	IN_CLASSA_NET		0xff000000
+#define	IN_CLASSA_NSHIFT	24
+#define	IN_CLASSA_HOST		(0xffffffff & ~IN_CLASSA_NET)
+#define	IN_CLASSA_MAX		128
+#define	IN_CLASSB(a)		((((in_addr_t)(a)) & 0xc0000000) == 0x80000000)
+#define	IN_CLASSB_NET		0xffff0000
+#define	IN_CLASSB_NSHIFT	16
+#define	IN_CLASSB_HOST		(0xffffffff & ~IN_CLASSB_NET)
+#define	IN_CLASSB_MAX		65536
+#define	IN_CLASSC(a)		((((in_addr_t)(a)) & 0xe0000000) == 0xc0000000)
+#define	IN_CLASSC_NET		0xffffff00
+#define	IN_CLASSC_NSHIFT	8
+#define	IN_CLASSC_HOST		(0xffffffff & ~IN_CLASSC_NET)
+#define	IN_CLASSD(a)		((((in_addr_t)(a)) & 0xf0000000) == 0xe0000000)
+#define	IN_MULTICAST(a)		IN_CLASSD(a)
+#define	IN_EXPERIMENTAL(a)	((((in_addr_t)(a)) & 0xe0000000) == 0xe0000000)
+#define	IN_BADCLASS(a) ((((in_addr_t)(a)) & 0xf0000000) == 0xf0000000)
+// } from musl
+
+#endif // _BITS_NETINET_IN_H

include/bits/signal.h

+#ifndef _BITS_SIGNAL_H
+#define _BITS_SIGNAL_H
+
+#define SIG_DFL ((void (*)(int))0)
+#define SIG_IGN ((void (*)(int))1)
+#define SIG_ERR ((void (*)(int))-1)
+
+typedef struct siginfo siginfo_t;
+typedef unsigned long long sigset_t;
+typedef struct ucontext ucontext_t;
+typedef struct mcontext mcontext_t;
+
+struct sigaction {
+  union {
+    void (*sa_handler)(int);
+    void (*sa_sigaction)(int, siginfo_t *, void *);
+  };
+  unsigned long sa_flags;
+  void (*sa_restorer)(void);
+  sigset_t sa_mask;
+};
+
+#endif // _BITS_SIGNAL_H

include/bits/stdio.h

 #ifndef _BITS_STDIO_H
 #define _BITS_STDIO_H
 
-#define EOF (-1)
-#define BUFSIZ 1024
-#define stdin __stdin()
-#define stdout __stdout()
-#define stderr __stderr()
+// XXX: this is only here because cbindgen can't handle string constants
+#define P_tmpdir "/tmp"
 
-int fprintf(FILE * stream, const char * fmt, ...);
-int printf(const char * fmt, ...);
-int snprintf(char *s, size_t n, const char * fmt, ...);
-int sprintf(char *s, const char * fmt, ...);
-int fscanf(FILE * stream, const char * fmt, ...);
-int scanf(const char * fmt, ...);
-int sscanf(const char * input, const char * fmt, ...);
+typedef struct FILE FILE;
+
+// A typedef doesn't suffice, because libgmp uses this definition to check if
+// STDIO was loaded.
+#define FILE FILE
 
 #endif /* _BITS_STDIO_H */

include/bits/stdlib.h

+#ifndef _BITS_STDLIB_H
+#define _BITS_STDLIB_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+long double strtold(const char *nptr, char **endptr);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif /* _BITS_STDLIB_H */

include/bits/sys/ioctl.h

+// Shamelessly copy-pasted from musl
+
+#define _IOC(a,b,c,d) ( ((a)<<30) | ((b)<<8) | (c) | ((d)<<16) )
+#define _IOC_NONE  0U
+#define _IOC_WRITE 1U
+#define _IOC_READ  2U
+
+#define _IO(a,b) _IOC(_IOC_NONE,(a),(b),0)
+#define _IOW(a,b,c) _IOC(_IOC_WRITE,(a),(b),sizeof(c))
+#define _IOR(a,b,c) _IOC(_IOC_READ,(a),(b),sizeof(c))
+#define _IOWR(a,b,c) _IOC(_IOC_READ|_IOC_WRITE,(a),(b),sizeof(c))

include/bits/sys/mman.h

+#ifndef _BITS_SYS_MMAN_H
+#define _BITS_SYS_MMAN_H
+
+#define MAP_FAILED ((void *) -1)
+
+#endif

include/bits/sys/ptrace.h

+#ifndef _BITS_SYS_PTRACE_H
+#define _BITS_SYS_PTRACE_H
+
+#endif

include/bits/sys/select.h

+#ifndef _BITS_SYS_SELECT_H
+#define _BITS_SYS_SELECT_H
+
+#define FD_SETSIZE 1024
+
+typedef struct fd_set {
+    unsigned long fds_bits[FD_SETSIZE / (8 * sizeof(unsigned long))];
+} fd_set;
+
+#define _FD_INDEX(fd) ((fd) / (8 * sizeof(unsigned long)))
+#define _FD_BITMASK(fd) (1UL << ((fd) & (8 * sizeof(unsigned long) - 1)))
+
+#define FD_ZERO(set) for (int i = 0; i < sizeof((set)->fds_bits) / sizeof(unsigned long); i += 1) { \
+                         (set)->fds_bits[i] = 0; \
+                     }
+
+#define FD_SET(fd, set) ((set)->fds_bits[_FD_INDEX(fd)] |= _FD_BITMASK(fd))
+#define FD_CLR(fd, set) ((set)->fds_bits[_FD_INDEX(fd)] &= ~(_FD_BITMASK(fd)))
+
+#define FD_ISSET(fd, set) (((set)->fds_bits[_FD_INDEX(fd)] & _FD_BITMASK(fd)) == _FD_BITMASK(fd))
+
+#endif