rubycc 1.0.0

data/include/float.h

@@ -0,0 +1,87 @@
+/* rubycc freestanding <float.h>: floating-type characteristics (ISO C 7.7).
+   float is IEEE 754 binary32 and double is binary64 on every target rubycc
+   supports, so those are unconditional. `long double` is not: x86-64 gives it
+   the x87 80-bit extended format, aarch64 the IEEE 754 binary128 quad. This
+   file is the freestanding layer -- one file for every machine, unlike
+   include/libc/glibc/<arch>/ -- so the machine split is carried inline, on the
+   arch macro the preprocessor predefines per target.
+
+   That split was missing until Step 200: this header handed x87's numbers to
+   aarch64 too. It went unnoticed because the aarch64 ABI harness covered only
+   the arch-layer headers, on the assumption that a freestanding header has
+   nothing arch-specific in it -- an assumption this file disproves. All the
+   values below were measured with each target's own gcc (the x86-64 column
+   reproduces this file's previous contents exactly, which is what validates
+   the method). */
+
+#ifndef _RUBYCC_FLOAT_H
+#define _RUBYCC_FLOAT_H
+
+/* Common to every floating type. */
+#define FLT_RADIX       2
+#define FLT_ROUNDS      1
+#define FLT_EVAL_METHOD 0
+#if defined(__aarch64__)
+#define DECIMAL_DIG     36
+#else
+#define DECIMAL_DIG     21
+#endif
+
+/* float (IEEE 754 binary32). */
+#define FLT_MANT_DIG    24
+#define FLT_DIG         6
+#define FLT_DECIMAL_DIG 9
+#define FLT_MIN_EXP     (-125)
+#define FLT_MIN_10_EXP  (-37)
+#define FLT_MAX_EXP     128
+#define FLT_MAX_10_EXP  38
+#define FLT_MAX         3.40282347e+38F
+#define FLT_MIN         1.17549435e-38F
+#define FLT_EPSILON     1.19209290e-7F
+#define FLT_TRUE_MIN    1.40129846e-45F
+#define FLT_HAS_SUBNORM 1
+
+/* double (IEEE 754 binary64). */
+#define DBL_MANT_DIG    53
+#define DBL_DIG         15
+#define DBL_DECIMAL_DIG 17
+#define DBL_MIN_EXP     (-1021)
+#define DBL_MIN_10_EXP  (-307)
+#define DBL_MAX_EXP     1024
+#define DBL_MAX_10_EXP  308
+#define DBL_MAX         1.7976931348623157e+308
+#define DBL_MIN         2.2250738585072014e-308
+#define DBL_EPSILON     2.2204460492503131e-16
+#define DBL_TRUE_MIN    4.9406564584124654e-324
+#define DBL_HAS_SUBNORM 1
+
+/* long double. The exponent range is the same either way -- both formats carry
+   15 exponent bits -- so only the precision-derived macros and the magnitudes
+   that depend on the mantissa width differ. */
+#define LDBL_MIN_EXP     (-16381)
+#define LDBL_MIN_10_EXP  (-4931)
+#define LDBL_MAX_EXP     16384
+#define LDBL_MAX_10_EXP  4932
+#define LDBL_HAS_SUBNORM 1
+
+#if defined(__aarch64__)
+/* IEEE 754 binary128 ("quad"): a 113-bit significand. */
+#define LDBL_MANT_DIG    113
+#define LDBL_DIG         33
+#define LDBL_DECIMAL_DIG 36
+#define LDBL_MAX         1.18973149535723176508575932662800702e+4932L
+#define LDBL_MIN         3.36210314311209350626267781732175260e-4932L
+#define LDBL_EPSILON     1.92592994438723585305597794258492732e-34L
+#define LDBL_TRUE_MIN    6.47517511943802511092443895822764655e-4966L
+#else
+/* x87 80-bit extended: a 64-bit significand. */
+#define LDBL_MANT_DIG    64
+#define LDBL_DIG         18
+#define LDBL_DECIMAL_DIG 21
+#define LDBL_MAX         1.18973149535723176502e+4932L
+#define LDBL_MIN         3.36210314311209350626e-4932L
+#define LDBL_EPSILON     1.08420217248550443401e-19L
+#define LDBL_TRUE_MIN    3.64519953188247460253e-4951L
+#endif
+
+#endif

data/include/iso646.h

@@ -0,0 +1,18 @@
+/* rubycc freestanding <iso646.h>: alternative operator spellings (ISO C 7.9). */
+
+#ifndef _RUBYCC_ISO646_H
+#define _RUBYCC_ISO646_H
+
+#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

data/include/libc/alloca.h

@@ -0,0 +1,18 @@
+/* rubycc bundled <alloca.h>: the alloca declaration, mapped onto the compiler
+   builtin (glibc/BSD extension). Derived from musl's <alloca.h> shape. Common
+   layer: the builtin mapping is the same on any target. */
+
+#ifndef _RUBYCC_ALLOCA_H
+#define _RUBYCC_ALLOCA_H
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+
+extern void *alloca(size_t __size);
+
+#undef alloca
+#define alloca(size) __builtin_alloca(size)
+
+#endif /* _RUBYCC_ALLOCA_H */

data/include/libc/arpa/inet.h

@@ -0,0 +1,61 @@
+/* rubycc bundled <arpa/inet.h>: the Internet address-manipulation declarations
+   (POSIX) -- the host<->network byte-order conversions and the inet_* address
+   conversions. Derived from musl's <arpa/inet.h> declaration set; the byte-order
+   direction is taken from <endian.h> (arch specific) and the address types are
+   fixed width, so this header itself carries nothing arch specific. Common layer.
+
+   Measured need (Step 64): msgpack's sysdep_endian.h includes this header solely
+   for __BYTE_ORDER / __LITTLE_ENDIAN and the ntohs/ntohl functions. glibc's real
+   <arpa/inet.h> fans out into the whole socket + kernel-UAPI chain (netinet/in.h,
+   sys/socket.h and the asm/asm-generic socket headers); the bundled header
+   collapses that -- no target gem uses sockets, so the socket UAPI surface is
+   deliberately not reproduced (measurement-driven, per the B7 plan). */
+
+#ifndef _RUBYCC_ARPA_INET_H
+#define _RUBYCC_ARPA_INET_H
+
+#include <stdint.h>
+#include <endian.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
+
+/* IPv4 address: a single network-order 32-bit word, the same one-field layout
+   glibc/musl commit to (sizeof 4, s_addr at offset 0). */
+#ifndef _RUBYCC_STRUCT_IN_ADDR
+#define _RUBYCC_STRUCT_IN_ADDR
+struct in_addr { in_addr_t s_addr; };
+#endif
+
+/* Host<->network byte-order conversions (network order is big-endian). Declared
+   as plain out-of-line functions resolving from the host libc, matching glibc's
+   real symbols; on a little-endian host each swaps its argument's bytes. */
+uint32_t htonl(uint32_t __hostlong);
+uint16_t htons(uint16_t __hostshort);
+uint32_t ntohl(uint32_t __netlong);
+uint16_t ntohs(uint16_t __netshort);
+
+/* IPv4 / IPv6 address conversions. */
+in_addr_t      inet_addr(const char *__cp);
+in_addr_t      inet_network(const char *__cp);
+struct in_addr inet_makeaddr(in_addr_t __net, in_addr_t __host);
+in_addr_t      inet_lnaof(struct in_addr __in);
+in_addr_t      inet_netof(struct in_addr __in);
+int            inet_aton(const char *__cp, struct in_addr *__inp);
+char          *inet_ntoa(struct in_addr __in);
+int            inet_pton(int __af, const char *__cp, void *__buf);
+const char    *inet_ntop(int __af, const void *__cp, char *__buf, socklen_t __len);
+
+#endif /* _RUBYCC_ARPA_INET_H */

data/include/libc/assert.h

@@ -0,0 +1,43 @@
+/* rubycc bundled <assert.h>: the assert macro and its __assert_fail hook (ISO C
+   7.2). Written clean room against the standard idiom (musl's <assert.h> was the
+   shape reference); the __assert_fail prototype matches glibc's so the macro
+   links against the host libc when present. Common layer. Deliberately has no
+   whole-file include guard: the standard requires assert to be redefined per the
+   current NDEBUG on every inclusion. */
+
+#include <features.h>
+
+#undef assert
+
+#ifdef NDEBUG
+# define assert(expr) ((void) 0)
+#else
+
+extern void __assert_fail(const char *__assertion, const char *__file,
+                          unsigned int __line, const char *__function)
+  __attribute__((__noreturn__));
+
+/* The enclosing function's name. C99's __func__ is the portable spelling, but
+   rubycc does not provide it, so under rubycc the (informational) function slot
+   is passed as a null pointer instead. */
+# if defined __RUBYCC__
+#  define __ASSERT_FUNCTION ((const char *) 0)
+# else
+#  define __ASSERT_FUNCTION __func__
+# endif
+
+# define assert(expr) \
+  ((void) ((expr) ? 0 : \
+           (__assert_fail(#expr, __FILE__, __LINE__, __ASSERT_FUNCTION), 0)))
+
+#endif /* NDEBUG */
+
+#ifndef _RUBYCC_ASSERT_H
+#define _RUBYCC_ASSERT_H
+
+/* static_assert: the C11 keyword, exposed under its library spelling. */
+#if !defined __cplusplus && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 202311L)
+# define static_assert _Static_assert
+#endif
+
+#endif /* _RUBYCC_ASSERT_H */

data/include/libc/dirent.h

@@ -0,0 +1,72 @@
+/* rubycc bundled <dirent.h>: directory stream access (POSIX.1). Provenance:
+   clean room against the POSIX public interface and the glibc/Linux ABI.
+   DIR is glibc's own public spelling `typedef struct __dirstream DIR;' with
+   struct __dirstream left incomplete -- glibc itself never defines it in a
+   public header (its fields are libio-internal), and every caller only ever
+   holds a `DIR *' returned by opendir/fdopendir, never a `DIR' by value, so
+   there is nothing to size or reproduce; following the same public spelling
+   is a POSIX/glibc interoperability fact, not glibc source copied.
+   struct dirent, unlike DIR, is a struct callers read members out of
+   directly, so it cannot be an opaque byte blob. Its member order
+   (d_ino, d_off, d_reclen, d_type, d_name) and the d_reclen/d_type slots
+   ahead of d_name are glibc/Linux ABI, not POSIX (POSIX only guarantees
+   d_name), the same way sys/stat.h's field order is a kernel ABI fact rather
+   than a POSIX one; the struct's size (280, with d_name[256]) and every
+   member's offset were measured against the glibc oracle on both x86-64 and
+   aarch64 (see test/test_header_abi.rb's DIRENT case) and the two agreed
+   exactly (ino_t/off_t are both 8-byte and d_reclen/d_type/d_name have no
+   arch-dependent width on either LP64 target), so this header lives in the
+   common layer. ino_t/off_t reuse the shared _RUBYCC_* guards sys/stat.h and
+   sys/types.h also carry. The DT_* file-type constants are the standard
+   Linux/glibc values (measured, both arches agree).
+   opendir/readdir/closedir/rewinddir/readdir_r/fdopendir/dirfd are POSIX
+   declarations whose bodies resolve from the host libc at link time
+   (Step 123, M5 H2). */
+
+#ifndef _RUBYCC_DIRENT_H
+#define _RUBYCC_DIRENT_H
+
+#ifndef _RUBYCC_INO_T
+#define _RUBYCC_INO_T
+typedef unsigned long ino_t;
+#endif
+#ifndef _RUBYCC_OFF_T
+#define _RUBYCC_OFF_T
+typedef long off_t;
+#endif
+
+/* Opaque directory-stream handle. Only ever used through a `DIR *'; struct
+   __dirstream is intentionally left incomplete, the same way glibc's own
+   public header leaves it. */
+typedef struct __dirstream DIR;
+
+/* struct dirent: 280 bytes, 8-byte aligned (measured, both arches). */
+struct dirent {
+  ino_t d_ino;            /* offset 0:  inode number */
+  off_t d_off;             /* offset 8:  offset to the next dirent */
+  unsigned short d_reclen; /* offset 16: length of this record */
+  unsigned char d_type;    /* offset 18: file type (DT_*) */
+  char d_name[256];        /* offset 19: null-terminated filename */
+};
+
+/* File-type values for d_type (measured, both arches agree). */
+#define DT_UNKNOWN 0
+#define DT_FIFO    1
+#define DT_CHR     2
+#define DT_DIR     4
+#define DT_BLK     6
+#define DT_REG     8
+#define DT_LNK     10
+#define DT_SOCK    12
+#define DT_WHT     14
+
+DIR *opendir(const char *__name);
+DIR *fdopendir(int __fd);
+struct dirent *readdir(DIR *__dirp);
+int readdir_r(DIR *__restrict __dirp, struct dirent *__restrict __entry,
+              struct dirent **__restrict __result);
+int closedir(DIR *__dirp);
+void rewinddir(DIR *__dirp);
+int dirfd(DIR *__dirp);
+
+#endif /* _RUBYCC_DIRENT_H */

data/include/libc/dlfcn.h

@@ -0,0 +1,58 @@
+/* rubycc bundled <dlfcn.h>: the dynamic-loading calls and the RTLD_* mode flags
+   (POSIX plus glibc extensions). Provenance: clean room against glibc's public
+   dynamic-linking ABI (bits/dlfcn.h), not derived from musl -- and not a kernel
+   UAPI, since dlopen is not a system-call interface. The RTLD_* values are that
+   ABI reproduced as measured integer constants (an ABI fact, not copied text --
+   see docs/HEADER-LICENSING.md); dlopen, dlsym, dlclose and dlerror are POSIX
+   declarations whose bodies resolve from the host libc at link time (the same
+   way errno.h's __errno_location does). Common layer: every RTLD_* value is
+   identical on x86-64 and aarch64. */
+
+#ifndef _RUBYCC_DLFCN_H
+#define _RUBYCC_DLFCN_H
+
+/* Binding modes (POSIX): one of these is required in the dlopen mode. */
+#define RTLD_LAZY   0x00001
+#define RTLD_NOW    0x00002
+
+/* Symbol visibility of the loaded object (POSIX). RTLD_LOCAL is the zero
+   default -- the absence of RTLD_GLOBAL. */
+#define RTLD_GLOBAL 0x00100
+#define RTLD_LOCAL  0
+
+/* glibc extensions to the dlopen mode. */
+#define RTLD_NOLOAD   0x00004
+#define RTLD_DEEPBIND 0x00008
+#define RTLD_NODELETE 0x01000
+
+/* Pseudo-handles for dlsym (glibc extensions): the next object after this one
+   in the search order, and the global default scope. */
+#define RTLD_NEXT    ((void *) -1l)
+#define RTLD_DEFAULT ((void *) 0)
+
+void *dlopen(const char *__file, int __mode);
+void *dlsym(void *__handle, const char *__name);
+int   dlclose(void *__handle);
+char *dlerror(void);
+
+/* Requests accepted by the glibc dlinfo extension.  They are enum constants
+   in the system header (rather than preprocessor macros), so extensions that
+   probe them with mkmf's have_const can see the same interface here. */
+enum {
+    RTLD_DI_LMID = 1,
+    RTLD_DI_LINKMAP = 2,
+    RTLD_DI_CONFIGADDR = 3,
+    RTLD_DI_SERINFO = 4,
+    RTLD_DI_SERINFOSIZE = 5,
+    RTLD_DI_ORIGIN = 6,
+    RTLD_DI_PROFILENAME = 7,
+    RTLD_DI_PROFILEOUT = 8,
+    RTLD_DI_TLS_MODID = 9,
+    RTLD_DI_TLS_DATA = 10,
+    RTLD_DI_PHDR = 11,
+    RTLD_DI_MAX = 11
+};
+
+int dlinfo(void *__handle, int __request, void *__arg);
+
+#endif /* _RUBYCC_DLFCN_H */

data/include/libc/features.h

@@ -0,0 +1,205 @@
+/* rubycc bundled <features.h>: the feature-test-macro reduction glibc's headers
+   consume. Clean room against the published POSIX/glibc feature-test protocol
+   (musl's own <features.h> was the shape reference; the __USE_* result set and
+   the glibc version macros are the glibc ABI, measured on the reference
+   platform). It maps the caller's request macros (_GNU_SOURCE, _POSIX_C_SOURCE,
+   _DEFAULT_SOURCE, __STRICT_ANSI__, ...) onto the __USE_* macros glibc headers
+   branch on. Common layer: the mapping is libc-defined, not arch-specific. */
+
+#ifndef _RUBYCC_FEATURES_H
+#define _RUBYCC_FEATURES_H
+
+/* glibc's guard, so a host <features.h> reached later is a no-op. */
+#ifndef _FEATURES_H
+#define _FEATURES_H 1
+
+/* _GNU_SOURCE turns on every feature set. */
+#if defined _GNU_SOURCE
+# undef  _ISOC95_SOURCE
+# define _ISOC95_SOURCE 1
+# undef  _ISOC99_SOURCE
+# define _ISOC99_SOURCE 1
+# undef  _ISOC11_SOURCE
+# define _ISOC11_SOURCE 1
+# undef  _POSIX_SOURCE
+# define _POSIX_SOURCE 1
+# undef  _POSIX_C_SOURCE
+# define _POSIX_C_SOURCE 200809L
+# undef  _XOPEN_SOURCE
+# define _XOPEN_SOURCE 700
+# undef  _XOPEN_SOURCE_EXTENDED
+# define _XOPEN_SOURCE_EXTENDED 1
+# undef  _LARGEFILE64_SOURCE
+# define _LARGEFILE64_SOURCE 1
+# undef  _DEFAULT_SOURCE
+# define _DEFAULT_SOURCE 1
+# undef  _ATFILE_SOURCE
+# define _ATFILE_SOURCE 1
+#endif
+
+/* With nothing requested and not in strict-ANSI mode, glibc turns on its default
+   (BSD/SVID/POSIX) surface. */
+#if (!defined __STRICT_ANSI__ \
+     && !defined _ISOC99_SOURCE && !defined _ISOC11_SOURCE \
+     && !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE \
+     && !defined _XOPEN_SOURCE && !defined _DEFAULT_SOURCE)
+# define _DEFAULT_SOURCE 1
+#endif
+
+/* _DEFAULT_SOURCE implies POSIX.1-2008 plus the misc/BSD extensions. POSIX is
+   only turned on *implicitly* here when the caller did not request it; that
+   distinction is exactly what __USE_POSIX_IMPLICITLY records (so _GNU_SOURCE,
+   which sets POSIX explicitly above, does not get it). */
+#ifdef _DEFAULT_SOURCE
+# if !defined _POSIX_SOURCE && !defined _POSIX_C_SOURCE
+#  define __USE_POSIX_IMPLICITLY 1
+#  define _POSIX_SOURCE 1
+#  define _POSIX_C_SOURCE 200809L
+# endif
+# ifndef _ATFILE_SOURCE
+#  define _ATFILE_SOURCE 1
+# endif
+#endif
+
+/* ISO C selections. */
+#if defined _ISOC11_SOURCE || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L)
+# define __USE_ISOC11 1
+#endif
+#if defined _ISOC99_SOURCE || defined _ISOC11_SOURCE \
+    || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L)
+# define __USE_ISOC99 1
+#endif
+#if defined _ISOC95_SOURCE || defined _ISOC99_SOURCE || defined _ISOC11_SOURCE \
+    || (defined __STDC_VERSION__ && __STDC_VERSION__ >= 199409L)
+# define __USE_ISOC95 1
+#endif
+
+/* POSIX selections, keyed off _POSIX_C_SOURCE's level. */
+#ifdef _POSIX_SOURCE
+# define __USE_POSIX 1
+#endif
+#if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 2
+# define __USE_POSIX2 1
+#endif
+#if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 199309L
+# define __USE_POSIX199309 1
+#endif
+#if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 199506L
+# define __USE_POSIX199506 1
+#endif
+#if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 200112L
+# define __USE_XOPEN2K 1
+# undef  __USE_ISOC95
+# define __USE_ISOC95 1
+# undef  __USE_ISOC99
+# define __USE_ISOC99 1
+#endif
+#if defined _POSIX_C_SOURCE && _POSIX_C_SOURCE >= 200809L
+# define __USE_XOPEN2K8 1
+# ifdef _ATFILE_SOURCE
+#  define __USE_ATFILE 1
+# endif
+#endif
+
+/* X/Open selections. */
+#ifdef _XOPEN_SOURCE
+# define __USE_XOPEN 1
+# if _XOPEN_SOURCE >= 500
+#  define __USE_XOPEN_EXTENDED 1
+#  define __USE_UNIX98 1
+#  undef _LARGEFILE_SOURCE
+#  define _LARGEFILE_SOURCE 1
+#  if _XOPEN_SOURCE >= 600
+#   if _XOPEN_SOURCE >= 700
+#    define __USE_XOPEN2K8 1
+#    define __USE_XOPEN2K8XSI 1
+#   endif
+#   define __USE_XOPEN2K 1
+#   define __USE_XOPEN2KXSI 1
+#   undef __USE_ISOC95
+#   define __USE_ISOC95 1
+#   undef __USE_ISOC99
+#   define __USE_ISOC99 1
+#  endif
+# else
+#  ifdef _XOPEN_SOURCE_EXTENDED
+#   define __USE_XOPEN_EXTENDED 1
+#  endif
+# endif
+#endif
+
+#ifdef _LARGEFILE_SOURCE
+# define __USE_LARGEFILE 1
+#endif
+#ifdef _LARGEFILE64_SOURCE
+# define __USE_LARGEFILE64 1
+#endif
+#if defined _FILE_OFFSET_BITS && _FILE_OFFSET_BITS == 64
+# define __USE_FILE_OFFSET64 1
+#endif
+
+#ifdef _DEFAULT_SOURCE
+# define __USE_MISC 1
+#endif
+
+#ifdef _ATFILE_SOURCE
+# define __USE_ATFILE 1
+#endif
+
+#ifdef _GNU_SOURCE
+# define __USE_GNU 1
+# define __USE_DYNAMIC_STACK_SIZE 1
+#endif
+
+/* No fortification by default. */
+#ifndef __USE_FORTIFY_LEVEL
+# define __USE_FORTIFY_LEVEL 0
+#endif
+
+/* rubycc presents the glibc ABI; report a version so version-gated header code
+   takes the same branch it does under glibc. Which version that is cannot be
+   written into a header set shipped to every host: on a host whose glibc is
+   older than the number below, a gate like "#if __GLIBC_PREREQ (2, 38)" would
+   select a branch whose symbols the local C library does not have (docs/GAPS.md
+   gap U). rubycc therefore measures the version from the C library the compile
+   will link against and predefines __GLIBC__ / __GLIBC_MINOR__ itself
+   (Preprocess::GlibcVersion), which is why each is defined here only when it is
+   absent. The values below are the fallback for the cases where no measurement
+   reached this header: the reference platform this header set was measured on
+   (glibc 2.39), a musl target (where the whole file is glibc's surface anyway,
+   and where these macros keep the values they have always had here), and a read
+   of this header by some other compiler. __GLIBC_PREREQ is not measured and not
+   guarded: it is a pure function of the two macros above. */
+#define __GNU_LIBRARY__ 6
+#ifndef __GLIBC__
+# define __GLIBC__       2
+#endif
+#ifndef __GLIBC_MINOR__
+# define __GLIBC_MINOR__ 39
+#endif
+#define __GLIBC_PREREQ(maj, min) \
+  ((__GLIBC__ << 16) + __GLIBC_MINOR__ >= ((maj) << 16) + (min))
+
+#define __GLIBC_USE(F) __GLIBC_USE_ ## F
+#define __GLIBC_USE_DEPRECATED_GETS 0
+#define __GLIBC_USE_DEPRECATED_SCANF 0
+#define __GLIBC_USE_C2X_STRTOL 0
+#define __GLIBC_USE_ISOC2X 0
+#define __GLIBC_USE_LIB_EXT2 0
+#define __GLIBC_USE_IEC_60559_BFP_EXT 0
+#define __GLIBC_USE_IEC_60559_BFP_EXT_C2X 0
+#define __GLIBC_USE_IEC_60559_EXT 0
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT 0
+#define __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X 0
+#define __GLIBC_USE_IEC_60559_TYPES_EXT 0
+
+/* rubycc ships its own <stdc-predef.h>-level knowledge; glibc's headers expect
+   __KERNEL_STRICT_NAMES cleared so the kernel-UAPI compatibility names appear. */
+#undef  __KERNEL_STRICT_NAMES
+
+/* The compiler-abstraction macros live here, exactly as glibc's <features.h>
+   pulls in <sys/cdefs.h>. */
+#include <sys/cdefs.h>
+
+#endif /* !_FEATURES_H */
+#endif /* _RUBYCC_FEATURES_H */

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

@@ -0,0 +1,108 @@
+/* rubycc bundled <ctype.h>: character classification (ISO C 7.4). glibc does
+   not return a bare 0/1 from isalpha() and kin -- it returns the masked bits of
+   a per-locale classification table reached through __ctype_b_loc(), so the
+   result values are part of its ABI. This header reproduces that mechanism clean
+   room from the published _ISbit formula and accessor signatures (not copied
+   from glibc, not derived from musl, whose ctype returns 0/1); the accessor
+   functions themselves are resolved from the host libc at link time. The whole
+   mechanism is glibc's, so under __RUBYCC_LIBC_MUSL__ (see the preprocessor's
+   LIBCS) the classification macros are switched off and the plain function
+   calls stand instead -- see the note above them. Placed in the glibc layer
+   because that is where the arch-switched headers live; the values themselves
+   are arch independent. */
+
+#ifndef _RUBYCC_CTYPE_H
+#define _RUBYCC_CTYPE_H
+
+/* The classification bit for each property, as glibc lays them out in the table
+   entry: properties 0-7 occupy the high byte, 8-11 the low byte. */
+#ifndef _ISbit
+# define _ISbit(bit) ((bit) < 8 ? ((1 << (bit)) << 8) : ((1 << (bit)) >> 8))
+#endif
+
+enum {
+  _ISupper  = _ISbit(0),
+  _ISlower  = _ISbit(1),
+  _ISalpha  = _ISbit(2),
+  _ISdigit  = _ISbit(3),
+  _ISxdigit = _ISbit(4),
+  _ISspace  = _ISbit(5),
+  _ISprint  = _ISbit(6),
+  _ISgraph  = _ISbit(7),
+  _ISblank  = _ISbit(8),
+  _IScntrl  = _ISbit(9),
+  _ISpunct  = _ISbit(10),
+  _ISalnum  = _ISbit(11)
+};
+
+extern const unsigned short int **__ctype_b_loc(void);
+extern const int **__ctype_tolower_loc(void);
+extern const int **__ctype_toupper_loc(void);
+
+/* The out-of-line entry points (declared so code taking their address still
+   links); the macros below inline the common case. */
+extern int isalnum(int __c);
+extern int isalpha(int __c);
+extern int iscntrl(int __c);
+extern int isdigit(int __c);
+extern int islower(int __c);
+extern int isgraph(int __c);
+extern int isprint(int __c);
+extern int ispunct(int __c);
+extern int isspace(int __c);
+extern int isupper(int __c);
+extern int isxdigit(int __c);
+extern int isblank(int __c);
+extern int tolower(int __c);
+extern int toupper(int __c);
+extern int isascii(int __c);
+extern int toascii(int __c);
+
+/* The classification macros are glibc's mechanism and glibc's result values,
+   so on musl they must not be used at all: the two libraries differ in the
+   *shape* of the answer, not merely in a constant. glibc's isalpha('a') is the
+   masked table entry (measured 1024, and 2048/8192/... for the other
+   properties) while musl's is a bare 1; and musl has no __ctype_b_loc() /
+   __ctype_tolower_loc() / __ctype_toupper_loc() to reach a table through in the
+   first place, so a table-lookup macro would not even link there. Both
+   behaviours measured with the ABI harness, glibc's on this host and musl's on
+   the CI aarch64 musl run (docs/STEPS.md Step 202). Under musl the macros are
+   therefore left undefined and every classifier resolves to the out-of-line
+   function declared above, which is what returns musl's 0/1. The accessor
+   prototypes and the _IS* enumerators stay declared on both: a prototype that
+   is never called emits nothing, and code that does call one is asking for
+   glibc's own interface by name. */
+#if !defined(__RUBYCC_LIBC_MUSL__)
+
+#define __isctype(c, type) ((*__ctype_b_loc())[(int)(c)] & (unsigned short int)(type))
+
+#define isalnum(c)  __isctype((c), _ISalnum)
+#define isalpha(c)  __isctype((c), _ISalpha)
+#define iscntrl(c)  __isctype((c), _IScntrl)
+#define isdigit(c)  __isctype((c), _ISdigit)
+#define islower(c)  __isctype((c), _ISlower)
+#define isgraph(c)  __isctype((c), _ISgraph)
+#define isprint(c)  __isctype((c), _ISprint)
+#define ispunct(c)  __isctype((c), _ISpunct)
+#define isspace(c)  __isctype((c), _ISspace)
+#define isupper(c)  __isctype((c), _ISupper)
+#define isxdigit(c) __isctype((c), _ISxdigit)
+#define isblank(c)  __isctype((c), _ISblank)
+
+#define tolower(c) ((int) (*__ctype_tolower_loc())[(int)(c)])
+#define toupper(c) ((int) (*__ctype_toupper_loc())[(int)(c)])
+
+#endif /* !__RUBYCC_LIBC_MUSL__ */
+
+/* isascii/toascii: glibc declares these under __USE_MISC || __USE_XOPEN and
+   defines them as pure bit tests (no locale classification table), so the
+   inline value matches glibc's out-of-line result exactly -- no ABI subtlety
+   like the isalpha() family above. Real sources (e.g. redcarpet's html.c) call
+   isascii() with only <ctype.h> included. They stay macros under either C
+   library: the probed values (isascii of 'a'/200/0/127, toascii of 0x1FF/'A')
+   measured identical on glibc and musl (docs/STEPS.md Step 202), which is why
+   they sit outside the branch above. */
+#define isascii(c) (((c) & ~0x7f) == 0)
+#define toascii(c) ((c) & 0x7f)
+
+#endif /* _RUBYCC_CTYPE_H */