include/bits/fcntl.h

 #ifndef _BITS_FCNTL_H
 #define _BITS_FCNTL_H
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int open(const char* filename, int flags, ...);
-int fcntl(int fildes, int cmd, ...);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif

include/bits/limits.h

@@ -26,7 +26,7 @@
 #define UINT_MAX 0xffffffff
 #define ULLONG_MAX 0xffffffffffffffff
 #define ULONG_MAX 0xffffffffffffffff
-#define USHRT_MAX 0xffffffffffffffff
+#define USHRT_MAX 0xffff
 #define WORD_BIT 32
 
 #endif

include/malloc.h → include/bits/malloc.h

-#ifndef _MALLOC_H
-#define _MALLOC_H
+#ifndef _BITS_MALLOC_H
+#define _BITS_MALLOC_H
 
 #include <stddef.h>
 

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/signal.h

@@ -5,4 +5,19 @@
 #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

@@ -6,21 +6,8 @@
 
 typedef struct FILE FILE;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-int asprintf(char **strp, const char * fmt, ...);
-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, ...);
-
-#ifdef __cplusplus
-} // extern "C"
-#endif
+// 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/sys/ptrace.h

 #ifndef _BITS_SYS_PTRACE_H
 #define _BITS_SYS_PTRACE_H
 
-int ptrace(int request, ...);
-
 #endif

include/bits/sys/socket.h

@@ -7,4 +7,10 @@ struct sockaddr_storage {
 	unsigned long __ss_align;
 };
 
+struct ucred {
+	pid_t pid;
+	uid_t uid;
+	gid_t gid;
+};
+
 #endif // _BITS_SYS_SOCKET_H

include/bits/unistd.h

@@ -7,10 +7,6 @@
 extern "C" {
 #endif
 
-int execl(const char *path, const char* argv0, ...);
-int execle(const char *path, const char* argv0, ...);
-int execlp(const char *file, const char* argv0, ...);
-
 #ifdef __cplusplus
 } // extern "C"
 #endif

include/bits/wchar.h

 #ifndef _BITS_WCHAR_H
 #define _BITS_WCHAR_H
+
+// int32_t, uint32_t, WCHAR_MIN, WCHAR_MAX
 #include <stdint.h>
 
-#define WEOF (0xffffffffu)
-#define WCHAR_MIN (0)
-#define WCHAR_MAX (0x7fffffff)
+#ifndef _WCHAR_T
+#define _WCHAR_T
+    #ifndef __WCHAR_TYPE__
+        #define __WCHAR_TYPE__ int32_t
+    #endif
+    typedef __WCHAR_TYPE__ wchar_t;
+#endif // _WCHAR_T
+
+#ifndef _WINT_T
+#define _WINT_T
+    #ifndef __WINT_TYPE__
+        #define __WINT_TYPE__ uint32_t
+    #endif
+    typedef __WINT_TYPE__ wint_t;
+#endif // _WINT_T
 
+// NULL, size_t, must come after wchar_t and wint_t
 #define __need_size_t
-#define __need_wchar_t
-#define __need_wint_t
 #define __need_NULL
+#include <stddef.h>
+
+#define WEOF (0xffffffffu)
 
 #endif /* _BITS_WCHAR_H */

include/bits/wctype.h

-#ifndef _BITS_WCTYPE_H
-#define _BITS_WCTYPE_H
-#include <stdint.h>
-
-#define __need_wint_t
-
-#endif /* _BITS_WCTYPE_H */

include/cpio.h

+#ifndef _RELIBC_CPIO_H
+#define _RELIBC_CPIO_H
+
+#define MAGIC "070707"
+
+#define C_IRUSR  00000400
+#define C_IWUSR  00000200
+#define C_IXUSR  00000100
+#define C_IRGRP  00000040
+#define C_IWGRP  00000020
+#define C_IXGRP  00000010
+#define C_IROTH  00000004
+#define C_IWOTH  00000002
+#define C_IXOTH  00000001
+
+#define C_ISUID  00004000
+#define C_ISGID  00002000
+#define C_ISVTX  00001000
+
+#define C_ISDIR  00040000
+#define C_ISFIFO 00010000
+#define C_ISREG  00100000
+#define C_ISBLK  00060000
+#define C_ISCHR  00020000
+#define C_ISCTG  00110000
+#define C_ISLNK  00120000
+#define C_ISSOCK 00140000
+
+#endif  /* _RELIBC_CPIO_H */

include/features.h

@@ -3,26 +3,92 @@
  * Copyright (c) 2020 Rich Felker musl-libc
  */
 
-#ifndef _FEATURES_H
-#define _FEATURES_H
+#ifndef _FEATURES_H__RELIBC
+#define _FEATURES_H__RELIBC
 
+// Version metadata for feature gating
+// This is useful for divergent implementation specific behavior
+// glibc, ulibc, and likely others define a similar macro
+// musl does not define an equivalent macro
+#define __RELIBC__ 1
+#define __RELIBC__MAJOR 0
+#define __RELIBC__MINOR 2
+
+/*
+ * Sources:
+ * https://en.cppreference.com/w/c/language/attributes
+ * https://clang.llvm.org/docs/LanguageExtensions.html
+ * https://gcc.gnu.org/onlinedocs/cpp/_005f_005fhas_005fc_005fattribute.html
+ * https://gcc.gnu.org/onlinedocs/cpp/Standard-Predefined-Macros.html
+ */
+
+// Clang doesn't define __has_cpp_attribute if compiling C code
+#if !defined(__has_cpp_attribute)
+    #define __has_cpp_attribute(x) 0
+#endif
+
+// Clang doesn't define __has_c_attribute if compiling C++ code
+#if !defined(__has_c_attribute)
+    #define __has_c_attribute(x) 0
+#endif
+
+// Check if C23+ attributes are available
+#if defined(__cplusplus)
+// HACK: GCC backports C++ attributes to C++98 but doesn't accept attributes
+// placed before the function like cbindgen emits.
+// Let's just disable attributes for C++98 by checking if a random C++11
+// feature is available.
+#define __HAS_ATTRIBUTE(x) __cpp_variable_templates &&__has_cpp_attribute(x)
+#else
+#define __HAS_ATTRIBUTE(x)                                                     \
+  (__has_c_attribute(x) || __STDC_VERSION__ >= 202311L ||                      \
+   __has_cpp_attribute(x))
+#endif
+
+// TODO: Not emitted with cbindgen
 #if __STDC_VERSION__ >= 199901L
-#define __restrict restrict
+    #define __restrict restrict
 #elif !defined(__GNUC__)
-#define __restrict
+    #define __restrict
 #endif
 
+// TODO: Not emitted with cbindgen
 #if __STDC_VERSION__ >= 199901L || defined(__cplusplus)
-#define __inline inline
+    #define __inline inline
 #elif !defined(__GNUC__)
-#define __inline
+    #define __inline
 #endif
 
-#if __STDC_VERSION__ >= 201112L
+// Analogous to Rust's Never type
+#if __HAS_ATTRIBUTE(noreturn)
+    #define __noreturn [[noreturn]]
+// #elif __STDC_VERSION__ >= 201112L
+// FIXME: cbindgen incorrectly places _Noreturn
+// #define __noreturn _Noreturn
 #elif defined(__GNUC__)
-#define _Noreturn __attribute__((__noreturn__))
+    #define __noreturn __attribute__((__noreturn__))
+#else
+    #define __noreturn
+#endif
+
+// Analogous to Rust's #[must_use]
+// C23 only
+#if __HAS_ATTRIBUTE(nodiscard)
+    #define __nodiscard [[nodiscard]]
+    #define __nodiscardNote(x) [[nodiscard(x)]]
+#else
+    #define __nodiscard
+    #define __nodiscardNote(x)
+#endif
+
+// Analogous to Rust's #[deprecated]
+// C23 only
+#if __HAS_ATTRIBUTE(deprecated)
+    #define __deprecated [[deprecated]]
+    #define __deprecatedNote(x) [[deprecated(x)]]
 #else
-#define _Noreturn
+    #define __deprecated
+    #define __deprecatedNote(x)
 #endif
 
 #endif

include/iso646.h

+// Copied from musl
+
+#ifndef _ISO646_H
+#define _ISO646_H
+
+#ifndef __cplusplus
+
+#define and    &&
+#define and_eq &=
+#define bitand &
+#define bitor  |
+#define compl  ~
+#define not    !
+#define not_eq !=
+#define or     ||
+#define or_eq  |=
+#define xor    ^
+#define xor_eq ^=
+
+#endif
+
+#endif

include/math.h

 #include <openlibm_math.h>
 
-// Included to fix mesa issues
+// Missing typedefs
+typedef float float_t;
+typedef double double_t;
+
 #ifndef M_PI
 #define	M_PI		3.14159265358979323846	/* pi */
 #endif
@@ -12,3 +15,7 @@
 #ifndef M_PI_4
 #define	M_PI_4		0.78539816339744830962	/* pi/4 */
 #endif
+
+#ifndef M_2_PI
+#define M_2_PI		0.63661977236758134308	/* 2/pi */
+#endif

include/setjmp.h

@@ -58,7 +58,12 @@ typedef unsigned long long jmp_buf[8];
 #endif
 
 #ifdef __x86_64__
-typedef unsigned long jmp_buf[8];
+typedef unsigned long jmp_buf[16];
+typedef jmp_buf sigjmp_buf;
+#endif
+
+#ifdef __riscv
+typedef unsigned long jmp_buf[26];
 #endif
 
 #ifdef __cplusplus

include/stdatomic.h

+/* Copyright (C) 2013-2022 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 3, or (at your option)
+any later version.
+
+GCC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+/* ISO C11 Standard:  7.17  Atomics <stdatomic.h>.  */
+
+#ifndef _STDATOMIC_H
+#define _STDATOMIC_H
+
+typedef enum
+  {
+    memory_order_relaxed = __ATOMIC_RELAXED,
+    memory_order_consume = __ATOMIC_CONSUME,
+    memory_order_acquire = __ATOMIC_ACQUIRE,
+    memory_order_release = __ATOMIC_RELEASE,
+    memory_order_acq_rel = __ATOMIC_ACQ_REL,
+    memory_order_seq_cst = __ATOMIC_SEQ_CST
+  } memory_order;
+
+
+typedef _Atomic _Bool atomic_bool;
+typedef _Atomic char atomic_char;
+typedef _Atomic signed char atomic_schar;
+typedef _Atomic unsigned char atomic_uchar;
+typedef _Atomic short atomic_short;
+typedef _Atomic unsigned short atomic_ushort;
+typedef _Atomic int atomic_int;
+typedef _Atomic unsigned int atomic_uint;
+typedef _Atomic long atomic_long;
+typedef _Atomic unsigned long atomic_ulong;
+typedef _Atomic long long atomic_llong;
+typedef _Atomic unsigned long long atomic_ullong;
+typedef _Atomic __CHAR16_TYPE__ atomic_char16_t;
+typedef _Atomic __CHAR32_TYPE__ atomic_char32_t;
+typedef _Atomic __WCHAR_TYPE__ atomic_wchar_t;
+typedef _Atomic __INT_LEAST8_TYPE__ atomic_int_least8_t;
+typedef _Atomic __UINT_LEAST8_TYPE__ atomic_uint_least8_t;
+typedef _Atomic __INT_LEAST16_TYPE__ atomic_int_least16_t;
+typedef _Atomic __UINT_LEAST16_TYPE__ atomic_uint_least16_t;
+typedef _Atomic __INT_LEAST32_TYPE__ atomic_int_least32_t;
+typedef _Atomic __UINT_LEAST32_TYPE__ atomic_uint_least32_t;
+typedef _Atomic __INT_LEAST64_TYPE__ atomic_int_least64_t;
+typedef _Atomic __UINT_LEAST64_TYPE__ atomic_uint_least64_t;
+typedef _Atomic __INT_FAST8_TYPE__ atomic_int_fast8_t;
+typedef _Atomic __UINT_FAST8_TYPE__ atomic_uint_fast8_t;
+typedef _Atomic __INT_FAST16_TYPE__ atomic_int_fast16_t;
+typedef _Atomic __UINT_FAST16_TYPE__ atomic_uint_fast16_t;
+typedef _Atomic __INT_FAST32_TYPE__ atomic_int_fast32_t;
+typedef _Atomic __UINT_FAST32_TYPE__ atomic_uint_fast32_t;
+typedef _Atomic __INT_FAST64_TYPE__ atomic_int_fast64_t;
+typedef _Atomic __UINT_FAST64_TYPE__ atomic_uint_fast64_t;
+typedef _Atomic __INTPTR_TYPE__ atomic_intptr_t;
+typedef _Atomic __UINTPTR_TYPE__ atomic_uintptr_t;
+typedef _Atomic __SIZE_TYPE__ atomic_size_t;
+typedef _Atomic __PTRDIFF_TYPE__ atomic_ptrdiff_t;
+typedef _Atomic __INTMAX_TYPE__ atomic_intmax_t;
+typedef _Atomic __UINTMAX_TYPE__ atomic_uintmax_t;        
+
+
+#define ATOMIC_VAR_INIT(VALUE)	(VALUE)
+
+/* Initialize an atomic object pointed to by PTR with VAL.  */
+#define atomic_init(PTR, VAL)                           \
+  atomic_store_explicit (PTR, VAL, __ATOMIC_RELAXED)
+
+#define kill_dependency(Y)			\
+  __extension__					\
+  ({						\
+    __auto_type __kill_dependency_tmp = (Y);	\
+    __kill_dependency_tmp;			\
+  })
+
+extern void atomic_thread_fence (memory_order);
+#define atomic_thread_fence(MO)	__atomic_thread_fence (MO)
+extern void atomic_signal_fence (memory_order);
+#define atomic_signal_fence(MO)	__atomic_signal_fence  (MO)
+#define atomic_is_lock_free(OBJ) __atomic_is_lock_free (sizeof (*(OBJ)), (OBJ))
+
+#define ATOMIC_BOOL_LOCK_FREE		__GCC_ATOMIC_BOOL_LOCK_FREE
+#define ATOMIC_CHAR_LOCK_FREE		__GCC_ATOMIC_CHAR_LOCK_FREE
+#define ATOMIC_CHAR16_T_LOCK_FREE	__GCC_ATOMIC_CHAR16_T_LOCK_FREE
+#define ATOMIC_CHAR32_T_LOCK_FREE	__GCC_ATOMIC_CHAR32_T_LOCK_FREE
+#define ATOMIC_WCHAR_T_LOCK_FREE	__GCC_ATOMIC_WCHAR_T_LOCK_FREE
+#define ATOMIC_SHORT_LOCK_FREE		__GCC_ATOMIC_SHORT_LOCK_FREE
+#define ATOMIC_INT_LOCK_FREE		__GCC_ATOMIC_INT_LOCK_FREE
+#define ATOMIC_LONG_LOCK_FREE		__GCC_ATOMIC_LONG_LOCK_FREE
+#define ATOMIC_LLONG_LOCK_FREE		__GCC_ATOMIC_LLONG_LOCK_FREE
+#define ATOMIC_POINTER_LOCK_FREE	__GCC_ATOMIC_POINTER_LOCK_FREE
+
+
+/* Note that these macros require __auto_type to remove
+   _Atomic qualifiers (and const qualifiers, if those are valid on
+   macro operands).
+   
+   Also note that the header file uses the generic form of __atomic
+   builtins, which requires the address to be taken of the value
+   parameter, and then we pass that value on.  This allows the macros
+   to work for any type, and the compiler is smart enough to convert
+   these to lock-free _N variants if possible, and throw away the
+   temps.  */
+
+#define atomic_store_explicit(PTR, VAL, MO)				\
+  __extension__								\
+  ({									\
+    __auto_type __atomic_store_ptr = (PTR);				\
+    __typeof__ ((void)0, *__atomic_store_ptr) __atomic_store_tmp = (VAL);	\
+    __atomic_store (__atomic_store_ptr, &__atomic_store_tmp, (MO));	\
+  })
+
+#define atomic_store(PTR, VAL)				\
+  atomic_store_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
+
+
+#define atomic_load_explicit(PTR, MO)					\
+  __extension__								\
+  ({									\
+    __auto_type __atomic_load_ptr = (PTR);				\
+    __typeof__ ((void)0, *__atomic_load_ptr) __atomic_load_tmp;			\
+    __atomic_load (__atomic_load_ptr, &__atomic_load_tmp, (MO));	\
+    __atomic_load_tmp;							\
+  })
+
+#define atomic_load(PTR)  atomic_load_explicit (PTR, __ATOMIC_SEQ_CST)
+
+
+#define atomic_exchange_explicit(PTR, VAL, MO)				\
+  __extension__								\
+  ({									\
+    __auto_type __atomic_exchange_ptr = (PTR);				\
+    __typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_val = (VAL);	\
+    __typeof__ ((void)0, *__atomic_exchange_ptr) __atomic_exchange_tmp;		\
+    __atomic_exchange (__atomic_exchange_ptr, &__atomic_exchange_val,	\
+		       &__atomic_exchange_tmp, (MO));			\
+    __atomic_exchange_tmp;						\
+  })
+
+#define atomic_exchange(PTR, VAL) 			\
+  atomic_exchange_explicit (PTR, VAL, __ATOMIC_SEQ_CST)
+
+
+#define atomic_compare_exchange_strong_explicit(PTR, VAL, DES, SUC, FAIL) \
+  __extension__								\
+  ({									\
+    __auto_type __atomic_compare_exchange_ptr = (PTR);			\
+    __typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
+      = (DES);								\
+    __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL),	\
+			       &__atomic_compare_exchange_tmp, 0,	\
+			       (SUC), (FAIL));				\
+  })
+
+#define atomic_compare_exchange_strong(PTR, VAL, DES) 			   \
+  atomic_compare_exchange_strong_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
+					   __ATOMIC_SEQ_CST)
+
+#define atomic_compare_exchange_weak_explicit(PTR, VAL, DES, SUC, FAIL) \
+  __extension__								\
+  ({									\
+    __auto_type __atomic_compare_exchange_ptr = (PTR);			\
+    __typeof__ ((void)0, *__atomic_compare_exchange_ptr) __atomic_compare_exchange_tmp \
+      = (DES);								\
+    __atomic_compare_exchange (__atomic_compare_exchange_ptr, (VAL),	\
+			       &__atomic_compare_exchange_tmp, 1,	\
+			       (SUC), (FAIL));				\
+  })
+
+#define atomic_compare_exchange_weak(PTR, VAL, DES)			\
+  atomic_compare_exchange_weak_explicit (PTR, VAL, DES, __ATOMIC_SEQ_CST, \
+					 __ATOMIC_SEQ_CST)
+
+
+
+#define atomic_fetch_add(PTR, VAL) __atomic_fetch_add ((PTR), (VAL), 	\
+						       __ATOMIC_SEQ_CST)
+#define atomic_fetch_add_explicit(PTR, VAL, MO) 			\
+			  __atomic_fetch_add ((PTR), (VAL), (MO))
+
+#define atomic_fetch_sub(PTR, VAL) __atomic_fetch_sub ((PTR), (VAL), 	\
+						       __ATOMIC_SEQ_CST)
+#define atomic_fetch_sub_explicit(PTR, VAL, MO) 			\
+			  __atomic_fetch_sub ((PTR), (VAL), (MO))
+
+#define atomic_fetch_or(PTR, VAL) __atomic_fetch_or ((PTR), (VAL), 	\
+						       __ATOMIC_SEQ_CST)
+#define atomic_fetch_or_explicit(PTR, VAL, MO) 			\
+			  __atomic_fetch_or ((PTR), (VAL), (MO))
+
+#define atomic_fetch_xor(PTR, VAL) __atomic_fetch_xor ((PTR), (VAL), 	\
+						       __ATOMIC_SEQ_CST)
+#define atomic_fetch_xor_explicit(PTR, VAL, MO) 			\
+			  __atomic_fetch_xor ((PTR), (VAL), (MO))
+
+#define atomic_fetch_and(PTR, VAL) __atomic_fetch_and ((PTR), (VAL), 	\
+						       __ATOMIC_SEQ_CST)
+#define atomic_fetch_and_explicit(PTR, VAL, MO) 			\
+			  __atomic_fetch_and ((PTR), (VAL), (MO))
+
+
+typedef _Atomic struct
+{
+#if __GCC_ATOMIC_TEST_AND_SET_TRUEVAL == 1
+  _Bool __val;
+#else
+  unsigned char __val;
+#endif
+} atomic_flag;
+
+#define ATOMIC_FLAG_INIT	{ 0 }
+
+
+extern _Bool atomic_flag_test_and_set (volatile atomic_flag *);
+#define atomic_flag_test_and_set(PTR) 					\
+			__atomic_test_and_set ((PTR), __ATOMIC_SEQ_CST)
+extern _Bool atomic_flag_test_and_set_explicit (volatile atomic_flag *,
+						memory_order);
+#define atomic_flag_test_and_set_explicit(PTR, MO)			\
+			__atomic_test_and_set ((PTR), (MO))
+
+extern void atomic_flag_clear (volatile atomic_flag *);
+#define atomic_flag_clear(PTR)	__atomic_clear ((PTR), __ATOMIC_SEQ_CST)
+extern void atomic_flag_clear_explicit (volatile atomic_flag *, memory_order);
+#define atomic_flag_clear_explicit(PTR, MO)   __atomic_clear ((PTR), (MO))
+
+#endif  /* _STDATOMIC_H */

include/stddef.h

@@ -9,12 +9,6 @@
 #endif
 typedef __PTRDIFF_TYPE__ ptrdiff_t;
 
-#ifndef __cplusplus
-typedef int32_t wchar_t;
-#endif /* #ifndef __cplusplus */
-typedef int32_t wint_t;
-
-
 typedef long unsigned int size_t;
 
 typedef struct { long long __ll; long double __ld; } max_align_t;

include/stdnoreturn.h

+/* Spec:
+ * The <stdnoreturn.h> header shall define the macro noreturn which shall
+ * expand to _Noreturn */
+
+#ifndef _STDNORETURN_H
+#define _STDNORETURN_H
+
+#ifndef __cplusplus
+/* Borrowed from musl */
+#if __STDC_VERSION__ >= 201112L
+#elif defined(__GNUC__)
+    #define _Noreturn __attribute__((__noreturn__))
+#else
+    #define _Noreturn
+#endif
+#define noreturn _Noreturn
+#endif
+
+#endif

include/sys/poll.h

+#include <poll.h>