rubycc 1.0.0

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

@@ -0,0 +1,54 @@
+/* rubycc bundled <endian.h>: byte-order identity macros and the host<->big/
+   little conversions (glibc/BSD extension). Derived from musl's <endian.h>
+   shape; the byte order and the glibc spellings (__BYTE_ORDER, bswap via the
+   compiler builtins) are pinned to the little-endian x86-64 ABI. ABI switch
+   layer: the byte order is arch specific. */
+
+#ifndef _RUBYCC_ENDIAN_H
+#define _RUBYCC_ENDIAN_H
+
+#define __LITTLE_ENDIAN 1234
+#define __BIG_ENDIAN    4321
+#define __PDP_ENDIAN    3412
+#define __BYTE_ORDER    __LITTLE_ENDIAN
+#define __FLOAT_WORD_ORDER __BYTE_ORDER
+
+/* BSD-style spellings (glibc exposes both under _DEFAULT_SOURCE). */
+#define LITTLE_ENDIAN   __LITTLE_ENDIAN
+#define BIG_ENDIAN      __BIG_ENDIAN
+#define PDP_ENDIAN      __PDP_ENDIAN
+#define BYTE_ORDER      __BYTE_ORDER
+
+/* Byte reversals as static inline helpers (arithmetic, so no compiler byte-swap
+   builtin is required and each argument is evaluated once). */
+static inline unsigned short __rubycc_bswap16(unsigned short __x) {
+  return (unsigned short) ((__x << 8) | (__x >> 8));
+}
+static inline unsigned int __rubycc_bswap32(unsigned int __x) {
+  return ((__x & 0x000000ffU) << 24) | ((__x & 0x0000ff00U) << 8)
+       | ((__x & 0x00ff0000U) >> 8) | ((__x & 0xff000000U) >> 24);
+}
+static inline unsigned long __rubycc_bswap64(unsigned long __x) {
+  return ((__x & 0x00000000000000ffUL) << 56) | ((__x & 0x000000000000ff00UL) << 40)
+       | ((__x & 0x0000000000ff0000UL) << 24) | ((__x & 0x00000000ff000000UL) << 8)
+       | ((__x & 0x000000ff00000000UL) >> 8)  | ((__x & 0x0000ff0000000000UL) >> 24)
+       | ((__x & 0x00ff000000000000UL) >> 40) | ((__x & 0xff00000000000000UL) >> 56);
+}
+
+/* Host is little-endian: the "le" forms are identities, the "be" forms swap. */
+#define htobe16(x) __rubycc_bswap16(x)
+#define htole16(x) ((unsigned short)(x))
+#define be16toh(x) __rubycc_bswap16(x)
+#define le16toh(x) ((unsigned short)(x))
+
+#define htobe32(x) __rubycc_bswap32(x)
+#define htole32(x) ((unsigned int)(x))
+#define be32toh(x) __rubycc_bswap32(x)
+#define le32toh(x) ((unsigned int)(x))
+
+#define htobe64(x) __rubycc_bswap64(x)
+#define htole64(x) ((unsigned long)(x))
+#define be64toh(x) __rubycc_bswap64(x)
+#define le64toh(x) ((unsigned long)(x))
+
+#endif /* _RUBYCC_ENDIAN_H */

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

@@ -0,0 +1,154 @@
+/* rubycc bundled <errno.h>: the error-number macros and the errno lvalue
+   (POSIX). Provenance: clean room against the Linux/asm-generic UAPI, not
+   derived from musl. The error numbers are the kernel ABI, reproduced here as
+   measured integer constants (an ABI fact, not copied text -- see
+   docs/HEADER-LICENSING.md); glibc reaches them via __errno_location, which
+   resolves from the host libc at link time. Placed in the glibc/aarch64 layer
+   because the numeric values are kernel-ABI specific. */
+
+#ifndef _RUBYCC_ERRNO_H
+#define _RUBYCC_ERRNO_H
+
+extern int *__errno_location(void);
+#define errno (*__errno_location())
+
+#define EPERM            1
+#define ENOENT           2
+#define ESRCH            3
+#define EINTR            4
+#define EIO              5
+#define ENXIO            6
+#define E2BIG            7
+#define ENOEXEC          8
+#define EBADF            9
+#define ECHILD           10
+#define EAGAIN           11
+#define ENOMEM           12
+#define EACCES           13
+#define EFAULT           14
+#define ENOTBLK          15
+#define EBUSY            16
+#define EEXIST           17
+#define EXDEV            18
+#define ENODEV           19
+#define ENOTDIR          20
+#define EISDIR           21
+#define EINVAL           22
+#define ENFILE           23
+#define EMFILE           24
+#define ENOTTY           25
+#define ETXTBSY          26
+#define EFBIG            27
+#define ENOSPC           28
+#define ESPIPE           29
+#define EROFS            30
+#define EMLINK           31
+#define EPIPE            32
+#define EDOM             33
+#define ERANGE           34
+#define EDEADLK          35
+#define ENAMETOOLONG     36
+#define ENOLCK           37
+#define ENOSYS           38
+#define ENOTEMPTY        39
+#define ELOOP            40
+#define ENOMSG           42
+#define EIDRM            43
+#define ECHRNG           44
+#define EL2NSYNC         45
+#define EL3HLT           46
+#define EL3RST           47
+#define ELNRNG           48
+#define EUNATCH          49
+#define ENOCSI           50
+#define EL2HLT           51
+#define EBADE            52
+#define EBADR            53
+#define EXFULL           54
+#define ENOANO           55
+#define EBADRQC          56
+#define EBADSLT          57
+#define EBFONT           59
+#define ENOSTR           60
+#define ENODATA          61
+#define ETIME            62
+#define ENOSR            63
+#define ENONET           64
+#define ENOPKG           65
+#define EREMOTE          66
+#define ENOLINK          67
+#define EADV             68
+#define ESRMNT           69
+#define ECOMM            70
+#define EPROTO           71
+#define EMULTIHOP        72
+#define EDOTDOT          73
+#define EBADMSG          74
+#define EOVERFLOW        75
+#define ENOTUNIQ         76
+#define EBADFD           77
+#define EREMCHG          78
+#define ELIBACC          79
+#define ELIBBAD          80
+#define ELIBSCN          81
+#define ELIBMAX          82
+#define ELIBEXEC         83
+#define EILSEQ           84
+#define ERESTART         85
+#define ESTRPIPE         86
+#define EUSERS           87
+#define ENOTSOCK         88
+#define EDESTADDRREQ     89
+#define EMSGSIZE         90
+#define EPROTOTYPE       91
+#define ENOPROTOOPT      92
+#define EPROTONOSUPPORT  93
+#define ESOCKTNOSUPPORT  94
+#define EOPNOTSUPP       95
+#define EPFNOSUPPORT     96
+#define EAFNOSUPPORT     97
+#define EADDRINUSE       98
+#define EADDRNOTAVAIL    99
+#define ENETDOWN         100
+#define ENETUNREACH      101
+#define ENETRESET        102
+#define ECONNABORTED     103
+#define ECONNRESET       104
+#define ENOBUFS          105
+#define EISCONN          106
+#define ENOTCONN         107
+#define ESHUTDOWN        108
+#define ETOOMANYREFS     109
+#define ETIMEDOUT        110
+#define ECONNREFUSED     111
+#define EHOSTDOWN        112
+#define EHOSTUNREACH     113
+#define EALREADY         114
+#define EINPROGRESS      115
+#define ESTALE           116
+#define EUCLEAN          117
+#define ENOTNAM          118
+#define ENAVAIL          119
+#define EISNAM           120
+#define EREMOTEIO        121
+#define EDQUOT           122
+#define ENOMEDIUM        123
+#define EMEDIUMTYPE      124
+#define ECANCELED        125
+#define ENOKEY           126
+#define EKEYEXPIRED      127
+#define EKEYREVOKED      128
+#define EKEYREJECTED     129
+#define EOWNERDEAD       130
+#define ENOTRECOVERABLE  131
+#define ERFKILL          132
+#define EHWPOISON        133
+
+/* Common aliases. */
+#define EWOULDBLOCK EAGAIN
+#define EDEADLOCK   EDEADLK
+
+extern char *program_invocation_name;
+extern char *program_invocation_short_name;
+
+#endif /* _RUBYCC_ERRNO_H */

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

@@ -0,0 +1,144 @@
+/* rubycc bundled <fcntl.h>: the open/fcntl flag macros, the fcntl commands,
+   the *at family constants, and struct flock (POSIX). Provenance: clean room
+   against the Linux kernel UAPI (asm-generic/fcntl.h plus the arch-specific
+   uapi/asm/fcntl.h), not derived from musl. The O_*, F_* and AT_* values and
+   the struct flock layout are ABI facts reproduced as measured integers, not
+   copied text (see docs/HEADER-LICENSING.md) -- the same treatment as
+   errno.h and sys/stat.h. open/openat/creat/fcntl are POSIX declarations.
+   Placed in the glibc/aarch64 layer because O_DIRECT, O_DIRECTORY and
+   O_NOFOLLOW swap bit assignments here versus x86-64's uapi/asm/fcntl.h.
+   Two macros -- O_ACCMODE and O_LARGEFILE -- additionally differ between the
+   two C libraries; both measured values are carried below, selected by
+   __RUBYCC_LIBC_MUSL__ (see the preprocessor's LIBCS). This is also the layer
+   that exists precisely because values move between machines -- the O_DIRECT
+   group below is the standing proof, and O_LARGEFILE is a second one: musl's
+   figure here (131072, i.e. 0400000) is not musl's x86-64 figure (32768,
+   i.e. 0100000). Had this file copied the x86-64 companion's musl value
+   instead of measuring its own, it would have been wrong. */
+
+#ifndef _RUBYCC_FCNTL_H
+#define _RUBYCC_FCNTL_H
+
+#ifndef _RUBYCC_MODE_T
+#define _RUBYCC_MODE_T
+typedef unsigned int mode_t;
+#endif
+#ifndef _RUBYCC_OFF_T
+#define _RUBYCC_OFF_T
+typedef long off_t;
+#endif
+#ifndef _RUBYCC_PID_T
+#define _RUBYCC_PID_T
+typedef int pid_t;
+#endif
+
+/* Access modes (octal). */
+#define O_RDONLY  0
+#define O_WRONLY  01
+#define O_RDWR    02
+/* O_ACCMODE is one of the two flag macros the two libcs disagree on: musl's
+   access-mode mask spans the O_PATH bit as well (measured 2097155, i.e.
+   010000003), glibc's is the low two bits only (measured 3, i.e. 03) -- the
+   same pair the x86-64 companion carries, and measured identically here
+   (docs/STEPS.md Step 202), not merely assumed to match it (R8). Both
+   figures are measurements of the ABI harness, glibc's on this host and
+   musl's on the CI aarch64 musl run. */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define O_ACCMODE 010000003
+#else
+#define O_ACCMODE 03
+#endif
+
+/* Creation and status flags (octal, kernel ABI). */
+#define O_CREAT     0100
+#define O_EXCL      0200
+#define O_NOCTTY    0400
+#define O_TRUNC     01000
+#define O_APPEND    02000
+#define O_NONBLOCK  04000
+#define O_NDELAY    O_NONBLOCK
+#define O_DSYNC     010000
+#define O_ASYNC     020000
+#define O_SYNC      04010000
+#define O_RSYNC     O_SYNC
+#define O_CLOEXEC   02000000
+/* O_LARGEFILE is the other flag macro the two libcs disagree on: musl hands
+   out the kernel's own large-file bit (measured 131072, i.e. 0400000) while
+   glibc, whose LP64 off_t is already 64-bit, leaves it empty (measured 0).
+   Unlike O_ACCMODE above, this is NOT the x86-64 companion's musl figure
+   (32768, i.e. 0100000): the large-file bit's position is arch specific, the
+   same way O_DIRECT/O_DIRECTORY/O_NOFOLLOW are, so copying x86-64's value here
+   would have been wrong rather than merely unmeasured (R8). Both measured
+   with the ABI harness, glibc's here and musl's on the CI aarch64 musl run
+   (docs/STEPS.md Step 202). */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define O_LARGEFILE 0400000
+#else
+#define O_LARGEFILE 0
+#endif
+#define O_NOATIME   01000000
+#define O_PATH      010000000
+
+/* Arch-specific bits (kernel uapi/asm/fcntl.h): O_DIRECT/O_DIRECTORY/
+   O_NOFOLLOW swap values here versus x86-64. */
+#define O_DIRECT    0200000
+#define O_DIRECTORY 040000
+#define O_NOFOLLOW  0100000
+
+#define __O_TMPFILE 020000000
+#define O_TMPFILE   (__O_TMPFILE | O_DIRECTORY)
+
+/* fcntl commands. */
+#define F_DUPFD  0
+#define F_GETFD  1
+#define F_SETFD  2
+#define F_GETFL  3
+#define F_SETFL  4
+#define F_GETLK  5
+#define F_SETLK  6
+#define F_SETLKW 7
+#define F_SETOWN 8
+#define F_GETOWN 9
+#define F_DUPFD_CLOEXEC 1030
+/* Linux pipe-buffer sizing (Fcntl exposes both). Measured on this target
+   rather than derived: 1024 + 7 and 1024 + 8 off the Linux-specific base,
+   the same pair on x86-64 and aarch64. */
+#define F_SETPIPE_SZ 1031
+#define F_GETPIPE_SZ 1032
+
+/* FD_CLOEXEC: the sole close-on-exec bit for F_GETFD/F_SETFD. */
+#define FD_CLOEXEC 1
+
+/* struct flock l_type / l_whence values. */
+#define F_RDLCK 0
+#define F_WRLCK 1
+#define F_UNLCK 2
+
+/* *at family flags. */
+#define AT_FDCWD            (-100)
+#define AT_SYMLINK_NOFOLLOW 0x100
+#define AT_REMOVEDIR        0x200
+#define AT_SYMLINK_FOLLOW   0x400
+#define AT_EACCESS          0x200
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#endif
+
+/* struct flock: 32 bytes, 8-byte aligned (LP64, measured). */
+struct flock {
+  short l_type;
+  short l_whence;
+  off_t l_start;
+  off_t l_len;
+  pid_t l_pid;
+};
+
+int open(const char *__file, int __oflag, ...);
+int openat(int __fd, const char *__file, int __oflag, ...);
+int creat(const char *__file, mode_t __mode);
+int fcntl(int __fd, int __cmd, ...);
+
+#endif /* _RUBYCC_FCNTL_H */

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

@@ -0,0 +1,182 @@
+/* rubycc bundled <inttypes.h>: the <stdint.h> types plus the printf/scanf
+   format-specifier macros (ISO C 7.8) and the greatest-width integer calls.
+   Derived from musl's <inttypes.h> shape; the PRI and SCN length modifiers are
+   pinned to the glibc x86-64 LP64 ABI (the 64-bit, MAX, PTR and fast16+ forms
+   use "l", measured). ABI switch layer: the format widths track the type
+   widths, which are arch specific. */
+
+#ifndef _RUBYCC_INTTYPES_H
+#define _RUBYCC_INTTYPES_H
+
+#include <stdint.h>
+
+#ifndef _RUBYCC_WCHAR_T
+#define _RUBYCC_WCHAR_T
+typedef int wchar_t;
+#endif
+
+typedef struct { intmax_t quot; intmax_t rem; } imaxdiv_t;
+
+#define PRId8 "d"
+#define PRId16 "d"
+#define PRId32 "d"
+#define PRId64 "ld"
+#define PRIdLEAST8 "d"
+#define PRIdLEAST16 "d"
+#define PRIdLEAST32 "d"
+#define PRIdLEAST64 "ld"
+#define PRIdFAST8 "d"
+#define PRIdFAST16 "ld"
+#define PRIdFAST32 "ld"
+#define PRIdFAST64 "ld"
+#define PRIdMAX "ld"
+#define PRIdPTR "ld"
+#define PRIi8 "i"
+#define PRIi16 "i"
+#define PRIi32 "i"
+#define PRIi64 "li"
+#define PRIiLEAST8 "i"
+#define PRIiLEAST16 "i"
+#define PRIiLEAST32 "i"
+#define PRIiLEAST64 "li"
+#define PRIiFAST8 "i"
+#define PRIiFAST16 "li"
+#define PRIiFAST32 "li"
+#define PRIiFAST64 "li"
+#define PRIiMAX "li"
+#define PRIiPTR "li"
+#define PRIo8 "o"
+#define PRIo16 "o"
+#define PRIo32 "o"
+#define PRIo64 "lo"
+#define PRIoLEAST8 "o"
+#define PRIoLEAST16 "o"
+#define PRIoLEAST32 "o"
+#define PRIoLEAST64 "lo"
+#define PRIoFAST8 "o"
+#define PRIoFAST16 "lo"
+#define PRIoFAST32 "lo"
+#define PRIoFAST64 "lo"
+#define PRIoMAX "lo"
+#define PRIoPTR "lo"
+#define PRIu8 "u"
+#define PRIu16 "u"
+#define PRIu32 "u"
+#define PRIu64 "lu"
+#define PRIuLEAST8 "u"
+#define PRIuLEAST16 "u"
+#define PRIuLEAST32 "u"
+#define PRIuLEAST64 "lu"
+#define PRIuFAST8 "u"
+#define PRIuFAST16 "lu"
+#define PRIuFAST32 "lu"
+#define PRIuFAST64 "lu"
+#define PRIuMAX "lu"
+#define PRIuPTR "lu"
+#define PRIx8 "x"
+#define PRIx16 "x"
+#define PRIx32 "x"
+#define PRIx64 "lx"
+#define PRIxLEAST8 "x"
+#define PRIxLEAST16 "x"
+#define PRIxLEAST32 "x"
+#define PRIxLEAST64 "lx"
+#define PRIxFAST8 "x"
+#define PRIxFAST16 "lx"
+#define PRIxFAST32 "lx"
+#define PRIxFAST64 "lx"
+#define PRIxMAX "lx"
+#define PRIxPTR "lx"
+#define PRIX8 "X"
+#define PRIX16 "X"
+#define PRIX32 "X"
+#define PRIX64 "lX"
+#define PRIXLEAST8 "X"
+#define PRIXLEAST16 "X"
+#define PRIXLEAST32 "X"
+#define PRIXLEAST64 "lX"
+#define PRIXFAST8 "X"
+#define PRIXFAST16 "lX"
+#define PRIXFAST32 "lX"
+#define PRIXFAST64 "lX"
+#define PRIXMAX "lX"
+#define PRIXPTR "lX"
+#define SCNd8 "hhd"
+#define SCNd16 "hd"
+#define SCNd32 "d"
+#define SCNd64 "ld"
+#define SCNdLEAST8 "hhd"
+#define SCNdLEAST16 "hd"
+#define SCNdLEAST32 "d"
+#define SCNdLEAST64 "ld"
+#define SCNdFAST8 "hhd"
+#define SCNdFAST16 "ld"
+#define SCNdFAST32 "ld"
+#define SCNdFAST64 "ld"
+#define SCNdMAX "ld"
+#define SCNdPTR "ld"
+#define SCNi8 "hhi"
+#define SCNi16 "hi"
+#define SCNi32 "i"
+#define SCNi64 "li"
+#define SCNiLEAST8 "hhi"
+#define SCNiLEAST16 "hi"
+#define SCNiLEAST32 "i"
+#define SCNiLEAST64 "li"
+#define SCNiFAST8 "hhi"
+#define SCNiFAST16 "li"
+#define SCNiFAST32 "li"
+#define SCNiFAST64 "li"
+#define SCNiMAX "li"
+#define SCNiPTR "li"
+#define SCNo8 "hho"
+#define SCNo16 "ho"
+#define SCNo32 "o"
+#define SCNo64 "lo"
+#define SCNoLEAST8 "hho"
+#define SCNoLEAST16 "ho"
+#define SCNoLEAST32 "o"
+#define SCNoLEAST64 "lo"
+#define SCNoFAST8 "hho"
+#define SCNoFAST16 "lo"
+#define SCNoFAST32 "lo"
+#define SCNoFAST64 "lo"
+#define SCNoMAX "lo"
+#define SCNoPTR "lo"
+#define SCNu8 "hhu"
+#define SCNu16 "hu"
+#define SCNu32 "u"
+#define SCNu64 "lu"
+#define SCNuLEAST8 "hhu"
+#define SCNuLEAST16 "hu"
+#define SCNuLEAST32 "u"
+#define SCNuLEAST64 "lu"
+#define SCNuFAST8 "hhu"
+#define SCNuFAST16 "lu"
+#define SCNuFAST32 "lu"
+#define SCNuFAST64 "lu"
+#define SCNuMAX "lu"
+#define SCNuPTR "lu"
+#define SCNx8 "hhx"
+#define SCNx16 "hx"
+#define SCNx32 "x"
+#define SCNx64 "lx"
+#define SCNxLEAST8 "hhx"
+#define SCNxLEAST16 "hx"
+#define SCNxLEAST32 "x"
+#define SCNxLEAST64 "lx"
+#define SCNxFAST8 "hhx"
+#define SCNxFAST16 "lx"
+#define SCNxFAST32 "lx"
+#define SCNxFAST64 "lx"
+#define SCNxMAX "lx"
+#define SCNxPTR "lx"
+
+intmax_t  imaxabs(intmax_t __n);
+imaxdiv_t imaxdiv(intmax_t __numer, intmax_t __denom);
+intmax_t  strtoimax(const char *__restrict __nptr, char **__restrict __endptr, int __base);
+uintmax_t strtoumax(const char *__restrict __nptr, char **__restrict __endptr, int __base);
+intmax_t  wcstoimax(const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base);
+uintmax_t wcstoumax(const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base);
+
+#endif /* _RUBYCC_INTTYPES_H */

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

@@ -0,0 +1,63 @@
+/* rubycc bundled <limits.h>: the arithmetic-type ranges (ISO C 5.2.4.2.1).
+   Derived from the ISO-mandated values with the `long`/`char` widths pinned to
+   the glibc x86-64 LP64 ABI (`long` is 64-bit); the arithmetic ranges are the
+   same under either C library, and only MB_LEN_MAX differs between them
+   (carried below under __RUBYCC_LIBC_MUSL__, see the preprocessor's LIBCS).
+   ABI switch layer: LONG_MAX is arch specific, and so is the signedness of
+   plain char -- that one is taken from the compiler's own __CHAR_UNSIGNED__
+   rather than from this directory. */
+
+#ifndef _RUBYCC_LIMITS_H
+#define _RUBYCC_LIMITS_H
+
+#define CHAR_BIT    8
+/* MB_LEN_MAX is the one value in this header the two C libraries disagree on:
+   musl reports 4 (its widest multibyte character, UTF-8's four bytes) and
+   glibc 16, the same pair the x86-64 companion carries -- but not copied from
+   it (a value's identity across two machines is a coincidence, not a rule
+   this layer may assume, R8): measured directly on the CI aarch64 musl run
+   (docs/STEPS.md Step 202), with glibc's on this host. */
+#if defined(__RUBYCC_LIBC_MUSL__)
+#define MB_LEN_MAX  4
+#else
+#define MB_LEN_MAX  16
+#endif
+
+#define SCHAR_MIN   (-128)
+#define SCHAR_MAX   127
+#define UCHAR_MAX   255
+
+/* Plain char's signedness is implementation-defined and pinned per ABI: signed
+   on the x86-64 SysV ABI, unsigned on AAPCS64. rubycc predefines
+   __CHAR_UNSIGNED__ on a target of the latter kind (as gcc does), so the range
+   follows the compilation target rather than this header's directory. */
+#ifdef __CHAR_UNSIGNED__
+#define CHAR_MIN    0
+#define CHAR_MAX    UCHAR_MAX
+#else
+#define CHAR_MIN    SCHAR_MIN
+#define CHAR_MAX    SCHAR_MAX
+#endif
+
+#define SHRT_MIN    (-32768)
+#define SHRT_MAX    32767
+#define USHRT_MAX   65535
+
+#define INT_MIN     (-INT_MAX-1)
+#define INT_MAX     2147483647
+#define UINT_MAX    4294967295U
+
+#define LONG_MIN    (-LONG_MAX-1L)
+#define LONG_MAX    9223372036854775807L
+#define ULONG_MAX   18446744073709551615UL
+
+#define LLONG_MIN   (-LLONG_MAX-1LL)
+#define LLONG_MAX   9223372036854775807LL
+#define ULLONG_MAX  18446744073709551615ULL
+
+/* GNU spellings some code still uses. */
+#define LONG_LONG_MIN   LLONG_MIN
+#define LONG_LONG_MAX   LLONG_MAX
+#define ULONG_LONG_MAX  ULLONG_MAX
+
+#endif /* _RUBYCC_LIMITS_H */