rubycc 1.0.0

data/include/libc/glibc/aarch64/pthread.h

@@ -0,0 +1,131 @@
+/* rubycc bundled <pthread.h>: the POSIX threads types, the mutex/attribute
+   enums and the core pthreads calls. Provenance: clean room against the glibc
+   pthreads ABI (bits/pthreadtypes.h, bits/pthreadtypes-arch.h and pthread.h),
+   not derived from musl or glibc source -- and a measured glibc ABI, not a
+   kernel UAPI, since the pthreads objects are glibc internal state rather than a
+   system-call interface. The opaque objects (pthread_mutex_t, pthread_cond_t,
+   pthread_attr_t and kin) are glibc implementation detail, so rubycc reproduces
+   only their measured size and alignment as an opaque byte blob -- a union of a
+   char __size[N] arm and the aligning scalar -- and does not copy glibc's
+   internal field layout (only what the ABI needs, exact; everything else opaque,
+   the same principle sys/stat.h follows for its reserved slots). Only that
+   size and alignment is an ABI fact reproduced by measurement, not copied text
+   (see docs/HEADER-LICENSING.md). The pthread_* calls are POSIX declarations
+   whose bodies resolve from the host libc at link time (glibc folds them into
+   libc), the same way errno.h's __errno_location does.
+   Placed in the glibc/aarch64 layer because the opaque sizes are arch dependent:
+   pthread_mutex_t, pthread_attr_t, pthread_mutexattr_t and pthread_condattr_t
+   are wider here than on x86-64, so this file differs from the companion
+   glibc/x86-64/pthread.h only in those four __size[N] counts (and this
+   provenance line).
+   musl disagrees with glibc on five of these objects here, one more than the
+   x86-64 companion's single case (pthread_rwlockattr_t's alignment): musl's
+   pthread_mutex_t is 40 bytes against glibc's 48, its pthread_attr_t 56
+   against glibc's 64, its pthread_mutexattr_t and pthread_condattr_t 4 bytes
+   against glibc's 8 (all four with the same alignment on both libcs), and its
+   pthread_rwlockattr_t is 4-byte aligned against glibc's 8 (same 8-byte size
+   on both) -- the opaque pthreads objects are the single most arch-dependent
+   thing in this layer, as the four differing __size[N] counts above already
+   show, so this file's musl figures are its own measurement rather than the
+   x86-64 companion's single-case one, taken on the CI aarch64 musl run
+   (docs/STEPS.md Step 202). Every other pthreads object here (pthread_t,
+   pthread_cond_t, pthread_rwlock_t and the small scalar handles) measured
+   identical on the two libraries. */
+
+#ifndef _RUBYCC_PTHREAD_H
+#define _RUBYCC_PTHREAD_H
+
+/* The thread handle and the small scalar handles (identical on both arches). */
+typedef unsigned long pthread_t;
+typedef int           pthread_once_t;
+typedef unsigned int  pthread_key_t;
+typedef int           pthread_spinlock_t;
+
+/* The opaque pthreads objects. Each carries real internal fields in glibc;
+   rubycc reproduces only the measured size and alignment as an opaque blob (the
+   char __size[N] arm alongside the aligning scalar), so a variable of the type
+   occupies the right space and alignment without copying glibc's field layout.
+   pthread_attr_t, pthread_mutex_t, pthread_mutexattr_t and pthread_condattr_t
+   have a wider __size[N] on aarch64 (the four counts that differ between the two
+   arch layers); the others are identical on both arches.
+   Five of these additionally differ by libc on this arch (see the provenance
+   note above): pthread_mutex_t, pthread_attr_t, pthread_mutexattr_t and
+   pthread_condattr_t are narrower on musl (same alignment as glibc), and
+   pthread_rwlockattr_t keeps glibc's 8-byte size but musl's alignment is
+   narrower. Both figures measured with the ABI harness, glibc's on this host
+   and musl's on the CI aarch64 musl run (docs/STEPS.md Step 202). */
+#if defined(__RUBYCC_LIBC_MUSL__)
+typedef union { char __size[56]; long __align; } pthread_attr_t;
+typedef union { char __size[40]; long __align; } pthread_mutex_t;
+typedef union { char __size[4];  int  __align; } pthread_mutexattr_t;
+typedef union { char __size[48]; long __align; } pthread_cond_t;
+typedef union { char __size[4];  int  __align; } pthread_condattr_t;
+typedef union { char __size[56]; long __align; } pthread_rwlock_t;
+typedef union { char __size[8];  int  __align; } pthread_rwlockattr_t;
+#else
+typedef union { char __size[64]; long __align; } pthread_attr_t;
+typedef union { char __size[48]; long __align; } pthread_mutex_t;
+typedef union { char __size[8];  int  __align; } pthread_mutexattr_t;
+typedef union { char __size[48]; long __align; } pthread_cond_t;
+typedef union { char __size[8];  int  __align; } pthread_condattr_t;
+typedef union { char __size[56]; long __align; } pthread_rwlock_t;
+typedef union { char __size[8];  long __align; } pthread_rwlockattr_t;
+#endif
+
+/* Mutex kinds (pthread_mutexattr_settype / __kind). */
+#define PTHREAD_MUTEX_NORMAL     0
+#define PTHREAD_MUTEX_RECURSIVE  1
+#define PTHREAD_MUTEX_ERRORCHECK 2
+#define PTHREAD_MUTEX_DEFAULT    PTHREAD_MUTEX_NORMAL
+
+/* Detach state (pthread_attr_setdetachstate). */
+#define PTHREAD_CREATE_JOINABLE  0
+#define PTHREAD_CREATE_DETACHED  1
+
+/* Process-shared attribute values. */
+#define PTHREAD_PROCESS_PRIVATE  0
+#define PTHREAD_PROCESS_SHARED   1
+
+/* Static initializers: zero the first arm of the opaque union. */
+#define PTHREAD_MUTEX_INITIALIZER  { { 0 } }
+#define PTHREAD_COND_INITIALIZER   { { 0 } }
+#define PTHREAD_RWLOCK_INITIALIZER { { 0 } }
+#define PTHREAD_ONCE_INIT 0
+
+int  pthread_create(pthread_t *__thread, const pthread_attr_t *__attr, void *(*__start)(void *), void *__arg);
+int  pthread_join(pthread_t __thread, void **__retval);
+int  pthread_detach(pthread_t __thread);
+pthread_t pthread_self(void);
+int  pthread_equal(pthread_t __t1, pthread_t __t2);
+int  pthread_kill(pthread_t __thread, int __sig);
+void pthread_exit(void *__retval);
+int  pthread_mutex_init(pthread_mutex_t *__mutex, const pthread_mutexattr_t *__attr);
+int  pthread_mutex_destroy(pthread_mutex_t *__mutex);
+int  pthread_mutex_lock(pthread_mutex_t *__mutex);
+int  pthread_mutex_trylock(pthread_mutex_t *__mutex);
+int  pthread_mutex_unlock(pthread_mutex_t *__mutex);
+int  pthread_cond_init(pthread_cond_t *__cond, const pthread_condattr_t *__attr);
+int  pthread_cond_destroy(pthread_cond_t *__cond);
+int  pthread_cond_wait(pthread_cond_t *__cond, pthread_mutex_t *__mutex);
+int  pthread_cond_signal(pthread_cond_t *__cond);
+int  pthread_cond_broadcast(pthread_cond_t *__cond);
+int  pthread_once(pthread_once_t *__once, void (*__init)(void));
+int  pthread_key_create(pthread_key_t *__key, void (*__destr)(void *));
+int  pthread_key_delete(pthread_key_t __key);
+void *pthread_getspecific(pthread_key_t __key);
+int  pthread_setspecific(pthread_key_t __key, const void *__value);
+int  pthread_attr_init(pthread_attr_t *__attr);
+int  pthread_attr_destroy(pthread_attr_t *__attr);
+int  pthread_mutexattr_init(pthread_mutexattr_t *__attr);
+int  pthread_mutexattr_destroy(pthread_mutexattr_t *__attr);
+int  pthread_mutexattr_settype(pthread_mutexattr_t *__attr, int __type);
+
+/* Process-fork hook registration (a process-wide call, unlike the
+   thread-manipulation calls above). Declaring this turns stackprof's
+   build failure from a compile-time "implicit declaration" error into a
+   link-time one: glibc supplies pthread_atfork only from libc_nonshared.a,
+   whose member references __dso_handle, which rubycc's linker cannot yet
+   resolve (Step 146 gap 6, a separate, unfixed problem). */
+int  pthread_atfork(void (*__prepare)(void), void (*__parent)(void), void (*__child)(void));
+
+#endif /* _RUBYCC_PTHREAD_H */

data/include/libc/glibc/aarch64/setjmp.h

@@ -0,0 +1,84 @@
+/* rubycc bundled <setjmp.h>: the ISO C non-local jump facility (C11 7.13) plus
+   the POSIX sigsetjmp/siglongjmp pair. Provenance: clean room against the
+   glibc setjmp ABI (bits/setjmp.h, struct __jmp_buf_tag in bits/setjmpP.h),
+   not derived from musl or glibc source -- and a measured glibc ABI, not a
+   kernel UAPI, since jmp_buf is glibc internal state (a saved register set)
+   rather than a system-call interface. jmp_buf/sigjmp_buf are glibc
+   implementation detail (the callee-saved registers, stack pointer, program
+   counter, and -- for sigjmp_buf -- the saved signal mask), so rubycc
+   reproduces only their measured size and alignment as an opaque byte blob --
+   a union of a char __size[N] arm and the aligning scalar -- and does not copy
+   glibc's internal field layout (__jmpbuf / __mask_was_saved / __saved_mask),
+   the same principle pthread.h follows for its opaque objects. Only that size
+   and alignment is an ABI fact reproduced by measurement, not copied text (see
+   docs/HEADER-LICENSING.md). setjmp/longjmp/_setjmp/_longjmp/siglongjmp are
+   POSIX/ISO C declarations whose bodies resolve from the host libc at link
+   time (glibc folds them into libc), the same way errno.h's __errno_location
+   does. sigsetjmp is the one exception: glibc exports no plain `sigsetjmp'
+   symbol, only `__sigsetjmp' (measured: a plain `int sigsetjmp(...)'
+   declaration fails to link against glibc), so this header follows glibc's own
+   public macro contract and expands `sigsetjmp' onto `__sigsetjmp' -- a
+   documented interoperability fact, not copied glibc source.
+   Placed in the glibc/aarch64 layer because the opaque size is arch dependent:
+   jmp_buf holds one register set per architecture, so it is wider here than on
+   x86-64 (aarch64 saves more callee-saved integer and FP/SIMD registers) -- this
+   file differs from the companion glibc/x86-64/setjmp.h only in the __size[N]
+   count (and this provenance line).
+   Measured: sizeof(jmp_buf) == sizeof(sigjmp_buf) == 312, _Alignof == 8, on
+   aarch64 glibc (a small probe printing sizeof/_Alignof, cross-compiled with
+   aarch64-linux-gnu-gcc -static and run under qemu-aarch64; see
+   test/test_header_abi.rb's SETJMP case run against the cross-gcc oracle for
+   the same values).
+   Caution for rubycc users: 7.13.2.1p3 of the C standard leaves the values of
+   non-volatile automatic variables modified between setjmp and longjmp
+   unspecified if they were changed after the setjmp call. rubycc performs no
+   register allocation across calls -- every local is spilled to its stack slot
+   on every store -- so in practice such values come back unchanged after a
+   longjmp, which is the conservative (safe) side of that rule: rubycc never
+   restores a stale value the way an optimizing compiler that shuffled variables
+   into registers might. Do not rely on this coincidence; write code that treats
+   such variables as unspecified, as the standard requires, and mark anything
+   that must survive the jump `volatile`. */
+
+#ifndef _RUBYCC_SETJMP_H
+#define _RUBYCC_SETJMP_H
+
+/* The opaque saved-context blocks. glibc stores the callee-saved registers,
+   stack pointer and program counter (and, for sigjmp_buf, the saved signal
+   mask) inside; rubycc reproduces only the measured size and alignment as an
+   opaque blob (the char __size[N] arm alongside the aligning scalar), so a
+   variable of the type occupies the right space and alignment without copying
+   glibc's field layout. Wider than on x86-64 (a different register file),
+   which is why this header lives in the arch layer. */
+/* One named type, not two anonymous ones. C gives every anonymous union its
+   own distinct type, so declaring jmp_buf and sigjmp_buf separately made
+   them incompatible: passing a jmp_buf to siglongjmp() was a type error
+   here while gcc accepted it, because glibc spells both as arrays of one
+   shared tag. Measured: gcc reports sizeof and _Alignof identical for the
+   two names (312 and 8 on this target), which is what lets them share a
+   definition. Found building google-protobuf's ruby-upb.h, which stores a
+   jmp_buf and hands it to siglongjmp(). */
+union __jmp_buf_tag { char __size[312]; long __align; };
+typedef union __jmp_buf_tag jmp_buf[1];
+typedef union __jmp_buf_tag sigjmp_buf[1];
+
+int  setjmp(jmp_buf __env);
+void longjmp(jmp_buf __env, int __val) __attribute__((__noreturn__));
+
+/* BSD/POSIX non-restoring variants (do not save/restore the signal mask). */
+int  _setjmp(jmp_buf __env);
+void _longjmp(jmp_buf __env, int __val) __attribute__((__noreturn__));
+
+/* POSIX sigsetjmp. glibc exports no plain `sigsetjmp' symbol -- only
+   `__sigsetjmp' -- because sigsetjmp must capture its caller's own stack
+   frame, so glibc's own <setjmp.h> makes `sigsetjmp' a macro onto
+   `__sigsetjmp' rather than a plain function (a documented public-interface
+   fact, not glibc source text: measured here by observing that a plain
+   `int sigsetjmp(...)' declaration fails to link against glibc, while
+   `__sigsetjmp' does). rubycc's header follows that same public contract so
+   generated calls resolve against the host libc. */
+int  __sigsetjmp(sigjmp_buf __env, int __savemask);
+#define sigsetjmp(__env, __savemask) __sigsetjmp(__env, __savemask)
+void siglongjmp(sigjmp_buf __env, int __val) __attribute__((__noreturn__));
+
+#endif /* _RUBYCC_SETJMP_H */

data/include/libc/glibc/aarch64/stdint.h

@@ -0,0 +1,174 @@
+/* rubycc bundled <stdint.h>: exact/least/fast-width integer typedefs and their
+   limit and constant-suffix macros (ISO C 7.20). Derived from musl's <stdint.h>
+   as the declaration shape, with the widths pinned to the aarch64 LP64 ABI
+   (measured): intmax_t/intptr_t are `long`, and the fast types are 64-bit on
+   glibc but 32-bit on musl -- see below. The one ABI difference from the
+   x86-64 layer besides the fast types is WCHAR_MIN/WCHAR_MAX: aarch64 makes
+   wchar_t unsigned, so the macros are 0 and UINT32_MAX rather than the signed
+   INT32_MIN/INT32_MAX. The wchar_t typedef itself is left `typedef int wchar_t`
+   (signed): it is shared with the freestanding <stddef.h> through the
+   _RUBYCC_WCHAR_T guard, so changing its signedness only here would make the two
+   disagree depending on include order. wchar_t's signedness is therefore a known
+   limitation (like long double's width); the ABI surface the harness checks --
+   the WCHAR_MIN/WCHAR_MAX macro values -- is what is pinned to aarch64 here.
+   The fast types are the other place the two C libraries part company, and here
+   it is a machine-dependent fact rather than a portable one: on this arch
+   [u]int_fast16_t/[u]int_fast32_t are 4 bytes, 4-byte aligned on musl against
+   8 bytes, 8-byte aligned on glibc (both sizeof/_Alignof pairs measured with
+   the ABI harness, glibc's on this host and musl's on the CI aarch64 musl run,
+   docs/STEPS.md Step 202) -- the same split the x86-64 companion carries, but
+   measured here rather than copied from there, since a fast type's width is
+   exactly the kind of thing this arch layer exists to keep per-machine (R8).
+   The limit macros further down follow these widths rather than restating
+   them. ABI switch layer: these widths are arch specific. */
+
+#ifndef _RUBYCC_STDINT_H
+#define _RUBYCC_STDINT_H
+
+#ifndef _RUBYCC_WCHAR_T
+#define _RUBYCC_WCHAR_T
+typedef int wchar_t;
+#endif
+
+typedef signed char        int8_t;
+typedef short              int16_t;
+typedef int                int32_t;
+typedef long               int64_t;
+typedef unsigned char      uint8_t;
+typedef unsigned short     uint16_t;
+typedef unsigned int       uint32_t;
+typedef unsigned long      uint64_t;
+
+typedef signed char        int_least8_t;
+typedef short              int_least16_t;
+typedef int                int_least32_t;
+typedef long               int_least64_t;
+typedef unsigned char      uint_least8_t;
+typedef unsigned short     uint_least16_t;
+typedef unsigned int       uint_least32_t;
+typedef unsigned long      uint_least64_t;
+
+typedef signed char        int_fast8_t;
+#if defined(__RUBYCC_LIBC_MUSL__)
+typedef int                int_fast16_t;
+typedef int                int_fast32_t;
+#else
+typedef long               int_fast16_t;
+typedef long               int_fast32_t;
+#endif
+typedef long               int_fast64_t;
+typedef unsigned char      uint_fast8_t;
+#if defined(__RUBYCC_LIBC_MUSL__)
+typedef unsigned int       uint_fast16_t;
+typedef unsigned int       uint_fast32_t;
+#else
+typedef unsigned long      uint_fast16_t;
+typedef unsigned long      uint_fast32_t;
+#endif
+typedef unsigned long      uint_fast64_t;
+
+#ifndef _RUBYCC_INTPTR_T
+#define _RUBYCC_INTPTR_T
+typedef long               intptr_t;
+#endif
+#ifndef _RUBYCC_UINTPTR_T
+#define _RUBYCC_UINTPTR_T
+typedef unsigned long      uintptr_t;
+#endif
+typedef long               intmax_t;
+typedef unsigned long      uintmax_t;
+
+/* Exact-width limits. */
+#define INT8_MIN    (-128)
+#define INT16_MIN   (-32768)
+#define INT32_MIN   (-2147483647-1)
+#define INT64_MIN   (-9223372036854775807L-1)
+#define INT8_MAX    (127)
+#define INT16_MAX   (32767)
+#define INT32_MAX   (2147483647)
+#define INT64_MAX   (9223372036854775807L)
+#define UINT8_MAX   (255)
+#define UINT16_MAX  (65535)
+#define UINT32_MAX  (4294967295U)
+#define UINT64_MAX  (18446744073709551615UL)
+
+/* Least-width limits (same representation as the exact widths here). */
+#define INT_LEAST8_MIN    INT8_MIN
+#define INT_LEAST16_MIN   INT16_MIN
+#define INT_LEAST32_MIN   INT32_MIN
+#define INT_LEAST64_MIN   INT64_MIN
+#define INT_LEAST8_MAX    INT8_MAX
+#define INT_LEAST16_MAX   INT16_MAX
+#define INT_LEAST32_MAX   INT32_MAX
+#define INT_LEAST64_MAX   INT64_MAX
+#define UINT_LEAST8_MAX   UINT8_MAX
+#define UINT_LEAST16_MAX  UINT16_MAX
+#define UINT_LEAST32_MAX  UINT32_MAX
+#define UINT_LEAST64_MAX  UINT64_MAX
+
+/* Fast-width limits (fast8 is 8-bit; fast64 is 64-bit on both libcs). The
+   fast16/fast32 group is the range of the type selected above: 32-bit on
+   musl, so INT_FAST16_MAX/INT_FAST32_MAX are 2147483647 there against
+   glibc's 9223372036854775807 (both measured with the ABI harness, glibc's
+   on this host and musl's on the CI aarch64 musl run, docs/STEPS.md
+   Step 202). The MIN and unsigned MAX macros are spelled through the same
+   exact-width names, so they follow the width rather than being asserted
+   separately. */
+#define INT_FAST8_MIN     INT8_MIN
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define INT_FAST16_MIN    INT32_MIN
+#define INT_FAST32_MIN    INT32_MIN
+#else
+#define INT_FAST16_MIN    INT64_MIN
+#define INT_FAST32_MIN    INT64_MIN
+#endif
+#define INT_FAST64_MIN    INT64_MIN
+#define INT_FAST8_MAX     INT8_MAX
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define INT_FAST16_MAX    INT32_MAX
+#define INT_FAST32_MAX    INT32_MAX
+#else
+#define INT_FAST16_MAX    INT64_MAX
+#define INT_FAST32_MAX    INT64_MAX
+#endif
+#define INT_FAST64_MAX    INT64_MAX
+#define UINT_FAST8_MAX    UINT8_MAX
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define UINT_FAST16_MAX   UINT32_MAX
+#define UINT_FAST32_MAX   UINT32_MAX
+#else
+#define UINT_FAST16_MAX   UINT64_MAX
+#define UINT_FAST32_MAX   UINT64_MAX
+#endif
+#define UINT_FAST64_MAX   UINT64_MAX
+
+/* Pointer-holding, greatest-width, and the stddef/wchar companions. */
+#define INTPTR_MIN        INT64_MIN
+#define INTPTR_MAX        INT64_MAX
+#define UINTPTR_MAX       UINT64_MAX
+#define INTMAX_MIN        INT64_MIN
+#define INTMAX_MAX        INT64_MAX
+#define UINTMAX_MAX       UINT64_MAX
+#define PTRDIFF_MIN       INT64_MIN
+#define PTRDIFF_MAX       INT64_MAX
+#define SIZE_MAX          UINT64_MAX
+#define SIG_ATOMIC_MIN    INT32_MIN
+#define SIG_ATOMIC_MAX    INT32_MAX
+#define WCHAR_MIN         0
+#define WCHAR_MAX         UINT32_MAX
+#define WINT_MIN          (0U)
+#define WINT_MAX          (4294967295U)
+
+/* Constant-expression suffix macros. */
+#define INT8_C(c)     c
+#define INT16_C(c)    c
+#define INT32_C(c)    c
+#define INT64_C(c)    c ## L
+#define UINT8_C(c)    c
+#define UINT16_C(c)   c
+#define UINT32_C(c)   c ## U
+#define UINT64_C(c)   c ## UL
+#define INTMAX_C(c)   c ## L
+#define UINTMAX_C(c)  c ## UL
+
+#endif /* _RUBYCC_STDINT_H */

data/include/libc/glibc/aarch64/sys/epoll.h

@@ -0,0 +1,88 @@
+/* rubycc bundled <sys/epoll.h> (aarch64): the Linux epoll(7) event-notification
+   interface. Provenance: clean room against the Linux kernel UAPI
+   (linux/eventpoll.h) and the glibc call surface, not derived from musl or
+   glibc source. The EPOLL_CTL_ / EPOLL / EPOLL_CLOEXEC values and struct
+   epoll_event's layout are that ABI reproduced as measured integer constants
+   and measured field offsets (an ABI fact, not copied text -- see
+   docs/HEADER-LICENSING.md sec. 4), the same treatment as poll.h and
+   sys/socket.h.
+
+   Arch layer, unlike poll.h: this file differs from its x86-64 sibling in
+   exactly one place, struct epoll_event's packing. The kernel fixed the
+   x86-64 epoll_event at 12 bytes so a 32-bit and a 64-bit process see the
+   same array stride, which forces the 8-byte-aligned epoll_data_t to offset
+   4; aarch64 has no 32-bit compat concern of that shape, so the struct is
+   laid out naturally. Measured with the cross gcc oracle under qemu:
+
+     x86-64 : sizeof 12, _Alignof 1, events @ 0, data @ 4   (packed)
+     aarch64: sizeof 16, _Alignof 8, events @ 0, data @ 8   (not packed)
+
+   Every macro value below measured identical to the x86-64 copy's.
+
+   epoll_create/epoll_create1/epoll_ctl/epoll_wait are Linux/glibc
+   declarations whose bodies resolve from the host libc at link time.
+
+   Not included: epoll_pwait/epoll_pwait2 (their sigset_t / struct timespec
+   parameters would mean cross-including <signal.h> and <time.h>, and no
+   corpus census hit needs them -- nio4r and unicorn, the two gems that put
+   this header on the list, reach epoll_create/epoll_ctl/epoll_wait only). */
+
+#ifndef _RUBYCC_SYS_EPOLL_H
+#define _RUBYCC_SYS_EPOLL_H
+
+#include <stdint.h>
+
+/* epoll_ctl operations (measured, both arches). */
+#define EPOLL_CTL_ADD 1
+#define EPOLL_CTL_DEL 2
+#define EPOLL_CTL_MOD 3
+
+/* epoll_create1 flag; shares O_CLOEXEC's bit (measured, both arches). */
+#define EPOLL_CLOEXEC 0x80000
+
+/* Event bits. The first six are the poll(2) values epoll reuses; the top four
+   are epoll's own behaviour switches (measured, both arches). EPOLLET does not
+   fit a signed int, so it is spelled as the unsigned hex value the oracle
+   printed. */
+#define EPOLLIN         0x001
+#define EPOLLPRI        0x002
+#define EPOLLOUT        0x004
+#define EPOLLERR        0x008
+#define EPOLLHUP        0x010
+#define EPOLLRDNORM     0x040
+#define EPOLLRDBAND     0x080
+#define EPOLLWRNORM     0x100
+#define EPOLLWRBAND     0x200
+#define EPOLLMSG        0x400
+#define EPOLLRDHUP      0x2000
+#define EPOLLEXCLUSIVE  0x10000000
+#define EPOLLWAKEUP     0x20000000
+#define EPOLLONESHOT    0x40000000
+#define EPOLLET         0x80000000
+
+/* The caller-owned cookie epoll hands back with each ready event: 8 bytes,
+   8-byte aligned (measured, both arches), all four arms at offset 0. */
+union epoll_data {
+  void    *ptr;
+  int      fd;
+  uint32_t u32;
+  uint64_t u64;
+};
+
+typedef union epoll_data epoll_data_t;
+
+/* struct epoll_event: 16 bytes, 8-byte aligned on aarch64 (measured) -- no
+   packed attribute here, so `data` takes its natural offset 8 and the struct
+   its natural size, which is where this file parts from the x86-64 copy. */
+struct epoll_event {
+  uint32_t     events; /* offset 0: an EPOLL* bit set */
+  epoll_data_t data;   /* offset 8 */
+};
+
+int epoll_create(int __size);
+int epoll_create1(int __flags);
+int epoll_ctl(int __epfd, int __op, int __fd, struct epoll_event *__event);
+int epoll_wait(int __epfd, struct epoll_event *__events, int __maxevents,
+               int __timeout);
+
+#endif /* _RUBYCC_SYS_EPOLL_H */

data/include/libc/glibc/aarch64/sys/fcntl.h

@@ -0,0 +1,19 @@
+/* rubycc bundled <sys/fcntl.h>: the traditional compatibility alias for
+   <fcntl.h>. Provenance: clean room -- glibc's own <sys/fcntl.h> is a one-line
+   shim (`#include <fcntl.h>`, confirmed by inspecting the host's copy at
+   /usr/aarch64-linux-gnu/include/sys/fcntl.h and its x86-64 counterpart,
+   which agree byte for byte); nothing else is emitted so there is no ABI
+   surface to measure beyond fcntl.h's own (already covered by that header's
+   Spec). Placed alongside fcntl.h in the glibc/aarch64 layer (the same
+   directory choice fcntl.h itself made, because O_DIRECT/O_DIRECTORY/
+   O_NOFOLLOW here swap bit assignments against x86-64) purely for
+   directory-structure symmetry with sys/select.h, sys/stat.h, sys/time.h and
+   sys/types.h, which already live one per arch even where -- like this file
+   -- their content does not differ (Step 124, M5 H2). */
+
+#ifndef _RUBYCC_SYS_FCNTL_H
+#define _RUBYCC_SYS_FCNTL_H
+
+#include <fcntl.h>
+
+#endif /* _RUBYCC_SYS_FCNTL_H */

data/include/libc/glibc/aarch64/sys/select.h

@@ -0,0 +1,75 @@
+/* rubycc bundled <sys/select.h>: fd_set and select()/pselect() (POSIX). Derived
+   from musl's <sys/select.h> shape; fd_set is pinned to the glibc x86-64 ABI --
+   __FD_SETSIZE is 1024 and __fd_mask is `long`, giving a 128-byte set (measured).
+   The typedef guards reuse glibc's (__sigset_t_defined) so a host <signal.h> on
+   the path does not redefine sigset_t. ABI switch layer: FD_SETSIZE and the mask
+   width are arch specific. */
+
+#ifndef _RUBYCC_SYS_SELECT_H
+#define _RUBYCC_SYS_SELECT_H
+
+#ifndef _RUBYCC_TIME_T
+#define _RUBYCC_TIME_T
+typedef long time_t;
+#endif
+#ifndef _RUBYCC_SUSECONDS_T
+#define _RUBYCC_SUSECONDS_T
+typedef long suseconds_t;
+#endif
+
+#ifndef __timeval_defined
+#define __timeval_defined 1
+struct timeval {
+  time_t      tv_sec;
+  suseconds_t tv_usec;
+};
+#endif
+#ifndef _STRUCT_TIMESPEC
+#define _STRUCT_TIMESPEC 1
+struct timespec {
+  time_t tv_sec;
+  long   tv_nsec;
+};
+#endif
+
+#ifndef __sigset_t_defined
+#define __sigset_t_defined 1
+typedef struct { unsigned long __val[1024 / (8 * sizeof(unsigned long))]; } __sigset_t;
+typedef __sigset_t sigset_t;
+#endif
+
+#define __FD_SETSIZE 1024
+typedef long __fd_mask;
+#define __NFDBITS (8 * (int) sizeof(__fd_mask))
+
+typedef struct {
+  __fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS];
+} fd_set;
+
+typedef __fd_mask fd_mask;
+
+#define FD_SETSIZE __FD_SETSIZE
+
+#define __FD_ELT(d)  ((d) / __NFDBITS)
+#define __FD_MASK(d) ((__fd_mask) (1UL << ((d) % __NFDBITS)))
+
+#define FD_ZERO(set) \
+  do { \
+    unsigned long __i; \
+    fd_set *__s = (set); \
+    for (__i = 0; __i < sizeof(fd_set) / sizeof(__fd_mask); ++__i) \
+      __s->__fds_bits[__i] = 0; \
+  } while (0)
+#define FD_SET(d, set)   ((set)->__fds_bits[__FD_ELT(d)] |= __FD_MASK(d))
+#define FD_CLR(d, set)   ((set)->__fds_bits[__FD_ELT(d)] &= ~__FD_MASK(d))
+#define FD_ISSET(d, set) (((set)->__fds_bits[__FD_ELT(d)] & __FD_MASK(d)) != 0)
+
+int select(int __nfds, fd_set *__restrict __readfds,
+           fd_set *__restrict __writefds, fd_set *__restrict __exceptfds,
+           struct timeval *__restrict __timeout);
+int pselect(int __nfds, fd_set *__restrict __readfds,
+            fd_set *__restrict __writefds, fd_set *__restrict __exceptfds,
+            const struct timespec *__restrict __timeout,
+            const sigset_t *__restrict __sigmask);
+
+#endif /* _RUBYCC_SYS_SELECT_H */