rubycc 1.0.0

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

@@ -0,0 +1,136 @@
+/* rubycc bundled <sys/stat.h>: struct stat and the file-mode macros (POSIX).
+   Provenance: clean room against the Linux aarch64 kernel ABI, not derived from
+   musl. struct stat is pinned to that ABI, which differs from x86-64's: it is
+   128 bytes (not 144), st_mode precedes st_nlink, nlink_t/blksize_t are 32-bit,
+   and glibc reserves three slots to reach that size -- an 8-byte __pad1 after
+   st_rdev (a second dev_t's worth of space), a 4-byte __pad2 after st_blksize,
+   and a trailing int __glibc_reserved[2]. The measured field offsets are st_dev
+   0, st_ino 8, st_mode 16, st_nlink 20, st_uid 24, st_gid 28, st_rdev 32,
+   st_size 48, st_blksize 56, st_blocks 64, st_atim 72, st_mtim 88, st_ctim 104.
+   Both the layout and the S_IF* octal values are ABI facts reproduced by
+   measurement, not copied text (see docs/HEADER-LICENSING.md). The S_IF* values
+   are the kernel ABI, identical to x86-64. Placed in the glibc/aarch64 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 int 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 int 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;          /*  0 */
+  ino_t   st_ino;          /*  8 */
+  mode_t  st_mode;         /* 16 (precedes st_nlink on aarch64) */
+  nlink_t st_nlink;        /* 20 (32-bit) */
+  uid_t   st_uid;          /* 24 */
+  gid_t   st_gid;          /* 28 */
+  dev_t   st_rdev;         /* 32 */
+  dev_t   __pad1;          /* 40 (reserved dev_t slot) */
+  off_t   st_size;         /* 48 */
+  blksize_t st_blksize;    /* 56 (32-bit) */
+  int     __pad2;          /* 60 */
+  blkcnt_t  st_blocks;     /* 64 */
+  struct timespec st_atim; /* 72 */
+  struct timespec st_mtim; /* 88 */
+  struct timespec st_ctim; /* 104 */
+  int __glibc_reserved[2]; /* 120, filling out to 128 */
+};
+
+/* 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 */

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

@@ -0,0 +1,167 @@
+/* rubycc bundled <sys/syscall.h> (aarch64): the system-call numbers, as the
+   SYS_ names callers pass to syscall(2). Provenance: clean room against the
+   Linux kernel's aarch64 (asm-generic) system-call table, not derived from
+   musl or glibc source. Every number below was printed from the glibc oracle
+   under the cross toolchain and qemu (an ABI fact, not copied text -- see
+   docs/HEADER-LICENSING.md sec. 4).
+
+   Arch layer, necessarily: aarch64 uses the modern asm-generic numbering
+   while x86-64 keeps its own historical table, and measured side by side the
+   two disagree on essentially every entry -- SYS_read is 63 here and 0
+   there, SYS_write 64 vs 1, SYS_openat 56 vs 257, SYS_epoll_ctl 21 vs 233.
+   The x86-64 sibling carries the same set of names with its own numbers; the
+   only entries where the two agree are the io_uring trio (425/426/427),
+   allocated from the shared modern range. See that file's header note for
+   the __NR_/SYS_ two-level spelling and the scope rule (only names present
+   on both targets, so the legacy x86-64-only entry points -- open, poll,
+   select, pipe, dup2 and their kin, which the asm-generic table simply does
+   not have -- are left out on both sides).
+
+   Like glibc's, this header does not declare syscall() itself; the prototype
+   belongs to <unistd.h>. */
+
+#ifndef _RUBYCC_SYS_SYSCALL_H
+#define _RUBYCC_SYS_SYSCALL_H
+
+/* Basic file I/O. */
+#define __NR_read     63
+#define __NR_write    64
+#define __NR_close    57
+#define __NR_lseek    62
+#define __NR_openat   56
+#define __NR_readlinkat 78
+#define __NR_faccessat  48
+#define __NR_ioctl    29
+#define __NR_fcntl    25
+#define __NR_pipe2    59
+#define __NR_dup3     24
+
+/* Filesystem statistics (the calls behind <sys/statfs.h>). */
+#define __NR_statfs   43
+#define __NR_fstatfs  44
+
+/* Memory. */
+#define __NR_mmap     222
+#define __NR_mprotect 226
+#define __NR_munmap   215
+
+/* Processes, threads and signals. */
+#define __NR_clone          220
+#define __NR_exit           93
+#define __NR_exit_group     94
+#define __NR_getpid         172
+#define __NR_gettid         178
+#define __NR_kill           129
+#define __NR_tgkill         131
+#define __NR_rt_sigaction   134
+#define __NR_rt_sigprocmask 135
+#define __NR_futex          98
+#define __NR_sched_yield    124
+#define __NR_getcpu         168
+#define __NR_membarrier     283
+#define __NR_getrandom      278
+
+/* Time. */
+#define __NR_nanosleep       101
+#define __NR_clock_gettime   113
+#define __NR_clock_nanosleep 115
+
+/* Event notification: the file-descriptor-based interfaces libev drives
+   through raw syscalls when the libc wrappers are not available. */
+#define __NR_epoll_create1     20
+#define __NR_epoll_ctl         21
+#define __NR_epoll_pwait       22
+#define __NR_ppoll             73
+#define __NR_pselect6          72
+#define __NR_eventfd2          19
+#define __NR_signalfd4         74
+#define __NR_inotify_init1     26
+#define __NR_inotify_add_watch 27
+#define __NR_inotify_rm_watch  28
+#define __NR_timerfd_create    85
+#define __NR_timerfd_settime   86
+#define __NR_timerfd_gettime   87
+
+/* Asynchronous I/O: the legacy linux-aio calls and io_uring. These have no
+   libc wrappers at all, which is why libev issues them by number. The aio
+   five sit at 0..4 here, the very start of the asm-generic table. */
+#define __NR_io_setup          0
+#define __NR_io_destroy        1
+#define __NR_io_submit         2
+#define __NR_io_cancel         3
+#define __NR_io_getevents      4
+#define __NR_io_uring_setup    425
+#define __NR_io_uring_enter    426
+#define __NR_io_uring_register 427
+
+/* Sockets. */
+#define __NR_socket     198
+#define __NR_setsockopt 208
+
+/* The SYS_ spellings: aliases of the __NR_ names above, which is the
+   relationship measured against the real header. */
+#define SYS_read     __NR_read
+#define SYS_write    __NR_write
+#define SYS_close    __NR_close
+#define SYS_lseek    __NR_lseek
+#define SYS_openat   __NR_openat
+#define SYS_readlinkat __NR_readlinkat
+#define SYS_faccessat  __NR_faccessat
+#define SYS_ioctl    __NR_ioctl
+#define SYS_fcntl    __NR_fcntl
+#define SYS_pipe2    __NR_pipe2
+#define SYS_dup3     __NR_dup3
+
+#define SYS_statfs   __NR_statfs
+#define SYS_fstatfs  __NR_fstatfs
+
+#define SYS_mmap     __NR_mmap
+#define SYS_mprotect __NR_mprotect
+#define SYS_munmap   __NR_munmap
+
+#define SYS_clone          __NR_clone
+#define SYS_exit           __NR_exit
+#define SYS_exit_group     __NR_exit_group
+#define SYS_getpid         __NR_getpid
+#define SYS_gettid         __NR_gettid
+#define SYS_kill           __NR_kill
+#define SYS_tgkill         __NR_tgkill
+#define SYS_rt_sigaction   __NR_rt_sigaction
+#define SYS_rt_sigprocmask __NR_rt_sigprocmask
+#define SYS_futex          __NR_futex
+#define SYS_sched_yield    __NR_sched_yield
+#define SYS_getcpu         __NR_getcpu
+#define SYS_membarrier     __NR_membarrier
+#define SYS_getrandom      __NR_getrandom
+
+#define SYS_nanosleep       __NR_nanosleep
+#define SYS_clock_gettime   __NR_clock_gettime
+#define SYS_clock_nanosleep __NR_clock_nanosleep
+
+#define SYS_epoll_create1     __NR_epoll_create1
+#define SYS_epoll_ctl         __NR_epoll_ctl
+#define SYS_epoll_pwait       __NR_epoll_pwait
+#define SYS_ppoll             __NR_ppoll
+#define SYS_pselect6          __NR_pselect6
+#define SYS_eventfd2          __NR_eventfd2
+#define SYS_signalfd4         __NR_signalfd4
+#define SYS_inotify_init1     __NR_inotify_init1
+#define SYS_inotify_add_watch __NR_inotify_add_watch
+#define SYS_inotify_rm_watch  __NR_inotify_rm_watch
+#define SYS_timerfd_create    __NR_timerfd_create
+#define SYS_timerfd_settime   __NR_timerfd_settime
+#define SYS_timerfd_gettime   __NR_timerfd_gettime
+
+#define SYS_io_setup          __NR_io_setup
+#define SYS_io_destroy        __NR_io_destroy
+#define SYS_io_getevents      __NR_io_getevents
+#define SYS_io_submit         __NR_io_submit
+#define SYS_io_cancel         __NR_io_cancel
+#define SYS_io_uring_setup    __NR_io_uring_setup
+#define SYS_io_uring_enter    __NR_io_uring_enter
+#define SYS_io_uring_register __NR_io_uring_register
+
+#define SYS_socket     __NR_socket
+#define SYS_setsockopt __NR_setsockopt
+
+#endif /* _RUBYCC_SYS_SYSCALL_H */

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

@@ -0,0 +1,74 @@
+/* rubycc bundled <sys/time.h>: struct timeval and the BSD time calls (POSIX).
+   Derived from musl's <sys/time.h> shape; struct timeval's members are pinned to
+   the glibc x86-64 ABI (time_t and suseconds_t are both `long`, giving a 16-byte
+   layout, measured). The struct guard reuses glibc's __timeval_defined. ABI
+   switch layer: the member widths are arch specific. */
+
+#ifndef _RUBYCC_SYS_TIME_H
+#define _RUBYCC_SYS_TIME_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
+
+struct timezone {
+  int tz_minuteswest;
+  int tz_dsttime;
+};
+
+struct itimerval {
+  struct timeval it_interval;
+  struct timeval it_value;
+};
+
+#define ITIMER_REAL    0
+#define ITIMER_VIRTUAL 1
+#define ITIMER_PROF    2
+
+int gettimeofday(struct timeval *__restrict __tv, void *__restrict __tz);
+int settimeofday(const struct timeval *__tv, const struct timezone *__tz);
+int getitimer(int __which, struct itimerval *__value);
+int setitimer(int __which, const struct itimerval *__restrict __new,
+              struct itimerval *__restrict __old);
+int utimes(const char *__file, const struct timeval __tvp[2]);
+
+/* Convenience timeval arithmetic macros (glibc/BSD, under _DEFAULT_SOURCE). */
+#define timerisset(tvp)   ((tvp)->tv_sec || (tvp)->tv_usec)
+#define timerclear(tvp)   ((tvp)->tv_sec = (tvp)->tv_usec = 0)
+#define timercmp(a, b, CMP) \
+  (((a)->tv_sec == (b)->tv_sec) ? \
+   ((a)->tv_usec CMP (b)->tv_usec) : \
+   ((a)->tv_sec CMP (b)->tv_sec))
+#define timeradd(a, b, result)                        \
+  do {                                                \
+    (result)->tv_sec = (a)->tv_sec + (b)->tv_sec;     \
+    (result)->tv_usec = (a)->tv_usec + (b)->tv_usec;  \
+    if ((result)->tv_usec >= 1000000) {               \
+      ++(result)->tv_sec;                             \
+      (result)->tv_usec -= 1000000;                   \
+    }                                                 \
+  } while (0)
+#define timersub(a, b, result)                        \
+  do {                                                \
+    (result)->tv_sec = (a)->tv_sec - (b)->tv_sec;     \
+    (result)->tv_usec = (a)->tv_usec - (b)->tv_usec;  \
+    if ((result)->tv_usec < 0) {                      \
+      --(result)->tv_sec;                             \
+      (result)->tv_usec += 1000000;                   \
+    }                                                 \
+  } while (0)
+
+#endif /* _RUBYCC_SYS_TIME_H */

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

@@ -0,0 +1,127 @@
+/* rubycc bundled <sys/types.h>: the width-critical POSIX typedefs. Derived from
+   musl's <sys/types.h> shape; every width and signedness is pinned to the glibc
+   aarch64 LP64 ABI (measured): off_t/time_t/ssize_t are `long`, pid_t is `int`,
+   dev_t/ino_t are `unsigned long`. Two typedefs are narrower here than in the
+   x86-64 layer: aarch64 glibc makes nlink_t `unsigned int` and blksize_t `int`
+   (both 32-bit), where x86-64 makes them 64-bit. Each typedef is guarded by a
+   shared _RUBYCC_* tag so the other bundled headers that also spell these types
+   agree rather than redefine (in particular <sys/stat.h> in this same layer,
+   which must pin nlink_t/blksize_t to the identical widths). ABI switch layer:
+   the widths are arch specific. */
+
+#ifndef _RUBYCC_SYS_TYPES_H
+#define _RUBYCC_SYS_TYPES_H
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_SSIZE_T
+#define _RUBYCC_SSIZE_T
+typedef long ssize_t;
+#endif
+#ifndef _RUBYCC_OFF_T
+#define _RUBYCC_OFF_T
+typedef long off_t;
+#endif
+typedef long off64_t;
+typedef long loff_t;
+#ifndef _RUBYCC_PID_T
+#define _RUBYCC_PID_T
+typedef int pid_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_MODE_T
+#define _RUBYCC_MODE_T
+typedef unsigned int mode_t;
+#endif
+#ifndef _RUBYCC_INO_T
+#define _RUBYCC_INO_T
+typedef unsigned long ino_t;
+#endif
+typedef unsigned long ino64_t;
+#ifndef _RUBYCC_DEV_T
+#define _RUBYCC_DEV_T
+typedef unsigned long dev_t;
+#endif
+#ifndef _RUBYCC_NLINK_T
+#define _RUBYCC_NLINK_T
+typedef unsigned int nlink_t;
+#endif
+#ifndef _RUBYCC_BLKSIZE_T
+#define _RUBYCC_BLKSIZE_T
+typedef int blksize_t;
+#endif
+#ifndef _RUBYCC_BLKCNT_T
+#define _RUBYCC_BLKCNT_T
+typedef long blkcnt_t;
+#endif
+typedef long blkcnt64_t;
+#ifndef _RUBYCC_FSBLKCNT_T
+#define _RUBYCC_FSBLKCNT_T
+typedef unsigned long fsblkcnt_t;
+#endif
+typedef unsigned long fsblkcnt64_t;
+#ifndef _RUBYCC_FSFILCNT_T
+#define _RUBYCC_FSFILCNT_T
+typedef unsigned long fsfilcnt_t;
+#endif
+typedef unsigned long fsfilcnt64_t;
+#ifndef _RUBYCC_TIME_T
+#define _RUBYCC_TIME_T
+typedef long time_t;
+#endif
+#ifndef _RUBYCC_CLOCK_T
+#define _RUBYCC_CLOCK_T
+typedef long clock_t;
+#endif
+#ifndef _RUBYCC_CLOCKID_T
+#define _RUBYCC_CLOCKID_T
+typedef int clockid_t;
+#endif
+#ifndef _RUBYCC_TIMER_T
+#define _RUBYCC_TIMER_T
+typedef void *timer_t;
+#endif
+#ifndef _RUBYCC_SUSECONDS_T
+#define _RUBYCC_SUSECONDS_T
+typedef long suseconds_t;
+#endif
+#ifndef _RUBYCC_USECONDS_T
+#define _RUBYCC_USECONDS_T
+typedef unsigned int useconds_t;
+#endif
+#ifndef _RUBYCC_ID_T
+#define _RUBYCC_ID_T
+typedef unsigned int id_t;
+#endif
+#ifndef _RUBYCC_KEY_T
+#define _RUBYCC_KEY_T
+typedef int key_t;
+#endif
+
+typedef long register_t;
+typedef int  daddr_t;
+typedef char *caddr_t;
+
+/* BSD short-hand integer names (glibc exposes them under _DEFAULT_SOURCE). */
+typedef unsigned char  u_char;
+typedef unsigned short u_short;
+typedef unsigned int   u_int;
+typedef unsigned long  u_long;
+typedef unsigned char  ushort;
+typedef unsigned int   uint;
+typedef unsigned long  ulong;
+typedef unsigned char  u_int8_t;
+typedef unsigned short u_int16_t;
+typedef unsigned int   u_int32_t;
+typedef unsigned long  u_int64_t;
+
+#endif /* _RUBYCC_SYS_TYPES_H */

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

@@ -0,0 +1,113 @@
+/* rubycc bundled <time.h>: the calendar/clock types and declarations (ISO C
+   7.27, POSIX). Derived from musl's <time.h> shape; time_t is pinned to `long`
+   and `struct tm` carries glibc's tm_gmtoff/tm_zone extension so its 56-byte
+   layout matches the reference ABI (measured). The struct guards reuse glibc's
+   (__struct_tm_defined, _STRUCT_TIMESPEC) so a host header coexisting on the
+   path does not redefine. ABI switch layer: time_t width and struct tm layout
+   are arch specific. */
+
+#ifndef _RUBYCC_TIME_H
+#define _RUBYCC_TIME_H
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+#ifndef _RUBYCC_SIZE_T
+#define _RUBYCC_SIZE_T
+typedef unsigned long size_t;
+#endif
+#ifndef _RUBYCC_TIME_T
+#define _RUBYCC_TIME_T
+typedef long time_t;
+#endif
+#ifndef _RUBYCC_CLOCK_T
+#define _RUBYCC_CLOCK_T
+typedef long clock_t;
+#endif
+#ifndef _RUBYCC_CLOCKID_T
+#define _RUBYCC_CLOCKID_T
+typedef int clockid_t;
+#endif
+#ifndef _RUBYCC_TIMER_T
+#define _RUBYCC_TIMER_T
+typedef void *timer_t;
+#endif
+#ifndef _RUBYCC_PID_T
+#define _RUBYCC_PID_T
+typedef int pid_t;
+#endif
+
+#define CLOCKS_PER_SEC ((clock_t) 1000000)
+#define TIME_UTC 1
+
+/* POSIX clock ids. */
+#define CLOCK_REALTIME           0
+#define CLOCK_MONOTONIC          1
+#define CLOCK_PROCESS_CPUTIME_ID 2
+#define CLOCK_THREAD_CPUTIME_ID  3
+#define CLOCK_MONOTONIC_RAW      4
+#define CLOCK_REALTIME_COARSE    5
+#define CLOCK_MONOTONIC_COARSE   6
+#define CLOCK_BOOTTIME           7
+#define TIMER_ABSTIME            1
+
+#ifndef _STRUCT_TIMESPEC
+#define _STRUCT_TIMESPEC 1
+struct timespec {
+  time_t tv_sec;
+  long   tv_nsec;
+};
+#endif
+
+#ifndef __struct_tm_defined
+#define __struct_tm_defined 1
+struct tm {
+  int tm_sec;
+  int tm_min;
+  int tm_hour;
+  int tm_mday;
+  int tm_mon;
+  int tm_year;
+  int tm_wday;
+  int tm_yday;
+  int tm_isdst;
+  long tm_gmtoff;
+  const char *tm_zone;
+};
+#endif
+
+struct itimerspec {
+  struct timespec it_interval;
+  struct timespec it_value;
+};
+
+clock_t clock(void);
+time_t time(time_t *__timer);
+double difftime(time_t __time1, time_t __time0);
+time_t mktime(struct tm *__tp);
+size_t strftime(char *__restrict __s, size_t __maxsize,
+                const char *__restrict __format, const struct tm *__restrict __tp);
+struct tm *gmtime(const time_t *__timer);
+struct tm *localtime(const time_t *__timer);
+struct tm *gmtime_r(const time_t *__restrict __timer, struct tm *__restrict __tp);
+struct tm *localtime_r(const time_t *__restrict __timer, struct tm *__restrict __tp);
+char *asctime(const struct tm *__tp);
+char *ctime(const time_t *__timer);
+char *asctime_r(const struct tm *__restrict __tp, char *__restrict __buf);
+char *ctime_r(const time_t *__restrict __timer, char *__restrict __buf);
+char *strptime(const char *__restrict __s, const char *__restrict __fmt, struct tm *__tp);
+
+int nanosleep(const struct timespec *__requested_time, struct timespec *__remaining);
+int clock_gettime(clockid_t __clock_id, struct timespec *__tp);
+int clock_settime(clockid_t __clock_id, const struct timespec *__tp);
+int clock_getres(clockid_t __clock_id, struct timespec *__res);
+time_t timegm(struct tm *__tp);
+time_t timelocal(struct tm *__tp);
+
+extern char *tzname[2];
+extern long timezone;
+extern int daylight;
+void tzset(void);
+
+#endif /* _RUBYCC_TIME_H */