luaur-code-gen 0.1.0

Native (A64/X64) code generation for Luau (Rust).
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use core::ffi::{c_int, c_void};

use crate::macros::call_fallback_yield::CALL_FALLBACK_YIELD;
use luaur_vm::functions::lua_v_tryfunc_tm::lua_v_tryfunc_tm;
use luaur_vm::macros::clvalue::clvalue;
use luaur_vm::macros::lua_callinfo_native::LUA_CALLINFO_NATIVE;
use luaur_vm::macros::lua_multret::LUA_MULTRET;
use luaur_vm::macros::setnilvalue::setnilvalue;
use luaur_vm::macros::setobj_2_s::setobj2s;
use luaur_vm::macros::ttisfunction::ttisfunction;
use luaur_vm::records::call_info::CallInfo;
use luaur_vm::records::closure::Closure;
use luaur_vm::type_aliases::lua_state::lua_State;
use luaur_vm::type_aliases::stk_id::StkId;
use luaur_vm::type_aliases::t_value::TValue;

pub unsafe fn call_fallback(
    L: *mut lua_State,
    ra: StkId,
    mut argtop: StkId,
    nresults: c_int,
) -> *mut Closure {
    if !ttisfunction!(ra as *const TValue) {
        lua_v_tryfunc_tm(L, ra);
        argtop = argtop.add(1);
    }

    let ccl = clvalue!(ra as *const TValue);

    if luaur_common::FFlag::LuauClosureUsageCounter.get() {
        (*ccl).usage += 1;
    }

    let ci = incr_ci_local(L);
    (*ci).func = ra;
    (*ci).base = ra.add(1);
    (*ci).top = argtop.add((*ccl).stacksize as usize);
    (*ci).savedpc = core::ptr::null();
    (*ci).flags = 0;
    (*ci).nresults = nresults;

    (*L).base = (*ci).base;
    (*L).top = argtop;

    luaur_vm::macros::lua_d_checkstackfornewci::luaD_checkstackfornewci(
        L,
        (*ccl).stacksize as c_int,
    );
    luaur_common::LUAU_ASSERT!((*ci).top <= (*L).stack_last);

    if (*ccl).isC == 0 {
        let p = {
            let l = &(*ccl).inner.l;
            l.p
        };

        let mut argi = (*L).top;
        let argend = (*L).base.add((*p).numparams as usize);
        while argi < argend {
            setnilvalue!(argi);
            argi = argi.add(1);
        }
        (*L).top = if (*p).is_vararg != 0 { argi } else { (*ci).top };

        (*ci).savedpc = (*p).code;

        let has_native_target = if luaur_common::FFlag::LuauNativeCodeTargetCheck.get() {
            (*p).exectarget != 0
        } else {
            !(*p).execdata.is_null()
        };

        if has_native_target {
            (*ci).flags = LUA_CALLINFO_NATIVE as u32;
        }

        ccl
    } else {
        let func = {
            let c = &(*ccl).inner.c;
            c.f
        };
        let n = match func {
            Some(f) => f(L),
            None => 0,
        };

        if n < 0 {
            return CALL_FALLBACK_YIELD as usize as *mut Closure;
        }

        let ci = (*L).ci;
        let cip = ci.sub(1);

        if luaur_common::FFlag::LuauClosureUsageCounter.get() {
            luaur_common::LUAU_ASSERT!((*ccl).usage > 0);
            (*ccl).usage -= 1;
        }

        let mut res = (*ci).func;
        let mut vali = (*L).top.sub(n as usize);
        let valend = (*L).top;

        let mut i = nresults;
        while i != 0 && vali < valend {
            setobj2s!(L, res, vali as *const TValue);
            res = res.add(1);
            vali = vali.add(1);
            i -= 1;
        }
        while i > 0 {
            setnilvalue!(res);
            res = res.add(1);
            i -= 1;
        }

        (*L).ci = cip;
        (*L).base = (*cip).base;
        (*L).top = if nresults == LUA_MULTRET {
            res
        } else {
            (*cip).top
        };

        core::ptr::null_mut()
    }
}

unsafe fn incr_ci_local(L: *mut lua_State) -> *mut CallInfo {
    if (*L).ci == (*L).end_ci {
        luaur_vm::functions::lua_d_grow_ci::luaD_growCI(L);
    } else {
        (*L).ci = (*L).ci.add(1);
    }

    (*L).ci
}

#[no_mangle]
pub unsafe extern "C" fn callFallback(
    L: *mut lua_State,
    ra: StkId,
    argtop: StkId,
    nresults: c_int,
) -> *mut c_void {
    call_fallback(L, ra, argtop, nresults).cast()
}