kit

x86_64.c (5061B)

---

 /*
  * lib/coro/x86_64.c -- x86_64 System V ABI implementations of
  *   setjmp / longjmp                       (<setjmp.h>)
  *   __kit_coro_ctx_init / __kit_coro_switch / trampoline   (<kit/coro.h>)
  *
  * Callee-saved set on SysV: rbx, rbp, r12-r15. (No callee-saved xmm
  * regs -- those are MS-ABI specific; see x86_64_win.c.)
  *
  *   regs[0]:  rbx     regs[4]:  r14
  *   regs[1]:  rbp     regs[5]:  r15
  *   regs[2]:  r12     regs[6]:  rsp
  *   regs[3]:  r13     regs[7]:  rip
  *
  * sizeof = 64, 16-byte aligned.
  *
  *   setjmp(env)             %rdi=env
  *   longjmp(env, val)       %rdi=env, %esi=val
  *   __kit_coro_switch(f, t, val)  %rdi=from, %rsi=to, %rdx=val
  *
  * The "save rsp/rip" trick: at function entry, (%rsp) holds the
  * caller's return address (just pushed by `call`); 8(%rsp) is the
  * caller's pre-call rsp. Saving those two lets longjmp/__kit_coro_switch
  * "land" at the call site exactly as if the function had returned.
  */
 
 #include <kit/coro.h>
 #include <setjmp.h>
 #include <stddef.h>
 #include <stdint.h>
 
 struct __kit_x86_64_ctx {
   uintptr_t regs[8];
 } __attribute__((aligned(16)));
 
 _Static_assert(sizeof(struct __kit_x86_64_ctx) == 64, "layout");
 _Static_assert(_Alignof(struct __kit_x86_64_ctx) == 16, "align");
 _Static_assert(sizeof(struct __kit_x86_64_ctx) <= sizeof(coro_ctx),
                "fits coro_ctx");
 _Static_assert(sizeof(struct __kit_x86_64_ctx) <= sizeof(jmp_buf),
                "fits jmp_buf");
 _Static_assert(_Alignof(coro_ctx) >= _Alignof(struct __kit_x86_64_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_x86_64_ctx* c = (struct __kit_x86_64_ctx*)ctx;
 
   /* x86_64 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[1] = 0;                                /* rbp */
   c->regs[3] = (uintptr_t)entry;                 /* r13 -- entry fn */
   c->regs[6] = top;                              /* rsp */
   c->regs[7] = (uintptr_t)__kit_coro_trampoline; /* rip */
 }
 
 #define STR_(x) #x
 #define STR(x) STR_(x)
 #define SYM(n) STR(__USER_LABEL_PREFIX__) #n
 
 /* Save callee-saved + (caller's) rsp + rip into [reg]; clobbers %rax.
    Used at function-entry stack discipline: (%rsp)=ret-addr, 8(%rsp)=pre-call
    rsp. */
 #define SAVE_INTO(reg)       \
   "    movq %rbx,  0(" reg   \
   ")\n"                      \
   "    movq %rbp,  8(" reg   \
   ")\n"                      \
   "    movq %r12, 16(" reg   \
   ")\n"                      \
   "    movq %r13, 24(" reg   \
   ")\n"                      \
   "    movq %r14, 32(" reg   \
   ")\n"                      \
   "    movq %r15, 40(" reg   \
   ")\n"                      \
   "    leaq 8(%rsp), %rax\n" \
   "    movq %rax, 48(" reg   \
   ")\n"                      \
   "    movq (%rsp), %rax\n"  \
   "    movq %rax, 56(" reg ")\n"
 
 /* Restore callee-saved + rsp from [reg], leave rip in %rcx ready to
    jmp. Caller delivers the destination value in %rax beforehand. */
 #define RESTORE_FROM(reg) \
   "    movq  0(" reg      \
   "), %rbx\n"             \
   "    movq  8(" reg      \
   "), %rbp\n"             \
   "    movq 16(" reg      \
   "), %r12\n"             \
   "    movq 24(" reg      \
   "), %r13\n"             \
   "    movq 32(" reg      \
   "), %r14\n"             \
   "    movq 40(" reg      \
   "), %r15\n"             \
   "    movq 48(" reg      \
   "), %rsp\n"             \
   "    movq 56(" reg "), %rcx\n"
 
 __asm__ (
     ".text\n"
     ".p2align 4\n"
 
     /* setjmp(env) -- env=%rdi */
     ".weak " SYM(setjmp) "\n"
     SYM(setjmp) ":\n"
     SAVE_INTO("%rdi")
     "    xorl %eax, %eax\n"
     "    ret\n"
 
     /* longjmp(env, val) -- env=%rdi, val=%esi.
        longjmp(_, 0) must deliver 1 (C11 7.13.2.1p4). */
     ".weak " SYM(longjmp) "\n"
     SYM(longjmp) ":\n"
     "    movslq %esi, %rax\n"        /* sign-extend int → long */
     "    testq %rax, %rax\n"
     "    movl  $1, %edx\n"
     "    cmoveq %rdx, %rax\n"
     RESTORE_FROM("%rdi")
     "    jmpq *%rcx\n"
 
     /* __kit_coro_switch(from, to, value) -- from=%rdi, to=%rsi, value=%rdx. */
     ".globl " SYM(__kit_coro_switch) "\n"
     SYM(__kit_coro_switch) ":\n"
     SAVE_INTO("%rdi")
     "    movq %rdx, %rax\n"          /* deliver value as return reg */
     RESTORE_FROM("%rsi")
     "    jmpq *%rcx\n"
 
     /* __kit_coro_trampoline -- on first entry: %rax=value,
        %r13=entry, %rsp=stack_top (no return addr pushed -- __kit_coro_switch
        reaches here via jmp). System V wants %rsp+8 ≡ 16 (mod 16) at
        function entry; the andq below makes that hold defensively. */
     ".globl " SYM(__kit_coro_trampoline) "\n"
     SYM(__kit_coro_trampoline) ":\n"
     "    andq $-16, %rsp\n"
     "    movq %rax, %rdi\n"          /* value → first arg */
     "    callq *%r13\n"               /* entry(value) */
     "    ud2\n"
 );