tl-llvm 0.3.4

LLVM backend for ThinkingLanguage (Phase 30)
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234

// ThinkingLanguage — LLVM type definitions
// Maps TL's VmValue to LLVM IR types via opaque pointer representation.

use inkwell::context::Context;
use inkwell::types::{FloatType, FunctionType, IntType, PointerType, VoidType};

/// LLVM type definitions for the TL runtime interface.
///
/// All TL values are represented as opaque pointers (`i8*`) in LLVM IR.
/// Arithmetic and comparisons are dispatched through runtime helper functions
/// that operate on `*const VmValue` / `*mut VmValue`.
pub struct LlvmTypes<'ctx> {
    pub vmvalue_ptr: PointerType<'ctx>,
    pub i8_type: IntType<'ctx>,
    pub i32_type: IntType<'ctx>,
    pub i64_type: IntType<'ctx>,
    pub f64_type: FloatType<'ctx>,
    pub bool_type: IntType<'ctx>,
    pub void_type: VoidType<'ctx>,

    // Runtime helper function types
    /// (ptr a, ptr b, ptr out) -> void  [arithmetic ops]
    pub rt_binop_ty: FunctionType<'ctx>,
    /// (ptr a, ptr b) -> i64  [comparison returning -1/0/1]
    pub rt_cmp_ty: FunctionType<'ctx>,
    /// (ptr val) -> i64  [truthiness check]
    pub rt_truthy_ty: FunctionType<'ctx>,
    /// (ptr ctx, ptr fn, ptr args, i64 nargs, ptr out) -> i64
    pub rt_call_ty: FunctionType<'ctx>,
    /// (ptr ctx, ptr name, i64 name_len, ptr out) -> i64
    pub rt_get_global_ty: FunctionType<'ctx>,
    /// (ptr ctx, ptr name, i64 name_len, ptr val) -> i64
    pub rt_set_global_ty: FunctionType<'ctx>,
    /// (ptr ctx, i64 builtin_id, ptr args, i64 nargs, ptr out) -> i64
    pub rt_builtin_ty: FunctionType<'ctx>,
    /// (ptr proto, i64 idx, ptr out) -> void
    pub rt_get_const_ty: FunctionType<'ctx>,
    /// (ptr vals, i64 count, ptr out) -> void
    pub rt_make_list_ty: FunctionType<'ctx>,
    /// (ptr keys, ptr vals, i64 count, ptr out) -> void
    pub rt_make_map_ty: FunctionType<'ctx>,
    /// (ptr out) -> void  [load constant None/True/False]
    pub rt_load_const_ty: FunctionType<'ctx>,
    /// (ptr val, ptr idx, ptr out) -> i64  [get index]
    pub rt_get_index_ty: FunctionType<'ctx>,
    /// (ptr val, ptr idx, ptr new_val) -> i64  [set index]
    pub rt_set_index_ty: FunctionType<'ctx>,
    /// (ptr val, ptr name, i64 name_len, ptr out) -> i64  [get member]
    pub rt_get_member_ty: FunctionType<'ctx>,
    /// (ptr val, ptr name, i64 name_len, ptr new_val) -> i64  [set member]
    pub rt_set_member_ty: FunctionType<'ctx>,
    /// (ptr ctx, ptr obj, ptr name, i64 name_len, ptr args, i64 nargs, ptr out) -> i64
    pub rt_method_call_ty: FunctionType<'ctx>,
    /// (ptr ctx, i64 opcode, i64 a, i64 b, i64 c, ptr regs_base, i64 num_regs) -> i64
    pub rt_vm_exec_op_ty: FunctionType<'ctx>,
    /// (ptr a, ptr b, ptr out) -> void  [comparison producing Bool VmValue]
    pub rt_cmp_op_ty: FunctionType<'ctx>,
    /// (ptr ctx, ptr proto_const_idx, ptr upvalue_data, i64 num_upvalues, ptr regs_base, ptr out) -> void
    pub rt_make_closure_ty: FunctionType<'ctx>,
    /// (ptr a, ptr out) -> void  [unary ops]
    pub rt_unary_ty: FunctionType<'ctx>,

    /// Standard TL function type: (ptr ctx, ptr args, i64 nargs, ptr retval) -> i64
    pub tl_fn_ty: FunctionType<'ctx>,
}

impl<'ctx> LlvmTypes<'ctx> {
    pub fn new(context: &'ctx Context) -> Self {
        let i8_type = context.i8_type();
        let i32_type = context.i32_type();
        let i64_type = context.i64_type();
        let f64_type = context.f64_type();
        let bool_type = context.bool_type();
        let void_type = context.void_type();
        let ptr_type = context.ptr_type(inkwell::AddressSpace::default());

        // Runtime helper function types
        let rt_binop_ty =
            void_type.fn_type(&[ptr_type.into(), ptr_type.into(), ptr_type.into()], false);
        let rt_cmp_ty = i64_type.fn_type(&[ptr_type.into(), ptr_type.into()], false);
        let rt_truthy_ty = i64_type.fn_type(&[ptr_type.into()], false);
        let rt_call_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_get_global_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_set_global_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_builtin_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_get_const_ty =
            void_type.fn_type(&[ptr_type.into(), i64_type.into(), ptr_type.into()], false);
        let rt_make_list_ty =
            void_type.fn_type(&[ptr_type.into(), i64_type.into(), ptr_type.into()], false);
        let rt_make_map_ty = void_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_load_const_ty = void_type.fn_type(&[ptr_type.into()], false);
        let rt_get_index_ty =
            i64_type.fn_type(&[ptr_type.into(), ptr_type.into(), ptr_type.into()], false);
        let rt_set_index_ty =
            i64_type.fn_type(&[ptr_type.into(), ptr_type.into(), ptr_type.into()], false);
        let rt_get_member_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_set_member_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_method_call_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_vm_exec_op_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                i64_type.into(),
                i64_type.into(),
                i64_type.into(),
                i64_type.into(),
                ptr_type.into(),
                i64_type.into(),
            ],
            false,
        );
        let rt_cmp_op_ty =
            void_type.fn_type(&[ptr_type.into(), ptr_type.into(), ptr_type.into()], false);
        let rt_make_closure_ty = void_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
                ptr_type.into(),
            ],
            false,
        );
        let rt_unary_ty = void_type.fn_type(&[ptr_type.into(), ptr_type.into()], false);
        let tl_fn_ty = i64_type.fn_type(
            &[
                ptr_type.into(),
                ptr_type.into(),
                i64_type.into(),
                ptr_type.into(),
            ],
            false,
        );

        LlvmTypes {
            vmvalue_ptr: ptr_type,
            i8_type,
            i32_type,
            i64_type,
            f64_type,
            bool_type,
            void_type,
            rt_binop_ty,
            rt_cmp_ty,
            rt_truthy_ty,
            rt_call_ty,
            rt_get_global_ty,
            rt_set_global_ty,
            rt_builtin_ty,
            rt_get_const_ty,
            rt_make_list_ty,
            rt_make_map_ty,
            rt_load_const_ty,
            rt_get_index_ty,
            rt_set_index_ty,
            rt_get_member_ty,
            rt_set_member_ty,
            rt_method_call_ty,
            rt_vm_exec_op_ty,
            rt_cmp_op_ty,
            rt_make_closure_ty,
            rt_unary_ty,
            tl_fn_ty,
        }
    }
}