boot2

lispcc-syscall.c (6743B)

---

 /* lispcc-syscall.c — replaces mes's per-arch inline-asm syscall wrappers
  * with C wrappers that call P1pp's labelled syscall entry points.
  *
  * The P1pp labels (sys_read / sys_write / sys_open / sys_close /
  * sys_lseek / sys_brk / sys_unlink / sys_exit) are defined in
  * P1/P1pp.P1pp and resolved at the linker stage thanks to cc.scm's
  * external-linkage rule (commit 6488cca).
  *
  * Layering:
  *   public libc (read, write, open, …) — comes from the posix layer
  *      └─ low-level _read, _write, _open3 — provided here
  *           └─ named sys_* labels — provided by P1pp.P1pp
  *
  * mes's linux/{brk,close,lseek,_open3,_read,unlink}.c are NOT vendored;
  * the equivalents live here and bypass mes's _sys_callN indirection.
  * mes's linux/<arch>-mes-{mescc,gcc}/{syscall,_exit,_write,…}.c are
  * also unused — those are the inline-asm files we replace.
  */
 
 #include <mes/lib.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <sys/stat.h>
 
 /* mes's <stdio.h> defines stdin/stdout/stderr as macros expanding to
  * (FILE*)0/1/2. That works for libc's own .c files, but client code
  * (cc-libc tests, eventually tcc-boot2's compiled output) that uses
  * `extern FILE *stdout;` needs a real linkage symbol. Drop the macros
  * after libc's headers have set their guards, then define globals
  * with the same initializer values. mes's libc bodies that already
  * referenced `stdout` had the macro substitution happen on their
  * #include path; subsequent .c files re-include <stdio.h> but hit
  * the include guard and so see the now-undef'd identifiers, which
  * resolve to our globals at link time (same numeric value, same fd). */
 #undef stdin
 #undef stdout
 #undef stderr
 FILE *stdin  = (FILE *) 0;
 FILE *stdout = (FILE *) 1;
 FILE *stderr = (FILE *) 2;
 
 /* `__stdout` and friends (the int-typed fd globals oputs / fdputs read)
  * are file-scope initialized in mes/mes_open.c — but that initializer
  * is gated behind `#if SYSTEM_LIBC`, which we don't define. Without
  * SYSTEM_LIBC we'd be left with only mes/globals.c's tentative
  * `int __stdout;`, which zero-inits — meaning oputs("ok") writes to
  * fd 0 (read-only stdin) and silently no-ops. unified-libc.c includes
  * lispcc-syscall.c before globals.c, so cc.scm's redecl-merge sees
  * the proper definition first and absorbs the later tentative. */
 int __stdin  = 0;
 int __stdout = 1;
 int __stderr = 2;
 
 extern long sys_read   (long fd, long buf, long n);
 extern long sys_write  (long fd, long buf, long n);
 extern long sys_open   (long path, long flags, long mode);
 extern long sys_close  (long fd);
 extern long sys_lseek  (long fd, long off, long whence);
 extern long sys_brk    (long addr);
 extern long sys_unlink (long path);
 extern long sys_exit   (long code);
 
 /* mes/globals.c already provides `int errno;` and the FILE-helper
  * indirections (__buffered_read_clear, __ungetc_clear, __ungetc_init).
  * mes/__buffered_read.c and mes/fdgetc.c implement them. */
 
 ssize_t
 _read (int filedes, void *buffer, size_t size)
 {
   return sys_read (filedes, (long) buffer, (long) size);
 }
 
 ssize_t
 _write (int filedes, void const *buffer, size_t size)
 {
   return sys_write (filedes, (long) buffer, (long) size);
 }
 
 int
 _open3 (char const *file_name, int flags, int mask)
 {
   int r = sys_open ((long) file_name, flags, mask);
   __ungetc_init ();
   if (r > 2)
     {
       if (r >= __FILEDES_MAX)
         {
           errno = EMFILE;
           return -1;
         }
       __ungetc_clear (r);
       __buffered_read_clear (r);
     }
   return r;
 }
 
 int
 close (int filedes)
 {
   long r = sys_close (filedes);
   if (r < 0)
     {
       errno = -r;
       return -1;
     }
   errno = 0;
   return (int) r;
 }
 
 off_t
 _lseek (int filedes, off_t offset, int whence)
 {
   return sys_lseek (filedes, offset, whence);
 }
 
 off_t
 lseek (int filedes, off_t offset, int whence)
 {
   /* mirrors mes's linux/lseek.c: drain the per-fd read buffer before
    * letting the kernel see a positional move; SEEK_CUR offsets must
    * back out the buffered-but-not-yet-consumed bytes. */
   size_t skip = __buffered_read_clear (filedes);
   if (whence == SEEK_CUR)
     offset -= skip;
   return sys_lseek (filedes, offset, whence);
 }
 
 long
 brk (void *addr)
 {
   return sys_brk ((long) addr);
 }
 
 int
 unlink (char const *file_name)
 {
   long r = sys_unlink ((long) file_name);
   if (r < 0)
     {
       errno = -r;
       return -1;
     }
   errno = 0;
   return 0;
 }
 
 void
 _exit (int status)
 {
   sys_exit (status);
 }
 
 /* Linux aarch64/amd64/riscv64 stack at exec entry:
  *   [sp]               = argc
  *   [sp + 8 * (1)]     = argv[0]
  *   ...
  *   [sp + 8 * (argc+1)] = NULL  (terminates argv)
  *   [sp + 8 * (argc+2)] = envp[0]
  * Our :_start passes (a0=argc, a1=argv) to :p1_main. envp follows
  * argv's NULL terminator, so we compute it from argv. tcc's getenv
  * walks the resulting environ; without initialization it dereferences
  * NULL on the first call and segfaults during tcc_new(). */
 extern char **environ;
 
 void
 __libc_init (int argc, char **argv)
 {
   (void) argc;
   char **p = argv;
   while (*p)
     p++;
   environ = p + 1;
 }
 
 /* ---- ENOSYS stubs for libc-internal references not exercised by ----
  * tcc-boot2's golden path. The mes libc transitively pulls these in
  * (posix/getcwd.c → _getcwd, posix/execvp.c → execve, stdlib/abort.c
  * → raise, …). Providing -ENOSYS stubs keeps the link clean; if any
  * of these surfaces in a real workload, replace the stub with a P1pp
  * label and a thin wrapper above. */
 
 #define ENOSYS 38
 
 char *
 _getcwd (char *buffer, size_t size)
 {
   (void) buffer; (void) size;
   errno = ENOSYS;
   return 0;
 }
 
 int
 access (char const *path, int mode)
 {
   (void) path; (void) mode;
   errno = ENOSYS;
   return -1;
 }
 
 void
 assert_msg (int check, char *msg)
 {
   if (!check)
     {
       sys_write (2, (long) msg, 0);
       sys_exit (1);
     }
 }
 
 int
 execve (char const *file, char *const argv[], char *const envp[])
 {
   (void) file; (void) argv; (void) envp;
   errno = ENOSYS;
   return -1;
 }
 
 int
 fsync (int filedes)
 {
   (void) filedes;
   return 0;
 }
 
 int
 raise (int sig)
 {
   /* abort() calls raise(SIGABRT); take that as a hard exit. */
   sys_exit (128 + sig);
   return -1;
 }
 
 int
 rmdir (char const *file_name)
 {
   (void) file_name;
   errno = ENOSYS;
   return -1;
 }
 
 int
 stat (char const *file_name, struct stat *buf)
 {
   (void) file_name; (void) buf;
   errno = ENOSYS;
   return -1;
 }
 
 double
 strtod (char const *string, char **tailptr)
 {
   /* tcc.flat.c never reaches strtod under our defines (HAVE_FLOAT off),
    * and stdlib/strtof.c only forwards. cc.scm rejects FP literals, so
    * we cast a zero int — same numeric value, no `0.0` token. */
   if (tailptr)
     *tailptr = (char *) string;
   return (double) 0;
 }