/* vim: ts=4 sw=4 sts=4 et tw=78
 * Copyright (c) 2011 James R. McKaskill. See license in ffi.h
 */
|.if X64
|.arch x64
|.else
|.arch x86
|.endif

|.actionlist build_actionlist
|.globalnames globnames
|.externnames extnames

|.if not X64
|.define RET_H, edx // for int64_t returns
|.define RET_L, eax
|.endif

|.if X64WIN
|
|.macro call_rrrp, func, arg0, arg1, arg2, arg3
| mov64 r9, arg3
| mov r8, arg2
| mov rdx, arg1
| mov rcx, arg0
| call func
|.endmacro
|.macro call_rrrr, func, arg0, arg1, arg2, arg3
| mov r9, arg3
| mov r8, arg2
| mov rdx, arg1
| mov rcx, arg0
| call func
|.endmacro
|
|.macro call_rrp, func, arg0, arg1, arg2
| mov64 r8, arg2
| mov rdx, arg1
| mov rcx, arg0
| call func
|.endmacro
|.macro call_rrr, func, arg0, arg1, arg2
| mov r8, arg2
| mov rdx, arg1
| mov rcx, arg0
| call func
|.endmacro
|
|.macro call_rp, func, arg0, arg1
| mov64 rdx, arg1
| mov rcx, arg0
| call func
|.endmacro
|.macro call_rr, func, arg0, arg1
| mov rdx, arg1
| mov rcx, arg0
| call func
|.endmacro
|
|.macro call_r, func, arg0
| mov rcx, arg0
| call func
|.endmacro
|
|.elif X64
|
| // the 5 and 6 arg forms are only used on posix x64
|.macro call_rrrrrr, func, arg0, arg1, arg2, arg3, arg4, arg5
| mov r9, arg5
| mov r8, arg4
| mov rcx, arg3
| mov rdx, arg2
| mov rsi, arg1
| mov rdi, arg0
| call func
|.endmacro
|.macro call_rrrrr, func, arg0, arg1, arg2, arg3, arg4
| mov r8, arg4
| mov rcx, arg3
| mov rdx, arg2
| mov rsi, arg1
| mov rdi, arg0
| call func
|.endmacro
|
|.macro call_rrrp, func, arg0, arg1, arg2, arg3
| mov64 rcx, arg3
| mov rdx, arg2
| mov rsi, arg1
| mov rdi, arg0
| call func
|.endmacro
|.macro call_rrrr, func, arg0, arg1, arg2, arg3
| mov rcx, arg3
| mov rdx, arg2
| mov rsi, arg1
| mov rdi, arg0
| call func
|.endmacro
|
|.macro call_rrp, func, arg0, arg1, arg2
| mov64 rdx, arg2
| mov rsi, arg1
| mov rdi, arg0
| call func
|.endmacro
|.macro call_rrr, func, arg0, arg1, arg2
| mov rdx, arg2
| mov rsi, arg1
| mov rdi, arg0
| call func
|.endmacro
|
|.macro call_rp, func, arg0, arg1
| mov64 rsi, arg1
| mov rdi, arg0
| call func
|.endmacro
|.macro call_rr, func, arg0, arg1
| mov rsi, arg1
| mov rdi, arg0
| call func
|.endmacro
|
|.macro call_r, func, arg0
| mov rdi, arg0
| call func
|.endmacro
|
|.else
| // define the 64bit registers to the 32 bit counterparts, so the common
| // code can use r*x for all pointers
|.define rax, eax
|.define rcx, ecx
|.define rdx, edx
|.define rsp, esp
|.define rbp, ebp
|.define rdi, edi
|.define rsi, esi
|.define mov64, mov
|
|.macro call_rrrr, func, arg0, arg1, arg2, arg3
| mov dword [rsp+12], arg3
| mov dword [rsp+8], arg2
| mov dword [rsp+4], arg1
| mov dword [rsp], arg0
| call func
|.endmacro
|.macro call_rrr, func, arg0, arg1, arg2
| mov dword [rsp+8], arg2
| mov dword [rsp+4], arg1
| mov dword [rsp], arg0
| call func
|.endmacro
|.macro call_rr, func, arg0, arg1
| mov dword [rsp+4], arg1
| mov dword [rsp], arg0
| call func
|.endmacro
|.macro call_r, func, arg0
| mov dword [rsp], arg0
| call func
|.endmacro
|
|.define call_rrrp, call_rrrr
|.define call_rrp, call_rrr
|.define call_rp, call_rr
|
|.endif

#if defined _WIN64 || defined __amd64__
#define JUMP_SIZE 14
#else
#define JUMP_SIZE 4
#endif

#define MIN_BRANCH INT32_MIN
#define MAX_BRANCH INT32_MAX
#define BRANCH_OFF 4

static void compile_extern_jump(struct jit* jit, lua_State* L, cfunction func, uint8_t* code)
{
    /* The jump code is the function pointer followed by a stub to call the
     * function pointer. The stub exists in 64 bit so we can jump to functions
     * with an offset greater than 2 GB.
     *
     * Note we have to manually set this up since there are commands buffered
     * in the jit state and dynasm doesn't support rip relative addressing.
     *
     * eg on 64 bit:
     * 0-8: function ptr
     * 8-14: jmp aword [rip-14]
     *
     * for 32 bit we only set the function ptr as it can always fit in a 32
     * bit displacement
     */
#if defined _WIN64 || defined __amd64__
    *(cfunction*) code = func;
    code[8] = 0xFF; /* FF /4 operand for jmp */
    code[9] = 0x25; /* RIP displacement */
    *(int32_t*) &code[10] = -14;
#else
    *(cfunction*) code = func;
#endif
}

void compile_globals(struct jit* jit, lua_State* L)
{
    struct jit* Dst = jit;
    int* perr = &jit->last_errno;
    dasm_setup(Dst, build_actionlist);

    /* Note: since the return code uses EBP to reset the stack pointer, we
     * don't have to track the amount of stack space used. It also means we
     * can handle stdcall and cdecl with the same code.
     */

    /* Note the various call_* functions want 32 bytes of 16 byte aligned
     * stack
     */

    |.if X64
    |.define L_ARG, r12
    |.define TOP, r13
    |.else
    |.define L_ARG, rdi
    |.define TOP, rsi
    |.endif

    |.macro epilog
    |.if X64
    | mov TOP, [rbp-16]
    | mov L_ARG, [rbp-8]
    |.else
    | mov TOP, [rbp-8]
    | mov L_ARG, [rbp-4]
    |.endif
    | mov rsp, rbp
    | pop rbp
    | ret
    |.endmacro

    |.macro get_errno // note trashes registers
    | call extern GetLastError
    | mov64 rcx, perr
    | mov dword [rcx], eax
    |.endmacro

    /* the general idea for the return functions is:
     * 1) Save return value on stack
     * 2) Call get_errno (this trashes the registers hence #1)
     * 3) Unpack return value from stack
     * 4) Call lua push function
     * 5) Set eax to number of returned args (0 or 1)
     * 6) Call return which pops our stack frame
     */

    |->lua_return_arg:
    | mov eax, 1
    | epilog

    |->lua_return_void:
    | get_errno
    | mov eax, 0
    | epilog

    |->lua_return_double:
    |.if X64
    | movq qword [rsp+32], xmm0
    |.else
    | fstp qword [rsp+4] // note get_errno doesn't require any stack on x86
    |.endif
    |
    | get_errno
    |
    |.if X64WIN
    | movq xmm1, qword [rsp+32]
    | mov rcx, L_ARG
    |.elif X64
    | movq xmm0, qword [rsp+32]
    | mov rdi, L_ARG
    |.else
    | mov [rsp], L_ARG
    |.endif
    | call extern lua_pushnumber
    | jmp ->lua_return_arg

    |->lua_return_bool:
    | movzx eax, al
    | mov [rsp+32], eax
    | get_errno
    | mov eax, [rsp+32]
    | call_rr extern lua_pushboolean, L_ARG, rax
    | jmp ->lua_return_arg

    |->lua_return_int:
    | mov [rsp+32], eax
    | get_errno
    | mov eax, [rsp+32]
    | call_rr extern push_int, L_ARG, rax
    | jmp ->lua_return_arg

    |->lua_return_uint:
    | mov [rsp+32], eax
    | get_errno
    | mov eax, [rsp+32]
    | call_rr extern push_uint, L_ARG, rax
    | jmp ->lua_return_arg

    |->too_few_arguments:
    | mov ax, 0
    | call_rp extern luaL_error, L_ARG, &"too few arguments"

    |->too_many_arguments:
    | mov ax, 0
    | call_rp extern luaL_error, L_ARG, &"too many arguments"

    |->save_registers:
    | // use rbp relative so we store values in the outer stack frame
    |.if X64WIN
    | // use the provided shadow space for int registers above prev rbp and
    | // return address
    | mov [rbp+16], rcx
    | mov [rbp+24], rdx
    | mov [rbp+32], r8
    | mov [rbp+40], r9
    | // use the extra space we added for float registers
    | // -16 to store underneath previous value of L_ARG
    | movq qword [rbp-16], xmm0
    | movq qword [rbp-24], xmm1
    | movq qword [rbp-32], xmm2
    | movq qword [rbp-40], xmm3
    |.elif X64
    | movq qword [rbp-16], xmm0
    | movq qword [rbp-24], xmm1
    | movq qword [rbp-32], xmm2
    | movq qword [rbp-40], xmm3
    | movq qword [rbp-48], xmm4
    | movq qword [rbp-56], xmm5
    | movq qword [rbp-64], xmm6
    | movq qword [rbp-72], xmm7
    | mov [rbp-80], rdi
    | mov [rbp-88], rsi
    | mov [rbp-96], rdx
    | mov [rbp-104], rcx
    | mov [rbp-112], r8
    | mov [rbp-120], r9
    |.else
    | // fastcall, -8 to store underneath previous value of L_ARG
    | mov [rbp-8], ecx
    | mov [rbp-12], edx
    |.endif
    | ret

    compile(Dst, L, NULL, LUA_NOREF);
}

int x86_return_size(lua_State* L, int usr, const struct ctype* ct)
{
    int ret = 0;
    const struct ctype* mt;

    if (ct->calling_convention != C_CALL) {
        size_t i;
        size_t argn = lua_rawlen(L, usr);
        for (i = 1; i <= argn; i++) {
            lua_rawgeti(L, usr, (int) i);
            mt = (const struct ctype*) lua_touserdata(L, -1);

            if (mt->pointers) {
                ret += sizeof(void*);
            } else {
                switch (mt->type) {
                case DOUBLE_TYPE:
                case COMPLEX_FLOAT_TYPE:
                case INT64_TYPE:
                    ret += 8;
                    break;
                case COMPLEX_DOUBLE_TYPE:
                    ret += 16;
                    break;
                case INTPTR_TYPE:
                    ret += sizeof(intptr_t);
                    break;
                case FUNCTION_PTR_TYPE:
                    ret += sizeof(cfunction);
                    break;
                case BOOL_TYPE:
                case FLOAT_TYPE:
                case INT8_TYPE:
                case INT16_TYPE:
                case INT32_TYPE:
                case ENUM_TYPE:
                    ret += 4;
                    break;
                default:
                    return luaL_error(L, "NYI - argument type");
                }
            }

            lua_pop(L, 1);
        }
    }

#if !defined _WIN64 && !defined __amd64__
    lua_rawgeti(L, usr, 0);
    mt = (const struct ctype*) lua_touserdata(L, -1);
    if (!mt->pointers && mt->type == COMPLEX_DOUBLE_TYPE) {
        ret += sizeof(void*);
    }
    lua_pop(L, 1);
#endif

    return ret;
}

#ifdef _WIN64
#define MAX_REGISTERS(ct) 4 /* rcx, rdx, r8, r9 */

#elif defined __amd64__
#define MAX_INT_REGISTERS(ct) 6 /* rdi, rsi, rdx, rcx, r8, r9 */
#define MAX_FLOAT_REGISTERS(ct) 8 /* xmm0-7 */

#else
#define MAX_INT_REGISTERS(ct) ((ct)->calling_convention == FAST_CALL ? 2 /* ecx, edx */ : 0)
#define MAX_FLOAT_REGISTERS(ct) 0
#endif

struct reg_alloc {
#ifdef _WIN64
    int regs;
    int is_float[4];
    int is_int[4];
#else
    int floats;
    int ints;
#endif
    int off;
};

#ifdef _WIN64
#define REGISTER_STACK_SPACE(ct) (4*8)
#elif defined __amd64__
#define REGISTER_STACK_SPACE(ct) (14*8)
#else
#define REGISTER_STACK_SPACE(ct) ALIGN_UP(((ct)->calling_convention == FAST_CALL ? 2*4 : 0), 15)
#endif

/* Fastcall:
 * Uses ecx, edx as first two int registers
 * Everything else on stack (include 64bit ints)
 * No overflow stack space
 * Pops the stack before returning
 * Returns int in eax, float in ST0
 * We use the same register allocation logic as posix x64 with 2 int regs and 0 float regs
 */

static void get_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
{
    /* grab the register from the shadow space */
#ifdef _WIN64
    if (reg->regs < MAX_REGISTERS(ct)) {
        | mov rcx, [rbp + 16 + 8*reg->regs]
        reg->regs++;
    }
#elif __amd64__
    if (reg->ints < MAX_INT_REGISTERS(ct)) {
        | mov rcx, [rbp - 80 - 8*reg->ints]
        reg->ints++;
    }
#else
    if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
        | mov ecx, [rbp - 8 - 4*reg->ints]
        reg->ints++;
    }
#endif
    else if (is_int64) {
        |.if X64
        | mov rcx, [rbp + reg->off]
        |.else
        | mov rcx, [rbp + reg->off]
        | mov rdx, [rbp + reg->off + 4]
        |.endif
        reg->off += 8;
    } else {
        | mov ecx, [rbp + reg->off]
        reg->off += 4;
    }
}

static void add_int(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_int64)
{
#ifdef _WIN64
    if (reg->regs < MAX_REGISTERS(ct)) {
        | mov [rsp + 32 + 8*(reg->regs)], rax
        reg->is_int[reg->regs++] = 1;
    }
#elif __amd64__
    if (reg->ints < MAX_INT_REGISTERS(ct)) {
        | mov [rsp + 32 + 8*reg->ints], rax
        reg->ints++;
    }
#else
    if (!is_int64 && reg->ints < MAX_INT_REGISTERS(ct)) {
        | mov [rsp + 32 + 4*reg->ints], rax
        reg->ints++;
    }
#endif

    else if (is_int64) {
        |.if X64
        | mov [rsp + reg->off], rax
        |.else
        | mov [rsp + reg->off], RET_L
        | mov [rsp + reg->off + 4], RET_H
        |.endif
        reg->off += 8;
    } else {
        | mov [rsp+reg->off], eax
        reg->off += 4;
    }
}

static void get_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
{
#if !defined _WIN64 && !defined __amd64__
    assert(MAX_FLOAT_REGISTERS(ct) == 0);
    if (is_double) {
        | fld qword [rbp + reg->off]
        reg->off += 8;
    } else {
        | fld dword [rbp + reg->off]
        reg->off += 4;
    }
#else
    int off;

#ifdef _WIN64
    if (reg->regs < MAX_REGISTERS(ct)) {
        off = -16 - 8*reg->regs;
        reg->regs++;
    }
#else
    if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
        off = -16 - 8*reg->floats;
        reg->floats++;
    }
#endif
    else {
        off = reg->off;
        reg->off += is_double ? 8 : 4;
    }

    if (is_double) {
        | movq xmm0, qword [rbp + off]
    } else {
        | cvtss2sd xmm0, dword [rbp + off]
    }
#endif
}

static void add_float(Dst_DECL, const struct ctype* ct, struct reg_alloc* reg, int is_double)
{
#if !defined _WIN64 && !defined __amd64__
    assert(MAX_FLOAT_REGISTERS(ct) == 0);
    if (is_double) {
        | fstp qword [rsp + reg->off]
        reg->off += 8;
    } else {
        | fstp dword [rsp + reg->off]
        reg->off += 4;
    }
#else

#ifdef _WIN64
    if (reg->regs < MAX_REGISTERS(ct)) {
        if (is_double) {
            | movq qword [rsp + 32 + 8*(reg->regs)], xmm0
        } else {
            | cvtsd2ss xmm0, xmm0
            | movq qword [rsp + 32 + 8*(reg->regs)], xmm0
        }
        reg->is_float[reg->regs++] = 1;
    }
#else
    if (reg->floats < MAX_FLOAT_REGISTERS(ct)) {
        if (is_double) {
            | movq qword [rsp + 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats)], xmm0
        } else {
            | cvtsd2ss xmm0, xmm0
            | movq qword [rsp + 32 + 8*(MAX_INT_REGISTERS(ct) + reg->floats)], xmm0
        }
        reg->floats++;
    }
#endif

    else if (is_double) {
        | movq qword [rsp + reg->off], xmm0
        reg->off += 8;
    } else {
        | cvtsd2ss xmm0, xmm0
        | movd dword [rsp + reg->off], xmm0
        reg->off += 4;
    }
#endif
}

#if defined _WIN64 || defined __amd64__
#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 1)
#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 1)
#else
#define add_pointer(jit, ct, reg) add_int(jit, ct, reg, 0)
#define get_pointer(jit, ct, reg) get_int(jit, ct, reg, 0)
#endif

cfunction compile_callback(lua_State* L, int fidx, int ct_usr, const struct ctype* ct)
{
    int i, nargs;
    cfunction* pf;
    struct ctype ct2 = *ct;
    const struct ctype* mt;
    struct reg_alloc reg;
    int num_upvals = 0;
    int top = lua_gettop(L);
    struct jit* Dst = get_jit(L);
    int ref;
    int hidden_arg_off = 0;

    ct_usr = lua_absindex(L, ct_usr);
    fidx = lua_absindex(L, fidx);

    assert(lua_isnil(L, fidx) || lua_isfunction(L, fidx));

    memset(&reg, 0, sizeof(reg));
#ifdef _WIN64
    reg.off = 16 + REGISTER_STACK_SPACE(ct); /* stack registers are above the shadow space */
#elif __amd64__
    reg.off = 16;
#else
    reg.off = 8;
#endif

    dasm_setup(Dst, build_actionlist);

    // add a table to store ctype and function upvalues
    // callback_set assumes the first value is the lua function
    nargs = (int) lua_rawlen(L, ct_usr);
    lua_newtable(L);
    lua_pushvalue(L, -1);
    ref = luaL_ref(L, LUA_REGISTRYINDEX);

    if (ct->has_var_arg) {
        luaL_error(L, "can't create callbacks with varargs");
    }

    // setup a stack frame to hold args for the call into lua_call

    | push rbp
    | mov rbp, rsp
    | push L_ARG
    | // stack is 4 or 8 (mod 16) (L_ARG, rbp, rip)
    |.if X64
    | // 8 to realign, 16 for return vars, 32 for local calls, rest to save registers
    | sub rsp, 8 + 16 + 32 + REGISTER_STACK_SPACE(ct)
    | call ->save_registers
    |.else
    | // 4 to realign, 16 for return vars, 32 for local calls, rest to save registers
    | sub rsp, 4 + 16 + 32 + REGISTER_STACK_SPACE(ct)
    if (ct->calling_convention == FAST_CALL) {
        | call ->save_registers
    }
    |.endif

    // hardcode the lua_State* value into the assembly
    | mov64 L_ARG, L

    /* get the upval table */
    | call_rrr extern lua_rawgeti, L_ARG, LUA_REGISTRYINDEX, ref

    /* get the lua function */
    lua_pushvalue(L, fidx);
    lua_rawseti(L, -2, ++num_upvals);
    assert(num_upvals == CALLBACK_FUNC_USR_IDX);
    | call_rrr extern lua_rawgeti, L_ARG, -1, num_upvals

#if !defined _WIN64 && !defined __amd64__
    lua_rawgeti(L, ct_usr, 0);
    mt = (const struct ctype*) lua_touserdata(L, -1);
    if (!mt->pointers && mt->type == COMPLEX_DOUBLE_TYPE) {
        hidden_arg_off = reg.off;
        reg.off += sizeof(void*);
    }
    lua_pop(L, 1);
#else
    (void) hidden_arg_off;
#endif

    for (i = 1; i <= nargs; i++) {
        lua_rawgeti(L, ct_usr, i);
        mt = (const struct ctype*) lua_touserdata(L, -1);

        if (mt->pointers) {
            lua_getuservalue(L, -1);
            lua_rawseti(L, -3, ++num_upvals); /* usr value */
            lua_rawseti(L, -2, ++num_upvals); /* mt */
            /* on the lua stack in the callback:
             * upval tbl, lua func, i-1 args
             */
            | call_rrr extern lua_rawgeti, L_ARG, -i-1, num_upvals-1
            | call_rrp extern push_cdata, L_ARG, -1, mt
            get_pointer(Dst, ct, &reg);
            | mov [rax], rcx
            | call_rr, extern lua_remove, L_ARG, -2
        } else {
            switch (mt->type) {
            case INT64_TYPE:
                lua_getuservalue(L, -1);
                lua_rawseti(L, -3, ++num_upvals); /* mt */
                lua_pop(L, 1);
                | call_rrp extern push_cdata, L_ARG, 0, mt
                get_int(Dst, ct, &reg, 1);
                |.if X64
                | mov [rax], rcx
                |.else
                | mov [rax], ecx
                | mov [rax+4], edx
                |.endif
                break;

            case INTPTR_TYPE:
                lua_getuservalue(L, -1);
                lua_rawseti(L, -3, ++num_upvals); /* mt */
                lua_pop(L, 1);
                | call_rrp extern push_cdata, L_ARG, 0, mt
                get_pointer(Dst, ct, &reg);
                | mov [rax], rcx
                break;

            case COMPLEX_FLOAT_TYPE:
                lua_pop(L, 1);
#if defined _WIN64 || defined __amd64__
                /* complex floats are two floats packed into a double */
                | call_rrp extern push_cdata, L_ARG, 0, mt
                get_float(Dst, ct, &reg, 1);
                | movq qword [rax], xmm0
#else
                /* complex floats are real followed by imag on the stack */
                | call_rrp extern push_cdata, L_ARG, 0, mt
                get_float(Dst, ct, &reg, 0);
                | fstp dword [rax]
                get_float(Dst, ct, &reg, 0);
                | fstp dword [rax+4]
#endif
                break;

            case COMPLEX_DOUBLE_TYPE:
                lua_pop(L, 1);
                | call_rrp extern push_cdata, L_ARG, 0, mt
                /* real */
                get_float(Dst, ct, &reg, 1);
                |.if X64
                | movq qword [rax], xmm0
                |.else
                | fstp qword [rax]
                |.endif
                /* imag */
                get_float(Dst, ct, &reg, 1);
                |.if X64
                | movq qword [rax+8], xmm0
                |.else
                | fstp qword [rax+8]
                |.endif
                break;

            case FLOAT_TYPE:
            case DOUBLE_TYPE:
                lua_pop(L, 1);
                get_float(Dst, ct, &reg, mt->type == DOUBLE_TYPE);
                |.if X64WIN
                | movq xmm1, xmm0
                | mov rcx, L_ARG
                |.elif X64
                | // for 64bit xmm0 is already set
                | mov rdi, L_ARG
                |.else
                | fstp qword [rsp+4]
                | mov [rsp], L_ARG
                |.endif
                | call extern lua_pushnumber
                break;

            case BOOL_TYPE:
                lua_pop(L, 1);
                get_int(Dst, ct, &reg, 0);
                | movzx ecx, cl
                | call_rr extern lua_pushboolean, L_ARG, rcx
                break;

            case INT8_TYPE:
                lua_pop(L, 1);
                get_int(Dst, ct, &reg, 0);
                if (mt->is_unsigned) {
                    | movzx ecx, cl
                } else {
                    | movsx ecx, cl
                }
                | call_rr extern push_int, L_ARG, rcx
                break;

            case INT16_TYPE:
                lua_pop(L, 1);
                get_int(Dst, ct, &reg, 0);
                if (mt->is_unsigned) {
                    | movzx ecx, cx
                } else {
                    | movsx ecx, cx
                }
                | call_rr extern push_int, L_ARG, rcx
                break;

            case ENUM_TYPE:
            case INT32_TYPE:
                lua_pop(L, 1);
                get_int(Dst, ct, &reg, 0);
                if (mt->is_unsigned) {
                    | call_rr extern push_uint, L_ARG, rcx
                } else {
                    | call_rr extern push_int, L_ARG, rcx
                }
                break;

            default:
                luaL_error(L, "NYI: callback arg type");
            }
        }
    }

    lua_rawgeti(L, ct_usr, 0);
    mt = (const struct ctype*) lua_touserdata(L, -1);

    | call_rrrp extern lua_callk, L_ARG, nargs, (mt->pointers || mt->type != VOID_TYPE) ? 1 : 0, 0

    // Unpack the return argument if not "void", also clean-up the lua stack
    // to remove the return argument and bind table. Use lua_settop rather
    // than lua_pop as lua_pop is implemented as a macro.
    if (mt->pointers) {
        lua_getuservalue(L, -1);
        lua_rawseti(L, -3, ++num_upvals); /* usr value */
        lua_rawseti(L, -2, ++num_upvals); /* mt */
        | call_rrr extern lua_rawgeti, L_ARG, -2, num_upvals-1
        | call_rrrp extern check_typed_pointer, L_ARG, -2, -1, mt
        | mov [rsp+32], rax
        | call_rr extern lua_settop, L_ARG, -4
        | mov rax, [rsp+32]

    } else {
        switch (mt->type) {
        case ENUM_TYPE:
            lua_getuservalue(L, -1);
            lua_rawseti(L, -3, ++num_upvals); /* usr value */
            lua_rawseti(L, -2, ++num_upvals); /* mt */
            | call_rrr extern lua_rawgeti, L_ARG, -2, num_upvals-1
            | call_rrrp, extern check_enum, L_ARG, -2, -1, mt
            | mov [rsp+32], eax
            | call_rr extern lua_settop, L_ARG, -4
            | mov eax, [rsp+32]
            break;

        case VOID_TYPE:
            lua_pop(L, 1);
            | call_rr extern lua_settop, L_ARG, -2
            break;

        case BOOL_TYPE:
        case INT8_TYPE:
        case INT16_TYPE:
        case INT32_TYPE:
            lua_pop(L, 1);
            if (mt->is_unsigned) {
                | call_rr extern check_uint32, L_ARG, -1
            } else {
                | call_rr extern check_int32, L_ARG, -1
            }
            | mov [rsp+32], eax
            | call_rr extern lua_settop, L_ARG, -3
            | mov eax, [rsp+32]
            break;

        case INT64_TYPE:
            lua_pop(L, 1);

            if (mt->is_unsigned) {
                | call_rr extern check_uint64, L_ARG, -1
            } else {
                | call_rr extern check_int64, L_ARG, -1
            }

            |.if X64
            | mov [rsp+32], rax
            |.else
            | mov [rsp+32], RET_L
            | mov [rsp+36], RET_H
            |.endif
            | call_rr extern lua_settop, L_ARG, -3
            |.if X64
            | mov rax, [rsp+32]
            |.else
            | mov RET_L, [rsp+32]
            | mov RET_H, [rsp+36]
            |.endif
            break;

        case INTPTR_TYPE:
            lua_pop(L, 1);
            | call_rr extern check_uintptr, L_ARG, -1
            | mov [rsp+32], rax
            | call_rr extern lua_settop, L_ARG, -3
            | mov rax, [rsp+32]
            break;

        case FLOAT_TYPE:
        case DOUBLE_TYPE:
            lua_pop(L, 1);
            | call_rr extern check_double, L_ARG, -1
            |.if X64
            | movq qword [rsp+32], xmm0
            | call_rr extern lua_settop, L_ARG, -3
            if (mt->type == FLOAT_TYPE) {
                | cvtsd2ss xmm0, qword [rsp+32]
            } else {
                | movq xmm0, qword [rsp+32]
            }
            |.else
            | fstp qword [rsp+32]
            | call_rr extern lua_settop, L_ARG, -3
            | fld qword [rsp+32]
            |.endif
            break;

        case COMPLEX_FLOAT_TYPE:
            lua_pop(L, 1);
#if !defined HAVE_COMPLEX
            luaL_error(L, "ffi lib compiled without complex number support");
#endif
            /* on 64 bit complex floats are two floats packed into a double,
             * on 32 bit returned complex floats use eax and edx */
            | call_rr extern check_complex_float, L_ARG, -1
            |
            |.if X64
            | movq qword [rsp+32], xmm0
            |.else
            | mov [rsp+32], eax
            | mov [rsp+36], edx
            |.endif
            |
            | call_rr extern lua_settop, L_ARG, -3
            |
            |.if X64
            | movq xmm0, qword [rsp+32]
            |.else
            | mov eax, [rsp+32]
            | mov edx, [rsp+36]
            |.endif
            break;

        case COMPLEX_DOUBLE_TYPE:
            lua_pop(L, 1);
#if !defined HAVE_COMPLEX
            luaL_error(L, "ffi lib compiled without complex number support");
#endif
            /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
             * there is a hidden first parameter that points to 16 bytes where
             * the returned arg is stored which is popped by the called
             * function */
#if defined _WIN64 || defined __amd64__
            | call_rr extern check_complex_double, L_ARG, -1
            | movq qword [rsp+32], xmm0
            | movq qword [rsp+40], xmm1
            | call_rr extern lua_settop, L_ARG, -3
            | movq xmm0, qword [rsp+32]
            | movq xmm1, qword [rsp+40]
#else
            | mov rcx, [rbp + hidden_arg_off]
            | call_rrr extern check_complex_double, rcx, L_ARG, -1
            | sub rsp, 4 // to realign from popped hidden arg
            | call_rr extern lua_settop, L_ARG, -3
#endif
            break;

        default:
            luaL_error(L, "NYI: callback return type");
        }
    }

    |.if X64
    | mov L_ARG, [rbp-8]
    |.else
    | mov L_ARG, [rbp-4]
    |.endif
    | mov rsp, rbp
    | pop rbp
    | ret x86_return_size(L, ct_usr, ct)

    lua_pop(L, 1); /* upval table - already in registry */
    assert(lua_gettop(L) == top);

    ct2.is_jitted = 1;
    pf = (cfunction*) push_cdata(L, ct_usr, &ct2);
    *pf = compile(Dst, L, NULL, ref);

    assert(lua_gettop(L) == top + 1);

    return *pf;
}

void compile_function(lua_State* L, cfunction func, int ct_usr, const struct ctype* ct)
{
    size_t i, nargs;
    int num_upvals;
    const struct ctype* mbr_ct;
    struct jit* Dst = get_jit(L);
    struct reg_alloc reg;
    void* p;
    int top = lua_gettop(L);
    int* perr = &Dst->last_errno;

    ct_usr = lua_absindex(L, ct_usr);

    memset(&reg, 0, sizeof(reg));
    reg.off = 32 + REGISTER_STACK_SPACE(ct);

    dasm_setup(Dst, build_actionlist);

    p = push_cdata(L, ct_usr, ct);
    *(cfunction*) p = func;
    num_upvals = 1;

    nargs = lua_rawlen(L, ct_usr);

    if (ct->calling_convention != C_CALL && ct->has_var_arg) {
        luaL_error(L, "vararg is only allowed with the c calling convention");
    }

    | push rbp
    | mov rbp, rsp
    | push L_ARG
    | push TOP
    | // stack is 0 (mod 16) (TOP, L_ARG, rbp, rip)
    |
    | // Get L from our arguments and allocate some stack for lua_gettop
    |.if X64WIN
    | mov L_ARG, rcx
    | sub rsp, 32 // shadow space
    |.elif X64
    | mov L_ARG, rdi
    |.else
    | mov L_ARG, [rbp + 8]
    | sub rsp, 16
    |.endif
    |
    | call_r extern lua_gettop, L_ARG
    | mov TOP, rax // no need for movzxd rax, eax - high word guarenteed to be zero by x86-64
    | cmp rax, nargs
    | jl ->too_few_arguments

    if (!ct->has_var_arg) {
        | jg ->too_many_arguments
    }

    /* no need to zero extend eax returned by lua_gettop to rax as x86-64
     * preguarentees that the upper 32 bits will be zero */
    | shl rax, 4 // reserve 16 bytes per argument - this maintains the alignment mod 16
    | sub rsp, rax
    | sub rsp, 32 + REGISTER_STACK_SPACE(ct) // reserve an extra 32 to call local functions

#if !defined _WIN64 && !defined __amd64__
    /* Returned complex doubles require a hidden first parameter where the
     * data is stored, which is popped by the calling code. */
    lua_rawgeti(L, ct_usr, 0);
    mbr_ct = (const struct ctype*) lua_touserdata(L, -1);
    if (!mbr_ct->pointers && mbr_ct->type == COMPLEX_DOUBLE_TYPE) {
        /* we can allocate more space for arguments as long as no add_*
         * function has been called yet, mbr_ct will be added as an upvalue in
         * the return processing later */
        | call_rrp extern push_cdata, L_ARG, 0, mbr_ct
        | sub rsp, 16
        add_pointer(Dst, ct, &reg);
    }
    lua_pop(L, 1);
#endif

    for (i = 1; i <= nargs; i++) {
        lua_rawgeti(L, ct_usr, (int) i);
        mbr_ct = (const struct ctype*) lua_touserdata(L, -1);

        if (mbr_ct->pointers) {
            lua_getuservalue(L, -1);
            num_upvals += 2;
            | call_rrrp extern check_typed_pointer, L_ARG, i, lua_upvalueindex(num_upvals), mbr_ct
            add_pointer(Dst, ct, &reg);
        } else {
            switch (mbr_ct->type) {
            case FUNCTION_PTR_TYPE:
                lua_getuservalue(L, -1);
                num_upvals += 2;
                | call_rrrp extern check_typed_cfunction, L_ARG, i, lua_upvalueindex(num_upvals), mbr_ct
                add_pointer(Dst, ct, &reg);
                break;

            case ENUM_TYPE:
                lua_getuservalue(L, -1);
                num_upvals += 2;
                | call_rrrp, extern check_enum, L_ARG, i, lua_upvalueindex(num_upvals), mbr_ct
                add_int(Dst, ct, &reg, 0);
                break;

            case INT8_TYPE:
                | call_rr extern check_int32, L_ARG, i
                if (mbr_ct->is_unsigned) {
                    | movzx eax, al
                } else {
                    | movsx eax, al
                }
                add_int(Dst, ct, &reg, 0);
                lua_pop(L, 1);
                break;

            case INT16_TYPE:
                | call_rr extern check_int32, L_ARG, i
                if (mbr_ct->is_unsigned) {
                    | movzx eax, ax
                } else {
                    | movsx eax, ax
                }
                add_int(Dst, ct, &reg, 0);
                lua_pop(L, 1);
                break;

            case BOOL_TYPE:
                | call_rr extern check_int32, L_ARG, i
                | cmp eax, 0
                | setne al
                | movzx eax, al
                add_int(Dst, ct, &reg, 0);
                lua_pop(L, 1);
                break;

            case INT32_TYPE:
                if (mbr_ct->is_unsigned) {
                    | call_rr extern check_uint32, L_ARG, i
                } else {
                    | call_rr extern check_int32, L_ARG, i
                }
                add_int(Dst, ct, &reg, 0);
                lua_pop(L, 1);
                break;

            case INTPTR_TYPE:
                | call_rr extern check_uintptr, L_ARG, i
                add_pointer(Dst, ct, &reg);
                lua_pop(L, 1);
                break;

            case INT64_TYPE:
                if (mbr_ct->is_unsigned) {
                    | call_rr extern check_uint64, L_ARG, i
                } else {
                    | call_rr extern check_int64, L_ARG, i
                }
                add_int(Dst, ct, &reg, 1);
                lua_pop(L, 1);
                break;

            case DOUBLE_TYPE:
                | call_rr extern check_double, L_ARG, i
                add_float(Dst, ct, &reg, 1);
                lua_pop(L, 1);
                break;

            case COMPLEX_DOUBLE_TYPE:
                /* on 64 bit, returned complex doubles use xmm0, xmm1, on 32 bit
                 * there is a hidden first parameter that points to 16 bytes where
                 * the returned arg is stored (this is popped by the called
                 * function) */
#if defined _WIN64 || defined __amd64__
                | call_rr extern check_complex_double, L_ARG, i
                add_float(Dst, ct, &reg, 1);
                | movq xmm0, xmm1
                add_float(Dst, ct, &reg, 1);
#else
                | lea rax, [rsp+reg.off]
                | sub rsp, 4
                | call_rrr extern check_complex_double, rax, L_ARG, i
                reg.off += 16;
#endif
                lua_pop(L, 1);
                break;

            case FLOAT_TYPE:
                | call_rr extern check_double, L_ARG, i
                add_float(Dst, ct, &reg, 0);
                lua_pop(L, 1);
                break;

            case COMPLEX_FLOAT_TYPE:
#if defined _WIN64 || defined __amd64__
                | call_rr extern check_complex_float, L_ARG, i
                /* complex floats are two floats packed into a double */
                add_float(Dst, ct, &reg, 1);
#else
                /* returned complex floats use eax and edx */
                | call_rr extern check_complex_float, L_ARG, i
                | mov [rsp], eax
                | fld dword [rsp]
                add_float(Dst, ct, &reg, 0);
                | mov [rsp], edx
                | fld dword [rsp]
                add_float(Dst, ct, &reg, 0);
#endif
                lua_pop(L, 1);
                break;

            default:
                luaL_error(L, "NYI: call arg type");
            }
        }
    }

    if (ct->has_var_arg) {
#ifdef _WIN64
        |.if X64WIN
        if (reg.regs < MAX_REGISTERS(ct)) {
            assert(reg.regs == nargs);
            | cmp TOP, MAX_REGISTERS(ct)
            | jle >1
            | // unpack onto stack
            | mov rax, rsp
            | add rax, 32 + 8*MAX_REGISTERS(ct)
            | call_rrrr extern unpack_varargs_stack, L_ARG, MAX_REGISTERS(ct)+1, TOP, rax
            | // unpack to registers
            | mov rax, rsp
            | add rax, 32 + 8*(reg.regs)
            | call_rrrr extern unpack_varargs_reg, L_ARG, nargs+1, MAX_REGISTERS(ct), rax
            | jmp >2
            |1:
            | // unpack just to registers
            | mov rax, rsp
            | add rax, 32 + 8*(reg.regs)
            | call_rrrr extern unpack_varargs_reg, L_ARG, nargs+1, TOP, rax
            |2:
        } else {
            | // unpack just to stack
            | mov rax, rsp
            | add rax, reg.off
            | call_rrrr extern unpack_varargs_stack, L_ARG, nargs+1, TOP, rax
        }

        for (i = nargs; i < MAX_REGISTERS(ct); i++) {
            reg.is_int[i] = reg.is_float[i] = 1;
        }
        reg.regs = MAX_REGISTERS(ct);
#elif defined __amd64__
        |.elif X64
        if (reg.floats < MAX_FLOAT_REGISTERS(ct)) {
            | mov rax, rsp
            | add rax, 32 + 8*(MAX_INT_REGISTERS(ct) + reg.floats)
            | call_rrrrr extern unpack_varargs_float, L_ARG, nargs+1, TOP, MAX_FLOAT_REGISTERS(ct) - reg.floats, rax
        }

        if (reg.ints < MAX_INT_REGISTERS(ct)) {
            | mov rax, rsp
            | add rax, 32 + 8*(reg.ints)
            | call_rrrrr extern unpack_varargs_int, L_ARG, nargs+1, TOP, MAX_INT_REGISTERS(ct) - reg.ints, rax
        }

        | mov rax, rsp
        | add rax, reg.off
        | call_rrrrrr extern unpack_varargs_stack_skip, L_ARG, nargs+1, TOP, MAX_INT_REGISTERS(ct) - reg.ints, MAX_FLOAT_REGISTERS(ct) - reg.floats, rax

        reg.floats = MAX_FLOAT_REGISTERS(ct);
        reg.ints = MAX_INT_REGISTERS(ct);
#else
        |.else
        | mov rax, rsp
        | add rax, reg.off
        | call_rrrr extern unpack_varargs_stack, L_ARG, nargs+1, TOP, rax
        |.endif
#endif
    }

    | mov64 rcx, perr
    | mov eax, dword [rcx]
    | call_r extern SetLastError, rax

    /* remove the stack space to call local functions */
    |.if X32WIN
    | add rsp, 28 // SetLastError will have already popped 4
    |.else
    | add rsp, 32
    |.endif

#ifdef _WIN64
    |.if X64WIN
    switch (reg.regs) {
    case 4:
        if (reg.is_float[3]) {
            | movq xmm3, qword [rsp + 8*3]
        }
        if (reg.is_int[3]) {
            | mov r9, [rsp + 8*3]
        }
    case 3:
        if (reg.is_float[2]) {
            | movq xmm2, qword [rsp + 8*2]
        }
        if (reg.is_int[2]) {
            | mov r8, [rsp + 8*2]
        }
    case 2:
        if (reg.is_float[1]) {
            | movq xmm1, qword [rsp + 8*1]
        }
        if (reg.is_int[1]) {
            | mov rdx, [rsp + 8*1]
        }
    case 1:
        if (reg.is_float[0]) {
            | movq xmm0, qword [rsp]
        }
        if (reg.is_int[0]) {
            | mov rcx, [rsp]
        }
    case 0:
        break;
    }

    /* don't remove the space for the registers as we need 32 bytes of register overflow space */
    assert(REGISTER_STACK_SPACE(ct) == 32);

#elif defined __amd64__
    |.elif X64
    switch (reg.floats) {
    case 8:
        | movq xmm7, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+7)]
    case 7:
        | movq xmm6, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+6)]
    case 6:
        | movq xmm5, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+5)]
    case 5:
        | movq xmm4, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+4)]
    case 4:
        | movq xmm3, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+3)]
    case 3:
        | movq xmm2, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+2)]
    case 2:
        | movq xmm1, qword [rsp + 8*(MAX_INT_REGISTERS(ct)+1)]
    case 1:
        | movq xmm0, qword [rsp + 8*(MAX_INT_REGISTERS(ct))]
    case 0:
        break;
    }

    switch (reg.ints) {
    case 6:
        | mov r9, [rsp + 8*5]
    case 5:
        | mov r8, [rsp + 8*4]
    case 4:
        | mov rcx, [rsp + 8*3]
    case 3:
        | mov rdx, [rsp + 8*2]
    case 2:
        | mov rsi, [rsp + 8*1]
    case 1:
        | mov rdi, [rsp]
    case 0:
        break;
    }

    | add rsp, REGISTER_STACK_SPACE(ct)
#else
    |.else
    if (ct->calling_convention == FAST_CALL) {
        switch (reg.ints) {
        case 2:
            | mov edx, [rsp + 4]
        case 1:
            | mov ecx, [rsp]
        case 0:
            break;
        }

        | add rsp, REGISTER_STACK_SPACE(ct)
    }
    |.endif
#endif

#ifdef __amd64__
    if (ct->has_var_arg) {
        /* al stores an upper limit on the number of float register, note that
         * its allowed to be more than the actual number of float registers used as
         * long as its 0-8 */
        |.if X64 and not X64WIN
        | mov al, 8
        |.endif
    }
#endif

    | call extern FUNCTION
    | sub rsp, 48 // 32 to be able to call local functions, 16 so we can store some local variables

    /* note on windows X86 the stack may be only aligned to 4 (stdcall will
     * have popped a multiple of 4 bytes), but we don't need 16 byte alignment on
     * that platform
     */

    lua_rawgeti(L, ct_usr, 0);
    mbr_ct = (const struct ctype*) lua_touserdata(L, -1);

    if (mbr_ct->pointers || mbr_ct->type == INTPTR_TYPE) {
        lua_getuservalue(L, -1);
        num_upvals += 2;
        | mov [rsp+32], rax // save the pointer
        | get_errno
        | call_rrp extern push_cdata, L_ARG, lua_upvalueindex(num_upvals), mbr_ct
        | mov rcx, [rsp+32]
        | mov [rax], rcx // *(void**) cdata = val
        | jmp ->lua_return_arg

    } else {
        switch (mbr_ct->type) {
        case FUNCTION_PTR_TYPE:
            lua_getuservalue(L, -1);
            num_upvals += 2;
            | mov [rsp+32], rax // save the function pointer
            | get_errno
            | call_rrp extern push_cdata, L_ARG, lua_upvalueindex(num_upvals), mbr_ct
            | mov rcx, [rsp+32]
            | mov [rax], rcx // *(cfunction**) cdata = val
            | jmp ->lua_return_arg
            break;

        case INT64_TYPE:
            num_upvals++;
            | // save the return value
            |.if X64
            | mov [rsp+32], rax
            |.else
            | mov [rsp+36], edx // high
            | mov [rsp+32], eax // low
            |.endif
            |
            | get_errno
            | call_rrp extern push_cdata, L_ARG, 0, mbr_ct
            |
            | // *(int64_t*) cdata = val
            |.if X64
            | mov rcx, [rsp+32]
            | mov [rax], rcx
            |.else
            | mov rcx, [rsp+36]
            | mov rdx, [rsp+32]
            | mov [rax+4], rcx
            | mov [rax], rdx
            |.endif
            |
            | jmp ->lua_return_arg
            break;

        case COMPLEX_FLOAT_TYPE:
            num_upvals++;
            |.if X64
            | // complex floats are returned as two floats packed into xmm0
            | movq qword [rsp+32], xmm0
            |.else
            | // complex floats are returned as floats in eax and edx
            | mov [rsp+32], eax
            | mov [rsp+36], edx
            |.endif
            |
            | get_errno
            | call_rrp extern push_cdata, L_ARG, 0, mbr_ct
            |
            | // ((complex_float*) cdata) = val
            |.if X64
            | mov rcx, [rsp+32]
            | mov [rax], rcx
            |.else
            | mov ecx, [rsp+32]
            | mov [rax], ecx
            | mov ecx, [rsp+36]
            | mov [rax+4], ecx
            |.endif
            |
            | jmp ->lua_return_arg
            break;

        case COMPLEX_DOUBLE_TYPE:
            num_upvals++;
            |.if X64
            | // complex doubles are returned as xmm0 and xmm1
            | movq qword [rsp+40], xmm1
            | movq qword [rsp+32], xmm0
            |
            | get_errno
            | call_rrp extern push_cdata, L_ARG, 0, mbr_ct
            |
            | // ((complex_double*) cdata)->real = val0
            | // ((complex_double*) cdata)->imag = val1
            | mov rcx, [rsp+40]
            | mov [rax+8], rcx
            | mov rcx, [rsp+32]
            | mov [rax], rcx
            |
            |.else
            | // On 32 bit we have already handled this by pushing a new cdata
            | // and handing the cdata ptr in as the hidden first param, but
            | // still need to add mbr_ct as an upval as its used earlier.
            | // Hidden param was popped by called function, we need to realign.
            | sub rsp, 4
            | get_errno
            |.endif
            |
            | jmp ->lua_return_arg
            break;

        case VOID_TYPE:
            lua_pop(L, 1);
            | jmp ->lua_return_void
            break;

        case BOOL_TYPE:
            lua_pop(L, 1);
            | jmp ->lua_return_bool
            break;

        case INT8_TYPE:
            lua_pop(L, 1);
            if (mbr_ct->is_unsigned) {
                | movzx eax, al
            } else {
                | movsx eax, al
            }
            | jmp ->lua_return_int
            break;

        case INT16_TYPE:
            lua_pop(L, 1);
            if (mbr_ct->is_unsigned) {
                | movzx eax, ax
            } else {
                | movsx eax, ax
            }
            | jmp ->lua_return_int
            break;

        case INT32_TYPE:
        case ENUM_TYPE:
            lua_pop(L, 1);
            if (mbr_ct->is_unsigned) {
                | jmp ->lua_return_uint
            } else {
                | jmp ->lua_return_int
            }
            break;

        case FLOAT_TYPE:
            lua_pop(L, 1);
            |.if X64
            | cvtss2sd xmm0, xmm0
            |.endif
            | jmp ->lua_return_double
            break;

        case DOUBLE_TYPE:
            lua_pop(L, 1);
            | jmp ->lua_return_double
            break;

        default:
            luaL_error(L, "NYI: call return type");
        }
    }

    assert(lua_gettop(L) == top + num_upvals);
    {
        cfunction f = compile(Dst, L, func, LUA_NOREF);
        /* add a callback as an upval so that the jitted code gets cleaned up when
         * the function gets gc'd */
        push_callback(L, f);
        lua_pushcclosure(L, (lua_CFunction) f, num_upvals+1);
    }
}