1use crate::enums::bc_op_kind::BcOpKind;
2use crate::records::bc_inst::BcInst;
3use crate::records::bc_op::BcOp;
4use crate::records::bytecode_builder::BytecodeBuilder;
5use crate::records::bytecode_graph_serializer::BytecodeGraphSerializer;
6use luaur_common::enums::luau_capture_type::LuauCaptureType;
7use luaur_common::enums::luau_opcode::LuauOpcode;
8use luaur_common::macros::luau_assert::LUAU_ASSERT;
9use luaur_common::macros::luau_unreachable::LUAU_UNREACHABLE;
10
11impl<'a> BytecodeGraphSerializer<'a> {
12 pub fn emit_instruction(&mut self, insn_op: BcOp) {
13 let mut insn: BcInst = self.func.inst_op(insn_op).clone();
14 let insn: &mut BcInst = &mut insn;
15 self.bcb.set_debug_line(insn.line as i32);
16 match insn.op {
17 LuauOpcode::LOP_NOP | LuauOpcode::LOP_BREAK | LuauOpcode::LOP_NATIVECALL => {
18 self.bcb.emit_abc(insn.op, 0, 0, 0);
19 }
20 LuauOpcode::LOP_LOADNIL => {
21 let out = self.get_register(insn_op);
22 self.bcb.emit_abc(LuauOpcode::LOP_LOADNIL, out, 0, 0);
23 }
24 LuauOpcode::LOP_LOADB => {
25 if insn.ops.len() > 1 {
26 self.record_jump(insn, 1);
27 }
28 let imm_bool = self.get_imm_bool(insn, 0);
29 let out = self.get_register(insn_op);
30 self.bcb
31 .emit_abc(LuauOpcode::LOP_LOADB, out, imm_bool as u8, 0);
32 }
33 LuauOpcode::LOP_LOADN => {
34 let imm_int = self.get_imm_int(insn, 0);
35 let out = self.get_register(insn_op);
36 self.bcb.emit_ad(LuauOpcode::LOP_LOADN, out, imm_int as i16);
37 }
38 LuauOpcode::LOP_LOADK => {
39 let vm_const_input_d = self.get_vm_const_input_d(insn, 0);
40 let out = self.get_register(insn_op);
41 self.bcb
42 .emit_ad(LuauOpcode::LOP_LOADK, out, vm_const_input_d as i16);
43 }
44 LuauOpcode::LOP_MOVE => {
45 let reg_input = self.get_reg_input(insn, 0);
46 let out = self.get_register(insn_op);
47 self.bcb.emit_abc(LuauOpcode::LOP_MOVE, out, reg_input, 0);
48 }
49 LuauOpcode::LOP_GETGLOBAL => {
50 let imm_int = self.get_imm_int(insn, 0);
51 let out = self.get_register(insn_op);
52 self.bcb
53 .emit_abc(LuauOpcode::LOP_GETGLOBAL, out, 0, imm_int as u8);
54 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 1);
55 self.bcb.emit_aux(vm_const_input_aux);
56 }
57 LuauOpcode::LOP_SETGLOBAL => {
58 let reg_input = self.get_reg_input(insn, 0);
59 let imm_int = self.get_imm_int(insn, 1);
60 self.bcb
61 .emit_abc(LuauOpcode::LOP_SETGLOBAL, reg_input, 0, imm_int as u8);
62 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 2);
63 self.bcb.emit_aux(vm_const_input_aux);
64 }
65 LuauOpcode::LOP_GETUPVAL => {
66 let upval_input = self.get_upval_input(insn, 0);
67 let out = self.get_register(insn_op);
68 self.bcb
69 .emit_abc(LuauOpcode::LOP_GETUPVAL, out, upval_input, 0);
70 }
71 LuauOpcode::LOP_SETUPVAL => {
72 let reg_input = self.get_reg_input(insn, 0);
73 let upval_input = self.get_upval_input(insn, 1);
74 self.bcb
75 .emit_abc(LuauOpcode::LOP_SETUPVAL, reg_input, upval_input, 0);
76 }
77 LuauOpcode::LOP_CLOSEUPVALS => {
78 LUAU_ASSERT!(insn.ops.len() == 1 && insn.ops[0].kind == BcOpKind::VmReg);
79 self.bcb
80 .emit_abc(LuauOpcode::LOP_CLOSEUPVALS, insn.ops[0].index as u8, 0, 0);
81 }
82 LuauOpcode::LOP_GETIMPORT => {
83 let vm_const_input_d = self.get_vm_const_input_d(insn, 0);
84 let out = self.get_register(insn_op);
85 self.bcb
86 .emit_ad(LuauOpcode::LOP_GETIMPORT, out, vm_const_input_d as i16);
87 let imm_import = self.get_imm_import(insn, 1);
88 self.bcb.emit_aux(imm_import);
89 }
90 LuauOpcode::LOP_GETTABLE => {
91 let reg_input_0 = self.get_reg_input(insn, 0);
92 let reg_input_1 = self.get_reg_input(insn, 1);
93 let out = self.get_register(insn_op);
94 self.bcb
95 .emit_abc(LuauOpcode::LOP_GETTABLE, out, reg_input_0, reg_input_1);
96 }
97 LuauOpcode::LOP_SETTABLE => {
98 let reg_input_0 = self.get_reg_input(insn, 0);
99 let reg_input_1 = self.get_reg_input(insn, 1);
100 let reg_input_2 = self.get_reg_input(insn, 2);
101 self.bcb.emit_abc(
102 LuauOpcode::LOP_SETTABLE,
103 reg_input_0,
104 reg_input_1,
105 reg_input_2,
106 );
107 }
108 LuauOpcode::LOP_GETUDATAKS | LuauOpcode::LOP_GETTABLEKS => {
109 let reg_input_0 = self.get_reg_input(insn, 0);
110 let imm_int = self.get_imm_int(insn, 1);
111 let out = self.get_register(insn_op);
112 self.bcb.emit_abc(insn.op, out, reg_input_0, imm_int as u8);
113 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 2);
114 self.bcb.emit_aux(vm_const_input_aux);
115 }
116 LuauOpcode::LOP_SETUDATAKS | LuauOpcode::LOP_SETTABLEKS => {
117 let reg_input_0 = self.get_reg_input(insn, 0);
118 let reg_input_1 = self.get_reg_input(insn, 1);
119 let imm_int = self.get_imm_int(insn, 2);
120 self.bcb
121 .emit_abc(insn.op, reg_input_0, reg_input_1, imm_int as u8);
122 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 3);
123 self.bcb.emit_aux(vm_const_input_aux);
124 }
125 LuauOpcode::LOP_GETTABLEN => {
126 let reg_input_0 = self.get_reg_input(insn, 0);
127 let imm_int = self.get_imm_int(insn, 1);
128 let out = self.get_register(insn_op);
129 self.bcb.emit_abc(
130 LuauOpcode::LOP_GETTABLEN,
131 out,
132 reg_input_0,
133 (imm_int - 1) as u8,
134 );
135 }
136 LuauOpcode::LOP_SETTABLEN => {
137 let reg_input_0 = self.get_reg_input(insn, 0);
138 let reg_input_1 = self.get_reg_input(insn, 1);
139 let imm_int = self.get_imm_int(insn, 2);
140 self.bcb.emit_abc(
141 LuauOpcode::LOP_SETTABLEN,
142 reg_input_0,
143 reg_input_1,
144 (imm_int - 1) as u8,
145 );
146 }
147 LuauOpcode::LOP_NEWCLOSURE => {
148 let proto_input = self.get_proto_input(insn, 0);
149 let out = self.get_register(insn_op);
150 self.bcb
151 .emit_ad(LuauOpcode::LOP_NEWCLOSURE, out, proto_input as i16);
152 }
153 LuauOpcode::LOP_NAMECALLUDATA | LuauOpcode::LOP_NAMECALL => {
154 let reg_input_0 = self.get_reg_input(insn, 0);
155 let imm_int = self.get_imm_int(insn, 1);
156 let out = self.get_register(insn_op);
157 self.bcb.emit_abc(insn.op, out, reg_input_0, imm_int as u8);
158 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 2);
159 self.bcb.emit_aux(vm_const_input_aux);
160 }
161 LuauOpcode::LOP_CALL => {
162 let reg_input_2 = self.get_reg_input(insn, 2);
163 let imm_int_0 = self.get_imm_int(insn, 0);
164 let imm_int_1 = self.get_imm_int(insn, 1);
165 self.bcb.emit_abc(
166 LuauOpcode::LOP_CALL,
167 reg_input_2,
168 (imm_int_0 + 1) as u8,
169 (imm_int_1 + 1) as u8,
170 );
171 }
172 LuauOpcode::LOP_CALLFB => {
173 let reg_input_3 = self.get_reg_input(insn, 3);
174 let imm_int_0 = self.get_imm_int(insn, 0);
175 let imm_int_1 = self.get_imm_int(insn, 1);
176 let imm_int_2 = self.get_imm_int(insn, 2);
177 self.bcb.emit_abc(
178 LuauOpcode::LOP_CALLFB,
179 reg_input_3,
180 (imm_int_0 + 1) as u8,
181 (imm_int_1 + 1) as u8,
182 );
183 self.bcb.emit_aux(imm_int_2 as u32);
184 }
185 LuauOpcode::LOP_RETURN => {
186 LUAU_ASSERT!(insn.ops.len() > 1);
187 let reg_input_1 = self.get_reg_input(insn, 1);
188 let imm_int_0 = self.get_imm_int(insn, 0);
189 self.bcb.emit_abc(
190 LuauOpcode::LOP_RETURN,
191 reg_input_1,
192 (imm_int_0 + 1) as u8,
193 0,
194 );
195 }
196 LuauOpcode::LOP_JUMP => {
197 self.record_jump(insn, 0);
198 self.bcb.emit_ad(LuauOpcode::LOP_JUMP, 0, 0);
199 }
200 LuauOpcode::LOP_JUMPBACK => {
201 self.record_jump(insn, 0);
202 self.bcb.emit_ad(LuauOpcode::LOP_JUMPBACK, 0, 0);
203 }
204 LuauOpcode::LOP_JUMPIFNOT | LuauOpcode::LOP_JUMPIF => {
205 self.record_jump(insn, 1);
206 let reg_input_0 = self.get_reg_input(insn, 0);
207 self.bcb.emit_ad(insn.op, reg_input_0, 0);
208 }
209 LuauOpcode::LOP_JUMPIFEQ
210 | LuauOpcode::LOP_JUMPIFLE
211 | LuauOpcode::LOP_JUMPIFLT
212 | LuauOpcode::LOP_JUMPIFNOTEQ
213 | LuauOpcode::LOP_JUMPIFNOTLE
214 | LuauOpcode::LOP_JUMPIFNOTLT => {
215 self.record_jump(insn, 2);
216 let reg_input_0 = self.get_reg_input(insn, 0);
217 self.bcb.emit_ad(insn.op, reg_input_0, 0);
218 let reg_input_1 = self.get_reg_input(insn, 1);
219 self.bcb.emit_aux(reg_input_1 as u32);
220 }
221 LuauOpcode::LOP_ADD
222 | LuauOpcode::LOP_SUB
223 | LuauOpcode::LOP_MUL
224 | LuauOpcode::LOP_DIV
225 | LuauOpcode::LOP_MOD
226 | LuauOpcode::LOP_POW
227 | LuauOpcode::LOP_AND
228 | LuauOpcode::LOP_OR => {
229 let reg_input_0 = self.get_reg_input(insn, 0);
230 let reg_input_1 = self.get_reg_input(insn, 1);
231 let out = self.get_register(insn_op);
232 self.bcb.emit_abc(insn.op, out, reg_input_0, reg_input_1);
233 }
234 LuauOpcode::LOP_ADDK
235 | LuauOpcode::LOP_SUBK
236 | LuauOpcode::LOP_MULK
237 | LuauOpcode::LOP_DIVK
238 | LuauOpcode::LOP_MODK
239 | LuauOpcode::LOP_POWK
240 | LuauOpcode::LOP_ANDK
241 | LuauOpcode::LOP_ORK => {
242 let reg_input_0 = self.get_reg_input(insn, 0);
243 let vm_const_input_abc = self.get_vm_const_input_abc(insn, 1);
244 let out = self.get_register(insn_op);
245 self.bcb
246 .emit_abc(insn.op, out, reg_input_0, vm_const_input_abc);
247 }
248 LuauOpcode::LOP_CONCAT => {
249 LUAU_ASSERT!(insn.ops.len() > 0);
250 let reg_input_0 = self.get_reg_input(insn, 0);
251 let last_idx = insn.ops.len() - 1;
252 let reg_input_last = self.get_reg_input(insn, last_idx as u8);
253 let out = self.get_register(insn_op);
254 self.bcb
255 .emit_abc(LuauOpcode::LOP_CONCAT, out, reg_input_0, reg_input_last);
256 }
257 LuauOpcode::LOP_NOT | LuauOpcode::LOP_MINUS | LuauOpcode::LOP_LENGTH => {
258 let reg_input_0 = self.get_reg_input(insn, 0);
259 let out = self.get_register(insn_op);
260 self.bcb.emit_abc(insn.op, out, reg_input_0, 0);
261 }
262 LuauOpcode::LOP_NEWTABLE => {
263 let imm_int_0 = self.get_imm_int(insn, 0);
264 let imm_int_1 = self.get_imm_int(insn, 1);
265 let out = self.get_register(insn_op);
266 self.bcb
267 .emit_abc(LuauOpcode::LOP_NEWTABLE, out, imm_int_0 as u8, 0);
268 self.bcb.emit_aux(imm_int_1 as u32);
269 }
270 LuauOpcode::LOP_DUPTABLE => {
271 let vm_const_input_d = self.get_vm_const_input_d(insn, 0);
272 let out = self.get_register(insn_op);
273 self.bcb
274 .emit_ad(LuauOpcode::LOP_DUPTABLE, out, vm_const_input_d as i16);
275 }
276 LuauOpcode::LOP_SETLIST => {
277 LUAU_ASSERT!(insn.ops.len() > 2);
278 let reg_input_2 = self.get_reg_input(insn, 2);
279 let reg_input_3 = self.get_reg_input(insn, 3);
280 let imm_int_1 = self.get_imm_int(insn, 1);
281 let imm_int_0 = self.get_imm_int(insn, 0);
282 self.bcb.emit_abc(
283 LuauOpcode::LOP_SETLIST,
284 reg_input_2,
285 reg_input_3,
286 (imm_int_1 + 1) as u8,
287 );
288 self.bcb.emit_aux(imm_int_0 as u32);
289 }
290 LuauOpcode::LOP_FORNPREP => {
291 self.record_jump(insn, 3);
292 let reg_input_0 = self.get_reg_input(insn, 0);
293 self.bcb.emit_ad(LuauOpcode::LOP_FORNPREP, reg_input_0, 0);
294 }
295 LuauOpcode::LOP_FORNLOOP => {
296 self.record_jump(insn, 3);
297 let reg_input_0 = self.get_reg_input(insn, 0);
298 self.bcb.emit_ad(LuauOpcode::LOP_FORNLOOP, reg_input_0, 0);
299 }
300 LuauOpcode::LOP_FORGPREP
301 | LuauOpcode::LOP_FORGPREP_NEXT
302 | LuauOpcode::LOP_FORGPREP_INEXT => {
303 self.record_jump(insn, 3);
304 let reg_input_0 = self.get_reg_input(insn, 0);
305 self.bcb.emit_ad(insn.op, reg_input_0, 0);
306 }
307 LuauOpcode::LOP_FORGLOOP => {
308 self.record_jump(insn, 5);
309 let reg_input_0 = self.get_reg_input(insn, 0);
310 self.bcb.emit_ad(LuauOpcode::LOP_FORGLOOP, reg_input_0, 0);
311 let imm_bool_3 = self.get_imm_bool(insn, 3);
312 let imm_int_4 = self.get_imm_int(insn, 4);
313 let aux = (imm_bool_3 as u32) << 31 | (imm_int_4 as u32);
314 self.bcb.emit_aux(aux);
315 }
316 LuauOpcode::LOP_FASTCALL => {
317 let imm_int_0 = self.get_imm_int(insn, 0);
318 let imm_int_1 = self.get_imm_int(insn, 1);
319 self.bcb.emit_abc(
320 LuauOpcode::LOP_FASTCALL,
321 imm_int_0 as u8,
322 0,
323 imm_int_1 as u8,
324 );
325 }
326 LuauOpcode::LOP_FASTCALL1 => {
327 let imm_int_0 = self.get_imm_int(insn, 0);
328 let reg_input_1 = self.get_reg_input(insn, 1);
329 let imm_int_2 = self.get_imm_int(insn, 2);
330 self.bcb.emit_abc(
331 LuauOpcode::LOP_FASTCALL1,
332 imm_int_0 as u8,
333 reg_input_1,
334 imm_int_2 as u8,
335 );
336 }
337 LuauOpcode::LOP_FASTCALL2 => {
338 let imm_int_0 = self.get_imm_int(insn, 0);
339 let reg_input_1 = self.get_reg_input(insn, 1);
340 let imm_int_3 = self.get_imm_int(insn, 3);
341 let reg_input_2 = self.get_reg_input(insn, 2);
342 self.bcb.emit_abc(
343 LuauOpcode::LOP_FASTCALL2,
344 imm_int_0 as u8,
345 reg_input_1,
346 imm_int_3 as u8,
347 );
348 self.bcb.emit_aux(reg_input_2 as u32);
349 }
350 LuauOpcode::LOP_FASTCALL2K => {
351 let imm_int_0 = self.get_imm_int(insn, 0);
352 let reg_input_1 = self.get_reg_input(insn, 1);
353 let imm_int_3 = self.get_imm_int(insn, 3);
354 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 2);
355 self.bcb.emit_abc(
356 LuauOpcode::LOP_FASTCALL2K,
357 imm_int_0 as u8,
358 reg_input_1,
359 imm_int_3 as u8,
360 );
361 self.bcb.emit_aux(vm_const_input_aux);
362 }
363 LuauOpcode::LOP_FASTCALL3 => {
364 let imm_int_0 = self.get_imm_int(insn, 0);
365 let reg_input_1 = self.get_reg_input(insn, 1);
366 let imm_int_4 = self.get_imm_int(insn, 4);
367 let reg_input_2 = self.get_reg_input(insn, 2);
368 let reg_input_3 = self.get_reg_input(insn, 3);
369 let aux = reg_input_2 as u32 | (reg_input_3 as u32) << 8;
370 self.bcb.emit_abc(
371 LuauOpcode::LOP_FASTCALL3,
372 imm_int_0 as u8,
373 reg_input_1,
374 imm_int_4 as u8,
375 );
376 self.bcb.emit_aux(aux);
377 }
378 LuauOpcode::LOP_GETVARARGS => {
379 LUAU_ASSERT!(insn.ops.len() == 2 && insn.ops[0].kind == BcOpKind::VmReg);
380 let reg_index = insn.ops[0].index;
381 let imm_int_1 = self.get_imm_int(insn, 1);
382 self.bcb.emit_abc(
383 LuauOpcode::LOP_GETVARARGS,
384 reg_index as u8,
385 (imm_int_1 + 1) as u8,
386 0,
387 );
388 }
389 LuauOpcode::LOP_DUPCLOSURE => {
390 let vm_const_input_d = self.get_vm_const_input_d(insn, 0);
391 let out = self.get_register(insn_op);
392 self.bcb
393 .emit_ad(LuauOpcode::LOP_DUPCLOSURE, out, vm_const_input_d as i16);
394 }
395 LuauOpcode::LOP_PREPVARARGS => {
396 let imm_int_0 = self.get_imm_int(insn, 0);
397 self.bcb
398 .emit_ad(LuauOpcode::LOP_PREPVARARGS, imm_int_0 as u8, 0);
399 }
400 LuauOpcode::LOP_LOADKX => {
401 let out = self.get_register(insn_op);
402 self.bcb.emit_ad(LuauOpcode::LOP_LOADKX, out, 0);
403 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 0);
404 self.bcb.emit_aux(vm_const_input_aux);
405 }
406 LuauOpcode::LOP_JUMPX => {
407 self.record_jump(insn, 0);
408 self.bcb.emit_e(LuauOpcode::LOP_JUMPX, 0);
409 }
410 LuauOpcode::LOP_COVERAGE => {
411 let imm_int_0 = self.get_imm_int(insn, 0);
412 self.bcb.emit_e(LuauOpcode::LOP_COVERAGE, imm_int_0);
413 }
414 LuauOpcode::LOP_CAPTURE => {
415 let capture_type = self.get_imm_int(insn, 0) as u8;
416 if capture_type == LuauCaptureType::LCT_VAL as u8
417 || capture_type == LuauCaptureType::LCT_REF as u8
418 {
419 let reg_input_1 = self.get_reg_input(insn, 1);
420 let imm_int_2 = self.get_imm_int(insn, 2);
421 self.bcb.emit_abc(
422 LuauOpcode::LOP_CAPTURE,
423 capture_type,
424 reg_input_1,
425 imm_int_2 as u8,
426 );
427 } else {
428 let upval_input = self.get_upval_input(insn, 1);
429 let imm_int_2 = self.get_imm_int(insn, 2);
430 self.bcb.emit_abc(
431 LuauOpcode::LOP_CAPTURE,
432 capture_type,
433 upval_input,
434 imm_int_2 as u8,
435 );
436 }
437 }
438 LuauOpcode::LOP_SUBRK | LuauOpcode::LOP_DIVRK => {
439 let vm_const_input_abc = self.get_vm_const_input_abc(insn, 0);
440 let reg_input_1 = self.get_reg_input(insn, 1);
441 let out = self.get_register(insn_op);
442 self.bcb
443 .emit_abc(insn.op, out, vm_const_input_abc, reg_input_1);
444 }
445 LuauOpcode::LOP_JUMPXEQKNIL => {
446 self.record_jump(insn, 2);
447 let reg_input_0 = self.get_reg_input(insn, 0);
448 let imm_bool_1 = self.get_imm_bool(insn, 1);
449 let aux = (imm_bool_1 as u32) << 31;
450 self.bcb
451 .emit_ad(LuauOpcode::LOP_JUMPXEQKNIL, reg_input_0, 0);
452 self.bcb.emit_aux(aux);
453 }
454 LuauOpcode::LOP_JUMPXEQKB => {
455 self.record_jump(insn, 2);
456 let reg_input_0 = self.get_reg_input(insn, 0);
457 let imm_bool_1 = self.get_imm_bool(insn, 1);
458 let imm_bool_3 = self.get_imm_bool(insn, 3);
459 let aux = (imm_bool_1 as u32) << 31 | (imm_bool_3 as u32);
460 self.bcb.emit_ad(LuauOpcode::LOP_JUMPXEQKB, reg_input_0, 0);
461 self.bcb.emit_aux(aux);
462 }
463 LuauOpcode::LOP_JUMPXEQKN | LuauOpcode::LOP_JUMPXEQKS => {
464 self.record_jump(insn, 2);
465 let reg_input_0 = self.get_reg_input(insn, 0);
466 let imm_bool_1 = self.get_imm_bool(insn, 1);
467 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 3);
468 let aux = (imm_bool_1 as u32) << 31 | vm_const_input_aux;
469 self.bcb.emit_ad(insn.op, reg_input_0, 0);
470 self.bcb.emit_aux(aux);
471 }
472 LuauOpcode::LOP_IDIV => {
473 let reg_input_0 = self.get_reg_input(insn, 0);
474 let reg_input_1 = self.get_reg_input(insn, 1);
475 let out = self.get_register(insn_op);
476 self.bcb
477 .emit_abc(LuauOpcode::LOP_IDIV, out, reg_input_0, reg_input_1);
478 }
479 LuauOpcode::LOP_IDIVK => {
480 let reg_input_0 = self.get_reg_input(insn, 0);
481 let vm_const_input_abc = self.get_vm_const_input_abc(insn, 1);
482 let out = self.get_register(insn_op);
483 self.bcb
484 .emit_abc(LuauOpcode::LOP_IDIVK, out, reg_input_0, vm_const_input_abc);
485 }
486 LuauOpcode::LOP_NEWCLASSMEMBER => {
487 LUAU_ASSERT!(luaur_common::FFlag::DebugLuauUserDefinedClasses.get());
488 let reg_input_0 = self.get_reg_input(insn, 0);
489 let reg_input_1 = self.get_reg_input(insn, 1);
490 self.bcb
491 .emit_abc(LuauOpcode::LOP_NEWCLASSMEMBER, reg_input_0, 0, reg_input_1);
492 let vm_const_input_aux = self.get_vm_const_input_aux(insn, 2);
493 self.bcb.emit_aux(vm_const_input_aux);
494 }
495 LuauOpcode::LOP_CMPPROTO => {
496 self.record_jump(insn, 2);
497 let reg_input_0 = self.get_reg_input(insn, 0);
498 let imm_int_1 = self.get_imm_int(insn, 1);
499 self.bcb.emit_ad(LuauOpcode::LOP_CMPPROTO, reg_input_0, 0);
500 self.bcb.emit_aux(imm_int_1 as u32);
501 }
502 LuauOpcode::LOP__COUNT => {
503 LUAU_UNREACHABLE!();
504 }
505 }
506 }
507}