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

use crate::enums::builtin_impl_type::BuiltinImplType;
use crate::enums::ir_block_kind::IrBlockKind;
use crate::enums::ir_cmd::IrCmd;
use crate::enums::ir_condition::IrCondition;
use crate::enums::ir_op_kind::IrOpKind;
use crate::records::builtin_impl_result::BuiltinImplResult;
use crate::records::ir_builder::IrBuilder;
use crate::records::ir_op::IrOp;

pub fn translate_builtin_vector_clamp(
    build: &mut IrBuilder,
    nparams: i32,
    ra: i32,
    arg: i32,
    args: IrOp,
    arg3: IrOp,
    nresults: i32,
    fallback: IrOp,
    pcpos: i32,
) -> BuiltinImplResult {
    let arg1 = build.vm_reg(arg as u8);

    if nparams != 3
        || nresults > 1
        || arg1.kind() == IrOpKind::Constant
        || args.kind() == IrOpKind::Constant
        || arg3.kind() == IrOpKind::Constant
    {
        return BuiltinImplResult {
            r#type: BuiltinImplType::None,
            actual_result_count: -1,
        };
    }

    let lua_tvector = luaur_vm::enums::lua_type::lua_Type::LUA_TVECTOR as u8;
    let exit = build.vm_exit(pcpos as u32);
    build.load_and_check_tag(arg1, lua_tvector, exit);
    let exit = build.vm_exit(pcpos as u32);
    build.load_and_check_tag(args, lua_tvector, exit);
    let exit = build.vm_exit(pcpos as u32);
    build.load_and_check_tag(arg3, lua_tvector, exit);

    let block1 = build.block(IrBlockKind::Internal);
    let block2 = build.block(IrBlockKind::Internal);
    let block3 = build.block(IrBlockKind::Internal);

    let zero = build.const_int(0);
    let x = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, arg1, zero);
    let zero = build.const_int(0);
    let xmin = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, args, zero);
    let zero = build.const_int(0);
    let xmax = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, arg3, zero);

    let cond = build.cond(IrCondition::NotLessEqual);
    build.inst_ir_cmd_ir_op_ir_op_ir_op_ir_op_ir_op(
        IrCmd::JUMP_CMP_FLOAT,
        xmin,
        xmax,
        cond,
        fallback,
        block1,
    );

    build.begin_block(block1);

    let four = build.const_int(4);
    let y = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, arg1, four);
    let four = build.const_int(4);
    let ymin = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, args, four);
    let four = build.const_int(4);
    let ymax = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, arg3, four);

    let cond = build.cond(IrCondition::NotLessEqual);
    build.inst_ir_cmd_ir_op_ir_op_ir_op_ir_op_ir_op(
        IrCmd::JUMP_CMP_FLOAT,
        ymin,
        ymax,
        cond,
        fallback,
        block2,
    );

    build.begin_block(block2);

    let eight = build.const_int(8);
    let z = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, arg1, eight);
    let eight = build.const_int(8);
    let zmin = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, args, eight);
    let eight = build.const_int(8);
    let zmax = build.inst_ir_cmd_ir_op_ir_op(IrCmd::LOAD_FLOAT, arg3, eight);

    let cond = build.cond(IrCondition::NotLessEqual);
    build.inst_ir_cmd_ir_op_ir_op_ir_op_ir_op_ir_op(
        IrCmd::JUMP_CMP_FLOAT,
        zmin,
        zmax,
        cond,
        fallback,
        block3,
    );

    build.begin_block(block3);

    let xtemp = build.inst_ir_cmd_ir_op_ir_op(IrCmd::MAX_FLOAT, xmin, x);
    let xclamped = build.inst_ir_cmd_ir_op_ir_op(IrCmd::MIN_FLOAT, xmax, xtemp);

    let ytemp = build.inst_ir_cmd_ir_op_ir_op(IrCmd::MAX_FLOAT, ymin, y);
    let yclamped = build.inst_ir_cmd_ir_op_ir_op(IrCmd::MIN_FLOAT, ymax, ytemp);

    let ztemp = build.inst_ir_cmd_ir_op_ir_op(IrCmd::MAX_FLOAT, zmin, z);
    let zclamped = build.inst_ir_cmd_ir_op_ir_op(IrCmd::MIN_FLOAT, zmax, ztemp);

    let ra_reg = build.vm_reg(ra as u8);
    build.inst_ir_cmd_ir_op_ir_op_ir_op_ir_op(
        IrCmd::STORE_VECTOR,
        ra_reg,
        xclamped,
        yclamped,
        zclamped,
    );
    let tag = build.const_tag(lua_tvector);
    build.inst_ir_cmd_ir_op_ir_op(IrCmd::STORE_TAG, ra_reg, tag);

    BuiltinImplResult {
        r#type: BuiltinImplType::UsesFallback,
        actual_result_count: 1,
    }
}