rubycc 1.0.0

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

@@ -0,0 +1,111 @@
+/* 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/x86-64 layer because the opaque sizes are arch dependent:
+   pthread_mutex_t, pthread_attr_t, pthread_mutexattr_t and pthread_condattr_t
+   are wider on aarch64, so a companion glibc/aarch64/pthread.h differs from this
+   file only in those four __size[N] counts (and this provenance line). */
+
+#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. */
+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;
+/* pthread_rwlockattr_t is the one object the two C libraries lay out
+   differently here: 8 bytes on both, but 4-byte aligned on musl against
+   glibc's 8 (both sizeof/_Alignof pairs measured with the ABI harness, glibc's
+   on this host and musl's on the CI musl run, docs/STEPS.md Step 193), so the
+   aligning scalar of the opaque union is the narrower one there. Every other
+   pthreads object above measured identical on the two libraries. */
+#if defined(__RUBYCC_LIBC_MUSL__)
+typedef union { char __size[8];  int  __align; } pthread_rwlockattr_t;
+#else
+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/x86_64/setjmp.h

@@ -0,0 +1,82 @@
+/* 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/x86-64 layer because the opaque size is arch dependent:
+   jmp_buf holds one register set per architecture, so it is a different width
+   on aarch64 -- a companion glibc/aarch64/setjmp.h differs from this file only
+   in the __size[N] count (and this provenance line).
+   Measured: sizeof(jmp_buf) == sizeof(sigjmp_buf) == 200, _Alignof == 8, on
+   x86-64 glibc (a small probe printing sizeof/_Alignof, built and run with the
+   host gcc; see test/test_header_abi.rb's SETJMP case for the same values
+   checked against the gcc oracle).
+   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 on aarch64 (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 (200 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[200]; 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/x86_64/stdint.h

@@ -0,0 +1,163 @@
+/* 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 x86-64 LP64 ABI
+   (measured): intmax_t/intptr_t are `long`, and the fast types are 64-bit on
+   glibc but 32-bit on musl -- the one place in this header where the two C
+   libraries differ, carried below under __RUBYCC_LIBC_MUSL__ (see the
+   preprocessor's LIBCS). 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;
+
+/* The fast types are where the two C libraries part company: [u]int_fast16_t
+   and [u]int_fast32_t are 4 bytes, 4-byte aligned on musl and 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 musl run, docs/STEPS.md Step 193).
+   The fast8 and fast64 types agree on both. The limit macros further down
+   follow these widths rather than restating them. */
+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 musl run, docs/STEPS.md Step 193). 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         INT32_MIN
+#define WCHAR_MAX         INT32_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/x86_64/sys/epoll.h

@@ -0,0 +1,91 @@
+/* rubycc bundled <sys/epoll.h> (x86-64): 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: struct epoll_event's layout is the one place in
+   this header that differs between the two targets, and it differs by design.
+   The kernel fixed the x86-64 epoll_event at 12 bytes so that a 32-bit and a
+   64-bit process see the same array stride, which means the 8-byte-aligned
+   epoll_data_t union has to sit at offset 4 -- i.e. the struct is packed.
+   Measured with the glibc oracle:
+
+     x86-64 : sizeof 12, _Alignof 1, events @ 0, data @ 4   (packed)
+     aarch64: sizeof 16, _Alignof 8, events @ 0, data @ 8   (not packed)
+
+   so this header is in the arch layer (like fcntl.h, pthread.h, setjmp.h and
+   sys/stat.h) with an aarch64 sibling, rather than in the common layer with a
+   preprocessor branch. Every macro value, by contrast, measured identical on
+   both targets and is repeated verbatim in the aarch64 copy.
+
+   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: 12 bytes, 1-byte aligned on x86-64 (measured) -- the
+   packed attribute is what pulls `data` back to offset 4 and drops the
+   trailing padding, reproducing the kernel's deliberate 12-byte stride. */
+struct epoll_event {
+  uint32_t     events; /* offset 0: an EPOLL* bit set */
+  epoll_data_t data;   /* offset 4 (packed) */
+} __attribute__((packed));
+
+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/x86_64/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/include/x86_64-linux-gnu/sys/fcntl.h and its aarch64 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/x86-64 layer (the same
+   directory choice fcntl.h itself made, because O_DIRECT/O_DIRECTORY/
+   O_NOFOLLOW there swap bit assignments against aarch64) 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/x86_64/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 */

data/include/libc/glibc/x86_64/sys/stat.h

@@ -0,0 +1,130 @@
+/* rubycc bundled <sys/stat.h>: struct stat and the file-mode macros (POSIX).
+   Provenance: clean room against the Linux x86-64 kernel ABI, not derived from
+   musl. struct stat is pinned to that ABI: the field order, the __pad0 slot
+   before st_rdev, the nanosecond timespec fields and the trailing reserved
+   longs give the measured 144-byte layout. Both the layout and the S_IF* octal
+   values are ABI facts reproduced by measurement, not copied text (see
+   docs/HEADER-LICENSING.md). Placed in the glibc/x86-64 layer because they are
+   kernel-ABI specific. */
+
+#ifndef _RUBYCC_SYS_STAT_H
+#define _RUBYCC_SYS_STAT_H
+
+#ifndef _RUBYCC_DEV_T
+#define _RUBYCC_DEV_T
+typedef unsigned long dev_t;
+#endif
+#ifndef _RUBYCC_INO_T
+#define _RUBYCC_INO_T
+typedef unsigned long ino_t;
+#endif
+#ifndef _RUBYCC_NLINK_T
+#define _RUBYCC_NLINK_T
+typedef unsigned long nlink_t;
+#endif
+#ifndef _RUBYCC_MODE_T
+#define _RUBYCC_MODE_T
+typedef unsigned int mode_t;
+#endif
+#ifndef _RUBYCC_UID_T
+#define _RUBYCC_UID_T
+typedef unsigned int uid_t;
+#endif
+#ifndef _RUBYCC_GID_T
+#define _RUBYCC_GID_T
+typedef unsigned int gid_t;
+#endif
+#ifndef _RUBYCC_OFF_T
+#define _RUBYCC_OFF_T
+typedef long off_t;
+#endif
+#ifndef _RUBYCC_TIME_T
+#define _RUBYCC_TIME_T
+typedef long time_t;
+#endif
+#ifndef _RUBYCC_BLKSIZE_T
+#define _RUBYCC_BLKSIZE_T
+typedef long blksize_t;
+#endif
+#ifndef _RUBYCC_BLKCNT_T
+#define _RUBYCC_BLKCNT_T
+typedef long blkcnt_t;
+#endif
+#ifndef _STRUCT_TIMESPEC
+#define _STRUCT_TIMESPEC 1
+struct timespec {
+  time_t tv_sec;
+  long   tv_nsec;
+};
+#endif
+
+struct stat {
+  dev_t   st_dev;
+  ino_t   st_ino;
+  nlink_t st_nlink;
+  mode_t  st_mode;
+  uid_t   st_uid;
+  gid_t   st_gid;
+  int     __pad0;
+  dev_t   st_rdev;
+  off_t   st_size;
+  blksize_t st_blksize;
+  blkcnt_t  st_blocks;
+  struct timespec st_atim;
+  struct timespec st_mtim;
+  struct timespec st_ctim;
+  long __glibc_reserved[3];
+};
+
+/* POSIX.1-2008 second-resolution aliases onto the timespec fields. */
+#define st_atime st_atim.tv_sec
+#define st_mtime st_mtim.tv_sec
+#define st_ctime st_ctim.tv_sec
+
+/* File type bits (octal, kernel ABI). */
+#define S_IFMT   0170000
+#define S_IFDIR  0040000
+#define S_IFCHR  0020000
+#define S_IFBLK  0060000
+#define S_IFREG  0100000
+#define S_IFIFO  0010000
+#define S_IFLNK  0120000
+#define S_IFSOCK 0140000
+
+#define S_ISTYPE(mode, mask) (((mode) & S_IFMT) == (mask))
+#define S_ISDIR(mode)  S_ISTYPE((mode), S_IFDIR)
+#define S_ISCHR(mode)  S_ISTYPE((mode), S_IFCHR)
+#define S_ISBLK(mode)  S_ISTYPE((mode), S_IFBLK)
+#define S_ISREG(mode)  S_ISTYPE((mode), S_IFREG)
+#define S_ISFIFO(mode) S_ISTYPE((mode), S_IFIFO)
+#define S_ISLNK(mode)  S_ISTYPE((mode), S_IFLNK)
+#define S_ISSOCK(mode) S_ISTYPE((mode), S_IFSOCK)
+
+/* Permission bits. */
+#define S_ISUID 04000
+#define S_ISGID 02000
+#define S_ISVTX 01000
+#define S_IRUSR 0400
+#define S_IWUSR 0200
+#define S_IXUSR 0100
+#define S_IRWXU (S_IRUSR | S_IWUSR | S_IXUSR)
+#define S_IRGRP (S_IRUSR >> 3)
+#define S_IWGRP (S_IWUSR >> 3)
+#define S_IXGRP (S_IXUSR >> 3)
+#define S_IRWXG (S_IRWXU >> 3)
+#define S_IROTH (S_IRGRP >> 3)
+#define S_IWOTH (S_IWGRP >> 3)
+#define S_IXOTH (S_IXGRP >> 3)
+#define S_IRWXO (S_IRWXG >> 3)
+
+int stat(const char *__restrict __file, struct stat *__restrict __buf);
+int fstat(int __fd, struct stat *__buf);
+int lstat(const char *__restrict __file, struct stat *__restrict __buf);
+int fstatat(int __fd, const char *__restrict __file, struct stat *__restrict __buf, int __flag);
+int chmod(const char *__file, mode_t __mode);
+int fchmod(int __fd, mode_t __mode);
+int mkdir(const char *__path, mode_t __mode);
+int mkfifo(const char *__path, mode_t __mode);
+mode_t umask(mode_t __mask);
+
+#endif /* _RUBYCC_SYS_STAT_H */