Skip to main content

mirascript_core/emitter/
opcode.rs

1use strum::{Display, FromRepr, VariantArray};
2
3/// MiraScript OpCodes
4#[cfg_attr(feature = "wasm-constants", wasm_bindgen::prelude::wasm_bindgen)]
5#[repr(u8)]
6#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, VariantArray, Display, FromRepr)]
7pub enum OpCode {
8    // debugging
9    /// No operation
10    Noop = 0x00,
11
12    // operators
13    /// ADD %ret %1 %2\
14    /// %ret = %1 + %2
15    Add,
16    /// SUB %ret %1 %2\
17    /// %ret = %1 - %2
18    Sub,
19    /// MUL %ret %1 %2\
20    /// %ret = %1 * %2
21    Mul,
22    /// DIV %ret %1 %2\
23    /// %ret = %1 / %2
24    Div,
25    /// MOD %ret %1 %2\
26    /// %ret = %1 % %2
27    Mod,
28    /// EXP %ret %1 %2\
29    /// %ret = %1 ^ %2
30    Pow,
31    /// POS %ret %1\
32    /// %ret = +%1
33    Pos,
34    /// NEG %ret %1\
35    /// %ret = -%1
36    Neg,
37    /// NOT %ret %1\
38    /// %ret = !%1
39    Not,
40    /// PLUS %ret %1\
41    /// %ret = +%1
42    Plus,
43    /// EQ %ret %1 %2\
44    /// %ret = %1 == %2
45    Eq,
46    /// NEQ %ret %1 %2\
47    /// %ret = %1 != %2
48    Neq,
49    /// LT %ret %1 %2\
50    /// %ret = %1 < %2
51    Lt,
52    /// LTE %ret %1 %2\
53    /// %ret = %1 <= %2
54    Lte,
55    /// GT %ret %1 %2\
56    /// %ret = %1 > %2
57    Gt,
58    /// GTE %ret %1 %2\
59    /// %ret = %1 >= %2
60    Gte,
61    /// AEQ %ret %1 %2\
62    /// %ret = %1 =~ %2
63    Aeq,
64    /// NAEQ %ret %1 %2\
65    /// %ret = %1 !~ %2
66    Naeq,
67    /// SAME %ret %1 %2\
68    /// %ret = %1 === %2 // Same value zero
69    Same,
70    /// Nsame %ret %1 %2\
71    /// %ret = %1 !== %2
72    Nsame,
73    /// IN %ret %1 %2\
74    /// %ret = %1 in %2
75    In,
76    /// IN_GLOBAL %ret %1 %2\
77    /// %ret = %1 in global
78    InGlobal,
79    /// CONCAT %ret `n` %1 %2 ... %n\
80    /// %ret = %1 .. %2 .. ... .. %n
81    Concat,
82    /// FORMAT %ret %1 `index`\
83    /// %ret = format(%1, CONSTANTS\[index])
84    Format,
85    /// AND %ret %1 %2\
86    /// %ret = %1 && %2
87    And,
88    /// OR %ret %1 %2\
89    /// %ret = %1 || %2
90    Or,
91    /// ASSERT_INIT %v\
92    /// assert(%v != uninitialized)
93    AssertInit,
94    /// ASSERT_NON_NIL %v\
95    /// assert(%v != nil)
96    AssertNonNil,
97    /// TYPE %ret %1\
98    /// %ret = type(%1)
99    Type,
100    /// TO_BOOLEAN %ret %1\
101    /// %ret = boolean(%1)
102    ToBoolean,
103    /// TO_NUMBER %ret %1\
104    /// %ret = number(%1)
105    ToNumber,
106    /// TO_STRING %ret %1\
107    /// %ret = string(%1)
108    ToString,
109    // Hint: use Eq/Same %ret %1 %0 for is nil
110    /// IS_BOOLEAN %ret %1\
111    /// %ret = type(%1) == "boolean"
112    IsBoolean,
113    /// IS_NUMBER %ret %1\
114    /// %ret = type(%1) == "number"
115    IsNumber,
116    /// IS_STRING %ret %1\
117    /// %ret = type(%1) == "string"
118    IsString,
119    /// IS_RECORD %ret %1\
120    /// %ret = type(%1) == "record"
121    IsRecord,
122    /// IS_ARRAY %ret %1\
123    /// %ret = type(%1) == "array"
124    IsArray,
125
126    // variable management
127    /// CONSTANT %reg `index`\
128    /// %reg = CONSTANTS\[index]
129    Constant,
130    /// UNINIT %reg
131    /// %reg = uninitialized
132    Uninit,
133    /// ASSIGN %ret %1\
134    /// %ret = %1
135    Assign,
136    /// SWAP %1 %2\
137    /// (%1, %2) = (%2, %1)
138    Swap,
139    /// GET_UPVALUE %ret `level` %%up\
140    /// %ret = UPVALUES\[level]\[%%up]
141    GetUpvalue,
142    /// SET_UPVALUE %value `level` %%up \
143    /// UPVALUES\[level]\[%%up] = %value
144    SetUpvalue,
145    /// GET_GLOBAL %ret `name` \
146    /// %ret = GLOBALS\[CONSTANTS\[name]]
147    GetGlobal,
148    /// GET_GLOBAL_DYN %ret %name \
149    /// %ret = GLOBALS\[%name]
150    GetGlobalDyn,
151
152    // objects
153    /// RECORD %ret\
154    /// %ret = (
155    Record,
156    /// MODULE %ret `name`\
157    /// %ret = mod CONSTANTS\[name] {
158    Module,
159    /// FIELD `name` %field\
160    /// \[CONSTANTS\[name]]: %field,
161    Field,
162    /// FIELD_DYN %name %field\
163    /// \[%name]: %field,
164    FieldDyn,
165    /// FIELD_INDEX `index` %field\
166    /// \[index]: %field,
167    FieldIndex,
168    /// FIELD_OPT `name` %field\
169    /// \[CONSTANTS\[name]]?: %field,
170    FieldOpt,
171    /// FIELD_OPT_DYN %name %field\
172    /// \[%name]?: %field,
173    FieldOptDyn,
174    /// FIELD_OPT_INDEX `index` %field\
175    /// \[index]?: %field,
176    FieldOptIndex,
177    /// PICK %ret %var `n` `key_1` `key_2` ... `key_n`\
178    /// %ret = %var pick keys CONSTANTS\[key_1], CONSTANTS\[key_2], ..., CONSTANTS\[key_n]
179    Pick,
180    /// OMIT %ret %var `n` `key_1` `key_2` ... `key_n`\
181    /// %ret = %var omit keys CONSTANTS\[key_1], CONSTANTS\[key_2], ..., CONSTANTS\[key_n]
182    Omit,
183    /// ARRAY %ret\
184    /// %ret = \[
185    Array,
186    /// ITEM %item\
187    /// %item,
188    Item,
189    /// ITEM_RANGE `start` `end`\
190    /// `start`..`end`,
191    ItemRange,
192    /// ITEM_RANGE_DYN %start %end\
193    /// %start..%end,
194    ItemRangeDyn,
195    /// ITEM_RANGE_EXCLUSIVE_DYN %start %end\
196    /// %start..<%end,
197    ItemRangeExclusiveDyn,
198    /// SPREAD %var\
199    /// ..%var,
200    Spread,
201    /// FREEZE\
202    /// ) for record or ] for array
203    Freeze,
204    /// HAS %ret %var `key`\
205    /// %ret = initialized(%var\[CONSTANTS\[key]])
206    Has,
207    /// HAS_DYN %ret %var %key\
208    /// %ret = initialized(%var\[%key])
209    HasDyn,
210    /// HAS_INDEX %ret %var `index`\
211    /// %ret = initialized(%var\[index])
212    HasIndex,
213    /// GET %ret %var `key`\
214    /// %ret = %var\[CONSTANTS\[key]] ?? nil
215    Get,
216    /// GET_DYN %ret %var %key\
217    /// %ret = %var\[%key] ?? nil
218    GetDyn,
219    /// GET_INDEX %ret %var `index`\
220    /// %ret = %var\[index] ?? nil
221    GetIndex,
222    /// SET %value %var `key`\
223    /// %var\[CONSTANTS\[key]] = %value
224    Set,
225    /// SET_DYN %value %var %key\
226    /// %var\[%key] = %value
227    SetDyn,
228    /// SET_INDEX %value %var `index`\
229    /// %var\[index] = %value
230    SetIndex,
231    /// SLICE %ret %var `start` `end`\
232    /// %ret = %var\[start..end]
233    Slice,
234    /// SLICE_START %ret %var `end`\
235    /// %ret = %var\[..end]
236    SliceStart,
237    /// SLICE_END %ret %var `start`\
238    /// %ret = %var\[start..]
239    SliceEnd,
240    /// SLICE_DYN %ret %var %start %end\
241    /// %ret = %var\[%start..%end]
242    SliceDyn,
243    /// SLICE_EXCLUSIVE_DYN %ret %var %start %end\
244    /// %ret = %var\[%start..<%end]
245    SliceExclusiveDyn,
246    /// LENGTH %ret %var\
247    /// %ret = $Length(%var)
248    Length,
249
250    // control flow
251    /// LOOP `regn`\
252    /// loop { let %1, .. ,%regn;
253    Loop,
254    /// LOOP_FOR `regn` %iterable\
255    /// for %1 in %iterable { let %2, .. ,%regn;
256    LoopFor,
257    /// LOOP_RANGE `regn` %start %end\
258    /// for %1 in %start..%end { let %2, .. ,%regn;
259    LoopRange,
260    /// LOOP_RANGE_EXCLUSIVE `regn` %start %end\
261    /// for %1 in %start..<%end { let %2, .. ,%regn;
262    LoopRangeExclusive,
263    /// LOOP_END\
264    /// }
265    LoopEnd,
266    /// BREAK\
267    /// break;
268    Break,
269    /// CONTINUE\
270    /// continue;
271    Continue,
272    /// IF %cond\
273    /// if (%cond) {
274    If,
275    /// IF_NOT %cond\
276    /// if (!%cond) {
277    IfNot,
278    /// IF_INIT %var\
279    /// if (initialized(%var)) {
280    IfInit,
281    /// IF_NOT_INIT %var\
282    /// if (!initialized(%var)) {
283    IfNotInit,
284    /// IF_NIL %var\
285    /// if (%var == nil) {
286    IfNil,
287    /// IF_NOT_NIL %var\
288    /// if (%var != nil) {
289    IfNotNil,
290    /// ELSE\
291    /// } else {
292    Else,
293    /// IF_END\
294    /// }
295    IfEnd,
296    /// FUNC %f `argn` `regn`\
297    /// %f = (%1, %2, ... , %argn) => { let %argn+1, ... , %regn;
298    Func,
299    /// FUNC_VARG %f `argn` `regn`\
300    /// %f = (%1, %2, ... , %argn-1, ...%argn) => { let %argn+1, ... , %regn;
301    FuncVarg,
302    /// FUNC_END\
303    /// }
304    FuncEnd,
305    /// RETURN %value\
306    /// return %value;
307    Return,
308    /// CALL %ret `f` `argn` %1 %2 ... %argn `spread_n` `spread_arg_a` ...\
309    /// %ret = GLOBAL\[CONSTANTS\[f]](%1, %2, ... , %argn);
310    ///
311    /// If spread_arg_a is present, arg at that index will be spread
312    Call,
313    /// CALL_DYN %ret %f `argn` %1 %2 ... %argn `spread_n` `spread_arg_a` ...\
314    /// %ret = %f(%1, %2, ... , %argn);
315    ///
316    /// If spread_arg_a is present, arg at that index will be spread
317    CallDyn,
318}
319
320impl From<OpCode> for u8 {
321    fn from(op: OpCode) -> u8 {
322        op as u8
323    }
324}
325
326impl TryFrom<u8> for OpCode {
327    type Error = ();
328
329    fn try_from(value: u8) -> Result<Self, Self::Error> {
330        OpCode::from_repr(value).ok_or(())
331    }
332}
333
334impl OpCode {
335    pub const WIDE_MASK: u8 = 0x80;
336    pub const PARAM_MAX: u32 = u8::MAX as u32;
337    pub const PARAM_WIDE_MAX: u32 = u32::MAX;
338
339    pub fn code(&self) -> u8 {
340        *self as u8
341    }
342    pub fn wide_code(&self) -> u8 {
343        *self as u8 | Self::WIDE_MASK
344    }
345}
346
347pub trait OpParamTrait {
348    fn value(&self) -> u32;
349    fn is_wide(&self) -> bool;
350    fn code(&self) -> u8 {
351        debug_assert!(!self.is_wide());
352        self.value() as u8
353    }
354    fn wide_code(&self) -> [u8; 4] {
355        (self.value()).to_le_bytes()
356    }
357}
358
359#[derive(Debug, Clone, Copy, PartialEq, Eq)]
360pub struct Register(u32);
361
362impl Register {
363    pub fn new(index: usize) -> Self {
364        debug_assert!(index != 0);
365        Self(index as u32)
366    }
367
368    /// Write to this register will be ignored
369    /// Reading from this register will always return `nil`
370    pub const EMPTY: Self = Self(0);
371
372    pub fn is_empty(&self) -> bool {
373        self.0 == 0
374    }
375}
376
377impl OpParamTrait for Register {
378    fn value(&self) -> u32 {
379        self.0
380    }
381    fn is_wide(&self) -> bool {
382        self.value() > u8::MAX as u32
383    }
384}
385
386#[derive(Debug, Clone, Copy, PartialEq, Eq)]
387pub struct OpParam(i32);
388
389impl OpParam {
390    pub fn new(value: i32) -> Self {
391        value.into()
392    }
393}
394
395impl OpParamTrait for OpParam {
396    fn value(&self) -> u32 {
397        self.0 as u32
398    }
399
400    fn is_wide(&self) -> bool {
401        self.0 < i8::MIN as i32 || self.0 > i8::MAX as i32
402    }
403}
404
405impl From<usize> for OpParam {
406    fn from(param: usize) -> Self {
407        Self(param as i32)
408    }
409}
410
411impl From<i32> for OpParam {
412    fn from(param: i32) -> Self {
413        Self(param)
414    }
415}