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}