rubycc 1.0.0

data/include/libc/locale.h

@@ -0,0 +1,83 @@
+/* rubycc bundled <locale.h>: localization (ISO C11 7.11). Provenance: clean
+   room against the POSIX/C11 public interface -- struct lconv's member names,
+   types and order are the standard's own public contract (C11 7.11.1.1 fixes
+   the sequence "the following members ... in the order shown"), not glibc
+   implementation detail, so reproducing them is not a glibc derivation. Unlike
+   the opaque-blob types elsewhere in this tree (pthread_t, jmp_buf), every
+   member of struct lconv is used directly by callers, so it cannot be an
+   opaque byte blob; instead its size and every member's offset were measured
+   and confirmed against the glibc oracle (see test/test_header_abi.rb's LOCALE
+   case). The LC_* category numbers are glibc runtime ABI (setlocale is
+   answered by the host libc, so the numbers must match the host's own
+   enumeration, the same reasoning as unistd.h's _SC_* constants) and were
+   measured rather than invented. setlocale/localeconv are POSIX/ISO C
+   declarations whose bodies resolve from the host libc at link time.
+   Common layer: measured on both x86-64 and aarch64 glibc (both LP64), and
+   struct lconv's size (96) and every member offset agreed exactly across the
+   two arches (an all-pointer-and-char struct has no arch-dependent field
+   widths on either LP64 target), so this header is arch-neutral, unlike
+   pthread.h/setjmp.h/sys/stat.h.
+   Not included: glibc's locale_t / newlocale / uselocale / freelocale /
+   duplocale extensions. No corpus sample census hit needs them, so they are
+   left out to keep the surface to what is actually used (bigdecimal's use of
+   struct lconv via localeconv). */
+
+#ifndef _RUBYCC_LOCALE_H
+#define _RUBYCC_LOCALE_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+/* setlocale's category argument. Measured against glibc (matches the host's
+   own __LC_* enumeration, since setlocale resolves from the host libc). */
+#define LC_CTYPE          0
+#define LC_NUMERIC        1
+#define LC_TIME           2
+#define LC_COLLATE        3
+#define LC_MONETARY       4
+#define LC_MESSAGES       5
+#define LC_ALL            6
+#define LC_PAPER          7
+#define LC_NAME           8
+#define LC_ADDRESS        9
+#define LC_TELEPHONE      10
+#define LC_MEASUREMENT    11
+#define LC_IDENTIFICATION 12
+
+/* The numeric/monetary formatting conventions localeconv() reports. Member
+   names, types and order are the C11 7.11.1.1 public contract; every offset
+   below was measured against the glibc oracle on both x86-64 and aarch64 and
+   the two agreed byte for byte. */
+struct lconv {
+  char *decimal_point;
+  char *thousands_sep;
+  char *grouping;
+
+  char *int_curr_symbol;
+  char *currency_symbol;
+  char *mon_decimal_point;
+  char *mon_thousands_sep;
+  char *mon_grouping;
+  char *positive_sign;
+  char *negative_sign;
+  char int_frac_digits;
+  char frac_digits;
+  char p_cs_precedes;
+  char p_sep_by_space;
+  char n_cs_precedes;
+  char n_sep_by_space;
+  char p_sign_posn;
+  char n_sign_posn;
+  char int_p_cs_precedes;
+  char int_p_sep_by_space;
+  char int_n_cs_precedes;
+  char int_n_sep_by_space;
+  char int_p_sign_posn;
+  char int_n_sign_posn;
+};
+
+char *setlocale(int __category, const char *__locale);
+struct lconv *localeconv(void);
+
+#endif /* _RUBYCC_LOCALE_H */

data/include/libc/math.h

@@ -0,0 +1,191 @@
+/* rubycc bundled <math.h>: the floating-point declarations and classification
+   macros (ISO C 7.12). Derived from musl's <math.h> declaration set; the special
+   values and classifiers are expressed through the compiler builtins so they
+   fold to the same bit patterns gcc uses, and the FP_* / math_errhandling values
+   are measured (math_errhandling is the one the two C libraries differ on, so
+   both values are carried under __RUBYCC_LIBC_MUSL__; see the preprocessor's
+   LIBCS). Common layer: nothing here is arch specific beyond the (universal on
+   the hosted targets' IEEE 754 model; the two target libc ABIs select their
+   distinct FP_ILOGB* values below. */
+
+#ifndef _RUBYCC_MATH_H
+#define _RUBYCC_MATH_H
+
+/* Special magnitudes. rubycc does not implement gcc's __builtin_huge_val/inf/nan
+   family, so these use the classic overflow-literal and 0/0 spellings, which
+   both toolchains fold to the same IEEE 754 infinity / quiet-NaN bit patterns
+   (verified against gcc). */
+#define HUGE_VAL   (1e10000)
+#define HUGE_VALF  (1e10000f)
+#define HUGE_VALL  (1e10000L)
+#define INFINITY   (1e10000f)
+#define NAN        (0.0f / 0.0f)
+
+/* Classification result codes (glibc values). */
+#define FP_NAN       0
+#define FP_INFINITE  1
+#define FP_ZERO      2
+#define FP_SUBNORMAL 3
+#define FP_NORMAL    4
+
+/* glibc's AArch64 math ABI uses -2147483647 for FP_ILOGB0 and INT_MAX for
+   FP_ILOGBNAN; glibc's x86-64 uses INT_MIN for both. These are header ABI
+   values, not compiler implementation details, so select them from the target
+   macro just as float.h and the arch libc headers do.
+
+   musl uses INT_MIN for both on *every* machine, so the C library has to be
+   part of the selection and not only the architecture. Branching on the machine
+   alone was wrong exactly where the two disagree -- AArch64 musl, where this
+   header claimed glibc's pair (measured against Alpine's own gcc on an arm64
+   container, 2026-08-12, the first time the suite ran there). x86-64 musl agreed
+   with glibc by coincidence, which is why the x86-64 musl runs never caught
+   it. */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define FP_ILOGB0   (-2147483647-1)
+#define FP_ILOGBNAN (-2147483647-1)
+#elif defined(__aarch64__)
+#define FP_ILOGB0   (-2147483647)
+#define FP_ILOGBNAN (2147483647)
+#else
+#define FP_ILOGB0   (-2147483647-1)
+#define FP_ILOGBNAN (-2147483647-1)
+#endif
+
+#define MATH_ERRNO     1
+#define MATH_ERREXCEPT 2
+/* math_errhandling is the one value in this header the two C libraries
+   disagree on: musl reports 2 (it raises the floating-point exceptions but
+   does not promise errno) where glibc reports 3 (both). Measured with the ABI
+   harness, glibc's on this host and musl's on the CI musl run (docs/STEPS.md
+   Step 193); MATH_ERRNO, MATH_ERREXCEPT, the FP_* codes and FP_ILOGB* are
+   probed too; the FP_ILOGB* values are target-specific as documented above. */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define math_errhandling (MATH_ERREXCEPT)
+#else
+#define math_errhandling (MATH_ERRNO | MATH_ERREXCEPT)
+#endif
+
+/* Classifiers, implemented in C (rubycc has no __builtin_isnan/signbit/...).
+   The bit-inspecting helpers cover the double-or-narrower case; long double is
+   an 8-byte double on this target, so the double helper handles it too. */
+static inline int __rubycc_signbit(double __x) {
+  union { double __d; unsigned long __u; } __v; __v.__d = __x;
+  return (int) (__v.__u >> 63);
+}
+static inline int __rubycc_fpclassify(double __x) {
+  union { double __d; unsigned long __u; } __v; __v.__d = __x;
+  unsigned long __exp  = (__v.__u >> 52) & 0x7ffUL;
+  unsigned long __mant = __v.__u & 0xfffffffffffffUL;
+  if (__exp == 0)      return __mant == 0 ? FP_ZERO : FP_SUBNORMAL;
+  if (__exp == 0x7ffUL) return __mant == 0 ? FP_INFINITE : FP_NAN;
+  return FP_NORMAL;
+}
+
+#define fpclassify(x) __rubycc_fpclassify((double)(x))
+#define isnan(x)      ((x) != (x))
+#define isinf(x)      (!isnan((double)(x)) && ((x) == HUGE_VAL || (x) == -HUGE_VAL))
+#define isfinite(x)   (((x) - (x)) == 0)
+#define isnormal(x)   (fpclassify(x) == FP_NORMAL)
+#define signbit(x)    __rubycc_signbit((double)(x))
+#define isgreater(x, y)      ((x) > (y))
+#define isgreaterequal(x, y) ((x) >= (y))
+#define isless(x, y)         ((x) < (y))
+#define islessequal(x, y)    ((x) <= (y))
+#define islessgreater(x, y)  ((x) < (y) || (x) > (y))
+#define isunordered(x, y)    (isnan(x) || isnan(y))
+
+/* Common mathematical constants (glibc, under _DEFAULT_SOURCE). */
+#define M_E        2.7182818284590452354
+#define M_LOG2E    1.4426950408889634074
+#define M_LOG10E   0.43429448190325182765
+#define M_LN2      0.69314718055994530942
+#define M_LN10     2.30258509299404568402
+#define M_PI       3.14159265358979323846
+#define M_PI_2     1.57079632679489661923
+#define M_PI_4     0.78539816339744830962
+#define M_1_PI     0.31830988618379067154
+#define M_2_PI     0.63661977236758134308
+#define M_2_SQRTPI 1.12837916709551257390
+#define M_SQRT2    1.41421356237309504880
+#define M_SQRT1_2  0.70710678118654752440
+
+typedef float  float_t;
+typedef double double_t;
+
+/* Double, float and long-double declarations for the standard functions. */
+#define __RUBYCC_MATHDECL(name) \
+  double name(double); float name##f(float); long double name##l(long double);
+#define __RUBYCC_MATHDECL2(name) \
+  double name(double, double); float name##f(float, float); \
+  long double name##l(long double, long double);
+
+__RUBYCC_MATHDECL(acos)
+__RUBYCC_MATHDECL(asin)
+__RUBYCC_MATHDECL(atan)
+__RUBYCC_MATHDECL2(atan2)
+__RUBYCC_MATHDECL(cos)
+__RUBYCC_MATHDECL(sin)
+__RUBYCC_MATHDECL(tan)
+__RUBYCC_MATHDECL(cosh)
+__RUBYCC_MATHDECL(sinh)
+__RUBYCC_MATHDECL(tanh)
+__RUBYCC_MATHDECL(acosh)
+__RUBYCC_MATHDECL(asinh)
+__RUBYCC_MATHDECL(atanh)
+__RUBYCC_MATHDECL(exp)
+__RUBYCC_MATHDECL(exp2)
+__RUBYCC_MATHDECL(expm1)
+__RUBYCC_MATHDECL(log)
+__RUBYCC_MATHDECL(log10)
+__RUBYCC_MATHDECL(log1p)
+__RUBYCC_MATHDECL(log2)
+__RUBYCC_MATHDECL(logb)
+__RUBYCC_MATHDECL(cbrt)
+__RUBYCC_MATHDECL(sqrt)
+__RUBYCC_MATHDECL2(pow)
+__RUBYCC_MATHDECL2(hypot)
+__RUBYCC_MATHDECL(ceil)
+__RUBYCC_MATHDECL(fabs)
+__RUBYCC_MATHDECL(floor)
+__RUBYCC_MATHDECL2(fmod)
+__RUBYCC_MATHDECL(round)
+__RUBYCC_MATHDECL(trunc)
+__RUBYCC_MATHDECL(rint)
+__RUBYCC_MATHDECL(nearbyint)
+__RUBYCC_MATHDECL2(remainder)
+__RUBYCC_MATHDECL2(copysign)
+__RUBYCC_MATHDECL2(nextafter)
+__RUBYCC_MATHDECL2(fdim)
+__RUBYCC_MATHDECL2(fmax)
+__RUBYCC_MATHDECL2(fmin)
+__RUBYCC_MATHDECL(tgamma)
+__RUBYCC_MATHDECL(lgamma)
+__RUBYCC_MATHDECL(erf)
+__RUBYCC_MATHDECL(erfc)
+
+double frexp(double, int *);
+float  frexpf(float, int *);
+long double frexpl(long double, int *);
+double ldexp(double, int);
+float  ldexpf(float, int);
+long double ldexpl(long double, int);
+double modf(double, double *);
+float  modff(float, float *);
+long double modfl(long double, long double *);
+double scalbn(double, int);
+float  scalbnf(float, int);
+long double scalbnl(long double, int);
+double scalbln(double, long);
+double fma(double, double, double);
+float  fmaf(float, float, float);
+long double fmal(long double, long double, long double);
+double nan(const char *);
+float  nanf(const char *);
+long double nanl(const char *);
+int    ilogb(double);
+long   lround(double);
+long long llround(double);
+long   lrint(double);
+long long llrint(double);
+
+#endif /* _RUBYCC_MATH_H */

data/include/libc/netinet/in.h

@@ -0,0 +1,126 @@
+/* rubycc bundled <netinet/in.h>: the IPv4/IPv6 address types, the
+   sockaddr_in / sockaddr_in6 structs, the IPPROTO_* protocol numbers and the
+   INADDR_* well-known addresses. Provenance: clean room against the Linux
+   kernel UAPI (linux/in.h, linux/in6.h) and the glibc socket ABI, not derived
+   from musl -- the same treatment as sys/socket.h (see docs/HEADER-LICENSING.md).
+   The struct layouts and the IPPROTO_/INADDR_ integer values below are that ABI
+   reproduced as measured field offsets and measured integer constants, an ABI
+   fact rather than copied text. Common layer: every struct layout (sockaddr_in,
+   sockaddr_in6, in6_addr all included) and every macro value is identical on
+   x86-64 and aarch64.
+
+   Shares its address-type definitions with <arpa/inet.h> (in_addr_t, in_port_t,
+   struct in_addr, socklen_t) and its address-family type with <sys/socket.h>
+   (sa_family_t): each is guarded so whichever header is #included first wins
+   and the other's guard short-circuits, so #including both in either order
+   never redefines anything. htons/htonl/ntohs/ntohl are declared again here
+   with the identical signature <arpa/inet.h> uses -- a repeated declaration of
+   the same C function is legal and the two headers commonly get both
+   #included by real code (this file needs them for the sockaddr_in field
+   assignments a socket client/server writes). */
+
+#ifndef _RUBYCC_NETINET_IN_H
+#define _RUBYCC_NETINET_IN_H
+
+#include <stdint.h>
+
+#ifndef _RUBYCC_SOCKLEN_T
+#define _RUBYCC_SOCKLEN_T
+typedef unsigned int socklen_t;
+#endif
+
+#ifndef _RUBYCC_IN_ADDR_T
+#define _RUBYCC_IN_ADDR_T
+typedef uint32_t in_addr_t;
+#endif
+
+#ifndef _RUBYCC_IN_PORT_T
+#define _RUBYCC_IN_PORT_T
+typedef uint16_t in_port_t;
+#endif
+
+#ifndef _RUBYCC_STRUCT_IN_ADDR
+#define _RUBYCC_STRUCT_IN_ADDR
+struct in_addr { in_addr_t s_addr; };
+#endif
+
+#ifndef _RUBYCC_SA_FAMILY_T
+#define _RUBYCC_SA_FAMILY_T
+typedef unsigned short sa_family_t;
+#endif
+
+/* IPv6 address: 16 bytes, 4-byte aligned (measured, both arches). The union
+   gives access at three widths (glibc's in6_u); s6_addr is the POSIX-visible
+   byte-array name, macro'd onto the byte member of the union. */
+struct in6_addr {
+  union {
+    uint8_t  __u6_addr8[16];
+    uint16_t __u6_addr16[8];
+    uint32_t __u6_addr32[4];
+  } __in6_u;
+};
+#define s6_addr __in6_u.__u6_addr8
+
+/* struct sockaddr_in: 16 bytes, 4-byte aligned (measured, both arches), the
+   IPv4-specific socket address. */
+struct sockaddr_in {
+  sa_family_t    sin_family; /* offset 0 */
+  in_port_t      sin_port;   /* offset 2 */
+  struct in_addr sin_addr;   /* offset 4 */
+  unsigned char  sin_zero[8]; /* offset 8 */
+};
+
+/* struct sockaddr_in6: 28 bytes, 4-byte aligned (measured, both arches), the
+   IPv6-specific socket address. */
+struct sockaddr_in6 {
+  sa_family_t     sin6_family;   /* offset 0  */
+  in_port_t       sin6_port;     /* offset 2  */
+  uint32_t        sin6_flowinfo; /* offset 4  */
+  struct in6_addr sin6_addr;     /* offset 8  */
+  uint32_t        sin6_scope_id; /* offset 24 */
+};
+
+/* IP protocol numbers (Linux kernel UAPI, linux/in.h). */
+#define IPPROTO_IP   0
+#define IPPROTO_ICMP 1
+#define IPPROTO_TCP  6
+#define IPPROTO_UDP  17
+#define IPPROTO_IPV6 41
+#define IPPROTO_RAW  255
+
+/* Well-known IPv4 addresses (host byte order, glibc's in_addr_t-typed constants). */
+#define INADDR_ANY       ((in_addr_t)0x00000000)
+#define INADDR_LOOPBACK  ((in_addr_t)0x7f000001)
+#define INADDR_BROADCAST ((in_addr_t)0xffffffff)
+#define INADDR_NONE      ((in_addr_t)0xffffffff)
+
+/* Buffer sizes for inet_ntop's textual forms, counting the terminating NUL:
+   "255.255.255.255" and the longest IPv6 spelling (an IPv4-mapped address with
+   a scope, "ffff:...:255.255.255.255%4294967295"). Measured, and identical on
+   x86-64 and aarch64. */
+#define INET_ADDRSTRLEN  16
+#define INET6_ADDRSTRLEN 46
+
+/* Well-known IPv6 addresses, as struct in6_addr initializers (glibc's
+   IN6ADDR_*_INIT macros); the triple brace reaches through struct in6_addr's
+   anonymous union member down to the byte array. */
+#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 } } }
+
+/* The same two addresses as objects the host libc defines (measured: both are
+   real exported symbols, `V in6addr_any` / `V in6addr_loopback`). A program
+   that needs the *address* of one -- raindrops' linux_inet_diag.c memcmps
+   against &in6addr_any -- cannot use the initializer macros, so the
+   declarations have to be here for the definitions to resolve at link time. */
+extern const struct in6_addr in6addr_any;
+extern const struct in6_addr in6addr_loopback;
+
+/* Host<->network byte-order conversions (same declarations as <arpa/inet.h>). */
+uint32_t htonl(uint32_t __hostlong);
+uint16_t htons(uint16_t __hostshort);
+uint32_t ntohl(uint32_t __netlong);
+uint16_t ntohs(uint16_t __netshort);
+
+#endif /* _RUBYCC_NETINET_IN_H */

data/include/libc/netinet/tcp.h

@@ -0,0 +1,44 @@
+/* rubycc bundled <netinet/tcp.h>: the TCP-level setsockopt/getsockopt option
+   names (used with level IPPROTO_TCP). Provenance: clean room against the Linux
+   kernel UAPI (linux/tcp.h), not derived from musl. The TCP_* values are that
+   ABI reproduced as measured integer constants (an ABI fact, not copied text --
+   see docs/HEADER-LICENSING.md), the same treatment as errno.h and fcntl.h.
+   Common layer: every value is identical on x86-64 and aarch64. The large
+   struct tcp_info diagnostic block is deliberately omitted -- gems reach this
+   header for the option names (TCP_NODELAY and kin), not that struct. */
+
+#ifndef _RUBYCC_NETINET_TCP_H
+#define _RUBYCC_NETINET_TCP_H
+
+#define TCP_NODELAY      1
+#define TCP_MAXSEG       2
+#define TCP_CORK         3
+#define TCP_KEEPIDLE     4
+#define TCP_KEEPINTVL    5
+#define TCP_KEEPCNT      6
+#define TCP_INFO         11
+#define TCP_QUICKACK     12
+#define TCP_USER_TIMEOUT 18
+#define TCP_FASTOPEN     23
+
+/* The TCP state machine's states, as reported by TCP_INFO's tcpi_state and by
+   the kernel's inet_diag netlink replies. glibc spells them as an anonymous
+   enum and then #defines each name to itself, so a program can test one with
+   #ifdef; plain object macros are indistinguishable from that and are what the
+   rest of this header already uses. Measured, and identical on x86-64 and
+   aarch64. raindrops' linux_inet_diag.c compares idiag_state against
+   TCP_ESTABLISHED and TCP_LISTEN to split active connections from the listen
+   queue. */
+#define TCP_ESTABLISHED 1
+#define TCP_SYN_SENT    2
+#define TCP_SYN_RECV    3
+#define TCP_FIN_WAIT1   4
+#define TCP_FIN_WAIT2   5
+#define TCP_TIME_WAIT   6
+#define TCP_CLOSE       7
+#define TCP_CLOSE_WAIT  8
+#define TCP_LAST_ACK    9
+#define TCP_LISTEN      10
+#define TCP_CLOSING     11
+
+#endif /* _RUBYCC_NETINET_TCP_H */

data/include/libc/poll.h

@@ -0,0 +1,46 @@
+/* rubycc bundled <poll.h>: the poll(2) event macros and struct pollfd (POSIX).
+   Provenance: clean room against the Linux kernel UAPI (asm-generic/poll.h),
+   not derived from musl. The POLL* values are the kernel ABI, reproduced here
+   as measured integer constants (an ABI fact, not copied text -- see
+   docs/HEADER-LICENSING.md), the same treatment as errno.h and fcntl.h. struct
+   pollfd is a POSIX declaration. Common layer: struct pollfd's layout and every
+   POLLIN/POLLOUT/... value are identical on x86-64 and aarch64, unlike
+   fcntl.h's O_DIRECT family. */
+
+#ifndef _RUBYCC_POLL_H
+#define _RUBYCC_POLL_H
+
+#ifndef _RUBYCC_NFDS_T
+#define _RUBYCC_NFDS_T
+typedef unsigned long nfds_t;
+#endif
+
+/* struct pollfd: 8 bytes, 4-byte aligned (measured, both arches). */
+struct pollfd {
+  int fd;
+  short events;
+  short revents;
+};
+
+/* Event bits (Linux kernel UAPI, asm-generic/poll.h). POSIX. */
+#define POLLIN     0x001
+#define POLLPRI    0x002
+#define POLLOUT    0x004
+#define POLLERR    0x008
+#define POLLHUP    0x010
+#define POLLNVAL   0x020
+
+/* XOPEN extensions. */
+#define POLLRDNORM 0x040
+#define POLLRDBAND 0x080
+#define POLLWRNORM 0x100
+#define POLLWRBAND 0x200
+#define POLLMSG    0x400
+
+/* Linux extensions. */
+#define POLLREMOVE 0x1000
+#define POLLRDHUP  0x2000
+
+int poll(struct pollfd *__fds, nfds_t __nfds, int __timeout);
+
+#endif /* _RUBYCC_POLL_H */

data/include/libc/pwd.h

@@ -0,0 +1,58 @@
+/* rubycc bundled <pwd.h>: the user database access interface (POSIX.1 9.2.2).
+   Provenance: clean room against the POSIX public interface -- struct passwd's
+   member names, types and order are POSIX's own public contract, not glibc
+   implementation detail, so reproducing them is not a glibc derivation. Every
+   member is used directly by callers, so it cannot be an opaque byte blob;
+   instead its size and every member's offset were measured against the glibc
+   oracle on both x86-64 and aarch64 (see test/test_header_abi.rb's PWD case)
+   and the two agreed exactly (an all-pointer/uid_t/gid_t struct has no
+   arch-dependent field widths on either LP64 target), so this header lives in
+   the common layer. uid_t/gid_t reuse the shared _RUBYCC_* guards sys/types.h
+   and unistd.h also carry. getpwnam/getpwuid/getpwent/setpwent/endpwent/
+   getpwnam_r/getpwuid_r are POSIX declarations whose bodies resolve from the
+   host libc at link time (getpwnam_r/getpwuid_r answer through NSS, so their
+   result is a host runtime fact, not something rubycc computes).
+   Not included: fgetpwent/putpwent/getpw (glibc/BSD extensions no corpus
+   sample census hit needs), left out to keep the surface to what etc's use of
+   getpwnam/getpwuid actually requires (Step 123, M5 H2). */
+
+#ifndef _RUBYCC_PWD_H
+#define _RUBYCC_PWD_H
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_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
+
+/* A record in the user database. Member names, types and order are the
+   POSIX.1 public contract; every offset below was measured against the glibc
+   oracle on both x86-64 and aarch64 and the two agreed byte for byte. */
+struct passwd {
+  char *pw_name;   /* Username. */
+  char *pw_passwd; /* Hashed passphrase (if no shadow database). */
+  uid_t pw_uid;    /* User ID. */
+  gid_t pw_gid;    /* Group ID. */
+  char *pw_gecos;  /* Real name. */
+  char *pw_dir;    /* Home directory. */
+  char *pw_shell;  /* Shell program. */
+};
+
+struct passwd *getpwnam(const char *__name);
+struct passwd *getpwuid(uid_t __uid);
+struct passwd *getpwent(void);
+void setpwent(void);
+void endpwent(void);
+int getpwnam_r(const char *__restrict __name, struct passwd *__restrict __resultbuf,
+               char *__restrict __buffer, size_t __buflen, struct passwd **__restrict __result);
+int getpwuid_r(uid_t __uid, struct passwd *__restrict __resultbuf,
+               char *__restrict __buffer, size_t __buflen, struct passwd **__restrict __result);
+
+#endif /* _RUBYCC_PWD_H */

data/include/libc/regex.h

@@ -0,0 +1,53 @@
+/* Clean-room ABI subset: rubycc bundled <regex.h> exposes the POSIX
+   regular-expression ABI used by C
+   extensions such as oj. The public regex_t layout is part of glibc's ABI;
+   the implementation behind regcomp/regexec remains the host libc. */
+
+#ifndef _RUBYCC_REGEX_H
+#define _RUBYCC_REGEX_H
+
+#include <stddef.h>
+
+typedef unsigned long reg_syntax_t;
+
+struct re_dfa_t;
+struct re_pattern_buffer {
+    struct re_dfa_t *buffer;
+    unsigned long allocated;
+    unsigned long used;
+    reg_syntax_t syntax;
+    char *fastmap;
+    unsigned char *translate;
+    size_t re_nsub;
+    unsigned can_be_null : 1;
+    unsigned regs_allocated : 2;
+    unsigned fastmap_accurate : 1;
+    unsigned no_sub : 1;
+    unsigned not_bol : 1;
+    unsigned not_eol : 1;
+    unsigned newline_anchor : 1;
+};
+typedef struct re_pattern_buffer regex_t;
+
+typedef int regoff_t;
+typedef struct {
+    regoff_t rm_so;
+    regoff_t rm_eo;
+} regmatch_t;
+
+#define REG_EXTENDED 1
+#define REG_ICASE (1 << 1)
+#define REG_NEWLINE (1 << 2)
+#define REG_NOSUB (1 << 3)
+#define REG_NOTBOL 1
+#define REG_NOTEOL (1 << 1)
+#define REG_STARTEND (1 << 2)
+
+int regcomp(regex_t *__preg, const char *__pattern, int __cflags);
+int regexec(const regex_t *__preg, const char *__string, size_t __nmatch,
+            regmatch_t *__pmatch, int __eflags);
+size_t regerror(int __errcode, const regex_t *__preg, char *__errbuf,
+                size_t __errbuf_size);
+void regfree(regex_t *__preg);
+
+#endif /* _RUBYCC_REGEX_H */

data/include/libc/sched.h

@@ -0,0 +1,35 @@
+/* rubycc bundled <sched.h>: scheduling (POSIX.1), pared down to the surface
+   etc and google-protobuf's corpus samples actually reach (sched_yield,
+   sched_getcpu, and cpu_set_t's existence) rather than glibc's full affinity
+   API, per Step 123's (M5 H2) explicit scope. Provenance: clean room against
+   the glibc/Linux ABI. cpu_set_t is glibc-internal state (a bitmap of
+   CPU_SETSIZE bits used only through the CPU_SET/CPU_ZERO/CPU_ISSET macro
+   family, none of which any corpus sample census hit needs), so, like
+   pthread.h's opaque objects and setjmp.h's jmp_buf, rubycc reproduces only
+   its measured size and alignment as an opaque byte blob -- a union of a
+   char __size[N] arm and the aligning scalar -- and does not name glibc's
+   internal __bits array. That size/alignment (128, 8-byte aligned) was
+   measured against the glibc oracle on both x86-64 and aarch64 (see
+   test/test_header_abi.rb's SCHED case) and the two agreed exactly (both are
+   LP64, so CPU_SETSIZE/8 bytes of bitmap has no arch-dependent width), so
+   this header lives in the common layer. sched_yield/sched_getcpu are POSIX/
+   glibc declarations whose bodies resolve from the host libc at link time.
+   Not included: sched_setaffinity/sched_getaffinity/CPU_SET/CPU_ZERO/
+   CPU_ISSET and the sched_setscheduler family (no corpus sample census hit
+   needs them; adding the affinity macros would require reproducing
+   glibc-internal bit-numbering, not just an opaque size). */
+
+#ifndef _RUBYCC_SCHED_H
+#define _RUBYCC_SCHED_H
+
+#define CPU_SETSIZE 1024
+
+/* Opaque CPU affinity bitmap. glibc stores CPU_SETSIZE bits inside as an
+   array of unsigned long words; rubycc reproduces only the measured size and
+   alignment as an opaque blob, not the internal word layout. */
+typedef union { char __size[128]; long __align; } cpu_set_t;
+
+int sched_yield(void);
+int sched_getcpu(void);
+
+#endif /* _RUBYCC_SCHED_H */