kit

i386.c (5658B)

---

 /*
  * lib/coro/i386.c -- i386 System V (cdecl, ILP32) implementations of
  *   setjmp / longjmp                       (<setjmp.h>)
  *   __kit_coro_ctx_init / __kit_coro_switch / trampoline   (<kit/coro.h>)
  *
  * cdecl callee-saved set: ebx, esi, edi, ebp, esp. Args are pushed
  * right-to-left on the stack: at function entry, 4(%esp)=arg0,
  * 8(%esp)=arg1, 12(%esp)=arg2, (%esp)=return-address.
  *
  *   regs[0]:  ebx     (also stashes entry fn for the trampoline)
  *   regs[1]:  esi
  *   regs[2]:  edi
  *   regs[3]:  ebp
  *   regs[4]:  esp     (caller's pre-call esp)
  *   regs[5]:  eip     (return address)
  *
  * 6 × 4 = 24 bytes of state, padded to sizeof = 32 by the 16-byte
  * over-alignment (vs. natural 4) so coro_ctx's 16-byte alignment is
  * matched.
  *
  *   setjmp(env)             4(%esp)=env
  *   longjmp(env, val)       4(%esp)=env, 8(%esp)=val
  *   __kit_coro_switch(f, t, val)  4(%esp)=from, 8(%esp)=to, 12(%esp)=value
  *
  * The "save esp/eip" trick: at function entry, (%esp) holds the caller's
  * return address (just pushed by `call`); 4(%esp) is the caller's
  * pre-call esp. Saving those two lets longjmp/__kit_coro_switch "land" at the
  * call site exactly as if the function had returned.
  *
  * Modern SysV i386 (ABI rev 1.1+) requires 16-byte stack alignment
  * before each `call`; the trampoline `andl $-16, %esp` enforces this
  * defensively for fresh contexts.
  */
 
 #include <kit/coro.h>
 #include <setjmp.h>
 #include <stddef.h>
 #include <stdint.h>
 
 struct __kit_i386_ctx {
   uintptr_t regs[6];
 } __attribute__((aligned(16)));
 
 _Static_assert(sizeof(struct __kit_i386_ctx) == 32, "layout");
 _Static_assert(_Alignof(struct __kit_i386_ctx) == 16, "align");
 _Static_assert(sizeof(struct __kit_i386_ctx) <= sizeof(coro_ctx),
                "fits coro_ctx");
 _Static_assert(sizeof(struct __kit_i386_ctx) <= sizeof(jmp_buf),
                "fits jmp_buf");
 _Static_assert(_Alignof(coro_ctx) >= _Alignof(struct __kit_i386_ctx),
                "align coro_ctx");
 
 extern void __kit_coro_trampoline(void);
 
 void __kit_coro_ctx_init(coro_ctx* ctx, void* stack_base, size_t stack_len,
                          void (*entry)(uintptr_t)) {
   struct __kit_i386_ctx* c = (struct __kit_i386_ctx*)ctx;
 
   /* i386 stacks grow down; align top to 16. */
   uintptr_t top = (uintptr_t)stack_base + stack_len;
   top &= ~(uintptr_t)(CORO_STACK_ALIGN - 1);
 
   for (size_t i = 0; i < sizeof(*c) / sizeof(uintptr_t); ++i)
     ((uintptr_t*)c)[i] = 0;
 
   c->regs[0] = (uintptr_t)entry;                 /* ebx -- entry fn */
   c->regs[3] = 0;                                /* ebp */
   c->regs[4] = top;                              /* esp */
   c->regs[5] = (uintptr_t)__kit_coro_trampoline; /* eip */
 }
 
 #define STR_(x) #x
 #define STR(x) STR_(x)
 #define SYM(n) STR(__USER_LABEL_PREFIX__) #n
 
 /* Save callee-saved + (caller's) esp + eip into [reg]; clobbers %eax.
    Used at function-entry stack discipline: (%esp)=ret-addr, 4(%esp)=pre-call
    esp. */
 #define SAVE_INTO(reg)       \
   "    movl %ebx,  0(" reg   \
   ")\n"                      \
   "    movl %esi,  4(" reg   \
   ")\n"                      \
   "    movl %edi,  8(" reg   \
   ")\n"                      \
   "    movl %ebp, 12(" reg   \
   ")\n"                      \
   "    leal 4(%esp), %eax\n" \
   "    movl %eax, 16(" reg   \
   ")\n"                      \
   "    movl (%esp), %eax\n"  \
   "    movl %eax, 20(" reg ")\n"
 
 /* Restore callee-saved + esp from [reg], leave eip in %ecx ready to
    jmp. Caller delivers the destination value in %eax beforehand. */
 #define RESTORE_FROM(reg) \
   "    movl  0(" reg      \
   "), %ebx\n"             \
   "    movl  4(" reg      \
   "), %esi\n"             \
   "    movl  8(" reg      \
   "), %edi\n"             \
   "    movl 12(" reg      \
   "), %ebp\n"             \
   "    movl 16(" reg      \
   "), %esp\n"             \
   "    movl 20(" reg "), %ecx\n"
 
 __asm__ (
     ".text\n"
     ".p2align 4\n"
 
     /* setjmp(env) -- env at 4(%esp). */
     ".weak " SYM(setjmp) "\n"
     SYM(setjmp) ":\n"
     "    movl 4(%esp), %edx\n"
     SAVE_INTO("%edx")
     "    xorl %eax, %eax\n"
     "    ret\n"
 
     /* longjmp(env, val) -- env at 4(%esp), val at 8(%esp).
        longjmp(_, 0) must deliver 1 (C11 7.13.2.1p4). */
     ".weak " SYM(longjmp) "\n"
     SYM(longjmp) ":\n"
     "    movl 4(%esp), %edx\n"        /* env */
     "    movl 8(%esp), %eax\n"        /* val */
     "    testl %eax, %eax\n"
     "    movl  $1, %ecx\n"
     "    cmovel %ecx, %eax\n"
     RESTORE_FROM("%edx")
     "    jmp *%ecx\n"
 
     /* __kit_coro_switch(from, to, value) -- 4(%esp)=from, 8(%esp)=to, 12(%esp)=value.
        Read all three args before SAVE_INTO clobbers the stack frame. */
     ".globl " SYM(__kit_coro_switch) "\n"
     SYM(__kit_coro_switch) ":\n"
     "    movl 4(%esp),  %edx\n"       /* from */
     SAVE_INTO("%edx")
     "    movl 8(%esp),  %edx\n"       /* to (re-read; SAVE clobbered %eax not stack) */
     "    movl 12(%esp), %eax\n"       /* value -- delivered as return reg */
     RESTORE_FROM("%edx")
     "    jmp *%ecx\n"
 
     /* __kit_coro_trampoline -- on first entry: %eax=value, %ebx=entry,
        %esp=stack_top (no return addr pushed -- __kit_coro_switch reaches here
        via jmp). cdecl needs the arg pushed; align defensively, then
        reserve 12 bytes + push value so that after the upcoming `call`
        pushes the 4-byte return addr, the callee sees %esp+4 16-aligned. */
     ".globl " SYM(__kit_coro_trampoline) "\n"
     SYM(__kit_coro_trampoline) ":\n"
     "    andl $-16, %esp\n"
     "    subl $12, %esp\n"
     "    pushl %eax\n"                /* arg0 = value */
     "    calll *%ebx\n"               /* entry(value) */
     "    ud2\n"
 );