1#ifdef GET_OPCODE_NAMES
2OP_Activate,
3#endif
4#ifdef GET_INTERPFN_LIST
5&Interp_Activate,
6#endif
7#ifdef GET_INTERPFN_DISPATCHERS
8PRESERVE_NONE
9static bool Interp_Activate(InterpState &S) {
10 Activate(S);
11#if USE_TAILCALLS
12 MUSTTAIL return InterpNext(S);
13#else
14 return true;
15#endif
16}
17#endif
18#ifdef GET_DISASM
19case OP_Activate:
20 Text.Op = PrintName("Activate");
21 break;
22#endif
23#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
24bool emitActivate(SourceInfo);
25#endif
26#ifdef GET_LINK_IMPL
27bool ByteCodeEmitter::emitActivate(SourceInfo L) {
28 return emitOp<>(OP_Activate, L);
29}
30#endif
31#ifdef GET_EVAL_IMPL
32bool EvalEmitter::emitActivate(SourceInfo L) {
33 if (!isActive()) return true;
34 CurrentSource = L;
35 return Activate(S);
36}
37#endif
38#ifdef GET_OPCODE_NAMES
39OP_ActivateThisField,
40#endif
41#ifdef GET_INTERPFN_LIST
42&Interp_ActivateThisField,
43#endif
44#ifdef GET_INTERPFN_DISPATCHERS
45PRESERVE_NONE
46static bool Interp_ActivateThisField(InterpState &S) {
47 {
48 const auto V0 = ReadArg<uint32_t>(S, S.PC);
49 if (!ActivateThisField(S, V0)) return false;
50 }
51#if USE_TAILCALLS
52 MUSTTAIL return InterpNext(S);
53#else
54 return true;
55#endif
56}
57#endif
58#ifdef GET_DISASM
59case OP_ActivateThisField:
60 Text.Op = PrintName("ActivateThisField");
61 Text.Args.push_back(printArg<uint32_t>(PC));
62 break;
63#endif
64#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
65bool emitActivateThisField( uint32_t , SourceInfo);
66#endif
67#ifdef GET_LINK_IMPL
68bool ByteCodeEmitter::emitActivateThisField( uint32_t A0, SourceInfo L) {
69 return emitOp<uint32_t>(OP_ActivateThisField, A0, L);
70}
71#endif
72#ifdef GET_EVAL_IMPL
73bool EvalEmitter::emitActivateThisField( uint32_t A0, SourceInfo L) {
74 if (!isActive()) return true;
75 CurrentSource = L;
76 return ActivateThisField(S, A0);
77}
78#endif
79#ifdef GET_OPCODE_NAMES
80OP_AddSint8,
81OP_AddUint8,
82OP_AddSint16,
83OP_AddUint16,
84OP_AddSint32,
85OP_AddUint32,
86OP_AddSint64,
87OP_AddUint64,
88OP_AddIntAP,
89OP_AddIntAPS,
90OP_AddBool,
91OP_AddFixedPoint,
92#endif
93#ifdef GET_INTERPFN_LIST
94&Interp_AddSint8,
95&Interp_AddUint8,
96&Interp_AddSint16,
97&Interp_AddUint16,
98&Interp_AddSint32,
99&Interp_AddUint32,
100&Interp_AddSint64,
101&Interp_AddUint64,
102&Interp_AddIntAP,
103&Interp_AddIntAPS,
104&Interp_AddBool,
105&Interp_AddFixedPoint,
106#endif
107#ifdef GET_INTERPFN_DISPATCHERS
108PRESERVE_NONE
109static bool Interp_AddSint8(InterpState &S) {
110 if (!Add<PT_Sint8>(S, S.PC)) return false;
111#if USE_TAILCALLS
112 MUSTTAIL return InterpNext(S);
113#else
114 return true;
115#endif
116}
117PRESERVE_NONE
118static bool Interp_AddUint8(InterpState &S) {
119 if (!Add<PT_Uint8>(S, S.PC)) return false;
120#if USE_TAILCALLS
121 MUSTTAIL return InterpNext(S);
122#else
123 return true;
124#endif
125}
126PRESERVE_NONE
127static bool Interp_AddSint16(InterpState &S) {
128 if (!Add<PT_Sint16>(S, S.PC)) return false;
129#if USE_TAILCALLS
130 MUSTTAIL return InterpNext(S);
131#else
132 return true;
133#endif
134}
135PRESERVE_NONE
136static bool Interp_AddUint16(InterpState &S) {
137 if (!Add<PT_Uint16>(S, S.PC)) return false;
138#if USE_TAILCALLS
139 MUSTTAIL return InterpNext(S);
140#else
141 return true;
142#endif
143}
144PRESERVE_NONE
145static bool Interp_AddSint32(InterpState &S) {
146 if (!Add<PT_Sint32>(S, S.PC)) return false;
147#if USE_TAILCALLS
148 MUSTTAIL return InterpNext(S);
149#else
150 return true;
151#endif
152}
153PRESERVE_NONE
154static bool Interp_AddUint32(InterpState &S) {
155 if (!Add<PT_Uint32>(S, S.PC)) return false;
156#if USE_TAILCALLS
157 MUSTTAIL return InterpNext(S);
158#else
159 return true;
160#endif
161}
162PRESERVE_NONE
163static bool Interp_AddSint64(InterpState &S) {
164 if (!Add<PT_Sint64>(S, S.PC)) return false;
165#if USE_TAILCALLS
166 MUSTTAIL return InterpNext(S);
167#else
168 return true;
169#endif
170}
171PRESERVE_NONE
172static bool Interp_AddUint64(InterpState &S) {
173 if (!Add<PT_Uint64>(S, S.PC)) return false;
174#if USE_TAILCALLS
175 MUSTTAIL return InterpNext(S);
176#else
177 return true;
178#endif
179}
180PRESERVE_NONE
181static bool Interp_AddIntAP(InterpState &S) {
182 if (!Add<PT_IntAP>(S, S.PC)) return false;
183#if USE_TAILCALLS
184 MUSTTAIL return InterpNext(S);
185#else
186 return true;
187#endif
188}
189PRESERVE_NONE
190static bool Interp_AddIntAPS(InterpState &S) {
191 if (!Add<PT_IntAPS>(S, S.PC)) return false;
192#if USE_TAILCALLS
193 MUSTTAIL return InterpNext(S);
194#else
195 return true;
196#endif
197}
198PRESERVE_NONE
199static bool Interp_AddBool(InterpState &S) {
200 if (!Add<PT_Bool>(S, S.PC)) return false;
201#if USE_TAILCALLS
202 MUSTTAIL return InterpNext(S);
203#else
204 return true;
205#endif
206}
207PRESERVE_NONE
208static bool Interp_AddFixedPoint(InterpState &S) {
209 if (!Add<PT_FixedPoint>(S, S.PC)) return false;
210#if USE_TAILCALLS
211 MUSTTAIL return InterpNext(S);
212#else
213 return true;
214#endif
215}
216#endif
217#ifdef GET_DISASM
218case OP_AddSint8:
219 Text.Op = PrintName("AddSint8");
220 break;
221case OP_AddUint8:
222 Text.Op = PrintName("AddUint8");
223 break;
224case OP_AddSint16:
225 Text.Op = PrintName("AddSint16");
226 break;
227case OP_AddUint16:
228 Text.Op = PrintName("AddUint16");
229 break;
230case OP_AddSint32:
231 Text.Op = PrintName("AddSint32");
232 break;
233case OP_AddUint32:
234 Text.Op = PrintName("AddUint32");
235 break;
236case OP_AddSint64:
237 Text.Op = PrintName("AddSint64");
238 break;
239case OP_AddUint64:
240 Text.Op = PrintName("AddUint64");
241 break;
242case OP_AddIntAP:
243 Text.Op = PrintName("AddIntAP");
244 break;
245case OP_AddIntAPS:
246 Text.Op = PrintName("AddIntAPS");
247 break;
248case OP_AddBool:
249 Text.Op = PrintName("AddBool");
250 break;
251case OP_AddFixedPoint:
252 Text.Op = PrintName("AddFixedPoint");
253 break;
254#endif
255#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
256bool emitAddSint8(SourceInfo);
257bool emitAddUint8(SourceInfo);
258bool emitAddSint16(SourceInfo);
259bool emitAddUint16(SourceInfo);
260bool emitAddSint32(SourceInfo);
261bool emitAddUint32(SourceInfo);
262bool emitAddSint64(SourceInfo);
263bool emitAddUint64(SourceInfo);
264bool emitAddIntAP(SourceInfo);
265bool emitAddIntAPS(SourceInfo);
266bool emitAddBool(SourceInfo);
267bool emitAddFixedPoint(SourceInfo);
268#endif
269#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
270[[nodiscard]] bool emitAdd(PrimType, SourceInfo I);
271#endif
272#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
273bool
274#if defined(GET_EVAL_IMPL)
275EvalEmitter
276#else
277ByteCodeEmitter
278#endif
279::emitAdd(PrimType T0, SourceInfo I) {
280 switch (T0) {
281 case PT_Sint8:
282 return emitAddSint8(I);
283 case PT_Uint8:
284 return emitAddUint8(I);
285 case PT_Sint16:
286 return emitAddSint16(I);
287 case PT_Uint16:
288 return emitAddUint16(I);
289 case PT_Sint32:
290 return emitAddSint32(I);
291 case PT_Uint32:
292 return emitAddUint32(I);
293 case PT_Sint64:
294 return emitAddSint64(I);
295 case PT_Uint64:
296 return emitAddUint64(I);
297 case PT_IntAP:
298 return emitAddIntAP(I);
299 case PT_IntAPS:
300 return emitAddIntAPS(I);
301 case PT_Bool:
302 return emitAddBool(I);
303 case PT_FixedPoint:
304 return emitAddFixedPoint(I);
305 default: llvm_unreachable("invalid type: emitAdd");
306 }
307 llvm_unreachable("invalid enum value");
308}
309#endif
310#ifdef GET_LINK_IMPL
311bool ByteCodeEmitter::emitAddSint8(SourceInfo L) {
312 return emitOp<>(OP_AddSint8, L);
313}
314bool ByteCodeEmitter::emitAddUint8(SourceInfo L) {
315 return emitOp<>(OP_AddUint8, L);
316}
317bool ByteCodeEmitter::emitAddSint16(SourceInfo L) {
318 return emitOp<>(OP_AddSint16, L);
319}
320bool ByteCodeEmitter::emitAddUint16(SourceInfo L) {
321 return emitOp<>(OP_AddUint16, L);
322}
323bool ByteCodeEmitter::emitAddSint32(SourceInfo L) {
324 return emitOp<>(OP_AddSint32, L);
325}
326bool ByteCodeEmitter::emitAddUint32(SourceInfo L) {
327 return emitOp<>(OP_AddUint32, L);
328}
329bool ByteCodeEmitter::emitAddSint64(SourceInfo L) {
330 return emitOp<>(OP_AddSint64, L);
331}
332bool ByteCodeEmitter::emitAddUint64(SourceInfo L) {
333 return emitOp<>(OP_AddUint64, L);
334}
335bool ByteCodeEmitter::emitAddIntAP(SourceInfo L) {
336 return emitOp<>(OP_AddIntAP, L);
337}
338bool ByteCodeEmitter::emitAddIntAPS(SourceInfo L) {
339 return emitOp<>(OP_AddIntAPS, L);
340}
341bool ByteCodeEmitter::emitAddBool(SourceInfo L) {
342 return emitOp<>(OP_AddBool, L);
343}
344bool ByteCodeEmitter::emitAddFixedPoint(SourceInfo L) {
345 return emitOp<>(OP_AddFixedPoint, L);
346}
347#endif
348#ifdef GET_EVAL_IMPL
349bool EvalEmitter::emitAddSint8(SourceInfo L) {
350 if (!isActive()) return true;
351 CurrentSource = L;
352 return Add<PT_Sint8>(S, CodePtr());
353}
354bool EvalEmitter::emitAddUint8(SourceInfo L) {
355 if (!isActive()) return true;
356 CurrentSource = L;
357 return Add<PT_Uint8>(S, CodePtr());
358}
359bool EvalEmitter::emitAddSint16(SourceInfo L) {
360 if (!isActive()) return true;
361 CurrentSource = L;
362 return Add<PT_Sint16>(S, CodePtr());
363}
364bool EvalEmitter::emitAddUint16(SourceInfo L) {
365 if (!isActive()) return true;
366 CurrentSource = L;
367 return Add<PT_Uint16>(S, CodePtr());
368}
369bool EvalEmitter::emitAddSint32(SourceInfo L) {
370 if (!isActive()) return true;
371 CurrentSource = L;
372 return Add<PT_Sint32>(S, CodePtr());
373}
374bool EvalEmitter::emitAddUint32(SourceInfo L) {
375 if (!isActive()) return true;
376 CurrentSource = L;
377 return Add<PT_Uint32>(S, CodePtr());
378}
379bool EvalEmitter::emitAddSint64(SourceInfo L) {
380 if (!isActive()) return true;
381 CurrentSource = L;
382 return Add<PT_Sint64>(S, CodePtr());
383}
384bool EvalEmitter::emitAddUint64(SourceInfo L) {
385 if (!isActive()) return true;
386 CurrentSource = L;
387 return Add<PT_Uint64>(S, CodePtr());
388}
389bool EvalEmitter::emitAddIntAP(SourceInfo L) {
390 if (!isActive()) return true;
391 CurrentSource = L;
392 return Add<PT_IntAP>(S, CodePtr());
393}
394bool EvalEmitter::emitAddIntAPS(SourceInfo L) {
395 if (!isActive()) return true;
396 CurrentSource = L;
397 return Add<PT_IntAPS>(S, CodePtr());
398}
399bool EvalEmitter::emitAddBool(SourceInfo L) {
400 if (!isActive()) return true;
401 CurrentSource = L;
402 return Add<PT_Bool>(S, CodePtr());
403}
404bool EvalEmitter::emitAddFixedPoint(SourceInfo L) {
405 if (!isActive()) return true;
406 CurrentSource = L;
407 return Add<PT_FixedPoint>(S, CodePtr());
408}
409#endif
410#ifdef GET_OPCODE_NAMES
411OP_AddOffsetSint8,
412OP_AddOffsetUint8,
413OP_AddOffsetSint16,
414OP_AddOffsetUint16,
415OP_AddOffsetSint32,
416OP_AddOffsetUint32,
417OP_AddOffsetSint64,
418OP_AddOffsetUint64,
419OP_AddOffsetIntAP,
420OP_AddOffsetIntAPS,
421OP_AddOffsetBool,
422#endif
423#ifdef GET_INTERPFN_LIST
424&Interp_AddOffsetSint8,
425&Interp_AddOffsetUint8,
426&Interp_AddOffsetSint16,
427&Interp_AddOffsetUint16,
428&Interp_AddOffsetSint32,
429&Interp_AddOffsetUint32,
430&Interp_AddOffsetSint64,
431&Interp_AddOffsetUint64,
432&Interp_AddOffsetIntAP,
433&Interp_AddOffsetIntAPS,
434&Interp_AddOffsetBool,
435#endif
436#ifdef GET_INTERPFN_DISPATCHERS
437PRESERVE_NONE
438static bool Interp_AddOffsetSint8(InterpState &S) {
439 if (!AddOffset<PT_Sint8>(S, S.PC)) return false;
440#if USE_TAILCALLS
441 MUSTTAIL return InterpNext(S);
442#else
443 return true;
444#endif
445}
446PRESERVE_NONE
447static bool Interp_AddOffsetUint8(InterpState &S) {
448 if (!AddOffset<PT_Uint8>(S, S.PC)) return false;
449#if USE_TAILCALLS
450 MUSTTAIL return InterpNext(S);
451#else
452 return true;
453#endif
454}
455PRESERVE_NONE
456static bool Interp_AddOffsetSint16(InterpState &S) {
457 if (!AddOffset<PT_Sint16>(S, S.PC)) return false;
458#if USE_TAILCALLS
459 MUSTTAIL return InterpNext(S);
460#else
461 return true;
462#endif
463}
464PRESERVE_NONE
465static bool Interp_AddOffsetUint16(InterpState &S) {
466 if (!AddOffset<PT_Uint16>(S, S.PC)) return false;
467#if USE_TAILCALLS
468 MUSTTAIL return InterpNext(S);
469#else
470 return true;
471#endif
472}
473PRESERVE_NONE
474static bool Interp_AddOffsetSint32(InterpState &S) {
475 if (!AddOffset<PT_Sint32>(S, S.PC)) return false;
476#if USE_TAILCALLS
477 MUSTTAIL return InterpNext(S);
478#else
479 return true;
480#endif
481}
482PRESERVE_NONE
483static bool Interp_AddOffsetUint32(InterpState &S) {
484 if (!AddOffset<PT_Uint32>(S, S.PC)) return false;
485#if USE_TAILCALLS
486 MUSTTAIL return InterpNext(S);
487#else
488 return true;
489#endif
490}
491PRESERVE_NONE
492static bool Interp_AddOffsetSint64(InterpState &S) {
493 if (!AddOffset<PT_Sint64>(S, S.PC)) return false;
494#if USE_TAILCALLS
495 MUSTTAIL return InterpNext(S);
496#else
497 return true;
498#endif
499}
500PRESERVE_NONE
501static bool Interp_AddOffsetUint64(InterpState &S) {
502 if (!AddOffset<PT_Uint64>(S, S.PC)) return false;
503#if USE_TAILCALLS
504 MUSTTAIL return InterpNext(S);
505#else
506 return true;
507#endif
508}
509PRESERVE_NONE
510static bool Interp_AddOffsetIntAP(InterpState &S) {
511 if (!AddOffset<PT_IntAP>(S, S.PC)) return false;
512#if USE_TAILCALLS
513 MUSTTAIL return InterpNext(S);
514#else
515 return true;
516#endif
517}
518PRESERVE_NONE
519static bool Interp_AddOffsetIntAPS(InterpState &S) {
520 if (!AddOffset<PT_IntAPS>(S, S.PC)) return false;
521#if USE_TAILCALLS
522 MUSTTAIL return InterpNext(S);
523#else
524 return true;
525#endif
526}
527PRESERVE_NONE
528static bool Interp_AddOffsetBool(InterpState &S) {
529 if (!AddOffset<PT_Bool>(S, S.PC)) return false;
530#if USE_TAILCALLS
531 MUSTTAIL return InterpNext(S);
532#else
533 return true;
534#endif
535}
536#endif
537#ifdef GET_DISASM
538case OP_AddOffsetSint8:
539 Text.Op = PrintName("AddOffsetSint8");
540 break;
541case OP_AddOffsetUint8:
542 Text.Op = PrintName("AddOffsetUint8");
543 break;
544case OP_AddOffsetSint16:
545 Text.Op = PrintName("AddOffsetSint16");
546 break;
547case OP_AddOffsetUint16:
548 Text.Op = PrintName("AddOffsetUint16");
549 break;
550case OP_AddOffsetSint32:
551 Text.Op = PrintName("AddOffsetSint32");
552 break;
553case OP_AddOffsetUint32:
554 Text.Op = PrintName("AddOffsetUint32");
555 break;
556case OP_AddOffsetSint64:
557 Text.Op = PrintName("AddOffsetSint64");
558 break;
559case OP_AddOffsetUint64:
560 Text.Op = PrintName("AddOffsetUint64");
561 break;
562case OP_AddOffsetIntAP:
563 Text.Op = PrintName("AddOffsetIntAP");
564 break;
565case OP_AddOffsetIntAPS:
566 Text.Op = PrintName("AddOffsetIntAPS");
567 break;
568case OP_AddOffsetBool:
569 Text.Op = PrintName("AddOffsetBool");
570 break;
571#endif
572#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
573bool emitAddOffsetSint8(SourceInfo);
574bool emitAddOffsetUint8(SourceInfo);
575bool emitAddOffsetSint16(SourceInfo);
576bool emitAddOffsetUint16(SourceInfo);
577bool emitAddOffsetSint32(SourceInfo);
578bool emitAddOffsetUint32(SourceInfo);
579bool emitAddOffsetSint64(SourceInfo);
580bool emitAddOffsetUint64(SourceInfo);
581bool emitAddOffsetIntAP(SourceInfo);
582bool emitAddOffsetIntAPS(SourceInfo);
583bool emitAddOffsetBool(SourceInfo);
584#endif
585#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
586[[nodiscard]] bool emitAddOffset(PrimType, SourceInfo I);
587#endif
588#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
589bool
590#if defined(GET_EVAL_IMPL)
591EvalEmitter
592#else
593ByteCodeEmitter
594#endif
595::emitAddOffset(PrimType T0, SourceInfo I) {
596 switch (T0) {
597 case PT_Sint8:
598 return emitAddOffsetSint8(I);
599 case PT_Uint8:
600 return emitAddOffsetUint8(I);
601 case PT_Sint16:
602 return emitAddOffsetSint16(I);
603 case PT_Uint16:
604 return emitAddOffsetUint16(I);
605 case PT_Sint32:
606 return emitAddOffsetSint32(I);
607 case PT_Uint32:
608 return emitAddOffsetUint32(I);
609 case PT_Sint64:
610 return emitAddOffsetSint64(I);
611 case PT_Uint64:
612 return emitAddOffsetUint64(I);
613 case PT_IntAP:
614 return emitAddOffsetIntAP(I);
615 case PT_IntAPS:
616 return emitAddOffsetIntAPS(I);
617 case PT_Bool:
618 return emitAddOffsetBool(I);
619 default: llvm_unreachable("invalid type: emitAddOffset");
620 }
621 llvm_unreachable("invalid enum value");
622}
623#endif
624#ifdef GET_LINK_IMPL
625bool ByteCodeEmitter::emitAddOffsetSint8(SourceInfo L) {
626 return emitOp<>(OP_AddOffsetSint8, L);
627}
628bool ByteCodeEmitter::emitAddOffsetUint8(SourceInfo L) {
629 return emitOp<>(OP_AddOffsetUint8, L);
630}
631bool ByteCodeEmitter::emitAddOffsetSint16(SourceInfo L) {
632 return emitOp<>(OP_AddOffsetSint16, L);
633}
634bool ByteCodeEmitter::emitAddOffsetUint16(SourceInfo L) {
635 return emitOp<>(OP_AddOffsetUint16, L);
636}
637bool ByteCodeEmitter::emitAddOffsetSint32(SourceInfo L) {
638 return emitOp<>(OP_AddOffsetSint32, L);
639}
640bool ByteCodeEmitter::emitAddOffsetUint32(SourceInfo L) {
641 return emitOp<>(OP_AddOffsetUint32, L);
642}
643bool ByteCodeEmitter::emitAddOffsetSint64(SourceInfo L) {
644 return emitOp<>(OP_AddOffsetSint64, L);
645}
646bool ByteCodeEmitter::emitAddOffsetUint64(SourceInfo L) {
647 return emitOp<>(OP_AddOffsetUint64, L);
648}
649bool ByteCodeEmitter::emitAddOffsetIntAP(SourceInfo L) {
650 return emitOp<>(OP_AddOffsetIntAP, L);
651}
652bool ByteCodeEmitter::emitAddOffsetIntAPS(SourceInfo L) {
653 return emitOp<>(OP_AddOffsetIntAPS, L);
654}
655bool ByteCodeEmitter::emitAddOffsetBool(SourceInfo L) {
656 return emitOp<>(OP_AddOffsetBool, L);
657}
658#endif
659#ifdef GET_EVAL_IMPL
660bool EvalEmitter::emitAddOffsetSint8(SourceInfo L) {
661 if (!isActive()) return true;
662 CurrentSource = L;
663 return AddOffset<PT_Sint8>(S, CodePtr());
664}
665bool EvalEmitter::emitAddOffsetUint8(SourceInfo L) {
666 if (!isActive()) return true;
667 CurrentSource = L;
668 return AddOffset<PT_Uint8>(S, CodePtr());
669}
670bool EvalEmitter::emitAddOffsetSint16(SourceInfo L) {
671 if (!isActive()) return true;
672 CurrentSource = L;
673 return AddOffset<PT_Sint16>(S, CodePtr());
674}
675bool EvalEmitter::emitAddOffsetUint16(SourceInfo L) {
676 if (!isActive()) return true;
677 CurrentSource = L;
678 return AddOffset<PT_Uint16>(S, CodePtr());
679}
680bool EvalEmitter::emitAddOffsetSint32(SourceInfo L) {
681 if (!isActive()) return true;
682 CurrentSource = L;
683 return AddOffset<PT_Sint32>(S, CodePtr());
684}
685bool EvalEmitter::emitAddOffsetUint32(SourceInfo L) {
686 if (!isActive()) return true;
687 CurrentSource = L;
688 return AddOffset<PT_Uint32>(S, CodePtr());
689}
690bool EvalEmitter::emitAddOffsetSint64(SourceInfo L) {
691 if (!isActive()) return true;
692 CurrentSource = L;
693 return AddOffset<PT_Sint64>(S, CodePtr());
694}
695bool EvalEmitter::emitAddOffsetUint64(SourceInfo L) {
696 if (!isActive()) return true;
697 CurrentSource = L;
698 return AddOffset<PT_Uint64>(S, CodePtr());
699}
700bool EvalEmitter::emitAddOffsetIntAP(SourceInfo L) {
701 if (!isActive()) return true;
702 CurrentSource = L;
703 return AddOffset<PT_IntAP>(S, CodePtr());
704}
705bool EvalEmitter::emitAddOffsetIntAPS(SourceInfo L) {
706 if (!isActive()) return true;
707 CurrentSource = L;
708 return AddOffset<PT_IntAPS>(S, CodePtr());
709}
710bool EvalEmitter::emitAddOffsetBool(SourceInfo L) {
711 if (!isActive()) return true;
712 CurrentSource = L;
713 return AddOffset<PT_Bool>(S, CodePtr());
714}
715#endif
716#ifdef GET_OPCODE_NAMES
717OP_Addf,
718#endif
719#ifdef GET_INTERPFN_LIST
720&Interp_Addf,
721#endif
722#ifdef GET_INTERPFN_DISPATCHERS
723PRESERVE_NONE
724static bool Interp_Addf(InterpState &S) {
725 {
726 CodePtr OpPC = S.PC;
727 const auto V0 = ReadArg<uint32_t>(S, S.PC);
728 if (!Addf(S, OpPC, V0)) return false;
729 }
730#if USE_TAILCALLS
731 MUSTTAIL return InterpNext(S);
732#else
733 return true;
734#endif
735}
736#endif
737#ifdef GET_DISASM
738case OP_Addf:
739 Text.Op = PrintName("Addf");
740 Text.Args.push_back(printArg<uint32_t>(PC));
741 break;
742#endif
743#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
744bool emitAddf( uint32_t , SourceInfo);
745#endif
746#ifdef GET_LINK_IMPL
747bool ByteCodeEmitter::emitAddf( uint32_t A0, SourceInfo L) {
748 return emitOp<uint32_t>(OP_Addf, A0, L);
749}
750#endif
751#ifdef GET_EVAL_IMPL
752bool EvalEmitter::emitAddf( uint32_t A0, SourceInfo L) {
753 if (!isActive()) return true;
754 CurrentSource = L;
755 return Addf(S, CodePtr(), A0);
756}
757#endif
758#ifdef GET_OPCODE_NAMES
759OP_AddrOf,
760#endif
761#ifdef GET_INTERPFN_LIST
762&Interp_AddrOf,
763#endif
764#ifdef GET_INTERPFN_DISPATCHERS
765PRESERVE_NONE
766static bool Interp_AddrOf(InterpState &S) {
767 if (!AddrOf(S, S.PC)) return false;
768#if USE_TAILCALLS
769 MUSTTAIL return InterpNext(S);
770#else
771 return true;
772#endif
773}
774#endif
775#ifdef GET_DISASM
776case OP_AddrOf:
777 Text.Op = PrintName("AddrOf");
778 break;
779#endif
780#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
781bool emitAddrOf(SourceInfo);
782#endif
783#ifdef GET_LINK_IMPL
784bool ByteCodeEmitter::emitAddrOf(SourceInfo L) {
785 return emitOp<>(OP_AddrOf, L);
786}
787#endif
788#ifdef GET_EVAL_IMPL
789bool EvalEmitter::emitAddrOf(SourceInfo L) {
790 if (!isActive()) return true;
791 CurrentSource = L;
792 return AddrOf(S, CodePtr());
793}
794#endif
795#ifdef GET_OPCODE_NAMES
796OP_Alloc,
797#endif
798#ifdef GET_INTERPFN_LIST
799&Interp_Alloc,
800#endif
801#ifdef GET_INTERPFN_DISPATCHERS
802PRESERVE_NONE
803static bool Interp_Alloc(InterpState &S) {
804 {
805 CodePtr OpPC = S.PC;
806 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
807 if (!Alloc(S, OpPC, V0)) return false;
808 }
809#if USE_TAILCALLS
810 MUSTTAIL return InterpNext(S);
811#else
812 return true;
813#endif
814}
815#endif
816#ifdef GET_DISASM
817case OP_Alloc:
818 Text.Op = PrintName("Alloc");
819 Text.Args.push_back(printArg<const Descriptor *>(PC));
820 break;
821#endif
822#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
823bool emitAlloc( const Descriptor * , SourceInfo);
824#endif
825#ifdef GET_LINK_IMPL
826bool ByteCodeEmitter::emitAlloc( const Descriptor * A0, SourceInfo L) {
827 return emitOp<const Descriptor *>(OP_Alloc, A0, L);
828}
829#endif
830#ifdef GET_EVAL_IMPL
831bool EvalEmitter::emitAlloc( const Descriptor * A0, SourceInfo L) {
832 if (!isActive()) return true;
833 CurrentSource = L;
834 return Alloc(S, CodePtr(), A0);
835}
836#endif
837#ifdef GET_OPCODE_NAMES
838OP_AllocCNSint8,
839OP_AllocCNUint8,
840OP_AllocCNSint16,
841OP_AllocCNUint16,
842OP_AllocCNSint32,
843OP_AllocCNUint32,
844OP_AllocCNSint64,
845OP_AllocCNUint64,
846OP_AllocCNIntAP,
847OP_AllocCNIntAPS,
848OP_AllocCNBool,
849#endif
850#ifdef GET_INTERPFN_LIST
851&Interp_AllocCNSint8,
852&Interp_AllocCNUint8,
853&Interp_AllocCNSint16,
854&Interp_AllocCNUint16,
855&Interp_AllocCNSint32,
856&Interp_AllocCNUint32,
857&Interp_AllocCNSint64,
858&Interp_AllocCNUint64,
859&Interp_AllocCNIntAP,
860&Interp_AllocCNIntAPS,
861&Interp_AllocCNBool,
862#endif
863#ifdef GET_INTERPFN_DISPATCHERS
864PRESERVE_NONE
865static bool Interp_AllocCNSint8(InterpState &S) {
866 {
867 CodePtr OpPC = S.PC;
868 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
869 const auto V1 = ReadArg<bool>(S, S.PC);
870 if (!AllocCN<PT_Sint8>(S, OpPC, V0, V1)) return false;
871 }
872#if USE_TAILCALLS
873 MUSTTAIL return InterpNext(S);
874#else
875 return true;
876#endif
877}
878PRESERVE_NONE
879static bool Interp_AllocCNUint8(InterpState &S) {
880 {
881 CodePtr OpPC = S.PC;
882 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
883 const auto V1 = ReadArg<bool>(S, S.PC);
884 if (!AllocCN<PT_Uint8>(S, OpPC, V0, V1)) return false;
885 }
886#if USE_TAILCALLS
887 MUSTTAIL return InterpNext(S);
888#else
889 return true;
890#endif
891}
892PRESERVE_NONE
893static bool Interp_AllocCNSint16(InterpState &S) {
894 {
895 CodePtr OpPC = S.PC;
896 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
897 const auto V1 = ReadArg<bool>(S, S.PC);
898 if (!AllocCN<PT_Sint16>(S, OpPC, V0, V1)) return false;
899 }
900#if USE_TAILCALLS
901 MUSTTAIL return InterpNext(S);
902#else
903 return true;
904#endif
905}
906PRESERVE_NONE
907static bool Interp_AllocCNUint16(InterpState &S) {
908 {
909 CodePtr OpPC = S.PC;
910 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
911 const auto V1 = ReadArg<bool>(S, S.PC);
912 if (!AllocCN<PT_Uint16>(S, OpPC, V0, V1)) return false;
913 }
914#if USE_TAILCALLS
915 MUSTTAIL return InterpNext(S);
916#else
917 return true;
918#endif
919}
920PRESERVE_NONE
921static bool Interp_AllocCNSint32(InterpState &S) {
922 {
923 CodePtr OpPC = S.PC;
924 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
925 const auto V1 = ReadArg<bool>(S, S.PC);
926 if (!AllocCN<PT_Sint32>(S, OpPC, V0, V1)) return false;
927 }
928#if USE_TAILCALLS
929 MUSTTAIL return InterpNext(S);
930#else
931 return true;
932#endif
933}
934PRESERVE_NONE
935static bool Interp_AllocCNUint32(InterpState &S) {
936 {
937 CodePtr OpPC = S.PC;
938 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
939 const auto V1 = ReadArg<bool>(S, S.PC);
940 if (!AllocCN<PT_Uint32>(S, OpPC, V0, V1)) return false;
941 }
942#if USE_TAILCALLS
943 MUSTTAIL return InterpNext(S);
944#else
945 return true;
946#endif
947}
948PRESERVE_NONE
949static bool Interp_AllocCNSint64(InterpState &S) {
950 {
951 CodePtr OpPC = S.PC;
952 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
953 const auto V1 = ReadArg<bool>(S, S.PC);
954 if (!AllocCN<PT_Sint64>(S, OpPC, V0, V1)) return false;
955 }
956#if USE_TAILCALLS
957 MUSTTAIL return InterpNext(S);
958#else
959 return true;
960#endif
961}
962PRESERVE_NONE
963static bool Interp_AllocCNUint64(InterpState &S) {
964 {
965 CodePtr OpPC = S.PC;
966 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
967 const auto V1 = ReadArg<bool>(S, S.PC);
968 if (!AllocCN<PT_Uint64>(S, OpPC, V0, V1)) return false;
969 }
970#if USE_TAILCALLS
971 MUSTTAIL return InterpNext(S);
972#else
973 return true;
974#endif
975}
976PRESERVE_NONE
977static bool Interp_AllocCNIntAP(InterpState &S) {
978 {
979 CodePtr OpPC = S.PC;
980 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
981 const auto V1 = ReadArg<bool>(S, S.PC);
982 if (!AllocCN<PT_IntAP>(S, OpPC, V0, V1)) return false;
983 }
984#if USE_TAILCALLS
985 MUSTTAIL return InterpNext(S);
986#else
987 return true;
988#endif
989}
990PRESERVE_NONE
991static bool Interp_AllocCNIntAPS(InterpState &S) {
992 {
993 CodePtr OpPC = S.PC;
994 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
995 const auto V1 = ReadArg<bool>(S, S.PC);
996 if (!AllocCN<PT_IntAPS>(S, OpPC, V0, V1)) return false;
997 }
998#if USE_TAILCALLS
999 MUSTTAIL return InterpNext(S);
1000#else
1001 return true;
1002#endif
1003}
1004PRESERVE_NONE
1005static bool Interp_AllocCNBool(InterpState &S) {
1006 {
1007 CodePtr OpPC = S.PC;
1008 const auto V0 = ReadArg<const Descriptor *>(S, S.PC);
1009 const auto V1 = ReadArg<bool>(S, S.PC);
1010 if (!AllocCN<PT_Bool>(S, OpPC, V0, V1)) return false;
1011 }
1012#if USE_TAILCALLS
1013 MUSTTAIL return InterpNext(S);
1014#else
1015 return true;
1016#endif
1017}
1018#endif
1019#ifdef GET_DISASM
1020case OP_AllocCNSint8:
1021 Text.Op = PrintName("AllocCNSint8");
1022 Text.Args.push_back(printArg<const Descriptor *>(PC));
1023 Text.Args.push_back(printArg<bool>(PC));
1024 break;
1025case OP_AllocCNUint8:
1026 Text.Op = PrintName("AllocCNUint8");
1027 Text.Args.push_back(printArg<const Descriptor *>(PC));
1028 Text.Args.push_back(printArg<bool>(PC));
1029 break;
1030case OP_AllocCNSint16:
1031 Text.Op = PrintName("AllocCNSint16");
1032 Text.Args.push_back(printArg<const Descriptor *>(PC));
1033 Text.Args.push_back(printArg<bool>(PC));
1034 break;
1035case OP_AllocCNUint16:
1036 Text.Op = PrintName("AllocCNUint16");
1037 Text.Args.push_back(printArg<const Descriptor *>(PC));
1038 Text.Args.push_back(printArg<bool>(PC));
1039 break;
1040case OP_AllocCNSint32:
1041 Text.Op = PrintName("AllocCNSint32");
1042 Text.Args.push_back(printArg<const Descriptor *>(PC));
1043 Text.Args.push_back(printArg<bool>(PC));
1044 break;
1045case OP_AllocCNUint32:
1046 Text.Op = PrintName("AllocCNUint32");
1047 Text.Args.push_back(printArg<const Descriptor *>(PC));
1048 Text.Args.push_back(printArg<bool>(PC));
1049 break;
1050case OP_AllocCNSint64:
1051 Text.Op = PrintName("AllocCNSint64");
1052 Text.Args.push_back(printArg<const Descriptor *>(PC));
1053 Text.Args.push_back(printArg<bool>(PC));
1054 break;
1055case OP_AllocCNUint64:
1056 Text.Op = PrintName("AllocCNUint64");
1057 Text.Args.push_back(printArg<const Descriptor *>(PC));
1058 Text.Args.push_back(printArg<bool>(PC));
1059 break;
1060case OP_AllocCNIntAP:
1061 Text.Op = PrintName("AllocCNIntAP");
1062 Text.Args.push_back(printArg<const Descriptor *>(PC));
1063 Text.Args.push_back(printArg<bool>(PC));
1064 break;
1065case OP_AllocCNIntAPS:
1066 Text.Op = PrintName("AllocCNIntAPS");
1067 Text.Args.push_back(printArg<const Descriptor *>(PC));
1068 Text.Args.push_back(printArg<bool>(PC));
1069 break;
1070case OP_AllocCNBool:
1071 Text.Op = PrintName("AllocCNBool");
1072 Text.Args.push_back(printArg<const Descriptor *>(PC));
1073 Text.Args.push_back(printArg<bool>(PC));
1074 break;
1075#endif
1076#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1077bool emitAllocCNSint8( const Descriptor * , bool , SourceInfo);
1078bool emitAllocCNUint8( const Descriptor * , bool , SourceInfo);
1079bool emitAllocCNSint16( const Descriptor * , bool , SourceInfo);
1080bool emitAllocCNUint16( const Descriptor * , bool , SourceInfo);
1081bool emitAllocCNSint32( const Descriptor * , bool , SourceInfo);
1082bool emitAllocCNUint32( const Descriptor * , bool , SourceInfo);
1083bool emitAllocCNSint64( const Descriptor * , bool , SourceInfo);
1084bool emitAllocCNUint64( const Descriptor * , bool , SourceInfo);
1085bool emitAllocCNIntAP( const Descriptor * , bool , SourceInfo);
1086bool emitAllocCNIntAPS( const Descriptor * , bool , SourceInfo);
1087bool emitAllocCNBool( const Descriptor * , bool , SourceInfo);
1088#endif
1089#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1090[[nodiscard]] bool emitAllocCN(PrimType, const Descriptor *, bool, SourceInfo I);
1091#endif
1092#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
1093bool
1094#if defined(GET_EVAL_IMPL)
1095EvalEmitter
1096#else
1097ByteCodeEmitter
1098#endif
1099::emitAllocCN(PrimType T0, const Descriptor * A0, bool A1, SourceInfo I) {
1100 switch (T0) {
1101 case PT_Sint8:
1102 return emitAllocCNSint8(A0, A1, I);
1103 case PT_Uint8:
1104 return emitAllocCNUint8(A0, A1, I);
1105 case PT_Sint16:
1106 return emitAllocCNSint16(A0, A1, I);
1107 case PT_Uint16:
1108 return emitAllocCNUint16(A0, A1, I);
1109 case PT_Sint32:
1110 return emitAllocCNSint32(A0, A1, I);
1111 case PT_Uint32:
1112 return emitAllocCNUint32(A0, A1, I);
1113 case PT_Sint64:
1114 return emitAllocCNSint64(A0, A1, I);
1115 case PT_Uint64:
1116 return emitAllocCNUint64(A0, A1, I);
1117 case PT_IntAP:
1118 return emitAllocCNIntAP(A0, A1, I);
1119 case PT_IntAPS:
1120 return emitAllocCNIntAPS(A0, A1, I);
1121 case PT_Bool:
1122 return emitAllocCNBool(A0, A1, I);
1123 default: llvm_unreachable("invalid type: emitAllocCN");
1124 }
1125 llvm_unreachable("invalid enum value");
1126}
1127#endif
1128#ifdef GET_LINK_IMPL
1129bool ByteCodeEmitter::emitAllocCNSint8( const Descriptor * A0, bool A1, SourceInfo L) {
1130 return emitOp<const Descriptor *, bool>(OP_AllocCNSint8, A0, A1, L);
1131}
1132bool ByteCodeEmitter::emitAllocCNUint8( const Descriptor * A0, bool A1, SourceInfo L) {
1133 return emitOp<const Descriptor *, bool>(OP_AllocCNUint8, A0, A1, L);
1134}
1135bool ByteCodeEmitter::emitAllocCNSint16( const Descriptor * A0, bool A1, SourceInfo L) {
1136 return emitOp<const Descriptor *, bool>(OP_AllocCNSint16, A0, A1, L);
1137}
1138bool ByteCodeEmitter::emitAllocCNUint16( const Descriptor * A0, bool A1, SourceInfo L) {
1139 return emitOp<const Descriptor *, bool>(OP_AllocCNUint16, A0, A1, L);
1140}
1141bool ByteCodeEmitter::emitAllocCNSint32( const Descriptor * A0, bool A1, SourceInfo L) {
1142 return emitOp<const Descriptor *, bool>(OP_AllocCNSint32, A0, A1, L);
1143}
1144bool ByteCodeEmitter::emitAllocCNUint32( const Descriptor * A0, bool A1, SourceInfo L) {
1145 return emitOp<const Descriptor *, bool>(OP_AllocCNUint32, A0, A1, L);
1146}
1147bool ByteCodeEmitter::emitAllocCNSint64( const Descriptor * A0, bool A1, SourceInfo L) {
1148 return emitOp<const Descriptor *, bool>(OP_AllocCNSint64, A0, A1, L);
1149}
1150bool ByteCodeEmitter::emitAllocCNUint64( const Descriptor * A0, bool A1, SourceInfo L) {
1151 return emitOp<const Descriptor *, bool>(OP_AllocCNUint64, A0, A1, L);
1152}
1153bool ByteCodeEmitter::emitAllocCNIntAP( const Descriptor * A0, bool A1, SourceInfo L) {
1154 return emitOp<const Descriptor *, bool>(OP_AllocCNIntAP, A0, A1, L);
1155}
1156bool ByteCodeEmitter::emitAllocCNIntAPS( const Descriptor * A0, bool A1, SourceInfo L) {
1157 return emitOp<const Descriptor *, bool>(OP_AllocCNIntAPS, A0, A1, L);
1158}
1159bool ByteCodeEmitter::emitAllocCNBool( const Descriptor * A0, bool A1, SourceInfo L) {
1160 return emitOp<const Descriptor *, bool>(OP_AllocCNBool, A0, A1, L);
1161}
1162#endif
1163#ifdef GET_EVAL_IMPL
1164bool EvalEmitter::emitAllocCNSint8( const Descriptor * A0, bool A1, SourceInfo L) {
1165 if (!isActive()) return true;
1166 CurrentSource = L;
1167 return AllocCN<PT_Sint8>(S, CodePtr(), A0, A1);
1168}
1169bool EvalEmitter::emitAllocCNUint8( const Descriptor * A0, bool A1, SourceInfo L) {
1170 if (!isActive()) return true;
1171 CurrentSource = L;
1172 return AllocCN<PT_Uint8>(S, CodePtr(), A0, A1);
1173}
1174bool EvalEmitter::emitAllocCNSint16( const Descriptor * A0, bool A1, SourceInfo L) {
1175 if (!isActive()) return true;
1176 CurrentSource = L;
1177 return AllocCN<PT_Sint16>(S, CodePtr(), A0, A1);
1178}
1179bool EvalEmitter::emitAllocCNUint16( const Descriptor * A0, bool A1, SourceInfo L) {
1180 if (!isActive()) return true;
1181 CurrentSource = L;
1182 return AllocCN<PT_Uint16>(S, CodePtr(), A0, A1);
1183}
1184bool EvalEmitter::emitAllocCNSint32( const Descriptor * A0, bool A1, SourceInfo L) {
1185 if (!isActive()) return true;
1186 CurrentSource = L;
1187 return AllocCN<PT_Sint32>(S, CodePtr(), A0, A1);
1188}
1189bool EvalEmitter::emitAllocCNUint32( const Descriptor * A0, bool A1, SourceInfo L) {
1190 if (!isActive()) return true;
1191 CurrentSource = L;
1192 return AllocCN<PT_Uint32>(S, CodePtr(), A0, A1);
1193}
1194bool EvalEmitter::emitAllocCNSint64( const Descriptor * A0, bool A1, SourceInfo L) {
1195 if (!isActive()) return true;
1196 CurrentSource = L;
1197 return AllocCN<PT_Sint64>(S, CodePtr(), A0, A1);
1198}
1199bool EvalEmitter::emitAllocCNUint64( const Descriptor * A0, bool A1, SourceInfo L) {
1200 if (!isActive()) return true;
1201 CurrentSource = L;
1202 return AllocCN<PT_Uint64>(S, CodePtr(), A0, A1);
1203}
1204bool EvalEmitter::emitAllocCNIntAP( const Descriptor * A0, bool A1, SourceInfo L) {
1205 if (!isActive()) return true;
1206 CurrentSource = L;
1207 return AllocCN<PT_IntAP>(S, CodePtr(), A0, A1);
1208}
1209bool EvalEmitter::emitAllocCNIntAPS( const Descriptor * A0, bool A1, SourceInfo L) {
1210 if (!isActive()) return true;
1211 CurrentSource = L;
1212 return AllocCN<PT_IntAPS>(S, CodePtr(), A0, A1);
1213}
1214bool EvalEmitter::emitAllocCNBool( const Descriptor * A0, bool A1, SourceInfo L) {
1215 if (!isActive()) return true;
1216 CurrentSource = L;
1217 return AllocCN<PT_Bool>(S, CodePtr(), A0, A1);
1218}
1219#endif
1220#ifdef GET_OPCODE_NAMES
1221OP_AllocNSint8,
1222OP_AllocNUint8,
1223OP_AllocNSint16,
1224OP_AllocNUint16,
1225OP_AllocNSint32,
1226OP_AllocNUint32,
1227OP_AllocNSint64,
1228OP_AllocNUint64,
1229OP_AllocNIntAP,
1230OP_AllocNIntAPS,
1231OP_AllocNBool,
1232#endif
1233#ifdef GET_INTERPFN_LIST
1234&Interp_AllocNSint8,
1235&Interp_AllocNUint8,
1236&Interp_AllocNSint16,
1237&Interp_AllocNUint16,
1238&Interp_AllocNSint32,
1239&Interp_AllocNUint32,
1240&Interp_AllocNSint64,
1241&Interp_AllocNUint64,
1242&Interp_AllocNIntAP,
1243&Interp_AllocNIntAPS,
1244&Interp_AllocNBool,
1245#endif
1246#ifdef GET_INTERPFN_DISPATCHERS
1247PRESERVE_NONE
1248static bool Interp_AllocNSint8(InterpState &S) {
1249 {
1250 CodePtr OpPC = S.PC;
1251 const auto V0 = ReadArg<PrimType>(S, S.PC);
1252 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1253 const auto V2 = ReadArg<bool>(S, S.PC);
1254 if (!AllocN<PT_Sint8>(S, OpPC, V0, V1, V2)) return false;
1255 }
1256#if USE_TAILCALLS
1257 MUSTTAIL return InterpNext(S);
1258#else
1259 return true;
1260#endif
1261}
1262PRESERVE_NONE
1263static bool Interp_AllocNUint8(InterpState &S) {
1264 {
1265 CodePtr OpPC = S.PC;
1266 const auto V0 = ReadArg<PrimType>(S, S.PC);
1267 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1268 const auto V2 = ReadArg<bool>(S, S.PC);
1269 if (!AllocN<PT_Uint8>(S, OpPC, V0, V1, V2)) return false;
1270 }
1271#if USE_TAILCALLS
1272 MUSTTAIL return InterpNext(S);
1273#else
1274 return true;
1275#endif
1276}
1277PRESERVE_NONE
1278static bool Interp_AllocNSint16(InterpState &S) {
1279 {
1280 CodePtr OpPC = S.PC;
1281 const auto V0 = ReadArg<PrimType>(S, S.PC);
1282 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1283 const auto V2 = ReadArg<bool>(S, S.PC);
1284 if (!AllocN<PT_Sint16>(S, OpPC, V0, V1, V2)) return false;
1285 }
1286#if USE_TAILCALLS
1287 MUSTTAIL return InterpNext(S);
1288#else
1289 return true;
1290#endif
1291}
1292PRESERVE_NONE
1293static bool Interp_AllocNUint16(InterpState &S) {
1294 {
1295 CodePtr OpPC = S.PC;
1296 const auto V0 = ReadArg<PrimType>(S, S.PC);
1297 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1298 const auto V2 = ReadArg<bool>(S, S.PC);
1299 if (!AllocN<PT_Uint16>(S, OpPC, V0, V1, V2)) return false;
1300 }
1301#if USE_TAILCALLS
1302 MUSTTAIL return InterpNext(S);
1303#else
1304 return true;
1305#endif
1306}
1307PRESERVE_NONE
1308static bool Interp_AllocNSint32(InterpState &S) {
1309 {
1310 CodePtr OpPC = S.PC;
1311 const auto V0 = ReadArg<PrimType>(S, S.PC);
1312 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1313 const auto V2 = ReadArg<bool>(S, S.PC);
1314 if (!AllocN<PT_Sint32>(S, OpPC, V0, V1, V2)) return false;
1315 }
1316#if USE_TAILCALLS
1317 MUSTTAIL return InterpNext(S);
1318#else
1319 return true;
1320#endif
1321}
1322PRESERVE_NONE
1323static bool Interp_AllocNUint32(InterpState &S) {
1324 {
1325 CodePtr OpPC = S.PC;
1326 const auto V0 = ReadArg<PrimType>(S, S.PC);
1327 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1328 const auto V2 = ReadArg<bool>(S, S.PC);
1329 if (!AllocN<PT_Uint32>(S, OpPC, V0, V1, V2)) return false;
1330 }
1331#if USE_TAILCALLS
1332 MUSTTAIL return InterpNext(S);
1333#else
1334 return true;
1335#endif
1336}
1337PRESERVE_NONE
1338static bool Interp_AllocNSint64(InterpState &S) {
1339 {
1340 CodePtr OpPC = S.PC;
1341 const auto V0 = ReadArg<PrimType>(S, S.PC);
1342 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1343 const auto V2 = ReadArg<bool>(S, S.PC);
1344 if (!AllocN<PT_Sint64>(S, OpPC, V0, V1, V2)) return false;
1345 }
1346#if USE_TAILCALLS
1347 MUSTTAIL return InterpNext(S);
1348#else
1349 return true;
1350#endif
1351}
1352PRESERVE_NONE
1353static bool Interp_AllocNUint64(InterpState &S) {
1354 {
1355 CodePtr OpPC = S.PC;
1356 const auto V0 = ReadArg<PrimType>(S, S.PC);
1357 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1358 const auto V2 = ReadArg<bool>(S, S.PC);
1359 if (!AllocN<PT_Uint64>(S, OpPC, V0, V1, V2)) return false;
1360 }
1361#if USE_TAILCALLS
1362 MUSTTAIL return InterpNext(S);
1363#else
1364 return true;
1365#endif
1366}
1367PRESERVE_NONE
1368static bool Interp_AllocNIntAP(InterpState &S) {
1369 {
1370 CodePtr OpPC = S.PC;
1371 const auto V0 = ReadArg<PrimType>(S, S.PC);
1372 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1373 const auto V2 = ReadArg<bool>(S, S.PC);
1374 if (!AllocN<PT_IntAP>(S, OpPC, V0, V1, V2)) return false;
1375 }
1376#if USE_TAILCALLS
1377 MUSTTAIL return InterpNext(S);
1378#else
1379 return true;
1380#endif
1381}
1382PRESERVE_NONE
1383static bool Interp_AllocNIntAPS(InterpState &S) {
1384 {
1385 CodePtr OpPC = S.PC;
1386 const auto V0 = ReadArg<PrimType>(S, S.PC);
1387 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1388 const auto V2 = ReadArg<bool>(S, S.PC);
1389 if (!AllocN<PT_IntAPS>(S, OpPC, V0, V1, V2)) return false;
1390 }
1391#if USE_TAILCALLS
1392 MUSTTAIL return InterpNext(S);
1393#else
1394 return true;
1395#endif
1396}
1397PRESERVE_NONE
1398static bool Interp_AllocNBool(InterpState &S) {
1399 {
1400 CodePtr OpPC = S.PC;
1401 const auto V0 = ReadArg<PrimType>(S, S.PC);
1402 const auto V1 = ReadArg<const Expr *>(S, S.PC);
1403 const auto V2 = ReadArg<bool>(S, S.PC);
1404 if (!AllocN<PT_Bool>(S, OpPC, V0, V1, V2)) return false;
1405 }
1406#if USE_TAILCALLS
1407 MUSTTAIL return InterpNext(S);
1408#else
1409 return true;
1410#endif
1411}
1412#endif
1413#ifdef GET_DISASM
1414case OP_AllocNSint8:
1415 Text.Op = PrintName("AllocNSint8");
1416 Text.Args.push_back(printArg<PrimType>(PC));
1417 Text.Args.push_back(printArg<const Expr *>(PC));
1418 Text.Args.push_back(printArg<bool>(PC));
1419 break;
1420case OP_AllocNUint8:
1421 Text.Op = PrintName("AllocNUint8");
1422 Text.Args.push_back(printArg<PrimType>(PC));
1423 Text.Args.push_back(printArg<const Expr *>(PC));
1424 Text.Args.push_back(printArg<bool>(PC));
1425 break;
1426case OP_AllocNSint16:
1427 Text.Op = PrintName("AllocNSint16");
1428 Text.Args.push_back(printArg<PrimType>(PC));
1429 Text.Args.push_back(printArg<const Expr *>(PC));
1430 Text.Args.push_back(printArg<bool>(PC));
1431 break;
1432case OP_AllocNUint16:
1433 Text.Op = PrintName("AllocNUint16");
1434 Text.Args.push_back(printArg<PrimType>(PC));
1435 Text.Args.push_back(printArg<const Expr *>(PC));
1436 Text.Args.push_back(printArg<bool>(PC));
1437 break;
1438case OP_AllocNSint32:
1439 Text.Op = PrintName("AllocNSint32");
1440 Text.Args.push_back(printArg<PrimType>(PC));
1441 Text.Args.push_back(printArg<const Expr *>(PC));
1442 Text.Args.push_back(printArg<bool>(PC));
1443 break;
1444case OP_AllocNUint32:
1445 Text.Op = PrintName("AllocNUint32");
1446 Text.Args.push_back(printArg<PrimType>(PC));
1447 Text.Args.push_back(printArg<const Expr *>(PC));
1448 Text.Args.push_back(printArg<bool>(PC));
1449 break;
1450case OP_AllocNSint64:
1451 Text.Op = PrintName("AllocNSint64");
1452 Text.Args.push_back(printArg<PrimType>(PC));
1453 Text.Args.push_back(printArg<const Expr *>(PC));
1454 Text.Args.push_back(printArg<bool>(PC));
1455 break;
1456case OP_AllocNUint64:
1457 Text.Op = PrintName("AllocNUint64");
1458 Text.Args.push_back(printArg<PrimType>(PC));
1459 Text.Args.push_back(printArg<const Expr *>(PC));
1460 Text.Args.push_back(printArg<bool>(PC));
1461 break;
1462case OP_AllocNIntAP:
1463 Text.Op = PrintName("AllocNIntAP");
1464 Text.Args.push_back(printArg<PrimType>(PC));
1465 Text.Args.push_back(printArg<const Expr *>(PC));
1466 Text.Args.push_back(printArg<bool>(PC));
1467 break;
1468case OP_AllocNIntAPS:
1469 Text.Op = PrintName("AllocNIntAPS");
1470 Text.Args.push_back(printArg<PrimType>(PC));
1471 Text.Args.push_back(printArg<const Expr *>(PC));
1472 Text.Args.push_back(printArg<bool>(PC));
1473 break;
1474case OP_AllocNBool:
1475 Text.Op = PrintName("AllocNBool");
1476 Text.Args.push_back(printArg<PrimType>(PC));
1477 Text.Args.push_back(printArg<const Expr *>(PC));
1478 Text.Args.push_back(printArg<bool>(PC));
1479 break;
1480#endif
1481#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1482bool emitAllocNSint8( PrimType , const Expr * , bool , SourceInfo);
1483bool emitAllocNUint8( PrimType , const Expr * , bool , SourceInfo);
1484bool emitAllocNSint16( PrimType , const Expr * , bool , SourceInfo);
1485bool emitAllocNUint16( PrimType , const Expr * , bool , SourceInfo);
1486bool emitAllocNSint32( PrimType , const Expr * , bool , SourceInfo);
1487bool emitAllocNUint32( PrimType , const Expr * , bool , SourceInfo);
1488bool emitAllocNSint64( PrimType , const Expr * , bool , SourceInfo);
1489bool emitAllocNUint64( PrimType , const Expr * , bool , SourceInfo);
1490bool emitAllocNIntAP( PrimType , const Expr * , bool , SourceInfo);
1491bool emitAllocNIntAPS( PrimType , const Expr * , bool , SourceInfo);
1492bool emitAllocNBool( PrimType , const Expr * , bool , SourceInfo);
1493#endif
1494#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1495[[nodiscard]] bool emitAllocN(PrimType, PrimType, const Expr *, bool, SourceInfo I);
1496#endif
1497#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
1498bool
1499#if defined(GET_EVAL_IMPL)
1500EvalEmitter
1501#else
1502ByteCodeEmitter
1503#endif
1504::emitAllocN(PrimType T0, PrimType A0, const Expr * A1, bool A2, SourceInfo I) {
1505 switch (T0) {
1506 case PT_Sint8:
1507 return emitAllocNSint8(A0, A1, A2, I);
1508 case PT_Uint8:
1509 return emitAllocNUint8(A0, A1, A2, I);
1510 case PT_Sint16:
1511 return emitAllocNSint16(A0, A1, A2, I);
1512 case PT_Uint16:
1513 return emitAllocNUint16(A0, A1, A2, I);
1514 case PT_Sint32:
1515 return emitAllocNSint32(A0, A1, A2, I);
1516 case PT_Uint32:
1517 return emitAllocNUint32(A0, A1, A2, I);
1518 case PT_Sint64:
1519 return emitAllocNSint64(A0, A1, A2, I);
1520 case PT_Uint64:
1521 return emitAllocNUint64(A0, A1, A2, I);
1522 case PT_IntAP:
1523 return emitAllocNIntAP(A0, A1, A2, I);
1524 case PT_IntAPS:
1525 return emitAllocNIntAPS(A0, A1, A2, I);
1526 case PT_Bool:
1527 return emitAllocNBool(A0, A1, A2, I);
1528 default: llvm_unreachable("invalid type: emitAllocN");
1529 }
1530 llvm_unreachable("invalid enum value");
1531}
1532#endif
1533#ifdef GET_LINK_IMPL
1534bool ByteCodeEmitter::emitAllocNSint8( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1535 return emitOp<PrimType, const Expr *, bool>(OP_AllocNSint8, A0, A1, A2, L);
1536}
1537bool ByteCodeEmitter::emitAllocNUint8( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1538 return emitOp<PrimType, const Expr *, bool>(OP_AllocNUint8, A0, A1, A2, L);
1539}
1540bool ByteCodeEmitter::emitAllocNSint16( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1541 return emitOp<PrimType, const Expr *, bool>(OP_AllocNSint16, A0, A1, A2, L);
1542}
1543bool ByteCodeEmitter::emitAllocNUint16( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1544 return emitOp<PrimType, const Expr *, bool>(OP_AllocNUint16, A0, A1, A2, L);
1545}
1546bool ByteCodeEmitter::emitAllocNSint32( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1547 return emitOp<PrimType, const Expr *, bool>(OP_AllocNSint32, A0, A1, A2, L);
1548}
1549bool ByteCodeEmitter::emitAllocNUint32( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1550 return emitOp<PrimType, const Expr *, bool>(OP_AllocNUint32, A0, A1, A2, L);
1551}
1552bool ByteCodeEmitter::emitAllocNSint64( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1553 return emitOp<PrimType, const Expr *, bool>(OP_AllocNSint64, A0, A1, A2, L);
1554}
1555bool ByteCodeEmitter::emitAllocNUint64( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1556 return emitOp<PrimType, const Expr *, bool>(OP_AllocNUint64, A0, A1, A2, L);
1557}
1558bool ByteCodeEmitter::emitAllocNIntAP( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1559 return emitOp<PrimType, const Expr *, bool>(OP_AllocNIntAP, A0, A1, A2, L);
1560}
1561bool ByteCodeEmitter::emitAllocNIntAPS( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1562 return emitOp<PrimType, const Expr *, bool>(OP_AllocNIntAPS, A0, A1, A2, L);
1563}
1564bool ByteCodeEmitter::emitAllocNBool( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1565 return emitOp<PrimType, const Expr *, bool>(OP_AllocNBool, A0, A1, A2, L);
1566}
1567#endif
1568#ifdef GET_EVAL_IMPL
1569bool EvalEmitter::emitAllocNSint8( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1570 if (!isActive()) return true;
1571 CurrentSource = L;
1572 return AllocN<PT_Sint8>(S, CodePtr(), A0, A1, A2);
1573}
1574bool EvalEmitter::emitAllocNUint8( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1575 if (!isActive()) return true;
1576 CurrentSource = L;
1577 return AllocN<PT_Uint8>(S, CodePtr(), A0, A1, A2);
1578}
1579bool EvalEmitter::emitAllocNSint16( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1580 if (!isActive()) return true;
1581 CurrentSource = L;
1582 return AllocN<PT_Sint16>(S, CodePtr(), A0, A1, A2);
1583}
1584bool EvalEmitter::emitAllocNUint16( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1585 if (!isActive()) return true;
1586 CurrentSource = L;
1587 return AllocN<PT_Uint16>(S, CodePtr(), A0, A1, A2);
1588}
1589bool EvalEmitter::emitAllocNSint32( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1590 if (!isActive()) return true;
1591 CurrentSource = L;
1592 return AllocN<PT_Sint32>(S, CodePtr(), A0, A1, A2);
1593}
1594bool EvalEmitter::emitAllocNUint32( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1595 if (!isActive()) return true;
1596 CurrentSource = L;
1597 return AllocN<PT_Uint32>(S, CodePtr(), A0, A1, A2);
1598}
1599bool EvalEmitter::emitAllocNSint64( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1600 if (!isActive()) return true;
1601 CurrentSource = L;
1602 return AllocN<PT_Sint64>(S, CodePtr(), A0, A1, A2);
1603}
1604bool EvalEmitter::emitAllocNUint64( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1605 if (!isActive()) return true;
1606 CurrentSource = L;
1607 return AllocN<PT_Uint64>(S, CodePtr(), A0, A1, A2);
1608}
1609bool EvalEmitter::emitAllocNIntAP( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1610 if (!isActive()) return true;
1611 CurrentSource = L;
1612 return AllocN<PT_IntAP>(S, CodePtr(), A0, A1, A2);
1613}
1614bool EvalEmitter::emitAllocNIntAPS( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1615 if (!isActive()) return true;
1616 CurrentSource = L;
1617 return AllocN<PT_IntAPS>(S, CodePtr(), A0, A1, A2);
1618}
1619bool EvalEmitter::emitAllocNBool( PrimType A0, const Expr * A1, bool A2, SourceInfo L) {
1620 if (!isActive()) return true;
1621 CurrentSource = L;
1622 return AllocN<PT_Bool>(S, CodePtr(), A0, A1, A2);
1623}
1624#endif
1625#ifdef GET_OPCODE_NAMES
1626OP_ArrayDecay,
1627#endif
1628#ifdef GET_INTERPFN_LIST
1629&Interp_ArrayDecay,
1630#endif
1631#ifdef GET_INTERPFN_DISPATCHERS
1632PRESERVE_NONE
1633static bool Interp_ArrayDecay(InterpState &S) {
1634 if (!ArrayDecay(S, S.PC)) return false;
1635#if USE_TAILCALLS
1636 MUSTTAIL return InterpNext(S);
1637#else
1638 return true;
1639#endif
1640}
1641#endif
1642#ifdef GET_DISASM
1643case OP_ArrayDecay:
1644 Text.Op = PrintName("ArrayDecay");
1645 break;
1646#endif
1647#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1648bool emitArrayDecay(SourceInfo);
1649#endif
1650#ifdef GET_LINK_IMPL
1651bool ByteCodeEmitter::emitArrayDecay(SourceInfo L) {
1652 return emitOp<>(OP_ArrayDecay, L);
1653}
1654#endif
1655#ifdef GET_EVAL_IMPL
1656bool EvalEmitter::emitArrayDecay(SourceInfo L) {
1657 if (!isActive()) return true;
1658 CurrentSource = L;
1659 return ArrayDecay(S, CodePtr());
1660}
1661#endif
1662#ifdef GET_OPCODE_NAMES
1663OP_ArrayElemSint8,
1664OP_ArrayElemUint8,
1665OP_ArrayElemSint16,
1666OP_ArrayElemUint16,
1667OP_ArrayElemSint32,
1668OP_ArrayElemUint32,
1669OP_ArrayElemSint64,
1670OP_ArrayElemUint64,
1671OP_ArrayElemIntAP,
1672OP_ArrayElemIntAPS,
1673OP_ArrayElemBool,
1674OP_ArrayElemFixedPoint,
1675OP_ArrayElemPtr,
1676OP_ArrayElemMemberPtr,
1677OP_ArrayElemFloat,
1678OP_ArrayElemReflect,
1679#endif
1680#ifdef GET_INTERPFN_LIST
1681&Interp_ArrayElemSint8,
1682&Interp_ArrayElemUint8,
1683&Interp_ArrayElemSint16,
1684&Interp_ArrayElemUint16,
1685&Interp_ArrayElemSint32,
1686&Interp_ArrayElemUint32,
1687&Interp_ArrayElemSint64,
1688&Interp_ArrayElemUint64,
1689&Interp_ArrayElemIntAP,
1690&Interp_ArrayElemIntAPS,
1691&Interp_ArrayElemBool,
1692&Interp_ArrayElemFixedPoint,
1693&Interp_ArrayElemPtr,
1694&Interp_ArrayElemMemberPtr,
1695&Interp_ArrayElemFloat,
1696&Interp_ArrayElemReflect,
1697#endif
1698#ifdef GET_INTERPFN_DISPATCHERS
1699PRESERVE_NONE
1700static bool Interp_ArrayElemSint8(InterpState &S) {
1701 {
1702 CodePtr OpPC = S.PC;
1703 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1704 if (!ArrayElem<PT_Sint8>(S, OpPC, V0)) return false;
1705 }
1706#if USE_TAILCALLS
1707 MUSTTAIL return InterpNext(S);
1708#else
1709 return true;
1710#endif
1711}
1712PRESERVE_NONE
1713static bool Interp_ArrayElemUint8(InterpState &S) {
1714 {
1715 CodePtr OpPC = S.PC;
1716 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1717 if (!ArrayElem<PT_Uint8>(S, OpPC, V0)) return false;
1718 }
1719#if USE_TAILCALLS
1720 MUSTTAIL return InterpNext(S);
1721#else
1722 return true;
1723#endif
1724}
1725PRESERVE_NONE
1726static bool Interp_ArrayElemSint16(InterpState &S) {
1727 {
1728 CodePtr OpPC = S.PC;
1729 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1730 if (!ArrayElem<PT_Sint16>(S, OpPC, V0)) return false;
1731 }
1732#if USE_TAILCALLS
1733 MUSTTAIL return InterpNext(S);
1734#else
1735 return true;
1736#endif
1737}
1738PRESERVE_NONE
1739static bool Interp_ArrayElemUint16(InterpState &S) {
1740 {
1741 CodePtr OpPC = S.PC;
1742 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1743 if (!ArrayElem<PT_Uint16>(S, OpPC, V0)) return false;
1744 }
1745#if USE_TAILCALLS
1746 MUSTTAIL return InterpNext(S);
1747#else
1748 return true;
1749#endif
1750}
1751PRESERVE_NONE
1752static bool Interp_ArrayElemSint32(InterpState &S) {
1753 {
1754 CodePtr OpPC = S.PC;
1755 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1756 if (!ArrayElem<PT_Sint32>(S, OpPC, V0)) return false;
1757 }
1758#if USE_TAILCALLS
1759 MUSTTAIL return InterpNext(S);
1760#else
1761 return true;
1762#endif
1763}
1764PRESERVE_NONE
1765static bool Interp_ArrayElemUint32(InterpState &S) {
1766 {
1767 CodePtr OpPC = S.PC;
1768 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1769 if (!ArrayElem<PT_Uint32>(S, OpPC, V0)) return false;
1770 }
1771#if USE_TAILCALLS
1772 MUSTTAIL return InterpNext(S);
1773#else
1774 return true;
1775#endif
1776}
1777PRESERVE_NONE
1778static bool Interp_ArrayElemSint64(InterpState &S) {
1779 {
1780 CodePtr OpPC = S.PC;
1781 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1782 if (!ArrayElem<PT_Sint64>(S, OpPC, V0)) return false;
1783 }
1784#if USE_TAILCALLS
1785 MUSTTAIL return InterpNext(S);
1786#else
1787 return true;
1788#endif
1789}
1790PRESERVE_NONE
1791static bool Interp_ArrayElemUint64(InterpState &S) {
1792 {
1793 CodePtr OpPC = S.PC;
1794 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1795 if (!ArrayElem<PT_Uint64>(S, OpPC, V0)) return false;
1796 }
1797#if USE_TAILCALLS
1798 MUSTTAIL return InterpNext(S);
1799#else
1800 return true;
1801#endif
1802}
1803PRESERVE_NONE
1804static bool Interp_ArrayElemIntAP(InterpState &S) {
1805 {
1806 CodePtr OpPC = S.PC;
1807 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1808 if (!ArrayElem<PT_IntAP>(S, OpPC, V0)) return false;
1809 }
1810#if USE_TAILCALLS
1811 MUSTTAIL return InterpNext(S);
1812#else
1813 return true;
1814#endif
1815}
1816PRESERVE_NONE
1817static bool Interp_ArrayElemIntAPS(InterpState &S) {
1818 {
1819 CodePtr OpPC = S.PC;
1820 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1821 if (!ArrayElem<PT_IntAPS>(S, OpPC, V0)) return false;
1822 }
1823#if USE_TAILCALLS
1824 MUSTTAIL return InterpNext(S);
1825#else
1826 return true;
1827#endif
1828}
1829PRESERVE_NONE
1830static bool Interp_ArrayElemBool(InterpState &S) {
1831 {
1832 CodePtr OpPC = S.PC;
1833 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1834 if (!ArrayElem<PT_Bool>(S, OpPC, V0)) return false;
1835 }
1836#if USE_TAILCALLS
1837 MUSTTAIL return InterpNext(S);
1838#else
1839 return true;
1840#endif
1841}
1842PRESERVE_NONE
1843static bool Interp_ArrayElemFixedPoint(InterpState &S) {
1844 {
1845 CodePtr OpPC = S.PC;
1846 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1847 if (!ArrayElem<PT_FixedPoint>(S, OpPC, V0)) return false;
1848 }
1849#if USE_TAILCALLS
1850 MUSTTAIL return InterpNext(S);
1851#else
1852 return true;
1853#endif
1854}
1855PRESERVE_NONE
1856static bool Interp_ArrayElemPtr(InterpState &S) {
1857 {
1858 CodePtr OpPC = S.PC;
1859 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1860 if (!ArrayElem<PT_Ptr>(S, OpPC, V0)) return false;
1861 }
1862#if USE_TAILCALLS
1863 MUSTTAIL return InterpNext(S);
1864#else
1865 return true;
1866#endif
1867}
1868PRESERVE_NONE
1869static bool Interp_ArrayElemMemberPtr(InterpState &S) {
1870 {
1871 CodePtr OpPC = S.PC;
1872 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1873 if (!ArrayElem<PT_MemberPtr>(S, OpPC, V0)) return false;
1874 }
1875#if USE_TAILCALLS
1876 MUSTTAIL return InterpNext(S);
1877#else
1878 return true;
1879#endif
1880}
1881PRESERVE_NONE
1882static bool Interp_ArrayElemFloat(InterpState &S) {
1883 {
1884 CodePtr OpPC = S.PC;
1885 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1886 if (!ArrayElem<PT_Float>(S, OpPC, V0)) return false;
1887 }
1888#if USE_TAILCALLS
1889 MUSTTAIL return InterpNext(S);
1890#else
1891 return true;
1892#endif
1893}
1894PRESERVE_NONE
1895static bool Interp_ArrayElemReflect(InterpState &S) {
1896 {
1897 CodePtr OpPC = S.PC;
1898 const auto V0 = ReadArg<uint32_t>(S, S.PC);
1899 if (!ArrayElem<PT_Reflect>(S, OpPC, V0)) return false;
1900 }
1901#if USE_TAILCALLS
1902 MUSTTAIL return InterpNext(S);
1903#else
1904 return true;
1905#endif
1906}
1907#endif
1908#ifdef GET_DISASM
1909case OP_ArrayElemSint8:
1910 Text.Op = PrintName("ArrayElemSint8");
1911 Text.Args.push_back(printArg<uint32_t>(PC));
1912 break;
1913case OP_ArrayElemUint8:
1914 Text.Op = PrintName("ArrayElemUint8");
1915 Text.Args.push_back(printArg<uint32_t>(PC));
1916 break;
1917case OP_ArrayElemSint16:
1918 Text.Op = PrintName("ArrayElemSint16");
1919 Text.Args.push_back(printArg<uint32_t>(PC));
1920 break;
1921case OP_ArrayElemUint16:
1922 Text.Op = PrintName("ArrayElemUint16");
1923 Text.Args.push_back(printArg<uint32_t>(PC));
1924 break;
1925case OP_ArrayElemSint32:
1926 Text.Op = PrintName("ArrayElemSint32");
1927 Text.Args.push_back(printArg<uint32_t>(PC));
1928 break;
1929case OP_ArrayElemUint32:
1930 Text.Op = PrintName("ArrayElemUint32");
1931 Text.Args.push_back(printArg<uint32_t>(PC));
1932 break;
1933case OP_ArrayElemSint64:
1934 Text.Op = PrintName("ArrayElemSint64");
1935 Text.Args.push_back(printArg<uint32_t>(PC));
1936 break;
1937case OP_ArrayElemUint64:
1938 Text.Op = PrintName("ArrayElemUint64");
1939 Text.Args.push_back(printArg<uint32_t>(PC));
1940 break;
1941case OP_ArrayElemIntAP:
1942 Text.Op = PrintName("ArrayElemIntAP");
1943 Text.Args.push_back(printArg<uint32_t>(PC));
1944 break;
1945case OP_ArrayElemIntAPS:
1946 Text.Op = PrintName("ArrayElemIntAPS");
1947 Text.Args.push_back(printArg<uint32_t>(PC));
1948 break;
1949case OP_ArrayElemBool:
1950 Text.Op = PrintName("ArrayElemBool");
1951 Text.Args.push_back(printArg<uint32_t>(PC));
1952 break;
1953case OP_ArrayElemFixedPoint:
1954 Text.Op = PrintName("ArrayElemFixedPoint");
1955 Text.Args.push_back(printArg<uint32_t>(PC));
1956 break;
1957case OP_ArrayElemPtr:
1958 Text.Op = PrintName("ArrayElemPtr");
1959 Text.Args.push_back(printArg<uint32_t>(PC));
1960 break;
1961case OP_ArrayElemMemberPtr:
1962 Text.Op = PrintName("ArrayElemMemberPtr");
1963 Text.Args.push_back(printArg<uint32_t>(PC));
1964 break;
1965case OP_ArrayElemFloat:
1966 Text.Op = PrintName("ArrayElemFloat");
1967 Text.Args.push_back(printArg<uint32_t>(PC));
1968 break;
1969case OP_ArrayElemReflect:
1970 Text.Op = PrintName("ArrayElemReflect");
1971 Text.Args.push_back(printArg<uint32_t>(PC));
1972 break;
1973#endif
1974#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1975bool emitArrayElemSint8( uint32_t , SourceInfo);
1976bool emitArrayElemUint8( uint32_t , SourceInfo);
1977bool emitArrayElemSint16( uint32_t , SourceInfo);
1978bool emitArrayElemUint16( uint32_t , SourceInfo);
1979bool emitArrayElemSint32( uint32_t , SourceInfo);
1980bool emitArrayElemUint32( uint32_t , SourceInfo);
1981bool emitArrayElemSint64( uint32_t , SourceInfo);
1982bool emitArrayElemUint64( uint32_t , SourceInfo);
1983bool emitArrayElemIntAP( uint32_t , SourceInfo);
1984bool emitArrayElemIntAPS( uint32_t , SourceInfo);
1985bool emitArrayElemBool( uint32_t , SourceInfo);
1986bool emitArrayElemFixedPoint( uint32_t , SourceInfo);
1987bool emitArrayElemPtr( uint32_t , SourceInfo);
1988bool emitArrayElemMemberPtr( uint32_t , SourceInfo);
1989bool emitArrayElemFloat( uint32_t , SourceInfo);
1990bool emitArrayElemReflect( uint32_t , SourceInfo);
1991#endif
1992#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
1993[[nodiscard]] bool emitArrayElem(PrimType, uint32_t, SourceInfo I);
1994#endif
1995#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
1996bool
1997#if defined(GET_EVAL_IMPL)
1998EvalEmitter
1999#else
2000ByteCodeEmitter
2001#endif
2002::emitArrayElem(PrimType T0, uint32_t A0, SourceInfo I) {
2003 switch (T0) {
2004 case PT_Sint8:
2005 return emitArrayElemSint8(A0, I);
2006 case PT_Uint8:
2007 return emitArrayElemUint8(A0, I);
2008 case PT_Sint16:
2009 return emitArrayElemSint16(A0, I);
2010 case PT_Uint16:
2011 return emitArrayElemUint16(A0, I);
2012 case PT_Sint32:
2013 return emitArrayElemSint32(A0, I);
2014 case PT_Uint32:
2015 return emitArrayElemUint32(A0, I);
2016 case PT_Sint64:
2017 return emitArrayElemSint64(A0, I);
2018 case PT_Uint64:
2019 return emitArrayElemUint64(A0, I);
2020 case PT_IntAP:
2021 return emitArrayElemIntAP(A0, I);
2022 case PT_IntAPS:
2023 return emitArrayElemIntAPS(A0, I);
2024 case PT_Bool:
2025 return emitArrayElemBool(A0, I);
2026 case PT_FixedPoint:
2027 return emitArrayElemFixedPoint(A0, I);
2028 case PT_Ptr:
2029 return emitArrayElemPtr(A0, I);
2030 case PT_MemberPtr:
2031 return emitArrayElemMemberPtr(A0, I);
2032 case PT_Float:
2033 return emitArrayElemFloat(A0, I);
2034 case PT_Reflect:
2035 return emitArrayElemReflect(A0, I);
2036 }
2037 llvm_unreachable("invalid enum value");
2038}
2039#endif
2040#ifdef GET_LINK_IMPL
2041bool ByteCodeEmitter::emitArrayElemSint8( uint32_t A0, SourceInfo L) {
2042 return emitOp<uint32_t>(OP_ArrayElemSint8, A0, L);
2043}
2044bool ByteCodeEmitter::emitArrayElemUint8( uint32_t A0, SourceInfo L) {
2045 return emitOp<uint32_t>(OP_ArrayElemUint8, A0, L);
2046}
2047bool ByteCodeEmitter::emitArrayElemSint16( uint32_t A0, SourceInfo L) {
2048 return emitOp<uint32_t>(OP_ArrayElemSint16, A0, L);
2049}
2050bool ByteCodeEmitter::emitArrayElemUint16( uint32_t A0, SourceInfo L) {
2051 return emitOp<uint32_t>(OP_ArrayElemUint16, A0, L);
2052}
2053bool ByteCodeEmitter::emitArrayElemSint32( uint32_t A0, SourceInfo L) {
2054 return emitOp<uint32_t>(OP_ArrayElemSint32, A0, L);
2055}
2056bool ByteCodeEmitter::emitArrayElemUint32( uint32_t A0, SourceInfo L) {
2057 return emitOp<uint32_t>(OP_ArrayElemUint32, A0, L);
2058}
2059bool ByteCodeEmitter::emitArrayElemSint64( uint32_t A0, SourceInfo L) {
2060 return emitOp<uint32_t>(OP_ArrayElemSint64, A0, L);
2061}
2062bool ByteCodeEmitter::emitArrayElemUint64( uint32_t A0, SourceInfo L) {
2063 return emitOp<uint32_t>(OP_ArrayElemUint64, A0, L);
2064}
2065bool ByteCodeEmitter::emitArrayElemIntAP( uint32_t A0, SourceInfo L) {
2066 return emitOp<uint32_t>(OP_ArrayElemIntAP, A0, L);
2067}
2068bool ByteCodeEmitter::emitArrayElemIntAPS( uint32_t A0, SourceInfo L) {
2069 return emitOp<uint32_t>(OP_ArrayElemIntAPS, A0, L);
2070}
2071bool ByteCodeEmitter::emitArrayElemBool( uint32_t A0, SourceInfo L) {
2072 return emitOp<uint32_t>(OP_ArrayElemBool, A0, L);
2073}
2074bool ByteCodeEmitter::emitArrayElemFixedPoint( uint32_t A0, SourceInfo L) {
2075 return emitOp<uint32_t>(OP_ArrayElemFixedPoint, A0, L);
2076}
2077bool ByteCodeEmitter::emitArrayElemPtr( uint32_t A0, SourceInfo L) {
2078 return emitOp<uint32_t>(OP_ArrayElemPtr, A0, L);
2079}
2080bool ByteCodeEmitter::emitArrayElemMemberPtr( uint32_t A0, SourceInfo L) {
2081 return emitOp<uint32_t>(OP_ArrayElemMemberPtr, A0, L);
2082}
2083bool ByteCodeEmitter::emitArrayElemFloat( uint32_t A0, SourceInfo L) {
2084 return emitOp<uint32_t>(OP_ArrayElemFloat, A0, L);
2085}
2086bool ByteCodeEmitter::emitArrayElemReflect( uint32_t A0, SourceInfo L) {
2087 return emitOp<uint32_t>(OP_ArrayElemReflect, A0, L);
2088}
2089#endif
2090#ifdef GET_EVAL_IMPL
2091bool EvalEmitter::emitArrayElemSint8( uint32_t A0, SourceInfo L) {
2092 if (!isActive()) return true;
2093 CurrentSource = L;
2094 return ArrayElem<PT_Sint8>(S, CodePtr(), A0);
2095}
2096bool EvalEmitter::emitArrayElemUint8( uint32_t A0, SourceInfo L) {
2097 if (!isActive()) return true;
2098 CurrentSource = L;
2099 return ArrayElem<PT_Uint8>(S, CodePtr(), A0);
2100}
2101bool EvalEmitter::emitArrayElemSint16( uint32_t A0, SourceInfo L) {
2102 if (!isActive()) return true;
2103 CurrentSource = L;
2104 return ArrayElem<PT_Sint16>(S, CodePtr(), A0);
2105}
2106bool EvalEmitter::emitArrayElemUint16( uint32_t A0, SourceInfo L) {
2107 if (!isActive()) return true;
2108 CurrentSource = L;
2109 return ArrayElem<PT_Uint16>(S, CodePtr(), A0);
2110}
2111bool EvalEmitter::emitArrayElemSint32( uint32_t A0, SourceInfo L) {
2112 if (!isActive()) return true;
2113 CurrentSource = L;
2114 return ArrayElem<PT_Sint32>(S, CodePtr(), A0);
2115}
2116bool EvalEmitter::emitArrayElemUint32( uint32_t A0, SourceInfo L) {
2117 if (!isActive()) return true;
2118 CurrentSource = L;
2119 return ArrayElem<PT_Uint32>(S, CodePtr(), A0);
2120}
2121bool EvalEmitter::emitArrayElemSint64( uint32_t A0, SourceInfo L) {
2122 if (!isActive()) return true;
2123 CurrentSource = L;
2124 return ArrayElem<PT_Sint64>(S, CodePtr(), A0);
2125}
2126bool EvalEmitter::emitArrayElemUint64( uint32_t A0, SourceInfo L) {
2127 if (!isActive()) return true;
2128 CurrentSource = L;
2129 return ArrayElem<PT_Uint64>(S, CodePtr(), A0);
2130}
2131bool EvalEmitter::emitArrayElemIntAP( uint32_t A0, SourceInfo L) {
2132 if (!isActive()) return true;
2133 CurrentSource = L;
2134 return ArrayElem<PT_IntAP>(S, CodePtr(), A0);
2135}
2136bool EvalEmitter::emitArrayElemIntAPS( uint32_t A0, SourceInfo L) {
2137 if (!isActive()) return true;
2138 CurrentSource = L;
2139 return ArrayElem<PT_IntAPS>(S, CodePtr(), A0);
2140}
2141bool EvalEmitter::emitArrayElemBool( uint32_t A0, SourceInfo L) {
2142 if (!isActive()) return true;
2143 CurrentSource = L;
2144 return ArrayElem<PT_Bool>(S, CodePtr(), A0);
2145}
2146bool EvalEmitter::emitArrayElemFixedPoint( uint32_t A0, SourceInfo L) {
2147 if (!isActive()) return true;
2148 CurrentSource = L;
2149 return ArrayElem<PT_FixedPoint>(S, CodePtr(), A0);
2150}
2151bool EvalEmitter::emitArrayElemPtr( uint32_t A0, SourceInfo L) {
2152 if (!isActive()) return true;
2153 CurrentSource = L;
2154 return ArrayElem<PT_Ptr>(S, CodePtr(), A0);
2155}
2156bool EvalEmitter::emitArrayElemMemberPtr( uint32_t A0, SourceInfo L) {
2157 if (!isActive()) return true;
2158 CurrentSource = L;
2159 return ArrayElem<PT_MemberPtr>(S, CodePtr(), A0);
2160}
2161bool EvalEmitter::emitArrayElemFloat( uint32_t A0, SourceInfo L) {
2162 if (!isActive()) return true;
2163 CurrentSource = L;
2164 return ArrayElem<PT_Float>(S, CodePtr(), A0);
2165}
2166bool EvalEmitter::emitArrayElemReflect( uint32_t A0, SourceInfo L) {
2167 if (!isActive()) return true;
2168 CurrentSource = L;
2169 return ArrayElem<PT_Reflect>(S, CodePtr(), A0);
2170}
2171#endif
2172#ifdef GET_OPCODE_NAMES
2173OP_ArrayElemPopSint8,
2174OP_ArrayElemPopUint8,
2175OP_ArrayElemPopSint16,
2176OP_ArrayElemPopUint16,
2177OP_ArrayElemPopSint32,
2178OP_ArrayElemPopUint32,
2179OP_ArrayElemPopSint64,
2180OP_ArrayElemPopUint64,
2181OP_ArrayElemPopIntAP,
2182OP_ArrayElemPopIntAPS,
2183OP_ArrayElemPopBool,
2184OP_ArrayElemPopFixedPoint,
2185OP_ArrayElemPopPtr,
2186OP_ArrayElemPopMemberPtr,
2187OP_ArrayElemPopFloat,
2188OP_ArrayElemPopReflect,
2189#endif
2190#ifdef GET_INTERPFN_LIST
2191&Interp_ArrayElemPopSint8,
2192&Interp_ArrayElemPopUint8,
2193&Interp_ArrayElemPopSint16,
2194&Interp_ArrayElemPopUint16,
2195&Interp_ArrayElemPopSint32,
2196&Interp_ArrayElemPopUint32,
2197&Interp_ArrayElemPopSint64,
2198&Interp_ArrayElemPopUint64,
2199&Interp_ArrayElemPopIntAP,
2200&Interp_ArrayElemPopIntAPS,
2201&Interp_ArrayElemPopBool,
2202&Interp_ArrayElemPopFixedPoint,
2203&Interp_ArrayElemPopPtr,
2204&Interp_ArrayElemPopMemberPtr,
2205&Interp_ArrayElemPopFloat,
2206&Interp_ArrayElemPopReflect,
2207#endif
2208#ifdef GET_INTERPFN_DISPATCHERS
2209PRESERVE_NONE
2210static bool Interp_ArrayElemPopSint8(InterpState &S) {
2211 {
2212 CodePtr OpPC = S.PC;
2213 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2214 if (!ArrayElemPop<PT_Sint8>(S, OpPC, V0)) return false;
2215 }
2216#if USE_TAILCALLS
2217 MUSTTAIL return InterpNext(S);
2218#else
2219 return true;
2220#endif
2221}
2222PRESERVE_NONE
2223static bool Interp_ArrayElemPopUint8(InterpState &S) {
2224 {
2225 CodePtr OpPC = S.PC;
2226 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2227 if (!ArrayElemPop<PT_Uint8>(S, OpPC, V0)) return false;
2228 }
2229#if USE_TAILCALLS
2230 MUSTTAIL return InterpNext(S);
2231#else
2232 return true;
2233#endif
2234}
2235PRESERVE_NONE
2236static bool Interp_ArrayElemPopSint16(InterpState &S) {
2237 {
2238 CodePtr OpPC = S.PC;
2239 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2240 if (!ArrayElemPop<PT_Sint16>(S, OpPC, V0)) return false;
2241 }
2242#if USE_TAILCALLS
2243 MUSTTAIL return InterpNext(S);
2244#else
2245 return true;
2246#endif
2247}
2248PRESERVE_NONE
2249static bool Interp_ArrayElemPopUint16(InterpState &S) {
2250 {
2251 CodePtr OpPC = S.PC;
2252 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2253 if (!ArrayElemPop<PT_Uint16>(S, OpPC, V0)) return false;
2254 }
2255#if USE_TAILCALLS
2256 MUSTTAIL return InterpNext(S);
2257#else
2258 return true;
2259#endif
2260}
2261PRESERVE_NONE
2262static bool Interp_ArrayElemPopSint32(InterpState &S) {
2263 {
2264 CodePtr OpPC = S.PC;
2265 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2266 if (!ArrayElemPop<PT_Sint32>(S, OpPC, V0)) return false;
2267 }
2268#if USE_TAILCALLS
2269 MUSTTAIL return InterpNext(S);
2270#else
2271 return true;
2272#endif
2273}
2274PRESERVE_NONE
2275static bool Interp_ArrayElemPopUint32(InterpState &S) {
2276 {
2277 CodePtr OpPC = S.PC;
2278 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2279 if (!ArrayElemPop<PT_Uint32>(S, OpPC, V0)) return false;
2280 }
2281#if USE_TAILCALLS
2282 MUSTTAIL return InterpNext(S);
2283#else
2284 return true;
2285#endif
2286}
2287PRESERVE_NONE
2288static bool Interp_ArrayElemPopSint64(InterpState &S) {
2289 {
2290 CodePtr OpPC = S.PC;
2291 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2292 if (!ArrayElemPop<PT_Sint64>(S, OpPC, V0)) return false;
2293 }
2294#if USE_TAILCALLS
2295 MUSTTAIL return InterpNext(S);
2296#else
2297 return true;
2298#endif
2299}
2300PRESERVE_NONE
2301static bool Interp_ArrayElemPopUint64(InterpState &S) {
2302 {
2303 CodePtr OpPC = S.PC;
2304 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2305 if (!ArrayElemPop<PT_Uint64>(S, OpPC, V0)) return false;
2306 }
2307#if USE_TAILCALLS
2308 MUSTTAIL return InterpNext(S);
2309#else
2310 return true;
2311#endif
2312}
2313PRESERVE_NONE
2314static bool Interp_ArrayElemPopIntAP(InterpState &S) {
2315 {
2316 CodePtr OpPC = S.PC;
2317 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2318 if (!ArrayElemPop<PT_IntAP>(S, OpPC, V0)) return false;
2319 }
2320#if USE_TAILCALLS
2321 MUSTTAIL return InterpNext(S);
2322#else
2323 return true;
2324#endif
2325}
2326PRESERVE_NONE
2327static bool Interp_ArrayElemPopIntAPS(InterpState &S) {
2328 {
2329 CodePtr OpPC = S.PC;
2330 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2331 if (!ArrayElemPop<PT_IntAPS>(S, OpPC, V0)) return false;
2332 }
2333#if USE_TAILCALLS
2334 MUSTTAIL return InterpNext(S);
2335#else
2336 return true;
2337#endif
2338}
2339PRESERVE_NONE
2340static bool Interp_ArrayElemPopBool(InterpState &S) {
2341 {
2342 CodePtr OpPC = S.PC;
2343 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2344 if (!ArrayElemPop<PT_Bool>(S, OpPC, V0)) return false;
2345 }
2346#if USE_TAILCALLS
2347 MUSTTAIL return InterpNext(S);
2348#else
2349 return true;
2350#endif
2351}
2352PRESERVE_NONE
2353static bool Interp_ArrayElemPopFixedPoint(InterpState &S) {
2354 {
2355 CodePtr OpPC = S.PC;
2356 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2357 if (!ArrayElemPop<PT_FixedPoint>(S, OpPC, V0)) return false;
2358 }
2359#if USE_TAILCALLS
2360 MUSTTAIL return InterpNext(S);
2361#else
2362 return true;
2363#endif
2364}
2365PRESERVE_NONE
2366static bool Interp_ArrayElemPopPtr(InterpState &S) {
2367 {
2368 CodePtr OpPC = S.PC;
2369 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2370 if (!ArrayElemPop<PT_Ptr>(S, OpPC, V0)) return false;
2371 }
2372#if USE_TAILCALLS
2373 MUSTTAIL return InterpNext(S);
2374#else
2375 return true;
2376#endif
2377}
2378PRESERVE_NONE
2379static bool Interp_ArrayElemPopMemberPtr(InterpState &S) {
2380 {
2381 CodePtr OpPC = S.PC;
2382 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2383 if (!ArrayElemPop<PT_MemberPtr>(S, OpPC, V0)) return false;
2384 }
2385#if USE_TAILCALLS
2386 MUSTTAIL return InterpNext(S);
2387#else
2388 return true;
2389#endif
2390}
2391PRESERVE_NONE
2392static bool Interp_ArrayElemPopFloat(InterpState &S) {
2393 {
2394 CodePtr OpPC = S.PC;
2395 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2396 if (!ArrayElemPop<PT_Float>(S, OpPC, V0)) return false;
2397 }
2398#if USE_TAILCALLS
2399 MUSTTAIL return InterpNext(S);
2400#else
2401 return true;
2402#endif
2403}
2404PRESERVE_NONE
2405static bool Interp_ArrayElemPopReflect(InterpState &S) {
2406 {
2407 CodePtr OpPC = S.PC;
2408 const auto V0 = ReadArg<uint32_t>(S, S.PC);
2409 if (!ArrayElemPop<PT_Reflect>(S, OpPC, V0)) return false;
2410 }
2411#if USE_TAILCALLS
2412 MUSTTAIL return InterpNext(S);
2413#else
2414 return true;
2415#endif
2416}
2417#endif
2418#ifdef GET_DISASM
2419case OP_ArrayElemPopSint8:
2420 Text.Op = PrintName("ArrayElemPopSint8");
2421 Text.Args.push_back(printArg<uint32_t>(PC));
2422 break;
2423case OP_ArrayElemPopUint8:
2424 Text.Op = PrintName("ArrayElemPopUint8");
2425 Text.Args.push_back(printArg<uint32_t>(PC));
2426 break;
2427case OP_ArrayElemPopSint16:
2428 Text.Op = PrintName("ArrayElemPopSint16");
2429 Text.Args.push_back(printArg<uint32_t>(PC));
2430 break;
2431case OP_ArrayElemPopUint16:
2432 Text.Op = PrintName("ArrayElemPopUint16");
2433 Text.Args.push_back(printArg<uint32_t>(PC));
2434 break;
2435case OP_ArrayElemPopSint32:
2436 Text.Op = PrintName("ArrayElemPopSint32");
2437 Text.Args.push_back(printArg<uint32_t>(PC));
2438 break;
2439case OP_ArrayElemPopUint32:
2440 Text.Op = PrintName("ArrayElemPopUint32");
2441 Text.Args.push_back(printArg<uint32_t>(PC));
2442 break;
2443case OP_ArrayElemPopSint64:
2444 Text.Op = PrintName("ArrayElemPopSint64");
2445 Text.Args.push_back(printArg<uint32_t>(PC));
2446 break;
2447case OP_ArrayElemPopUint64:
2448 Text.Op = PrintName("ArrayElemPopUint64");
2449 Text.Args.push_back(printArg<uint32_t>(PC));
2450 break;
2451case OP_ArrayElemPopIntAP:
2452 Text.Op = PrintName("ArrayElemPopIntAP");
2453 Text.Args.push_back(printArg<uint32_t>(PC));
2454 break;
2455case OP_ArrayElemPopIntAPS:
2456 Text.Op = PrintName("ArrayElemPopIntAPS");
2457 Text.Args.push_back(printArg<uint32_t>(PC));
2458 break;
2459case OP_ArrayElemPopBool:
2460 Text.Op = PrintName("ArrayElemPopBool");
2461 Text.Args.push_back(printArg<uint32_t>(PC));
2462 break;
2463case OP_ArrayElemPopFixedPoint:
2464 Text.Op = PrintName("ArrayElemPopFixedPoint");
2465 Text.Args.push_back(printArg<uint32_t>(PC));
2466 break;
2467case OP_ArrayElemPopPtr:
2468 Text.Op = PrintName("ArrayElemPopPtr");
2469 Text.Args.push_back(printArg<uint32_t>(PC));
2470 break;
2471case OP_ArrayElemPopMemberPtr:
2472 Text.Op = PrintName("ArrayElemPopMemberPtr");
2473 Text.Args.push_back(printArg<uint32_t>(PC));
2474 break;
2475case OP_ArrayElemPopFloat:
2476 Text.Op = PrintName("ArrayElemPopFloat");
2477 Text.Args.push_back(printArg<uint32_t>(PC));
2478 break;
2479case OP_ArrayElemPopReflect:
2480 Text.Op = PrintName("ArrayElemPopReflect");
2481 Text.Args.push_back(printArg<uint32_t>(PC));
2482 break;
2483#endif
2484#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
2485bool emitArrayElemPopSint8( uint32_t , SourceInfo);
2486bool emitArrayElemPopUint8( uint32_t , SourceInfo);
2487bool emitArrayElemPopSint16( uint32_t , SourceInfo);
2488bool emitArrayElemPopUint16( uint32_t , SourceInfo);
2489bool emitArrayElemPopSint32( uint32_t , SourceInfo);
2490bool emitArrayElemPopUint32( uint32_t , SourceInfo);
2491bool emitArrayElemPopSint64( uint32_t , SourceInfo);
2492bool emitArrayElemPopUint64( uint32_t , SourceInfo);
2493bool emitArrayElemPopIntAP( uint32_t , SourceInfo);
2494bool emitArrayElemPopIntAPS( uint32_t , SourceInfo);
2495bool emitArrayElemPopBool( uint32_t , SourceInfo);
2496bool emitArrayElemPopFixedPoint( uint32_t , SourceInfo);
2497bool emitArrayElemPopPtr( uint32_t , SourceInfo);
2498bool emitArrayElemPopMemberPtr( uint32_t , SourceInfo);
2499bool emitArrayElemPopFloat( uint32_t , SourceInfo);
2500bool emitArrayElemPopReflect( uint32_t , SourceInfo);
2501#endif
2502#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
2503[[nodiscard]] bool emitArrayElemPop(PrimType, uint32_t, SourceInfo I);
2504#endif
2505#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
2506bool
2507#if defined(GET_EVAL_IMPL)
2508EvalEmitter
2509#else
2510ByteCodeEmitter
2511#endif
2512::emitArrayElemPop(PrimType T0, uint32_t A0, SourceInfo I) {
2513 switch (T0) {
2514 case PT_Sint8:
2515 return emitArrayElemPopSint8(A0, I);
2516 case PT_Uint8:
2517 return emitArrayElemPopUint8(A0, I);
2518 case PT_Sint16:
2519 return emitArrayElemPopSint16(A0, I);
2520 case PT_Uint16:
2521 return emitArrayElemPopUint16(A0, I);
2522 case PT_Sint32:
2523 return emitArrayElemPopSint32(A0, I);
2524 case PT_Uint32:
2525 return emitArrayElemPopUint32(A0, I);
2526 case PT_Sint64:
2527 return emitArrayElemPopSint64(A0, I);
2528 case PT_Uint64:
2529 return emitArrayElemPopUint64(A0, I);
2530 case PT_IntAP:
2531 return emitArrayElemPopIntAP(A0, I);
2532 case PT_IntAPS:
2533 return emitArrayElemPopIntAPS(A0, I);
2534 case PT_Bool:
2535 return emitArrayElemPopBool(A0, I);
2536 case PT_FixedPoint:
2537 return emitArrayElemPopFixedPoint(A0, I);
2538 case PT_Ptr:
2539 return emitArrayElemPopPtr(A0, I);
2540 case PT_MemberPtr:
2541 return emitArrayElemPopMemberPtr(A0, I);
2542 case PT_Float:
2543 return emitArrayElemPopFloat(A0, I);
2544 case PT_Reflect:
2545 return emitArrayElemPopReflect(A0, I);
2546 }
2547 llvm_unreachable("invalid enum value");
2548}
2549#endif
2550#ifdef GET_LINK_IMPL
2551bool ByteCodeEmitter::emitArrayElemPopSint8( uint32_t A0, SourceInfo L) {
2552 return emitOp<uint32_t>(OP_ArrayElemPopSint8, A0, L);
2553}
2554bool ByteCodeEmitter::emitArrayElemPopUint8( uint32_t A0, SourceInfo L) {
2555 return emitOp<uint32_t>(OP_ArrayElemPopUint8, A0, L);
2556}
2557bool ByteCodeEmitter::emitArrayElemPopSint16( uint32_t A0, SourceInfo L) {
2558 return emitOp<uint32_t>(OP_ArrayElemPopSint16, A0, L);
2559}
2560bool ByteCodeEmitter::emitArrayElemPopUint16( uint32_t A0, SourceInfo L) {
2561 return emitOp<uint32_t>(OP_ArrayElemPopUint16, A0, L);
2562}
2563bool ByteCodeEmitter::emitArrayElemPopSint32( uint32_t A0, SourceInfo L) {
2564 return emitOp<uint32_t>(OP_ArrayElemPopSint32, A0, L);
2565}
2566bool ByteCodeEmitter::emitArrayElemPopUint32( uint32_t A0, SourceInfo L) {
2567 return emitOp<uint32_t>(OP_ArrayElemPopUint32, A0, L);
2568}
2569bool ByteCodeEmitter::emitArrayElemPopSint64( uint32_t A0, SourceInfo L) {
2570 return emitOp<uint32_t>(OP_ArrayElemPopSint64, A0, L);
2571}
2572bool ByteCodeEmitter::emitArrayElemPopUint64( uint32_t A0, SourceInfo L) {
2573 return emitOp<uint32_t>(OP_ArrayElemPopUint64, A0, L);
2574}
2575bool ByteCodeEmitter::emitArrayElemPopIntAP( uint32_t A0, SourceInfo L) {
2576 return emitOp<uint32_t>(OP_ArrayElemPopIntAP, A0, L);
2577}
2578bool ByteCodeEmitter::emitArrayElemPopIntAPS( uint32_t A0, SourceInfo L) {
2579 return emitOp<uint32_t>(OP_ArrayElemPopIntAPS, A0, L);
2580}
2581bool ByteCodeEmitter::emitArrayElemPopBool( uint32_t A0, SourceInfo L) {
2582 return emitOp<uint32_t>(OP_ArrayElemPopBool, A0, L);
2583}
2584bool ByteCodeEmitter::emitArrayElemPopFixedPoint( uint32_t A0, SourceInfo L) {
2585 return emitOp<uint32_t>(OP_ArrayElemPopFixedPoint, A0, L);
2586}
2587bool ByteCodeEmitter::emitArrayElemPopPtr( uint32_t A0, SourceInfo L) {
2588 return emitOp<uint32_t>(OP_ArrayElemPopPtr, A0, L);
2589}
2590bool ByteCodeEmitter::emitArrayElemPopMemberPtr( uint32_t A0, SourceInfo L) {
2591 return emitOp<uint32_t>(OP_ArrayElemPopMemberPtr, A0, L);
2592}
2593bool ByteCodeEmitter::emitArrayElemPopFloat( uint32_t A0, SourceInfo L) {
2594 return emitOp<uint32_t>(OP_ArrayElemPopFloat, A0, L);
2595}
2596bool ByteCodeEmitter::emitArrayElemPopReflect( uint32_t A0, SourceInfo L) {
2597 return emitOp<uint32_t>(OP_ArrayElemPopReflect, A0, L);
2598}
2599#endif
2600#ifdef GET_EVAL_IMPL
2601bool EvalEmitter::emitArrayElemPopSint8( uint32_t A0, SourceInfo L) {
2602 if (!isActive()) return true;
2603 CurrentSource = L;
2604 return ArrayElemPop<PT_Sint8>(S, CodePtr(), A0);
2605}
2606bool EvalEmitter::emitArrayElemPopUint8( uint32_t A0, SourceInfo L) {
2607 if (!isActive()) return true;
2608 CurrentSource = L;
2609 return ArrayElemPop<PT_Uint8>(S, CodePtr(), A0);
2610}
2611bool EvalEmitter::emitArrayElemPopSint16( uint32_t A0, SourceInfo L) {
2612 if (!isActive()) return true;
2613 CurrentSource = L;
2614 return ArrayElemPop<PT_Sint16>(S, CodePtr(), A0);
2615}
2616bool EvalEmitter::emitArrayElemPopUint16( uint32_t A0, SourceInfo L) {
2617 if (!isActive()) return true;
2618 CurrentSource = L;
2619 return ArrayElemPop<PT_Uint16>(S, CodePtr(), A0);
2620}
2621bool EvalEmitter::emitArrayElemPopSint32( uint32_t A0, SourceInfo L) {
2622 if (!isActive()) return true;
2623 CurrentSource = L;
2624 return ArrayElemPop<PT_Sint32>(S, CodePtr(), A0);
2625}
2626bool EvalEmitter::emitArrayElemPopUint32( uint32_t A0, SourceInfo L) {
2627 if (!isActive()) return true;
2628 CurrentSource = L;
2629 return ArrayElemPop<PT_Uint32>(S, CodePtr(), A0);
2630}
2631bool EvalEmitter::emitArrayElemPopSint64( uint32_t A0, SourceInfo L) {
2632 if (!isActive()) return true;
2633 CurrentSource = L;
2634 return ArrayElemPop<PT_Sint64>(S, CodePtr(), A0);
2635}
2636bool EvalEmitter::emitArrayElemPopUint64( uint32_t A0, SourceInfo L) {
2637 if (!isActive()) return true;
2638 CurrentSource = L;
2639 return ArrayElemPop<PT_Uint64>(S, CodePtr(), A0);
2640}
2641bool EvalEmitter::emitArrayElemPopIntAP( uint32_t A0, SourceInfo L) {
2642 if (!isActive()) return true;
2643 CurrentSource = L;
2644 return ArrayElemPop<PT_IntAP>(S, CodePtr(), A0);
2645}
2646bool EvalEmitter::emitArrayElemPopIntAPS( uint32_t A0, SourceInfo L) {
2647 if (!isActive()) return true;
2648 CurrentSource = L;
2649 return ArrayElemPop<PT_IntAPS>(S, CodePtr(), A0);
2650}
2651bool EvalEmitter::emitArrayElemPopBool( uint32_t A0, SourceInfo L) {
2652 if (!isActive()) return true;
2653 CurrentSource = L;
2654 return ArrayElemPop<PT_Bool>(S, CodePtr(), A0);
2655}
2656bool EvalEmitter::emitArrayElemPopFixedPoint( uint32_t A0, SourceInfo L) {
2657 if (!isActive()) return true;
2658 CurrentSource = L;
2659 return ArrayElemPop<PT_FixedPoint>(S, CodePtr(), A0);
2660}
2661bool EvalEmitter::emitArrayElemPopPtr( uint32_t A0, SourceInfo L) {
2662 if (!isActive()) return true;
2663 CurrentSource = L;
2664 return ArrayElemPop<PT_Ptr>(S, CodePtr(), A0);
2665}
2666bool EvalEmitter::emitArrayElemPopMemberPtr( uint32_t A0, SourceInfo L) {
2667 if (!isActive()) return true;
2668 CurrentSource = L;
2669 return ArrayElemPop<PT_MemberPtr>(S, CodePtr(), A0);
2670}
2671bool EvalEmitter::emitArrayElemPopFloat( uint32_t A0, SourceInfo L) {
2672 if (!isActive()) return true;
2673 CurrentSource = L;
2674 return ArrayElemPop<PT_Float>(S, CodePtr(), A0);
2675}
2676bool EvalEmitter::emitArrayElemPopReflect( uint32_t A0, SourceInfo L) {
2677 if (!isActive()) return true;
2678 CurrentSource = L;
2679 return ArrayElemPop<PT_Reflect>(S, CodePtr(), A0);
2680}
2681#endif
2682#ifdef GET_OPCODE_NAMES
2683OP_ArrayElemPtrSint8,
2684OP_ArrayElemPtrUint8,
2685OP_ArrayElemPtrSint16,
2686OP_ArrayElemPtrUint16,
2687OP_ArrayElemPtrSint32,
2688OP_ArrayElemPtrUint32,
2689OP_ArrayElemPtrSint64,
2690OP_ArrayElemPtrUint64,
2691OP_ArrayElemPtrIntAP,
2692OP_ArrayElemPtrIntAPS,
2693OP_ArrayElemPtrBool,
2694#endif
2695#ifdef GET_INTERPFN_LIST
2696&Interp_ArrayElemPtrSint8,
2697&Interp_ArrayElemPtrUint8,
2698&Interp_ArrayElemPtrSint16,
2699&Interp_ArrayElemPtrUint16,
2700&Interp_ArrayElemPtrSint32,
2701&Interp_ArrayElemPtrUint32,
2702&Interp_ArrayElemPtrSint64,
2703&Interp_ArrayElemPtrUint64,
2704&Interp_ArrayElemPtrIntAP,
2705&Interp_ArrayElemPtrIntAPS,
2706&Interp_ArrayElemPtrBool,
2707#endif
2708#ifdef GET_INTERPFN_DISPATCHERS
2709PRESERVE_NONE
2710static bool Interp_ArrayElemPtrSint8(InterpState &S) {
2711 if (!ArrayElemPtr<PT_Sint8>(S, S.PC)) return false;
2712#if USE_TAILCALLS
2713 MUSTTAIL return InterpNext(S);
2714#else
2715 return true;
2716#endif
2717}
2718PRESERVE_NONE
2719static bool Interp_ArrayElemPtrUint8(InterpState &S) {
2720 if (!ArrayElemPtr<PT_Uint8>(S, S.PC)) return false;
2721#if USE_TAILCALLS
2722 MUSTTAIL return InterpNext(S);
2723#else
2724 return true;
2725#endif
2726}
2727PRESERVE_NONE
2728static bool Interp_ArrayElemPtrSint16(InterpState &S) {
2729 if (!ArrayElemPtr<PT_Sint16>(S, S.PC)) return false;
2730#if USE_TAILCALLS
2731 MUSTTAIL return InterpNext(S);
2732#else
2733 return true;
2734#endif
2735}
2736PRESERVE_NONE
2737static bool Interp_ArrayElemPtrUint16(InterpState &S) {
2738 if (!ArrayElemPtr<PT_Uint16>(S, S.PC)) return false;
2739#if USE_TAILCALLS
2740 MUSTTAIL return InterpNext(S);
2741#else
2742 return true;
2743#endif
2744}
2745PRESERVE_NONE
2746static bool Interp_ArrayElemPtrSint32(InterpState &S) {
2747 if (!ArrayElemPtr<PT_Sint32>(S, S.PC)) return false;
2748#if USE_TAILCALLS
2749 MUSTTAIL return InterpNext(S);
2750#else
2751 return true;
2752#endif
2753}
2754PRESERVE_NONE
2755static bool Interp_ArrayElemPtrUint32(InterpState &S) {
2756 if (!ArrayElemPtr<PT_Uint32>(S, S.PC)) return false;
2757#if USE_TAILCALLS
2758 MUSTTAIL return InterpNext(S);
2759#else
2760 return true;
2761#endif
2762}
2763PRESERVE_NONE
2764static bool Interp_ArrayElemPtrSint64(InterpState &S) {
2765 if (!ArrayElemPtr<PT_Sint64>(S, S.PC)) return false;
2766#if USE_TAILCALLS
2767 MUSTTAIL return InterpNext(S);
2768#else
2769 return true;
2770#endif
2771}
2772PRESERVE_NONE
2773static bool Interp_ArrayElemPtrUint64(InterpState &S) {
2774 if (!ArrayElemPtr<PT_Uint64>(S, S.PC)) return false;
2775#if USE_TAILCALLS
2776 MUSTTAIL return InterpNext(S);
2777#else
2778 return true;
2779#endif
2780}
2781PRESERVE_NONE
2782static bool Interp_ArrayElemPtrIntAP(InterpState &S) {
2783 if (!ArrayElemPtr<PT_IntAP>(S, S.PC)) return false;
2784#if USE_TAILCALLS
2785 MUSTTAIL return InterpNext(S);
2786#else
2787 return true;
2788#endif
2789}
2790PRESERVE_NONE
2791static bool Interp_ArrayElemPtrIntAPS(InterpState &S) {
2792 if (!ArrayElemPtr<PT_IntAPS>(S, S.PC)) return false;
2793#if USE_TAILCALLS
2794 MUSTTAIL return InterpNext(S);
2795#else
2796 return true;
2797#endif
2798}
2799PRESERVE_NONE
2800static bool Interp_ArrayElemPtrBool(InterpState &S) {
2801 if (!ArrayElemPtr<PT_Bool>(S, S.PC)) return false;
2802#if USE_TAILCALLS
2803 MUSTTAIL return InterpNext(S);
2804#else
2805 return true;
2806#endif
2807}
2808#endif
2809#ifdef GET_DISASM
2810case OP_ArrayElemPtrSint8:
2811 Text.Op = PrintName("ArrayElemPtrSint8");
2812 break;
2813case OP_ArrayElemPtrUint8:
2814 Text.Op = PrintName("ArrayElemPtrUint8");
2815 break;
2816case OP_ArrayElemPtrSint16:
2817 Text.Op = PrintName("ArrayElemPtrSint16");
2818 break;
2819case OP_ArrayElemPtrUint16:
2820 Text.Op = PrintName("ArrayElemPtrUint16");
2821 break;
2822case OP_ArrayElemPtrSint32:
2823 Text.Op = PrintName("ArrayElemPtrSint32");
2824 break;
2825case OP_ArrayElemPtrUint32:
2826 Text.Op = PrintName("ArrayElemPtrUint32");
2827 break;
2828case OP_ArrayElemPtrSint64:
2829 Text.Op = PrintName("ArrayElemPtrSint64");
2830 break;
2831case OP_ArrayElemPtrUint64:
2832 Text.Op = PrintName("ArrayElemPtrUint64");
2833 break;
2834case OP_ArrayElemPtrIntAP:
2835 Text.Op = PrintName("ArrayElemPtrIntAP");
2836 break;
2837case OP_ArrayElemPtrIntAPS:
2838 Text.Op = PrintName("ArrayElemPtrIntAPS");
2839 break;
2840case OP_ArrayElemPtrBool:
2841 Text.Op = PrintName("ArrayElemPtrBool");
2842 break;
2843#endif
2844#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
2845bool emitArrayElemPtrSint8(SourceInfo);
2846bool emitArrayElemPtrUint8(SourceInfo);
2847bool emitArrayElemPtrSint16(SourceInfo);
2848bool emitArrayElemPtrUint16(SourceInfo);
2849bool emitArrayElemPtrSint32(SourceInfo);
2850bool emitArrayElemPtrUint32(SourceInfo);
2851bool emitArrayElemPtrSint64(SourceInfo);
2852bool emitArrayElemPtrUint64(SourceInfo);
2853bool emitArrayElemPtrIntAP(SourceInfo);
2854bool emitArrayElemPtrIntAPS(SourceInfo);
2855bool emitArrayElemPtrBool(SourceInfo);
2856#endif
2857#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
2858[[nodiscard]] bool emitArrayElemPtr(PrimType, SourceInfo I);
2859#endif
2860#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
2861bool
2862#if defined(GET_EVAL_IMPL)
2863EvalEmitter
2864#else
2865ByteCodeEmitter
2866#endif
2867::emitArrayElemPtr(PrimType T0, SourceInfo I) {
2868 switch (T0) {
2869 case PT_Sint8:
2870 return emitArrayElemPtrSint8(I);
2871 case PT_Uint8:
2872 return emitArrayElemPtrUint8(I);
2873 case PT_Sint16:
2874 return emitArrayElemPtrSint16(I);
2875 case PT_Uint16:
2876 return emitArrayElemPtrUint16(I);
2877 case PT_Sint32:
2878 return emitArrayElemPtrSint32(I);
2879 case PT_Uint32:
2880 return emitArrayElemPtrUint32(I);
2881 case PT_Sint64:
2882 return emitArrayElemPtrSint64(I);
2883 case PT_Uint64:
2884 return emitArrayElemPtrUint64(I);
2885 case PT_IntAP:
2886 return emitArrayElemPtrIntAP(I);
2887 case PT_IntAPS:
2888 return emitArrayElemPtrIntAPS(I);
2889 case PT_Bool:
2890 return emitArrayElemPtrBool(I);
2891 default: llvm_unreachable("invalid type: emitArrayElemPtr");
2892 }
2893 llvm_unreachable("invalid enum value");
2894}
2895#endif
2896#ifdef GET_LINK_IMPL
2897bool ByteCodeEmitter::emitArrayElemPtrSint8(SourceInfo L) {
2898 return emitOp<>(OP_ArrayElemPtrSint8, L);
2899}
2900bool ByteCodeEmitter::emitArrayElemPtrUint8(SourceInfo L) {
2901 return emitOp<>(OP_ArrayElemPtrUint8, L);
2902}
2903bool ByteCodeEmitter::emitArrayElemPtrSint16(SourceInfo L) {
2904 return emitOp<>(OP_ArrayElemPtrSint16, L);
2905}
2906bool ByteCodeEmitter::emitArrayElemPtrUint16(SourceInfo L) {
2907 return emitOp<>(OP_ArrayElemPtrUint16, L);
2908}
2909bool ByteCodeEmitter::emitArrayElemPtrSint32(SourceInfo L) {
2910 return emitOp<>(OP_ArrayElemPtrSint32, L);
2911}
2912bool ByteCodeEmitter::emitArrayElemPtrUint32(SourceInfo L) {
2913 return emitOp<>(OP_ArrayElemPtrUint32, L);
2914}
2915bool ByteCodeEmitter::emitArrayElemPtrSint64(SourceInfo L) {
2916 return emitOp<>(OP_ArrayElemPtrSint64, L);
2917}
2918bool ByteCodeEmitter::emitArrayElemPtrUint64(SourceInfo L) {
2919 return emitOp<>(OP_ArrayElemPtrUint64, L);
2920}
2921bool ByteCodeEmitter::emitArrayElemPtrIntAP(SourceInfo L) {
2922 return emitOp<>(OP_ArrayElemPtrIntAP, L);
2923}
2924bool ByteCodeEmitter::emitArrayElemPtrIntAPS(SourceInfo L) {
2925 return emitOp<>(OP_ArrayElemPtrIntAPS, L);
2926}
2927bool ByteCodeEmitter::emitArrayElemPtrBool(SourceInfo L) {
2928 return emitOp<>(OP_ArrayElemPtrBool, L);
2929}
2930#endif
2931#ifdef GET_EVAL_IMPL
2932bool EvalEmitter::emitArrayElemPtrSint8(SourceInfo L) {
2933 if (!isActive()) return true;
2934 CurrentSource = L;
2935 return ArrayElemPtr<PT_Sint8>(S, CodePtr());
2936}
2937bool EvalEmitter::emitArrayElemPtrUint8(SourceInfo L) {
2938 if (!isActive()) return true;
2939 CurrentSource = L;
2940 return ArrayElemPtr<PT_Uint8>(S, CodePtr());
2941}
2942bool EvalEmitter::emitArrayElemPtrSint16(SourceInfo L) {
2943 if (!isActive()) return true;
2944 CurrentSource = L;
2945 return ArrayElemPtr<PT_Sint16>(S, CodePtr());
2946}
2947bool EvalEmitter::emitArrayElemPtrUint16(SourceInfo L) {
2948 if (!isActive()) return true;
2949 CurrentSource = L;
2950 return ArrayElemPtr<PT_Uint16>(S, CodePtr());
2951}
2952bool EvalEmitter::emitArrayElemPtrSint32(SourceInfo L) {
2953 if (!isActive()) return true;
2954 CurrentSource = L;
2955 return ArrayElemPtr<PT_Sint32>(S, CodePtr());
2956}
2957bool EvalEmitter::emitArrayElemPtrUint32(SourceInfo L) {
2958 if (!isActive()) return true;
2959 CurrentSource = L;
2960 return ArrayElemPtr<PT_Uint32>(S, CodePtr());
2961}
2962bool EvalEmitter::emitArrayElemPtrSint64(SourceInfo L) {
2963 if (!isActive()) return true;
2964 CurrentSource = L;
2965 return ArrayElemPtr<PT_Sint64>(S, CodePtr());
2966}
2967bool EvalEmitter::emitArrayElemPtrUint64(SourceInfo L) {
2968 if (!isActive()) return true;
2969 CurrentSource = L;
2970 return ArrayElemPtr<PT_Uint64>(S, CodePtr());
2971}
2972bool EvalEmitter::emitArrayElemPtrIntAP(SourceInfo L) {
2973 if (!isActive()) return true;
2974 CurrentSource = L;
2975 return ArrayElemPtr<PT_IntAP>(S, CodePtr());
2976}
2977bool EvalEmitter::emitArrayElemPtrIntAPS(SourceInfo L) {
2978 if (!isActive()) return true;
2979 CurrentSource = L;
2980 return ArrayElemPtr<PT_IntAPS>(S, CodePtr());
2981}
2982bool EvalEmitter::emitArrayElemPtrBool(SourceInfo L) {
2983 if (!isActive()) return true;
2984 CurrentSource = L;
2985 return ArrayElemPtr<PT_Bool>(S, CodePtr());
2986}
2987#endif
2988#ifdef GET_OPCODE_NAMES
2989OP_ArrayElemPtrPopSint8,
2990OP_ArrayElemPtrPopUint8,
2991OP_ArrayElemPtrPopSint16,
2992OP_ArrayElemPtrPopUint16,
2993OP_ArrayElemPtrPopSint32,
2994OP_ArrayElemPtrPopUint32,
2995OP_ArrayElemPtrPopSint64,
2996OP_ArrayElemPtrPopUint64,
2997OP_ArrayElemPtrPopIntAP,
2998OP_ArrayElemPtrPopIntAPS,
2999OP_ArrayElemPtrPopBool,
3000#endif
3001#ifdef GET_INTERPFN_LIST
3002&Interp_ArrayElemPtrPopSint8,
3003&Interp_ArrayElemPtrPopUint8,
3004&Interp_ArrayElemPtrPopSint16,
3005&Interp_ArrayElemPtrPopUint16,
3006&Interp_ArrayElemPtrPopSint32,
3007&Interp_ArrayElemPtrPopUint32,
3008&Interp_ArrayElemPtrPopSint64,
3009&Interp_ArrayElemPtrPopUint64,
3010&Interp_ArrayElemPtrPopIntAP,
3011&Interp_ArrayElemPtrPopIntAPS,
3012&Interp_ArrayElemPtrPopBool,
3013#endif
3014#ifdef GET_INTERPFN_DISPATCHERS
3015PRESERVE_NONE
3016static bool Interp_ArrayElemPtrPopSint8(InterpState &S) {
3017 if (!ArrayElemPtrPop<PT_Sint8>(S, S.PC)) return false;
3018#if USE_TAILCALLS
3019 MUSTTAIL return InterpNext(S);
3020#else
3021 return true;
3022#endif
3023}
3024PRESERVE_NONE
3025static bool Interp_ArrayElemPtrPopUint8(InterpState &S) {
3026 if (!ArrayElemPtrPop<PT_Uint8>(S, S.PC)) return false;
3027#if USE_TAILCALLS
3028 MUSTTAIL return InterpNext(S);
3029#else
3030 return true;
3031#endif
3032}
3033PRESERVE_NONE
3034static bool Interp_ArrayElemPtrPopSint16(InterpState &S) {
3035 if (!ArrayElemPtrPop<PT_Sint16>(S, S.PC)) return false;
3036#if USE_TAILCALLS
3037 MUSTTAIL return InterpNext(S);
3038#else
3039 return true;
3040#endif
3041}
3042PRESERVE_NONE
3043static bool Interp_ArrayElemPtrPopUint16(InterpState &S) {
3044 if (!ArrayElemPtrPop<PT_Uint16>(S, S.PC)) return false;
3045#if USE_TAILCALLS
3046 MUSTTAIL return InterpNext(S);
3047#else
3048 return true;
3049#endif
3050}
3051PRESERVE_NONE
3052static bool Interp_ArrayElemPtrPopSint32(InterpState &S) {
3053 if (!ArrayElemPtrPop<PT_Sint32>(S, S.PC)) return false;
3054#if USE_TAILCALLS
3055 MUSTTAIL return InterpNext(S);
3056#else
3057 return true;
3058#endif
3059}
3060PRESERVE_NONE
3061static bool Interp_ArrayElemPtrPopUint32(InterpState &S) {
3062 if (!ArrayElemPtrPop<PT_Uint32>(S, S.PC)) return false;
3063#if USE_TAILCALLS
3064 MUSTTAIL return InterpNext(S);
3065#else
3066 return true;
3067#endif
3068}
3069PRESERVE_NONE
3070static bool Interp_ArrayElemPtrPopSint64(InterpState &S) {
3071 if (!ArrayElemPtrPop<PT_Sint64>(S, S.PC)) return false;
3072#if USE_TAILCALLS
3073 MUSTTAIL return InterpNext(S);
3074#else
3075 return true;
3076#endif
3077}
3078PRESERVE_NONE
3079static bool Interp_ArrayElemPtrPopUint64(InterpState &S) {
3080 if (!ArrayElemPtrPop<PT_Uint64>(S, S.PC)) return false;
3081#if USE_TAILCALLS
3082 MUSTTAIL return InterpNext(S);
3083#else
3084 return true;
3085#endif
3086}
3087PRESERVE_NONE
3088static bool Interp_ArrayElemPtrPopIntAP(InterpState &S) {
3089 if (!ArrayElemPtrPop<PT_IntAP>(S, S.PC)) return false;
3090#if USE_TAILCALLS
3091 MUSTTAIL return InterpNext(S);
3092#else
3093 return true;
3094#endif
3095}
3096PRESERVE_NONE
3097static bool Interp_ArrayElemPtrPopIntAPS(InterpState &S) {
3098 if (!ArrayElemPtrPop<PT_IntAPS>(S, S.PC)) return false;
3099#if USE_TAILCALLS
3100 MUSTTAIL return InterpNext(S);
3101#else
3102 return true;
3103#endif
3104}
3105PRESERVE_NONE
3106static bool Interp_ArrayElemPtrPopBool(InterpState &S) {
3107 if (!ArrayElemPtrPop<PT_Bool>(S, S.PC)) return false;
3108#if USE_TAILCALLS
3109 MUSTTAIL return InterpNext(S);
3110#else
3111 return true;
3112#endif
3113}
3114#endif
3115#ifdef GET_DISASM
3116case OP_ArrayElemPtrPopSint8:
3117 Text.Op = PrintName("ArrayElemPtrPopSint8");
3118 break;
3119case OP_ArrayElemPtrPopUint8:
3120 Text.Op = PrintName("ArrayElemPtrPopUint8");
3121 break;
3122case OP_ArrayElemPtrPopSint16:
3123 Text.Op = PrintName("ArrayElemPtrPopSint16");
3124 break;
3125case OP_ArrayElemPtrPopUint16:
3126 Text.Op = PrintName("ArrayElemPtrPopUint16");
3127 break;
3128case OP_ArrayElemPtrPopSint32:
3129 Text.Op = PrintName("ArrayElemPtrPopSint32");
3130 break;
3131case OP_ArrayElemPtrPopUint32:
3132 Text.Op = PrintName("ArrayElemPtrPopUint32");
3133 break;
3134case OP_ArrayElemPtrPopSint64:
3135 Text.Op = PrintName("ArrayElemPtrPopSint64");
3136 break;
3137case OP_ArrayElemPtrPopUint64:
3138 Text.Op = PrintName("ArrayElemPtrPopUint64");
3139 break;
3140case OP_ArrayElemPtrPopIntAP:
3141 Text.Op = PrintName("ArrayElemPtrPopIntAP");
3142 break;
3143case OP_ArrayElemPtrPopIntAPS:
3144 Text.Op = PrintName("ArrayElemPtrPopIntAPS");
3145 break;
3146case OP_ArrayElemPtrPopBool:
3147 Text.Op = PrintName("ArrayElemPtrPopBool");
3148 break;
3149#endif
3150#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3151bool emitArrayElemPtrPopSint8(SourceInfo);
3152bool emitArrayElemPtrPopUint8(SourceInfo);
3153bool emitArrayElemPtrPopSint16(SourceInfo);
3154bool emitArrayElemPtrPopUint16(SourceInfo);
3155bool emitArrayElemPtrPopSint32(SourceInfo);
3156bool emitArrayElemPtrPopUint32(SourceInfo);
3157bool emitArrayElemPtrPopSint64(SourceInfo);
3158bool emitArrayElemPtrPopUint64(SourceInfo);
3159bool emitArrayElemPtrPopIntAP(SourceInfo);
3160bool emitArrayElemPtrPopIntAPS(SourceInfo);
3161bool emitArrayElemPtrPopBool(SourceInfo);
3162#endif
3163#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3164[[nodiscard]] bool emitArrayElemPtrPop(PrimType, SourceInfo I);
3165#endif
3166#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
3167bool
3168#if defined(GET_EVAL_IMPL)
3169EvalEmitter
3170#else
3171ByteCodeEmitter
3172#endif
3173::emitArrayElemPtrPop(PrimType T0, SourceInfo I) {
3174 switch (T0) {
3175 case PT_Sint8:
3176 return emitArrayElemPtrPopSint8(I);
3177 case PT_Uint8:
3178 return emitArrayElemPtrPopUint8(I);
3179 case PT_Sint16:
3180 return emitArrayElemPtrPopSint16(I);
3181 case PT_Uint16:
3182 return emitArrayElemPtrPopUint16(I);
3183 case PT_Sint32:
3184 return emitArrayElemPtrPopSint32(I);
3185 case PT_Uint32:
3186 return emitArrayElemPtrPopUint32(I);
3187 case PT_Sint64:
3188 return emitArrayElemPtrPopSint64(I);
3189 case PT_Uint64:
3190 return emitArrayElemPtrPopUint64(I);
3191 case PT_IntAP:
3192 return emitArrayElemPtrPopIntAP(I);
3193 case PT_IntAPS:
3194 return emitArrayElemPtrPopIntAPS(I);
3195 case PT_Bool:
3196 return emitArrayElemPtrPopBool(I);
3197 default: llvm_unreachable("invalid type: emitArrayElemPtrPop");
3198 }
3199 llvm_unreachable("invalid enum value");
3200}
3201#endif
3202#ifdef GET_LINK_IMPL
3203bool ByteCodeEmitter::emitArrayElemPtrPopSint8(SourceInfo L) {
3204 return emitOp<>(OP_ArrayElemPtrPopSint8, L);
3205}
3206bool ByteCodeEmitter::emitArrayElemPtrPopUint8(SourceInfo L) {
3207 return emitOp<>(OP_ArrayElemPtrPopUint8, L);
3208}
3209bool ByteCodeEmitter::emitArrayElemPtrPopSint16(SourceInfo L) {
3210 return emitOp<>(OP_ArrayElemPtrPopSint16, L);
3211}
3212bool ByteCodeEmitter::emitArrayElemPtrPopUint16(SourceInfo L) {
3213 return emitOp<>(OP_ArrayElemPtrPopUint16, L);
3214}
3215bool ByteCodeEmitter::emitArrayElemPtrPopSint32(SourceInfo L) {
3216 return emitOp<>(OP_ArrayElemPtrPopSint32, L);
3217}
3218bool ByteCodeEmitter::emitArrayElemPtrPopUint32(SourceInfo L) {
3219 return emitOp<>(OP_ArrayElemPtrPopUint32, L);
3220}
3221bool ByteCodeEmitter::emitArrayElemPtrPopSint64(SourceInfo L) {
3222 return emitOp<>(OP_ArrayElemPtrPopSint64, L);
3223}
3224bool ByteCodeEmitter::emitArrayElemPtrPopUint64(SourceInfo L) {
3225 return emitOp<>(OP_ArrayElemPtrPopUint64, L);
3226}
3227bool ByteCodeEmitter::emitArrayElemPtrPopIntAP(SourceInfo L) {
3228 return emitOp<>(OP_ArrayElemPtrPopIntAP, L);
3229}
3230bool ByteCodeEmitter::emitArrayElemPtrPopIntAPS(SourceInfo L) {
3231 return emitOp<>(OP_ArrayElemPtrPopIntAPS, L);
3232}
3233bool ByteCodeEmitter::emitArrayElemPtrPopBool(SourceInfo L) {
3234 return emitOp<>(OP_ArrayElemPtrPopBool, L);
3235}
3236#endif
3237#ifdef GET_EVAL_IMPL
3238bool EvalEmitter::emitArrayElemPtrPopSint8(SourceInfo L) {
3239 if (!isActive()) return true;
3240 CurrentSource = L;
3241 return ArrayElemPtrPop<PT_Sint8>(S, CodePtr());
3242}
3243bool EvalEmitter::emitArrayElemPtrPopUint8(SourceInfo L) {
3244 if (!isActive()) return true;
3245 CurrentSource = L;
3246 return ArrayElemPtrPop<PT_Uint8>(S, CodePtr());
3247}
3248bool EvalEmitter::emitArrayElemPtrPopSint16(SourceInfo L) {
3249 if (!isActive()) return true;
3250 CurrentSource = L;
3251 return ArrayElemPtrPop<PT_Sint16>(S, CodePtr());
3252}
3253bool EvalEmitter::emitArrayElemPtrPopUint16(SourceInfo L) {
3254 if (!isActive()) return true;
3255 CurrentSource = L;
3256 return ArrayElemPtrPop<PT_Uint16>(S, CodePtr());
3257}
3258bool EvalEmitter::emitArrayElemPtrPopSint32(SourceInfo L) {
3259 if (!isActive()) return true;
3260 CurrentSource = L;
3261 return ArrayElemPtrPop<PT_Sint32>(S, CodePtr());
3262}
3263bool EvalEmitter::emitArrayElemPtrPopUint32(SourceInfo L) {
3264 if (!isActive()) return true;
3265 CurrentSource = L;
3266 return ArrayElemPtrPop<PT_Uint32>(S, CodePtr());
3267}
3268bool EvalEmitter::emitArrayElemPtrPopSint64(SourceInfo L) {
3269 if (!isActive()) return true;
3270 CurrentSource = L;
3271 return ArrayElemPtrPop<PT_Sint64>(S, CodePtr());
3272}
3273bool EvalEmitter::emitArrayElemPtrPopUint64(SourceInfo L) {
3274 if (!isActive()) return true;
3275 CurrentSource = L;
3276 return ArrayElemPtrPop<PT_Uint64>(S, CodePtr());
3277}
3278bool EvalEmitter::emitArrayElemPtrPopIntAP(SourceInfo L) {
3279 if (!isActive()) return true;
3280 CurrentSource = L;
3281 return ArrayElemPtrPop<PT_IntAP>(S, CodePtr());
3282}
3283bool EvalEmitter::emitArrayElemPtrPopIntAPS(SourceInfo L) {
3284 if (!isActive()) return true;
3285 CurrentSource = L;
3286 return ArrayElemPtrPop<PT_IntAPS>(S, CodePtr());
3287}
3288bool EvalEmitter::emitArrayElemPtrPopBool(SourceInfo L) {
3289 if (!isActive()) return true;
3290 CurrentSource = L;
3291 return ArrayElemPtrPop<PT_Bool>(S, CodePtr());
3292}
3293#endif
3294#ifdef GET_OPCODE_NAMES
3295OP_Assume,
3296#endif
3297#ifdef GET_INTERPFN_LIST
3298&Interp_Assume,
3299#endif
3300#ifdef GET_INTERPFN_DISPATCHERS
3301PRESERVE_NONE
3302static bool Interp_Assume(InterpState &S) {
3303 if (!Assume(S, S.PC)) return false;
3304#if USE_TAILCALLS
3305 MUSTTAIL return InterpNext(S);
3306#else
3307 return true;
3308#endif
3309}
3310#endif
3311#ifdef GET_DISASM
3312case OP_Assume:
3313 Text.Op = PrintName("Assume");
3314 break;
3315#endif
3316#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3317bool emitAssume(SourceInfo);
3318#endif
3319#ifdef GET_LINK_IMPL
3320bool ByteCodeEmitter::emitAssume(SourceInfo L) {
3321 return emitOp<>(OP_Assume, L);
3322}
3323#endif
3324#ifdef GET_EVAL_IMPL
3325bool EvalEmitter::emitAssume(SourceInfo L) {
3326 if (!isActive()) return true;
3327 CurrentSource = L;
3328 return Assume(S, CodePtr());
3329}
3330#endif
3331#ifdef GET_OPCODE_NAMES
3332OP_BCP,
3333#endif
3334#ifdef GET_INTERPFN_LIST
3335&Interp_BCP,
3336#endif
3337#ifdef GET_INTERPFN_DISPATCHERS
3338PRESERVE_NONE
3339static bool Interp_BCP(InterpState &S) {
3340 {
3341 CodePtr OpPC = S.PC;
3342 const auto V0 = ReadArg<int32_t>(S, S.PC);
3343 const auto V1 = ReadArg<PrimType>(S, S.PC);
3344 if (!BCP(S, OpPC, V0, V1)) return false;
3345 }
3346#if USE_TAILCALLS
3347 MUSTTAIL return InterpNext(S);
3348#else
3349 return true;
3350#endif
3351}
3352#endif
3353#ifdef GET_DISASM
3354case OP_BCP:
3355 Text.Op = PrintName("BCP");
3356 Text.Args.push_back(printArg<int32_t>(PC));
3357 Text.Args.push_back(printArg<PrimType>(PC));
3358 break;
3359#endif
3360#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3361bool emitBCP( int32_t , PrimType , SourceInfo);
3362#endif
3363#ifdef GET_LINK_IMPL
3364bool ByteCodeEmitter::emitBCP( int32_t A0, PrimType A1, SourceInfo L) {
3365 return emitOp<int32_t, PrimType>(OP_BCP, A0, A1, L);
3366}
3367#endif
3368#ifdef GET_OPCODE_NAMES
3369OP_BitAndSint8,
3370OP_BitAndUint8,
3371OP_BitAndSint16,
3372OP_BitAndUint16,
3373OP_BitAndSint32,
3374OP_BitAndUint32,
3375OP_BitAndSint64,
3376OP_BitAndUint64,
3377OP_BitAndIntAP,
3378OP_BitAndIntAPS,
3379OP_BitAndFixedPoint,
3380#endif
3381#ifdef GET_INTERPFN_LIST
3382&Interp_BitAndSint8,
3383&Interp_BitAndUint8,
3384&Interp_BitAndSint16,
3385&Interp_BitAndUint16,
3386&Interp_BitAndSint32,
3387&Interp_BitAndUint32,
3388&Interp_BitAndSint64,
3389&Interp_BitAndUint64,
3390&Interp_BitAndIntAP,
3391&Interp_BitAndIntAPS,
3392&Interp_BitAndFixedPoint,
3393#endif
3394#ifdef GET_INTERPFN_DISPATCHERS
3395PRESERVE_NONE
3396static bool Interp_BitAndSint8(InterpState &S) {
3397 if (!BitAnd<PT_Sint8>(S)) return false;
3398#if USE_TAILCALLS
3399 MUSTTAIL return InterpNext(S);
3400#else
3401 return true;
3402#endif
3403}
3404PRESERVE_NONE
3405static bool Interp_BitAndUint8(InterpState &S) {
3406 if (!BitAnd<PT_Uint8>(S)) return false;
3407#if USE_TAILCALLS
3408 MUSTTAIL return InterpNext(S);
3409#else
3410 return true;
3411#endif
3412}
3413PRESERVE_NONE
3414static bool Interp_BitAndSint16(InterpState &S) {
3415 if (!BitAnd<PT_Sint16>(S)) return false;
3416#if USE_TAILCALLS
3417 MUSTTAIL return InterpNext(S);
3418#else
3419 return true;
3420#endif
3421}
3422PRESERVE_NONE
3423static bool Interp_BitAndUint16(InterpState &S) {
3424 if (!BitAnd<PT_Uint16>(S)) return false;
3425#if USE_TAILCALLS
3426 MUSTTAIL return InterpNext(S);
3427#else
3428 return true;
3429#endif
3430}
3431PRESERVE_NONE
3432static bool Interp_BitAndSint32(InterpState &S) {
3433 if (!BitAnd<PT_Sint32>(S)) return false;
3434#if USE_TAILCALLS
3435 MUSTTAIL return InterpNext(S);
3436#else
3437 return true;
3438#endif
3439}
3440PRESERVE_NONE
3441static bool Interp_BitAndUint32(InterpState &S) {
3442 if (!BitAnd<PT_Uint32>(S)) return false;
3443#if USE_TAILCALLS
3444 MUSTTAIL return InterpNext(S);
3445#else
3446 return true;
3447#endif
3448}
3449PRESERVE_NONE
3450static bool Interp_BitAndSint64(InterpState &S) {
3451 if (!BitAnd<PT_Sint64>(S)) return false;
3452#if USE_TAILCALLS
3453 MUSTTAIL return InterpNext(S);
3454#else
3455 return true;
3456#endif
3457}
3458PRESERVE_NONE
3459static bool Interp_BitAndUint64(InterpState &S) {
3460 if (!BitAnd<PT_Uint64>(S)) return false;
3461#if USE_TAILCALLS
3462 MUSTTAIL return InterpNext(S);
3463#else
3464 return true;
3465#endif
3466}
3467PRESERVE_NONE
3468static bool Interp_BitAndIntAP(InterpState &S) {
3469 if (!BitAnd<PT_IntAP>(S)) return false;
3470#if USE_TAILCALLS
3471 MUSTTAIL return InterpNext(S);
3472#else
3473 return true;
3474#endif
3475}
3476PRESERVE_NONE
3477static bool Interp_BitAndIntAPS(InterpState &S) {
3478 if (!BitAnd<PT_IntAPS>(S)) return false;
3479#if USE_TAILCALLS
3480 MUSTTAIL return InterpNext(S);
3481#else
3482 return true;
3483#endif
3484}
3485PRESERVE_NONE
3486static bool Interp_BitAndFixedPoint(InterpState &S) {
3487 if (!BitAnd<PT_FixedPoint>(S)) return false;
3488#if USE_TAILCALLS
3489 MUSTTAIL return InterpNext(S);
3490#else
3491 return true;
3492#endif
3493}
3494#endif
3495#ifdef GET_DISASM
3496case OP_BitAndSint8:
3497 Text.Op = PrintName("BitAndSint8");
3498 break;
3499case OP_BitAndUint8:
3500 Text.Op = PrintName("BitAndUint8");
3501 break;
3502case OP_BitAndSint16:
3503 Text.Op = PrintName("BitAndSint16");
3504 break;
3505case OP_BitAndUint16:
3506 Text.Op = PrintName("BitAndUint16");
3507 break;
3508case OP_BitAndSint32:
3509 Text.Op = PrintName("BitAndSint32");
3510 break;
3511case OP_BitAndUint32:
3512 Text.Op = PrintName("BitAndUint32");
3513 break;
3514case OP_BitAndSint64:
3515 Text.Op = PrintName("BitAndSint64");
3516 break;
3517case OP_BitAndUint64:
3518 Text.Op = PrintName("BitAndUint64");
3519 break;
3520case OP_BitAndIntAP:
3521 Text.Op = PrintName("BitAndIntAP");
3522 break;
3523case OP_BitAndIntAPS:
3524 Text.Op = PrintName("BitAndIntAPS");
3525 break;
3526case OP_BitAndFixedPoint:
3527 Text.Op = PrintName("BitAndFixedPoint");
3528 break;
3529#endif
3530#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3531bool emitBitAndSint8(SourceInfo);
3532bool emitBitAndUint8(SourceInfo);
3533bool emitBitAndSint16(SourceInfo);
3534bool emitBitAndUint16(SourceInfo);
3535bool emitBitAndSint32(SourceInfo);
3536bool emitBitAndUint32(SourceInfo);
3537bool emitBitAndSint64(SourceInfo);
3538bool emitBitAndUint64(SourceInfo);
3539bool emitBitAndIntAP(SourceInfo);
3540bool emitBitAndIntAPS(SourceInfo);
3541bool emitBitAndFixedPoint(SourceInfo);
3542#endif
3543#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3544[[nodiscard]] bool emitBitAnd(PrimType, SourceInfo I);
3545#endif
3546#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
3547bool
3548#if defined(GET_EVAL_IMPL)
3549EvalEmitter
3550#else
3551ByteCodeEmitter
3552#endif
3553::emitBitAnd(PrimType T0, SourceInfo I) {
3554 switch (T0) {
3555 case PT_Sint8:
3556 return emitBitAndSint8(I);
3557 case PT_Uint8:
3558 return emitBitAndUint8(I);
3559 case PT_Sint16:
3560 return emitBitAndSint16(I);
3561 case PT_Uint16:
3562 return emitBitAndUint16(I);
3563 case PT_Sint32:
3564 return emitBitAndSint32(I);
3565 case PT_Uint32:
3566 return emitBitAndUint32(I);
3567 case PT_Sint64:
3568 return emitBitAndSint64(I);
3569 case PT_Uint64:
3570 return emitBitAndUint64(I);
3571 case PT_IntAP:
3572 return emitBitAndIntAP(I);
3573 case PT_IntAPS:
3574 return emitBitAndIntAPS(I);
3575 case PT_FixedPoint:
3576 return emitBitAndFixedPoint(I);
3577 default: llvm_unreachable("invalid type: emitBitAnd");
3578 }
3579 llvm_unreachable("invalid enum value");
3580}
3581#endif
3582#ifdef GET_LINK_IMPL
3583bool ByteCodeEmitter::emitBitAndSint8(SourceInfo L) {
3584 return emitOp<>(OP_BitAndSint8, L);
3585}
3586bool ByteCodeEmitter::emitBitAndUint8(SourceInfo L) {
3587 return emitOp<>(OP_BitAndUint8, L);
3588}
3589bool ByteCodeEmitter::emitBitAndSint16(SourceInfo L) {
3590 return emitOp<>(OP_BitAndSint16, L);
3591}
3592bool ByteCodeEmitter::emitBitAndUint16(SourceInfo L) {
3593 return emitOp<>(OP_BitAndUint16, L);
3594}
3595bool ByteCodeEmitter::emitBitAndSint32(SourceInfo L) {
3596 return emitOp<>(OP_BitAndSint32, L);
3597}
3598bool ByteCodeEmitter::emitBitAndUint32(SourceInfo L) {
3599 return emitOp<>(OP_BitAndUint32, L);
3600}
3601bool ByteCodeEmitter::emitBitAndSint64(SourceInfo L) {
3602 return emitOp<>(OP_BitAndSint64, L);
3603}
3604bool ByteCodeEmitter::emitBitAndUint64(SourceInfo L) {
3605 return emitOp<>(OP_BitAndUint64, L);
3606}
3607bool ByteCodeEmitter::emitBitAndIntAP(SourceInfo L) {
3608 return emitOp<>(OP_BitAndIntAP, L);
3609}
3610bool ByteCodeEmitter::emitBitAndIntAPS(SourceInfo L) {
3611 return emitOp<>(OP_BitAndIntAPS, L);
3612}
3613bool ByteCodeEmitter::emitBitAndFixedPoint(SourceInfo L) {
3614 return emitOp<>(OP_BitAndFixedPoint, L);
3615}
3616#endif
3617#ifdef GET_EVAL_IMPL
3618bool EvalEmitter::emitBitAndSint8(SourceInfo L) {
3619 if (!isActive()) return true;
3620 CurrentSource = L;
3621 return BitAnd<PT_Sint8>(S);
3622}
3623bool EvalEmitter::emitBitAndUint8(SourceInfo L) {
3624 if (!isActive()) return true;
3625 CurrentSource = L;
3626 return BitAnd<PT_Uint8>(S);
3627}
3628bool EvalEmitter::emitBitAndSint16(SourceInfo L) {
3629 if (!isActive()) return true;
3630 CurrentSource = L;
3631 return BitAnd<PT_Sint16>(S);
3632}
3633bool EvalEmitter::emitBitAndUint16(SourceInfo L) {
3634 if (!isActive()) return true;
3635 CurrentSource = L;
3636 return BitAnd<PT_Uint16>(S);
3637}
3638bool EvalEmitter::emitBitAndSint32(SourceInfo L) {
3639 if (!isActive()) return true;
3640 CurrentSource = L;
3641 return BitAnd<PT_Sint32>(S);
3642}
3643bool EvalEmitter::emitBitAndUint32(SourceInfo L) {
3644 if (!isActive()) return true;
3645 CurrentSource = L;
3646 return BitAnd<PT_Uint32>(S);
3647}
3648bool EvalEmitter::emitBitAndSint64(SourceInfo L) {
3649 if (!isActive()) return true;
3650 CurrentSource = L;
3651 return BitAnd<PT_Sint64>(S);
3652}
3653bool EvalEmitter::emitBitAndUint64(SourceInfo L) {
3654 if (!isActive()) return true;
3655 CurrentSource = L;
3656 return BitAnd<PT_Uint64>(S);
3657}
3658bool EvalEmitter::emitBitAndIntAP(SourceInfo L) {
3659 if (!isActive()) return true;
3660 CurrentSource = L;
3661 return BitAnd<PT_IntAP>(S);
3662}
3663bool EvalEmitter::emitBitAndIntAPS(SourceInfo L) {
3664 if (!isActive()) return true;
3665 CurrentSource = L;
3666 return BitAnd<PT_IntAPS>(S);
3667}
3668bool EvalEmitter::emitBitAndFixedPoint(SourceInfo L) {
3669 if (!isActive()) return true;
3670 CurrentSource = L;
3671 return BitAnd<PT_FixedPoint>(S);
3672}
3673#endif
3674#ifdef GET_OPCODE_NAMES
3675OP_BitCast,
3676#endif
3677#ifdef GET_INTERPFN_LIST
3678&Interp_BitCast,
3679#endif
3680#ifdef GET_INTERPFN_DISPATCHERS
3681PRESERVE_NONE
3682static bool Interp_BitCast(InterpState &S) {
3683 if (!BitCast(S, S.PC)) return false;
3684#if USE_TAILCALLS
3685 MUSTTAIL return InterpNext(S);
3686#else
3687 return true;
3688#endif
3689}
3690#endif
3691#ifdef GET_DISASM
3692case OP_BitCast:
3693 Text.Op = PrintName("BitCast");
3694 break;
3695#endif
3696#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
3697bool emitBitCast(SourceInfo);
3698#endif
3699#ifdef GET_LINK_IMPL
3700bool ByteCodeEmitter::emitBitCast(SourceInfo L) {
3701 return emitOp<>(OP_BitCast, L);
3702}
3703#endif
3704#ifdef GET_EVAL_IMPL
3705bool EvalEmitter::emitBitCast(SourceInfo L) {
3706 if (!isActive()) return true;
3707 CurrentSource = L;
3708 return BitCast(S, CodePtr());
3709}
3710#endif
3711#ifdef GET_OPCODE_NAMES
3712OP_BitCastPrimUint8,
3713OP_BitCastPrimSint8,
3714OP_BitCastPrimUint16,
3715OP_BitCastPrimSint16,
3716OP_BitCastPrimUint32,
3717OP_BitCastPrimSint32,
3718OP_BitCastPrimUint64,
3719OP_BitCastPrimSint64,
3720OP_BitCastPrimIntAP,
3721OP_BitCastPrimIntAPS,
3722OP_BitCastPrimBool,
3723OP_BitCastPrimFloat,
3724OP_BitCastPrimPtr,
3725OP_BitCastPrimMemberPtr,
3726#endif
3727#ifdef GET_INTERPFN_LIST
3728&Interp_BitCastPrimUint8,
3729&Interp_BitCastPrimSint8,
3730&Interp_BitCastPrimUint16,
3731&Interp_BitCastPrimSint16,
3732&Interp_BitCastPrimUint32,
3733&Interp_BitCastPrimSint32,
3734&Interp_BitCastPrimUint64,
3735&Interp_BitCastPrimSint64,
3736&Interp_BitCastPrimIntAP,
3737&Interp_BitCastPrimIntAPS,
3738&Interp_BitCastPrimBool,
3739&Interp_BitCastPrimFloat,
3740&Interp_BitCastPrimPtr,
3741&Interp_BitCastPrimMemberPtr,
3742#endif
3743#ifdef GET_INTERPFN_DISPATCHERS
3744PRESERVE_NONE
3745static bool Interp_BitCastPrimUint8(InterpState &S) {
3746 {
3747 CodePtr OpPC = S.PC;
3748 const auto V0 = ReadArg<bool>(S, S.PC);
3749 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3750 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3751 const auto V3 = ReadArg<const Type *>(S, S.PC);
3752 if (!BitCastPrim<PT_Uint8>(S, OpPC, V0, V1, V2, V3)) return false;
3753 }
3754#if USE_TAILCALLS
3755 MUSTTAIL return InterpNext(S);
3756#else
3757 return true;
3758#endif
3759}
3760PRESERVE_NONE
3761static bool Interp_BitCastPrimSint8(InterpState &S) {
3762 {
3763 CodePtr OpPC = S.PC;
3764 const auto V0 = ReadArg<bool>(S, S.PC);
3765 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3766 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3767 const auto V3 = ReadArg<const Type *>(S, S.PC);
3768 if (!BitCastPrim<PT_Sint8>(S, OpPC, V0, V1, V2, V3)) return false;
3769 }
3770#if USE_TAILCALLS
3771 MUSTTAIL return InterpNext(S);
3772#else
3773 return true;
3774#endif
3775}
3776PRESERVE_NONE
3777static bool Interp_BitCastPrimUint16(InterpState &S) {
3778 {
3779 CodePtr OpPC = S.PC;
3780 const auto V0 = ReadArg<bool>(S, S.PC);
3781 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3782 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3783 const auto V3 = ReadArg<const Type *>(S, S.PC);
3784 if (!BitCastPrim<PT_Uint16>(S, OpPC, V0, V1, V2, V3)) return false;
3785 }
3786#if USE_TAILCALLS
3787 MUSTTAIL return InterpNext(S);
3788#else
3789 return true;
3790#endif
3791}
3792PRESERVE_NONE
3793static bool Interp_BitCastPrimSint16(InterpState &S) {
3794 {
3795 CodePtr OpPC = S.PC;
3796 const auto V0 = ReadArg<bool>(S, S.PC);
3797 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3798 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3799 const auto V3 = ReadArg<const Type *>(S, S.PC);
3800 if (!BitCastPrim<PT_Sint16>(S, OpPC, V0, V1, V2, V3)) return false;
3801 }
3802#if USE_TAILCALLS
3803 MUSTTAIL return InterpNext(S);
3804#else
3805 return true;
3806#endif
3807}
3808PRESERVE_NONE
3809static bool Interp_BitCastPrimUint32(InterpState &S) {
3810 {
3811 CodePtr OpPC = S.PC;
3812 const auto V0 = ReadArg<bool>(S, S.PC);
3813 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3814 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3815 const auto V3 = ReadArg<const Type *>(S, S.PC);
3816 if (!BitCastPrim<PT_Uint32>(S, OpPC, V0, V1, V2, V3)) return false;
3817 }
3818#if USE_TAILCALLS
3819 MUSTTAIL return InterpNext(S);
3820#else
3821 return true;
3822#endif
3823}
3824PRESERVE_NONE
3825static bool Interp_BitCastPrimSint32(InterpState &S) {
3826 {
3827 CodePtr OpPC = S.PC;
3828 const auto V0 = ReadArg<bool>(S, S.PC);
3829 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3830 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3831 const auto V3 = ReadArg<const Type *>(S, S.PC);
3832 if (!BitCastPrim<PT_Sint32>(S, OpPC, V0, V1, V2, V3)) return false;
3833 }
3834#if USE_TAILCALLS
3835 MUSTTAIL return InterpNext(S);
3836#else
3837 return true;
3838#endif
3839}
3840PRESERVE_NONE
3841static bool Interp_BitCastPrimUint64(InterpState &S) {
3842 {
3843 CodePtr OpPC = S.PC;
3844 const auto V0 = ReadArg<bool>(S, S.PC);
3845 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3846 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3847 const auto V3 = ReadArg<const Type *>(S, S.PC);
3848 if (!BitCastPrim<PT_Uint64>(S, OpPC, V0, V1, V2, V3)) return false;
3849 }
3850#if USE_TAILCALLS
3851 MUSTTAIL return InterpNext(S);
3852#else
3853 return true;
3854#endif
3855}
3856PRESERVE_NONE
3857static bool Interp_BitCastPrimSint64(InterpState &S) {
3858 {
3859 CodePtr OpPC = S.PC;
3860 const auto V0 = ReadArg<bool>(S, S.PC);
3861 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3862 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3863 const auto V3 = ReadArg<const Type *>(S, S.PC);
3864 if (!BitCastPrim<PT_Sint64>(S, OpPC, V0, V1, V2, V3)) return false;
3865 }
3866#if USE_TAILCALLS
3867 MUSTTAIL return InterpNext(S);
3868#else
3869 return true;
3870#endif
3871}
3872PRESERVE_NONE
3873static bool Interp_BitCastPrimIntAP(InterpState &S) {
3874 {
3875 CodePtr OpPC = S.PC;
3876 const auto V0 = ReadArg<bool>(S, S.PC);
3877 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3878 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3879 const auto V3 = ReadArg<const Type *>(S, S.PC);
3880 if (!BitCastPrim<PT_IntAP>(S, OpPC, V0, V1, V2, V3)) return false;
3881 }
3882#if USE_TAILCALLS
3883 MUSTTAIL return InterpNext(S);
3884#else
3885 return true;
3886#endif
3887}
3888PRESERVE_NONE
3889static bool Interp_BitCastPrimIntAPS(InterpState &S) {
3890 {
3891 CodePtr OpPC = S.PC;
3892 const auto V0 = ReadArg<bool>(S, S.PC);
3893 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3894 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3895 const auto V3 = ReadArg<const Type *>(S, S.PC);
3896 if (!BitCastPrim<PT_IntAPS>(S, OpPC, V0, V1, V2, V3)) return false;
3897 }
3898#if USE_TAILCALLS
3899 MUSTTAIL return InterpNext(S);
3900#else
3901 return true;
3902#endif
3903}
3904PRESERVE_NONE
3905static bool Interp_BitCastPrimBool(InterpState &S) {
3906 {
3907 CodePtr OpPC = S.PC;
3908 const auto V0 = ReadArg<bool>(S, S.PC);
3909 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3910 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3911 const auto V3 = ReadArg<const Type *>(S, S.PC);
3912 if (!BitCastPrim<PT_Bool>(S, OpPC, V0, V1, V2, V3)) return false;
3913 }
3914#if USE_TAILCALLS
3915 MUSTTAIL return InterpNext(S);
3916#else
3917 return true;
3918#endif
3919}
3920PRESERVE_NONE
3921static bool Interp_BitCastPrimFloat(InterpState &S) {
3922 {
3923 CodePtr OpPC = S.PC;
3924 const auto V0 = ReadArg<bool>(S, S.PC);
3925 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3926 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3927 const auto V3 = ReadArg<const Type *>(S, S.PC);
3928 if (!BitCastPrim<PT_Float>(S, OpPC, V0, V1, V2, V3)) return false;
3929 }
3930#if USE_TAILCALLS
3931 MUSTTAIL return InterpNext(S);
3932#else
3933 return true;
3934#endif
3935}
3936PRESERVE_NONE
3937static bool Interp_BitCastPrimPtr(InterpState &S) {
3938 {
3939 CodePtr OpPC = S.PC;
3940 const auto V0 = ReadArg<bool>(S, S.PC);
3941 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3942 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3943 const auto V3 = ReadArg<const Type *>(S, S.PC);
3944 if (!BitCastPrim<PT_Ptr>(S, OpPC, V0, V1, V2, V3)) return false;
3945 }
3946#if USE_TAILCALLS
3947 MUSTTAIL return InterpNext(S);
3948#else
3949 return true;
3950#endif
3951}
3952PRESERVE_NONE
3953static bool Interp_BitCastPrimMemberPtr(InterpState &S) {
3954 {
3955 CodePtr OpPC = S.PC;
3956 const auto V0 = ReadArg<bool>(S, S.PC);
3957 const auto V1 = ReadArg<uint32_t>(S, S.PC);
3958 const auto V2 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
3959 const auto V3 = ReadArg<const Type *>(S, S.PC);
3960 if (!BitCastPrim<PT_MemberPtr>(S, OpPC, V0, V1, V2, V3)) return false;
3961 }
3962#if USE_TAILCALLS
3963 MUSTTAIL return InterpNext(S);
3964#else
3965 return true;
3966#endif
3967}
3968#endif
3969#ifdef GET_DISASM
3970case OP_BitCastPrimUint8:
3971 Text.Op = PrintName("BitCastPrimUint8");
3972 Text.Args.push_back(printArg<bool>(PC));
3973 Text.Args.push_back(printArg<uint32_t>(PC));
3974 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
3975 Text.Args.push_back(printArg<const Type *>(PC));
3976 break;
3977case OP_BitCastPrimSint8:
3978 Text.Op = PrintName("BitCastPrimSint8");
3979 Text.Args.push_back(printArg<bool>(PC));
3980 Text.Args.push_back(printArg<uint32_t>(PC));
3981 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
3982 Text.Args.push_back(printArg<const Type *>(PC));
3983 break;
3984case OP_BitCastPrimUint16:
3985 Text.Op = PrintName("BitCastPrimUint16");
3986 Text.Args.push_back(printArg<bool>(PC));
3987 Text.Args.push_back(printArg<uint32_t>(PC));
3988 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
3989 Text.Args.push_back(printArg<const Type *>(PC));
3990 break;
3991case OP_BitCastPrimSint16:
3992 Text.Op = PrintName("BitCastPrimSint16");
3993 Text.Args.push_back(printArg<bool>(PC));
3994 Text.Args.push_back(printArg<uint32_t>(PC));
3995 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
3996 Text.Args.push_back(printArg<const Type *>(PC));
3997 break;
3998case OP_BitCastPrimUint32:
3999 Text.Op = PrintName("BitCastPrimUint32");
4000 Text.Args.push_back(printArg<bool>(PC));
4001 Text.Args.push_back(printArg<uint32_t>(PC));
4002 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4003 Text.Args.push_back(printArg<const Type *>(PC));
4004 break;
4005case OP_BitCastPrimSint32:
4006 Text.Op = PrintName("BitCastPrimSint32");
4007 Text.Args.push_back(printArg<bool>(PC));
4008 Text.Args.push_back(printArg<uint32_t>(PC));
4009 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4010 Text.Args.push_back(printArg<const Type *>(PC));
4011 break;
4012case OP_BitCastPrimUint64:
4013 Text.Op = PrintName("BitCastPrimUint64");
4014 Text.Args.push_back(printArg<bool>(PC));
4015 Text.Args.push_back(printArg<uint32_t>(PC));
4016 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4017 Text.Args.push_back(printArg<const Type *>(PC));
4018 break;
4019case OP_BitCastPrimSint64:
4020 Text.Op = PrintName("BitCastPrimSint64");
4021 Text.Args.push_back(printArg<bool>(PC));
4022 Text.Args.push_back(printArg<uint32_t>(PC));
4023 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4024 Text.Args.push_back(printArg<const Type *>(PC));
4025 break;
4026case OP_BitCastPrimIntAP:
4027 Text.Op = PrintName("BitCastPrimIntAP");
4028 Text.Args.push_back(printArg<bool>(PC));
4029 Text.Args.push_back(printArg<uint32_t>(PC));
4030 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4031 Text.Args.push_back(printArg<const Type *>(PC));
4032 break;
4033case OP_BitCastPrimIntAPS:
4034 Text.Op = PrintName("BitCastPrimIntAPS");
4035 Text.Args.push_back(printArg<bool>(PC));
4036 Text.Args.push_back(printArg<uint32_t>(PC));
4037 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4038 Text.Args.push_back(printArg<const Type *>(PC));
4039 break;
4040case OP_BitCastPrimBool:
4041 Text.Op = PrintName("BitCastPrimBool");
4042 Text.Args.push_back(printArg<bool>(PC));
4043 Text.Args.push_back(printArg<uint32_t>(PC));
4044 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4045 Text.Args.push_back(printArg<const Type *>(PC));
4046 break;
4047case OP_BitCastPrimFloat:
4048 Text.Op = PrintName("BitCastPrimFloat");
4049 Text.Args.push_back(printArg<bool>(PC));
4050 Text.Args.push_back(printArg<uint32_t>(PC));
4051 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4052 Text.Args.push_back(printArg<const Type *>(PC));
4053 break;
4054case OP_BitCastPrimPtr:
4055 Text.Op = PrintName("BitCastPrimPtr");
4056 Text.Args.push_back(printArg<bool>(PC));
4057 Text.Args.push_back(printArg<uint32_t>(PC));
4058 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4059 Text.Args.push_back(printArg<const Type *>(PC));
4060 break;
4061case OP_BitCastPrimMemberPtr:
4062 Text.Op = PrintName("BitCastPrimMemberPtr");
4063 Text.Args.push_back(printArg<bool>(PC));
4064 Text.Args.push_back(printArg<uint32_t>(PC));
4065 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
4066 Text.Args.push_back(printArg<const Type *>(PC));
4067 break;
4068#endif
4069#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4070bool emitBitCastPrimUint8( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4071bool emitBitCastPrimSint8( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4072bool emitBitCastPrimUint16( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4073bool emitBitCastPrimSint16( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4074bool emitBitCastPrimUint32( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4075bool emitBitCastPrimSint32( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4076bool emitBitCastPrimUint64( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4077bool emitBitCastPrimSint64( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4078bool emitBitCastPrimIntAP( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4079bool emitBitCastPrimIntAPS( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4080bool emitBitCastPrimBool( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4081bool emitBitCastPrimFloat( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4082bool emitBitCastPrimPtr( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4083bool emitBitCastPrimMemberPtr( bool , uint32_t , const llvm::fltSemantics * , const Type * , SourceInfo);
4084#endif
4085#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4086[[nodiscard]] bool emitBitCastPrim(PrimType, bool, uint32_t, const llvm::fltSemantics *, const Type *, SourceInfo I);
4087#endif
4088#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
4089bool
4090#if defined(GET_EVAL_IMPL)
4091EvalEmitter
4092#else
4093ByteCodeEmitter
4094#endif
4095::emitBitCastPrim(PrimType T0, bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo I) {
4096 switch (T0) {
4097 case PT_Uint8:
4098 return emitBitCastPrimUint8(A0, A1, A2, A3, I);
4099 case PT_Sint8:
4100 return emitBitCastPrimSint8(A0, A1, A2, A3, I);
4101 case PT_Uint16:
4102 return emitBitCastPrimUint16(A0, A1, A2, A3, I);
4103 case PT_Sint16:
4104 return emitBitCastPrimSint16(A0, A1, A2, A3, I);
4105 case PT_Uint32:
4106 return emitBitCastPrimUint32(A0, A1, A2, A3, I);
4107 case PT_Sint32:
4108 return emitBitCastPrimSint32(A0, A1, A2, A3, I);
4109 case PT_Uint64:
4110 return emitBitCastPrimUint64(A0, A1, A2, A3, I);
4111 case PT_Sint64:
4112 return emitBitCastPrimSint64(A0, A1, A2, A3, I);
4113 case PT_IntAP:
4114 return emitBitCastPrimIntAP(A0, A1, A2, A3, I);
4115 case PT_IntAPS:
4116 return emitBitCastPrimIntAPS(A0, A1, A2, A3, I);
4117 case PT_Bool:
4118 return emitBitCastPrimBool(A0, A1, A2, A3, I);
4119 case PT_Float:
4120 return emitBitCastPrimFloat(A0, A1, A2, A3, I);
4121 case PT_Ptr:
4122 return emitBitCastPrimPtr(A0, A1, A2, A3, I);
4123 case PT_MemberPtr:
4124 return emitBitCastPrimMemberPtr(A0, A1, A2, A3, I);
4125 default: llvm_unreachable("invalid type: emitBitCastPrim");
4126 }
4127 llvm_unreachable("invalid enum value");
4128}
4129#endif
4130#ifdef GET_LINK_IMPL
4131bool ByteCodeEmitter::emitBitCastPrimUint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4132 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimUint8, A0, A1, A2, A3, L);
4133}
4134bool ByteCodeEmitter::emitBitCastPrimSint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4135 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimSint8, A0, A1, A2, A3, L);
4136}
4137bool ByteCodeEmitter::emitBitCastPrimUint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4138 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimUint16, A0, A1, A2, A3, L);
4139}
4140bool ByteCodeEmitter::emitBitCastPrimSint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4141 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimSint16, A0, A1, A2, A3, L);
4142}
4143bool ByteCodeEmitter::emitBitCastPrimUint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4144 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimUint32, A0, A1, A2, A3, L);
4145}
4146bool ByteCodeEmitter::emitBitCastPrimSint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4147 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimSint32, A0, A1, A2, A3, L);
4148}
4149bool ByteCodeEmitter::emitBitCastPrimUint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4150 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimUint64, A0, A1, A2, A3, L);
4151}
4152bool ByteCodeEmitter::emitBitCastPrimSint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4153 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimSint64, A0, A1, A2, A3, L);
4154}
4155bool ByteCodeEmitter::emitBitCastPrimIntAP( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4156 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimIntAP, A0, A1, A2, A3, L);
4157}
4158bool ByteCodeEmitter::emitBitCastPrimIntAPS( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4159 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimIntAPS, A0, A1, A2, A3, L);
4160}
4161bool ByteCodeEmitter::emitBitCastPrimBool( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4162 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimBool, A0, A1, A2, A3, L);
4163}
4164bool ByteCodeEmitter::emitBitCastPrimFloat( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4165 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimFloat, A0, A1, A2, A3, L);
4166}
4167bool ByteCodeEmitter::emitBitCastPrimPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4168 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimPtr, A0, A1, A2, A3, L);
4169}
4170bool ByteCodeEmitter::emitBitCastPrimMemberPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4171 return emitOp<bool, uint32_t, const llvm::fltSemantics *, const Type *>(OP_BitCastPrimMemberPtr, A0, A1, A2, A3, L);
4172}
4173#endif
4174#ifdef GET_EVAL_IMPL
4175bool EvalEmitter::emitBitCastPrimUint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4176 if (!isActive()) return true;
4177 CurrentSource = L;
4178 return BitCastPrim<PT_Uint8>(S, CodePtr(), A0, A1, A2, A3);
4179}
4180bool EvalEmitter::emitBitCastPrimSint8( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4181 if (!isActive()) return true;
4182 CurrentSource = L;
4183 return BitCastPrim<PT_Sint8>(S, CodePtr(), A0, A1, A2, A3);
4184}
4185bool EvalEmitter::emitBitCastPrimUint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4186 if (!isActive()) return true;
4187 CurrentSource = L;
4188 return BitCastPrim<PT_Uint16>(S, CodePtr(), A0, A1, A2, A3);
4189}
4190bool EvalEmitter::emitBitCastPrimSint16( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4191 if (!isActive()) return true;
4192 CurrentSource = L;
4193 return BitCastPrim<PT_Sint16>(S, CodePtr(), A0, A1, A2, A3);
4194}
4195bool EvalEmitter::emitBitCastPrimUint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4196 if (!isActive()) return true;
4197 CurrentSource = L;
4198 return BitCastPrim<PT_Uint32>(S, CodePtr(), A0, A1, A2, A3);
4199}
4200bool EvalEmitter::emitBitCastPrimSint32( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4201 if (!isActive()) return true;
4202 CurrentSource = L;
4203 return BitCastPrim<PT_Sint32>(S, CodePtr(), A0, A1, A2, A3);
4204}
4205bool EvalEmitter::emitBitCastPrimUint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4206 if (!isActive()) return true;
4207 CurrentSource = L;
4208 return BitCastPrim<PT_Uint64>(S, CodePtr(), A0, A1, A2, A3);
4209}
4210bool EvalEmitter::emitBitCastPrimSint64( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4211 if (!isActive()) return true;
4212 CurrentSource = L;
4213 return BitCastPrim<PT_Sint64>(S, CodePtr(), A0, A1, A2, A3);
4214}
4215bool EvalEmitter::emitBitCastPrimIntAP( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4216 if (!isActive()) return true;
4217 CurrentSource = L;
4218 return BitCastPrim<PT_IntAP>(S, CodePtr(), A0, A1, A2, A3);
4219}
4220bool EvalEmitter::emitBitCastPrimIntAPS( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4221 if (!isActive()) return true;
4222 CurrentSource = L;
4223 return BitCastPrim<PT_IntAPS>(S, CodePtr(), A0, A1, A2, A3);
4224}
4225bool EvalEmitter::emitBitCastPrimBool( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4226 if (!isActive()) return true;
4227 CurrentSource = L;
4228 return BitCastPrim<PT_Bool>(S, CodePtr(), A0, A1, A2, A3);
4229}
4230bool EvalEmitter::emitBitCastPrimFloat( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4231 if (!isActive()) return true;
4232 CurrentSource = L;
4233 return BitCastPrim<PT_Float>(S, CodePtr(), A0, A1, A2, A3);
4234}
4235bool EvalEmitter::emitBitCastPrimPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4236 if (!isActive()) return true;
4237 CurrentSource = L;
4238 return BitCastPrim<PT_Ptr>(S, CodePtr(), A0, A1, A2, A3);
4239}
4240bool EvalEmitter::emitBitCastPrimMemberPtr( bool A0, uint32_t A1, const llvm::fltSemantics * A2, const Type * A3, SourceInfo L) {
4241 if (!isActive()) return true;
4242 CurrentSource = L;
4243 return BitCastPrim<PT_MemberPtr>(S, CodePtr(), A0, A1, A2, A3);
4244}
4245#endif
4246#ifdef GET_OPCODE_NAMES
4247OP_BitOrSint8,
4248OP_BitOrUint8,
4249OP_BitOrSint16,
4250OP_BitOrUint16,
4251OP_BitOrSint32,
4252OP_BitOrUint32,
4253OP_BitOrSint64,
4254OP_BitOrUint64,
4255OP_BitOrIntAP,
4256OP_BitOrIntAPS,
4257OP_BitOrFixedPoint,
4258#endif
4259#ifdef GET_INTERPFN_LIST
4260&Interp_BitOrSint8,
4261&Interp_BitOrUint8,
4262&Interp_BitOrSint16,
4263&Interp_BitOrUint16,
4264&Interp_BitOrSint32,
4265&Interp_BitOrUint32,
4266&Interp_BitOrSint64,
4267&Interp_BitOrUint64,
4268&Interp_BitOrIntAP,
4269&Interp_BitOrIntAPS,
4270&Interp_BitOrFixedPoint,
4271#endif
4272#ifdef GET_INTERPFN_DISPATCHERS
4273PRESERVE_NONE
4274static bool Interp_BitOrSint8(InterpState &S) {
4275 if (!BitOr<PT_Sint8>(S)) return false;
4276#if USE_TAILCALLS
4277 MUSTTAIL return InterpNext(S);
4278#else
4279 return true;
4280#endif
4281}
4282PRESERVE_NONE
4283static bool Interp_BitOrUint8(InterpState &S) {
4284 if (!BitOr<PT_Uint8>(S)) return false;
4285#if USE_TAILCALLS
4286 MUSTTAIL return InterpNext(S);
4287#else
4288 return true;
4289#endif
4290}
4291PRESERVE_NONE
4292static bool Interp_BitOrSint16(InterpState &S) {
4293 if (!BitOr<PT_Sint16>(S)) return false;
4294#if USE_TAILCALLS
4295 MUSTTAIL return InterpNext(S);
4296#else
4297 return true;
4298#endif
4299}
4300PRESERVE_NONE
4301static bool Interp_BitOrUint16(InterpState &S) {
4302 if (!BitOr<PT_Uint16>(S)) return false;
4303#if USE_TAILCALLS
4304 MUSTTAIL return InterpNext(S);
4305#else
4306 return true;
4307#endif
4308}
4309PRESERVE_NONE
4310static bool Interp_BitOrSint32(InterpState &S) {
4311 if (!BitOr<PT_Sint32>(S)) return false;
4312#if USE_TAILCALLS
4313 MUSTTAIL return InterpNext(S);
4314#else
4315 return true;
4316#endif
4317}
4318PRESERVE_NONE
4319static bool Interp_BitOrUint32(InterpState &S) {
4320 if (!BitOr<PT_Uint32>(S)) return false;
4321#if USE_TAILCALLS
4322 MUSTTAIL return InterpNext(S);
4323#else
4324 return true;
4325#endif
4326}
4327PRESERVE_NONE
4328static bool Interp_BitOrSint64(InterpState &S) {
4329 if (!BitOr<PT_Sint64>(S)) return false;
4330#if USE_TAILCALLS
4331 MUSTTAIL return InterpNext(S);
4332#else
4333 return true;
4334#endif
4335}
4336PRESERVE_NONE
4337static bool Interp_BitOrUint64(InterpState &S) {
4338 if (!BitOr<PT_Uint64>(S)) return false;
4339#if USE_TAILCALLS
4340 MUSTTAIL return InterpNext(S);
4341#else
4342 return true;
4343#endif
4344}
4345PRESERVE_NONE
4346static bool Interp_BitOrIntAP(InterpState &S) {
4347 if (!BitOr<PT_IntAP>(S)) return false;
4348#if USE_TAILCALLS
4349 MUSTTAIL return InterpNext(S);
4350#else
4351 return true;
4352#endif
4353}
4354PRESERVE_NONE
4355static bool Interp_BitOrIntAPS(InterpState &S) {
4356 if (!BitOr<PT_IntAPS>(S)) return false;
4357#if USE_TAILCALLS
4358 MUSTTAIL return InterpNext(S);
4359#else
4360 return true;
4361#endif
4362}
4363PRESERVE_NONE
4364static bool Interp_BitOrFixedPoint(InterpState &S) {
4365 if (!BitOr<PT_FixedPoint>(S)) return false;
4366#if USE_TAILCALLS
4367 MUSTTAIL return InterpNext(S);
4368#else
4369 return true;
4370#endif
4371}
4372#endif
4373#ifdef GET_DISASM
4374case OP_BitOrSint8:
4375 Text.Op = PrintName("BitOrSint8");
4376 break;
4377case OP_BitOrUint8:
4378 Text.Op = PrintName("BitOrUint8");
4379 break;
4380case OP_BitOrSint16:
4381 Text.Op = PrintName("BitOrSint16");
4382 break;
4383case OP_BitOrUint16:
4384 Text.Op = PrintName("BitOrUint16");
4385 break;
4386case OP_BitOrSint32:
4387 Text.Op = PrintName("BitOrSint32");
4388 break;
4389case OP_BitOrUint32:
4390 Text.Op = PrintName("BitOrUint32");
4391 break;
4392case OP_BitOrSint64:
4393 Text.Op = PrintName("BitOrSint64");
4394 break;
4395case OP_BitOrUint64:
4396 Text.Op = PrintName("BitOrUint64");
4397 break;
4398case OP_BitOrIntAP:
4399 Text.Op = PrintName("BitOrIntAP");
4400 break;
4401case OP_BitOrIntAPS:
4402 Text.Op = PrintName("BitOrIntAPS");
4403 break;
4404case OP_BitOrFixedPoint:
4405 Text.Op = PrintName("BitOrFixedPoint");
4406 break;
4407#endif
4408#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4409bool emitBitOrSint8(SourceInfo);
4410bool emitBitOrUint8(SourceInfo);
4411bool emitBitOrSint16(SourceInfo);
4412bool emitBitOrUint16(SourceInfo);
4413bool emitBitOrSint32(SourceInfo);
4414bool emitBitOrUint32(SourceInfo);
4415bool emitBitOrSint64(SourceInfo);
4416bool emitBitOrUint64(SourceInfo);
4417bool emitBitOrIntAP(SourceInfo);
4418bool emitBitOrIntAPS(SourceInfo);
4419bool emitBitOrFixedPoint(SourceInfo);
4420#endif
4421#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4422[[nodiscard]] bool emitBitOr(PrimType, SourceInfo I);
4423#endif
4424#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
4425bool
4426#if defined(GET_EVAL_IMPL)
4427EvalEmitter
4428#else
4429ByteCodeEmitter
4430#endif
4431::emitBitOr(PrimType T0, SourceInfo I) {
4432 switch (T0) {
4433 case PT_Sint8:
4434 return emitBitOrSint8(I);
4435 case PT_Uint8:
4436 return emitBitOrUint8(I);
4437 case PT_Sint16:
4438 return emitBitOrSint16(I);
4439 case PT_Uint16:
4440 return emitBitOrUint16(I);
4441 case PT_Sint32:
4442 return emitBitOrSint32(I);
4443 case PT_Uint32:
4444 return emitBitOrUint32(I);
4445 case PT_Sint64:
4446 return emitBitOrSint64(I);
4447 case PT_Uint64:
4448 return emitBitOrUint64(I);
4449 case PT_IntAP:
4450 return emitBitOrIntAP(I);
4451 case PT_IntAPS:
4452 return emitBitOrIntAPS(I);
4453 case PT_FixedPoint:
4454 return emitBitOrFixedPoint(I);
4455 default: llvm_unreachable("invalid type: emitBitOr");
4456 }
4457 llvm_unreachable("invalid enum value");
4458}
4459#endif
4460#ifdef GET_LINK_IMPL
4461bool ByteCodeEmitter::emitBitOrSint8(SourceInfo L) {
4462 return emitOp<>(OP_BitOrSint8, L);
4463}
4464bool ByteCodeEmitter::emitBitOrUint8(SourceInfo L) {
4465 return emitOp<>(OP_BitOrUint8, L);
4466}
4467bool ByteCodeEmitter::emitBitOrSint16(SourceInfo L) {
4468 return emitOp<>(OP_BitOrSint16, L);
4469}
4470bool ByteCodeEmitter::emitBitOrUint16(SourceInfo L) {
4471 return emitOp<>(OP_BitOrUint16, L);
4472}
4473bool ByteCodeEmitter::emitBitOrSint32(SourceInfo L) {
4474 return emitOp<>(OP_BitOrSint32, L);
4475}
4476bool ByteCodeEmitter::emitBitOrUint32(SourceInfo L) {
4477 return emitOp<>(OP_BitOrUint32, L);
4478}
4479bool ByteCodeEmitter::emitBitOrSint64(SourceInfo L) {
4480 return emitOp<>(OP_BitOrSint64, L);
4481}
4482bool ByteCodeEmitter::emitBitOrUint64(SourceInfo L) {
4483 return emitOp<>(OP_BitOrUint64, L);
4484}
4485bool ByteCodeEmitter::emitBitOrIntAP(SourceInfo L) {
4486 return emitOp<>(OP_BitOrIntAP, L);
4487}
4488bool ByteCodeEmitter::emitBitOrIntAPS(SourceInfo L) {
4489 return emitOp<>(OP_BitOrIntAPS, L);
4490}
4491bool ByteCodeEmitter::emitBitOrFixedPoint(SourceInfo L) {
4492 return emitOp<>(OP_BitOrFixedPoint, L);
4493}
4494#endif
4495#ifdef GET_EVAL_IMPL
4496bool EvalEmitter::emitBitOrSint8(SourceInfo L) {
4497 if (!isActive()) return true;
4498 CurrentSource = L;
4499 return BitOr<PT_Sint8>(S);
4500}
4501bool EvalEmitter::emitBitOrUint8(SourceInfo L) {
4502 if (!isActive()) return true;
4503 CurrentSource = L;
4504 return BitOr<PT_Uint8>(S);
4505}
4506bool EvalEmitter::emitBitOrSint16(SourceInfo L) {
4507 if (!isActive()) return true;
4508 CurrentSource = L;
4509 return BitOr<PT_Sint16>(S);
4510}
4511bool EvalEmitter::emitBitOrUint16(SourceInfo L) {
4512 if (!isActive()) return true;
4513 CurrentSource = L;
4514 return BitOr<PT_Uint16>(S);
4515}
4516bool EvalEmitter::emitBitOrSint32(SourceInfo L) {
4517 if (!isActive()) return true;
4518 CurrentSource = L;
4519 return BitOr<PT_Sint32>(S);
4520}
4521bool EvalEmitter::emitBitOrUint32(SourceInfo L) {
4522 if (!isActive()) return true;
4523 CurrentSource = L;
4524 return BitOr<PT_Uint32>(S);
4525}
4526bool EvalEmitter::emitBitOrSint64(SourceInfo L) {
4527 if (!isActive()) return true;
4528 CurrentSource = L;
4529 return BitOr<PT_Sint64>(S);
4530}
4531bool EvalEmitter::emitBitOrUint64(SourceInfo L) {
4532 if (!isActive()) return true;
4533 CurrentSource = L;
4534 return BitOr<PT_Uint64>(S);
4535}
4536bool EvalEmitter::emitBitOrIntAP(SourceInfo L) {
4537 if (!isActive()) return true;
4538 CurrentSource = L;
4539 return BitOr<PT_IntAP>(S);
4540}
4541bool EvalEmitter::emitBitOrIntAPS(SourceInfo L) {
4542 if (!isActive()) return true;
4543 CurrentSource = L;
4544 return BitOr<PT_IntAPS>(S);
4545}
4546bool EvalEmitter::emitBitOrFixedPoint(SourceInfo L) {
4547 if (!isActive()) return true;
4548 CurrentSource = L;
4549 return BitOr<PT_FixedPoint>(S);
4550}
4551#endif
4552#ifdef GET_OPCODE_NAMES
4553OP_BitXorSint8,
4554OP_BitXorUint8,
4555OP_BitXorSint16,
4556OP_BitXorUint16,
4557OP_BitXorSint32,
4558OP_BitXorUint32,
4559OP_BitXorSint64,
4560OP_BitXorUint64,
4561OP_BitXorIntAP,
4562OP_BitXorIntAPS,
4563OP_BitXorFixedPoint,
4564#endif
4565#ifdef GET_INTERPFN_LIST
4566&Interp_BitXorSint8,
4567&Interp_BitXorUint8,
4568&Interp_BitXorSint16,
4569&Interp_BitXorUint16,
4570&Interp_BitXorSint32,
4571&Interp_BitXorUint32,
4572&Interp_BitXorSint64,
4573&Interp_BitXorUint64,
4574&Interp_BitXorIntAP,
4575&Interp_BitXorIntAPS,
4576&Interp_BitXorFixedPoint,
4577#endif
4578#ifdef GET_INTERPFN_DISPATCHERS
4579PRESERVE_NONE
4580static bool Interp_BitXorSint8(InterpState &S) {
4581 if (!BitXor<PT_Sint8>(S)) return false;
4582#if USE_TAILCALLS
4583 MUSTTAIL return InterpNext(S);
4584#else
4585 return true;
4586#endif
4587}
4588PRESERVE_NONE
4589static bool Interp_BitXorUint8(InterpState &S) {
4590 if (!BitXor<PT_Uint8>(S)) return false;
4591#if USE_TAILCALLS
4592 MUSTTAIL return InterpNext(S);
4593#else
4594 return true;
4595#endif
4596}
4597PRESERVE_NONE
4598static bool Interp_BitXorSint16(InterpState &S) {
4599 if (!BitXor<PT_Sint16>(S)) return false;
4600#if USE_TAILCALLS
4601 MUSTTAIL return InterpNext(S);
4602#else
4603 return true;
4604#endif
4605}
4606PRESERVE_NONE
4607static bool Interp_BitXorUint16(InterpState &S) {
4608 if (!BitXor<PT_Uint16>(S)) return false;
4609#if USE_TAILCALLS
4610 MUSTTAIL return InterpNext(S);
4611#else
4612 return true;
4613#endif
4614}
4615PRESERVE_NONE
4616static bool Interp_BitXorSint32(InterpState &S) {
4617 if (!BitXor<PT_Sint32>(S)) return false;
4618#if USE_TAILCALLS
4619 MUSTTAIL return InterpNext(S);
4620#else
4621 return true;
4622#endif
4623}
4624PRESERVE_NONE
4625static bool Interp_BitXorUint32(InterpState &S) {
4626 if (!BitXor<PT_Uint32>(S)) return false;
4627#if USE_TAILCALLS
4628 MUSTTAIL return InterpNext(S);
4629#else
4630 return true;
4631#endif
4632}
4633PRESERVE_NONE
4634static bool Interp_BitXorSint64(InterpState &S) {
4635 if (!BitXor<PT_Sint64>(S)) return false;
4636#if USE_TAILCALLS
4637 MUSTTAIL return InterpNext(S);
4638#else
4639 return true;
4640#endif
4641}
4642PRESERVE_NONE
4643static bool Interp_BitXorUint64(InterpState &S) {
4644 if (!BitXor<PT_Uint64>(S)) return false;
4645#if USE_TAILCALLS
4646 MUSTTAIL return InterpNext(S);
4647#else
4648 return true;
4649#endif
4650}
4651PRESERVE_NONE
4652static bool Interp_BitXorIntAP(InterpState &S) {
4653 if (!BitXor<PT_IntAP>(S)) return false;
4654#if USE_TAILCALLS
4655 MUSTTAIL return InterpNext(S);
4656#else
4657 return true;
4658#endif
4659}
4660PRESERVE_NONE
4661static bool Interp_BitXorIntAPS(InterpState &S) {
4662 if (!BitXor<PT_IntAPS>(S)) return false;
4663#if USE_TAILCALLS
4664 MUSTTAIL return InterpNext(S);
4665#else
4666 return true;
4667#endif
4668}
4669PRESERVE_NONE
4670static bool Interp_BitXorFixedPoint(InterpState &S) {
4671 if (!BitXor<PT_FixedPoint>(S)) return false;
4672#if USE_TAILCALLS
4673 MUSTTAIL return InterpNext(S);
4674#else
4675 return true;
4676#endif
4677}
4678#endif
4679#ifdef GET_DISASM
4680case OP_BitXorSint8:
4681 Text.Op = PrintName("BitXorSint8");
4682 break;
4683case OP_BitXorUint8:
4684 Text.Op = PrintName("BitXorUint8");
4685 break;
4686case OP_BitXorSint16:
4687 Text.Op = PrintName("BitXorSint16");
4688 break;
4689case OP_BitXorUint16:
4690 Text.Op = PrintName("BitXorUint16");
4691 break;
4692case OP_BitXorSint32:
4693 Text.Op = PrintName("BitXorSint32");
4694 break;
4695case OP_BitXorUint32:
4696 Text.Op = PrintName("BitXorUint32");
4697 break;
4698case OP_BitXorSint64:
4699 Text.Op = PrintName("BitXorSint64");
4700 break;
4701case OP_BitXorUint64:
4702 Text.Op = PrintName("BitXorUint64");
4703 break;
4704case OP_BitXorIntAP:
4705 Text.Op = PrintName("BitXorIntAP");
4706 break;
4707case OP_BitXorIntAPS:
4708 Text.Op = PrintName("BitXorIntAPS");
4709 break;
4710case OP_BitXorFixedPoint:
4711 Text.Op = PrintName("BitXorFixedPoint");
4712 break;
4713#endif
4714#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4715bool emitBitXorSint8(SourceInfo);
4716bool emitBitXorUint8(SourceInfo);
4717bool emitBitXorSint16(SourceInfo);
4718bool emitBitXorUint16(SourceInfo);
4719bool emitBitXorSint32(SourceInfo);
4720bool emitBitXorUint32(SourceInfo);
4721bool emitBitXorSint64(SourceInfo);
4722bool emitBitXorUint64(SourceInfo);
4723bool emitBitXorIntAP(SourceInfo);
4724bool emitBitXorIntAPS(SourceInfo);
4725bool emitBitXorFixedPoint(SourceInfo);
4726#endif
4727#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
4728[[nodiscard]] bool emitBitXor(PrimType, SourceInfo I);
4729#endif
4730#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
4731bool
4732#if defined(GET_EVAL_IMPL)
4733EvalEmitter
4734#else
4735ByteCodeEmitter
4736#endif
4737::emitBitXor(PrimType T0, SourceInfo I) {
4738 switch (T0) {
4739 case PT_Sint8:
4740 return emitBitXorSint8(I);
4741 case PT_Uint8:
4742 return emitBitXorUint8(I);
4743 case PT_Sint16:
4744 return emitBitXorSint16(I);
4745 case PT_Uint16:
4746 return emitBitXorUint16(I);
4747 case PT_Sint32:
4748 return emitBitXorSint32(I);
4749 case PT_Uint32:
4750 return emitBitXorUint32(I);
4751 case PT_Sint64:
4752 return emitBitXorSint64(I);
4753 case PT_Uint64:
4754 return emitBitXorUint64(I);
4755 case PT_IntAP:
4756 return emitBitXorIntAP(I);
4757 case PT_IntAPS:
4758 return emitBitXorIntAPS(I);
4759 case PT_FixedPoint:
4760 return emitBitXorFixedPoint(I);
4761 default: llvm_unreachable("invalid type: emitBitXor");
4762 }
4763 llvm_unreachable("invalid enum value");
4764}
4765#endif
4766#ifdef GET_LINK_IMPL
4767bool ByteCodeEmitter::emitBitXorSint8(SourceInfo L) {
4768 return emitOp<>(OP_BitXorSint8, L);
4769}
4770bool ByteCodeEmitter::emitBitXorUint8(SourceInfo L) {
4771 return emitOp<>(OP_BitXorUint8, L);
4772}
4773bool ByteCodeEmitter::emitBitXorSint16(SourceInfo L) {
4774 return emitOp<>(OP_BitXorSint16, L);
4775}
4776bool ByteCodeEmitter::emitBitXorUint16(SourceInfo L) {
4777 return emitOp<>(OP_BitXorUint16, L);
4778}
4779bool ByteCodeEmitter::emitBitXorSint32(SourceInfo L) {
4780 return emitOp<>(OP_BitXorSint32, L);
4781}
4782bool ByteCodeEmitter::emitBitXorUint32(SourceInfo L) {
4783 return emitOp<>(OP_BitXorUint32, L);
4784}
4785bool ByteCodeEmitter::emitBitXorSint64(SourceInfo L) {
4786 return emitOp<>(OP_BitXorSint64, L);
4787}
4788bool ByteCodeEmitter::emitBitXorUint64(SourceInfo L) {
4789 return emitOp<>(OP_BitXorUint64, L);
4790}
4791bool ByteCodeEmitter::emitBitXorIntAP(SourceInfo L) {
4792 return emitOp<>(OP_BitXorIntAP, L);
4793}
4794bool ByteCodeEmitter::emitBitXorIntAPS(SourceInfo L) {
4795 return emitOp<>(OP_BitXorIntAPS, L);
4796}
4797bool ByteCodeEmitter::emitBitXorFixedPoint(SourceInfo L) {
4798 return emitOp<>(OP_BitXorFixedPoint, L);
4799}
4800#endif
4801#ifdef GET_EVAL_IMPL
4802bool EvalEmitter::emitBitXorSint8(SourceInfo L) {
4803 if (!isActive()) return true;
4804 CurrentSource = L;
4805 return BitXor<PT_Sint8>(S);
4806}
4807bool EvalEmitter::emitBitXorUint8(SourceInfo L) {
4808 if (!isActive()) return true;
4809 CurrentSource = L;
4810 return BitXor<PT_Uint8>(S);
4811}
4812bool EvalEmitter::emitBitXorSint16(SourceInfo L) {
4813 if (!isActive()) return true;
4814 CurrentSource = L;
4815 return BitXor<PT_Sint16>(S);
4816}
4817bool EvalEmitter::emitBitXorUint16(SourceInfo L) {
4818 if (!isActive()) return true;
4819 CurrentSource = L;
4820 return BitXor<PT_Uint16>(S);
4821}
4822bool EvalEmitter::emitBitXorSint32(SourceInfo L) {
4823 if (!isActive()) return true;
4824 CurrentSource = L;
4825 return BitXor<PT_Sint32>(S);
4826}
4827bool EvalEmitter::emitBitXorUint32(SourceInfo L) {
4828 if (!isActive()) return true;
4829 CurrentSource = L;
4830 return BitXor<PT_Uint32>(S);
4831}
4832bool EvalEmitter::emitBitXorSint64(SourceInfo L) {
4833 if (!isActive()) return true;
4834 CurrentSource = L;
4835 return BitXor<PT_Sint64>(S);
4836}
4837bool EvalEmitter::emitBitXorUint64(SourceInfo L) {
4838 if (!isActive()) return true;
4839 CurrentSource = L;
4840 return BitXor<PT_Uint64>(S);
4841}
4842bool EvalEmitter::emitBitXorIntAP(SourceInfo L) {
4843 if (!isActive()) return true;
4844 CurrentSource = L;
4845 return BitXor<PT_IntAP>(S);
4846}
4847bool EvalEmitter::emitBitXorIntAPS(SourceInfo L) {
4848 if (!isActive()) return true;
4849 CurrentSource = L;
4850 return BitXor<PT_IntAPS>(S);
4851}
4852bool EvalEmitter::emitBitXorFixedPoint(SourceInfo L) {
4853 if (!isActive()) return true;
4854 CurrentSource = L;
4855 return BitXor<PT_FixedPoint>(S);
4856}
4857#endif
4858#ifdef GET_OPCODE_NAMES
4859OP_CMP3Sint8,
4860OP_CMP3Uint8,
4861OP_CMP3Sint16,
4862OP_CMP3Uint16,
4863OP_CMP3Sint32,
4864OP_CMP3Uint32,
4865OP_CMP3Sint64,
4866OP_CMP3Uint64,
4867OP_CMP3IntAP,
4868OP_CMP3IntAPS,
4869OP_CMP3Bool,
4870OP_CMP3FixedPoint,
4871OP_CMP3Ptr,
4872OP_CMP3Float,
4873#endif
4874#ifdef GET_INTERPFN_LIST
4875&Interp_CMP3Sint8,
4876&Interp_CMP3Uint8,
4877&Interp_CMP3Sint16,
4878&Interp_CMP3Uint16,
4879&Interp_CMP3Sint32,
4880&Interp_CMP3Uint32,
4881&Interp_CMP3Sint64,
4882&Interp_CMP3Uint64,
4883&Interp_CMP3IntAP,
4884&Interp_CMP3IntAPS,
4885&Interp_CMP3Bool,
4886&Interp_CMP3FixedPoint,
4887&Interp_CMP3Ptr,
4888&Interp_CMP3Float,
4889#endif
4890#ifdef GET_INTERPFN_DISPATCHERS
4891PRESERVE_NONE
4892static bool Interp_CMP3Sint8(InterpState &S) {
4893 {
4894 CodePtr OpPC = S.PC;
4895 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4896 if (!CMP3<PT_Sint8>(S, OpPC, V0)) return false;
4897 }
4898#if USE_TAILCALLS
4899 MUSTTAIL return InterpNext(S);
4900#else
4901 return true;
4902#endif
4903}
4904PRESERVE_NONE
4905static bool Interp_CMP3Uint8(InterpState &S) {
4906 {
4907 CodePtr OpPC = S.PC;
4908 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4909 if (!CMP3<PT_Uint8>(S, OpPC, V0)) return false;
4910 }
4911#if USE_TAILCALLS
4912 MUSTTAIL return InterpNext(S);
4913#else
4914 return true;
4915#endif
4916}
4917PRESERVE_NONE
4918static bool Interp_CMP3Sint16(InterpState &S) {
4919 {
4920 CodePtr OpPC = S.PC;
4921 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4922 if (!CMP3<PT_Sint16>(S, OpPC, V0)) return false;
4923 }
4924#if USE_TAILCALLS
4925 MUSTTAIL return InterpNext(S);
4926#else
4927 return true;
4928#endif
4929}
4930PRESERVE_NONE
4931static bool Interp_CMP3Uint16(InterpState &S) {
4932 {
4933 CodePtr OpPC = S.PC;
4934 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4935 if (!CMP3<PT_Uint16>(S, OpPC, V0)) return false;
4936 }
4937#if USE_TAILCALLS
4938 MUSTTAIL return InterpNext(S);
4939#else
4940 return true;
4941#endif
4942}
4943PRESERVE_NONE
4944static bool Interp_CMP3Sint32(InterpState &S) {
4945 {
4946 CodePtr OpPC = S.PC;
4947 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4948 if (!CMP3<PT_Sint32>(S, OpPC, V0)) return false;
4949 }
4950#if USE_TAILCALLS
4951 MUSTTAIL return InterpNext(S);
4952#else
4953 return true;
4954#endif
4955}
4956PRESERVE_NONE
4957static bool Interp_CMP3Uint32(InterpState &S) {
4958 {
4959 CodePtr OpPC = S.PC;
4960 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4961 if (!CMP3<PT_Uint32>(S, OpPC, V0)) return false;
4962 }
4963#if USE_TAILCALLS
4964 MUSTTAIL return InterpNext(S);
4965#else
4966 return true;
4967#endif
4968}
4969PRESERVE_NONE
4970static bool Interp_CMP3Sint64(InterpState &S) {
4971 {
4972 CodePtr OpPC = S.PC;
4973 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4974 if (!CMP3<PT_Sint64>(S, OpPC, V0)) return false;
4975 }
4976#if USE_TAILCALLS
4977 MUSTTAIL return InterpNext(S);
4978#else
4979 return true;
4980#endif
4981}
4982PRESERVE_NONE
4983static bool Interp_CMP3Uint64(InterpState &S) {
4984 {
4985 CodePtr OpPC = S.PC;
4986 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
4987 if (!CMP3<PT_Uint64>(S, OpPC, V0)) return false;
4988 }
4989#if USE_TAILCALLS
4990 MUSTTAIL return InterpNext(S);
4991#else
4992 return true;
4993#endif
4994}
4995PRESERVE_NONE
4996static bool Interp_CMP3IntAP(InterpState &S) {
4997 {
4998 CodePtr OpPC = S.PC;
4999 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
5000 if (!CMP3<PT_IntAP>(S, OpPC, V0)) return false;
5001 }
5002#if USE_TAILCALLS
5003 MUSTTAIL return InterpNext(S);
5004#else
5005 return true;
5006#endif
5007}
5008PRESERVE_NONE
5009static bool Interp_CMP3IntAPS(InterpState &S) {
5010 {
5011 CodePtr OpPC = S.PC;
5012 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
5013 if (!CMP3<PT_IntAPS>(S, OpPC, V0)) return false;
5014 }
5015#if USE_TAILCALLS
5016 MUSTTAIL return InterpNext(S);
5017#else
5018 return true;
5019#endif
5020}
5021PRESERVE_NONE
5022static bool Interp_CMP3Bool(InterpState &S) {
5023 {
5024 CodePtr OpPC = S.PC;
5025 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
5026 if (!CMP3<PT_Bool>(S, OpPC, V0)) return false;
5027 }
5028#if USE_TAILCALLS
5029 MUSTTAIL return InterpNext(S);
5030#else
5031 return true;
5032#endif
5033}
5034PRESERVE_NONE
5035static bool Interp_CMP3FixedPoint(InterpState &S) {
5036 {
5037 CodePtr OpPC = S.PC;
5038 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
5039 if (!CMP3<PT_FixedPoint>(S, OpPC, V0)) return false;
5040 }
5041#if USE_TAILCALLS
5042 MUSTTAIL return InterpNext(S);
5043#else
5044 return true;
5045#endif
5046}
5047PRESERVE_NONE
5048static bool Interp_CMP3Ptr(InterpState &S) {
5049 {
5050 CodePtr OpPC = S.PC;
5051 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
5052 if (!CMP3<PT_Ptr>(S, OpPC, V0)) return false;
5053 }
5054#if USE_TAILCALLS
5055 MUSTTAIL return InterpNext(S);
5056#else
5057 return true;
5058#endif
5059}
5060PRESERVE_NONE
5061static bool Interp_CMP3Float(InterpState &S) {
5062 {
5063 CodePtr OpPC = S.PC;
5064 const auto V0 = ReadArg<const ComparisonCategoryInfo *>(S, S.PC);
5065 if (!CMP3<PT_Float>(S, OpPC, V0)) return false;
5066 }
5067#if USE_TAILCALLS
5068 MUSTTAIL return InterpNext(S);
5069#else
5070 return true;
5071#endif
5072}
5073#endif
5074#ifdef GET_DISASM
5075case OP_CMP3Sint8:
5076 Text.Op = PrintName("CMP3Sint8");
5077 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5078 break;
5079case OP_CMP3Uint8:
5080 Text.Op = PrintName("CMP3Uint8");
5081 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5082 break;
5083case OP_CMP3Sint16:
5084 Text.Op = PrintName("CMP3Sint16");
5085 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5086 break;
5087case OP_CMP3Uint16:
5088 Text.Op = PrintName("CMP3Uint16");
5089 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5090 break;
5091case OP_CMP3Sint32:
5092 Text.Op = PrintName("CMP3Sint32");
5093 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5094 break;
5095case OP_CMP3Uint32:
5096 Text.Op = PrintName("CMP3Uint32");
5097 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5098 break;
5099case OP_CMP3Sint64:
5100 Text.Op = PrintName("CMP3Sint64");
5101 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5102 break;
5103case OP_CMP3Uint64:
5104 Text.Op = PrintName("CMP3Uint64");
5105 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5106 break;
5107case OP_CMP3IntAP:
5108 Text.Op = PrintName("CMP3IntAP");
5109 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5110 break;
5111case OP_CMP3IntAPS:
5112 Text.Op = PrintName("CMP3IntAPS");
5113 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5114 break;
5115case OP_CMP3Bool:
5116 Text.Op = PrintName("CMP3Bool");
5117 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5118 break;
5119case OP_CMP3FixedPoint:
5120 Text.Op = PrintName("CMP3FixedPoint");
5121 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5122 break;
5123case OP_CMP3Ptr:
5124 Text.Op = PrintName("CMP3Ptr");
5125 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5126 break;
5127case OP_CMP3Float:
5128 Text.Op = PrintName("CMP3Float");
5129 Text.Args.push_back(printArg<const ComparisonCategoryInfo *>(PC));
5130 break;
5131#endif
5132#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5133bool emitCMP3Sint8( const ComparisonCategoryInfo * , SourceInfo);
5134bool emitCMP3Uint8( const ComparisonCategoryInfo * , SourceInfo);
5135bool emitCMP3Sint16( const ComparisonCategoryInfo * , SourceInfo);
5136bool emitCMP3Uint16( const ComparisonCategoryInfo * , SourceInfo);
5137bool emitCMP3Sint32( const ComparisonCategoryInfo * , SourceInfo);
5138bool emitCMP3Uint32( const ComparisonCategoryInfo * , SourceInfo);
5139bool emitCMP3Sint64( const ComparisonCategoryInfo * , SourceInfo);
5140bool emitCMP3Uint64( const ComparisonCategoryInfo * , SourceInfo);
5141bool emitCMP3IntAP( const ComparisonCategoryInfo * , SourceInfo);
5142bool emitCMP3IntAPS( const ComparisonCategoryInfo * , SourceInfo);
5143bool emitCMP3Bool( const ComparisonCategoryInfo * , SourceInfo);
5144bool emitCMP3FixedPoint( const ComparisonCategoryInfo * , SourceInfo);
5145bool emitCMP3Ptr( const ComparisonCategoryInfo * , SourceInfo);
5146bool emitCMP3Float( const ComparisonCategoryInfo * , SourceInfo);
5147#endif
5148#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5149[[nodiscard]] bool emitCMP3(PrimType, const ComparisonCategoryInfo *, SourceInfo I);
5150#endif
5151#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
5152bool
5153#if defined(GET_EVAL_IMPL)
5154EvalEmitter
5155#else
5156ByteCodeEmitter
5157#endif
5158::emitCMP3(PrimType T0, const ComparisonCategoryInfo * A0, SourceInfo I) {
5159 switch (T0) {
5160 case PT_Sint8:
5161 return emitCMP3Sint8(A0, I);
5162 case PT_Uint8:
5163 return emitCMP3Uint8(A0, I);
5164 case PT_Sint16:
5165 return emitCMP3Sint16(A0, I);
5166 case PT_Uint16:
5167 return emitCMP3Uint16(A0, I);
5168 case PT_Sint32:
5169 return emitCMP3Sint32(A0, I);
5170 case PT_Uint32:
5171 return emitCMP3Uint32(A0, I);
5172 case PT_Sint64:
5173 return emitCMP3Sint64(A0, I);
5174 case PT_Uint64:
5175 return emitCMP3Uint64(A0, I);
5176 case PT_IntAP:
5177 return emitCMP3IntAP(A0, I);
5178 case PT_IntAPS:
5179 return emitCMP3IntAPS(A0, I);
5180 case PT_Bool:
5181 return emitCMP3Bool(A0, I);
5182 case PT_FixedPoint:
5183 return emitCMP3FixedPoint(A0, I);
5184 case PT_Ptr:
5185 return emitCMP3Ptr(A0, I);
5186 case PT_Float:
5187 return emitCMP3Float(A0, I);
5188 default: llvm_unreachable("invalid type: emitCMP3");
5189 }
5190 llvm_unreachable("invalid enum value");
5191}
5192#endif
5193#ifdef GET_LINK_IMPL
5194bool ByteCodeEmitter::emitCMP3Sint8( const ComparisonCategoryInfo * A0, SourceInfo L) {
5195 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint8, A0, L);
5196}
5197bool ByteCodeEmitter::emitCMP3Uint8( const ComparisonCategoryInfo * A0, SourceInfo L) {
5198 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint8, A0, L);
5199}
5200bool ByteCodeEmitter::emitCMP3Sint16( const ComparisonCategoryInfo * A0, SourceInfo L) {
5201 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint16, A0, L);
5202}
5203bool ByteCodeEmitter::emitCMP3Uint16( const ComparisonCategoryInfo * A0, SourceInfo L) {
5204 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint16, A0, L);
5205}
5206bool ByteCodeEmitter::emitCMP3Sint32( const ComparisonCategoryInfo * A0, SourceInfo L) {
5207 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint32, A0, L);
5208}
5209bool ByteCodeEmitter::emitCMP3Uint32( const ComparisonCategoryInfo * A0, SourceInfo L) {
5210 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint32, A0, L);
5211}
5212bool ByteCodeEmitter::emitCMP3Sint64( const ComparisonCategoryInfo * A0, SourceInfo L) {
5213 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Sint64, A0, L);
5214}
5215bool ByteCodeEmitter::emitCMP3Uint64( const ComparisonCategoryInfo * A0, SourceInfo L) {
5216 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Uint64, A0, L);
5217}
5218bool ByteCodeEmitter::emitCMP3IntAP( const ComparisonCategoryInfo * A0, SourceInfo L) {
5219 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3IntAP, A0, L);
5220}
5221bool ByteCodeEmitter::emitCMP3IntAPS( const ComparisonCategoryInfo * A0, SourceInfo L) {
5222 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3IntAPS, A0, L);
5223}
5224bool ByteCodeEmitter::emitCMP3Bool( const ComparisonCategoryInfo * A0, SourceInfo L) {
5225 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Bool, A0, L);
5226}
5227bool ByteCodeEmitter::emitCMP3FixedPoint( const ComparisonCategoryInfo * A0, SourceInfo L) {
5228 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3FixedPoint, A0, L);
5229}
5230bool ByteCodeEmitter::emitCMP3Ptr( const ComparisonCategoryInfo * A0, SourceInfo L) {
5231 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Ptr, A0, L);
5232}
5233bool ByteCodeEmitter::emitCMP3Float( const ComparisonCategoryInfo * A0, SourceInfo L) {
5234 return emitOp<const ComparisonCategoryInfo *>(OP_CMP3Float, A0, L);
5235}
5236#endif
5237#ifdef GET_EVAL_IMPL
5238bool EvalEmitter::emitCMP3Sint8( const ComparisonCategoryInfo * A0, SourceInfo L) {
5239 if (!isActive()) return true;
5240 CurrentSource = L;
5241 return CMP3<PT_Sint8>(S, CodePtr(), A0);
5242}
5243bool EvalEmitter::emitCMP3Uint8( const ComparisonCategoryInfo * A0, SourceInfo L) {
5244 if (!isActive()) return true;
5245 CurrentSource = L;
5246 return CMP3<PT_Uint8>(S, CodePtr(), A0);
5247}
5248bool EvalEmitter::emitCMP3Sint16( const ComparisonCategoryInfo * A0, SourceInfo L) {
5249 if (!isActive()) return true;
5250 CurrentSource = L;
5251 return CMP3<PT_Sint16>(S, CodePtr(), A0);
5252}
5253bool EvalEmitter::emitCMP3Uint16( const ComparisonCategoryInfo * A0, SourceInfo L) {
5254 if (!isActive()) return true;
5255 CurrentSource = L;
5256 return CMP3<PT_Uint16>(S, CodePtr(), A0);
5257}
5258bool EvalEmitter::emitCMP3Sint32( const ComparisonCategoryInfo * A0, SourceInfo L) {
5259 if (!isActive()) return true;
5260 CurrentSource = L;
5261 return CMP3<PT_Sint32>(S, CodePtr(), A0);
5262}
5263bool EvalEmitter::emitCMP3Uint32( const ComparisonCategoryInfo * A0, SourceInfo L) {
5264 if (!isActive()) return true;
5265 CurrentSource = L;
5266 return CMP3<PT_Uint32>(S, CodePtr(), A0);
5267}
5268bool EvalEmitter::emitCMP3Sint64( const ComparisonCategoryInfo * A0, SourceInfo L) {
5269 if (!isActive()) return true;
5270 CurrentSource = L;
5271 return CMP3<PT_Sint64>(S, CodePtr(), A0);
5272}
5273bool EvalEmitter::emitCMP3Uint64( const ComparisonCategoryInfo * A0, SourceInfo L) {
5274 if (!isActive()) return true;
5275 CurrentSource = L;
5276 return CMP3<PT_Uint64>(S, CodePtr(), A0);
5277}
5278bool EvalEmitter::emitCMP3IntAP( const ComparisonCategoryInfo * A0, SourceInfo L) {
5279 if (!isActive()) return true;
5280 CurrentSource = L;
5281 return CMP3<PT_IntAP>(S, CodePtr(), A0);
5282}
5283bool EvalEmitter::emitCMP3IntAPS( const ComparisonCategoryInfo * A0, SourceInfo L) {
5284 if (!isActive()) return true;
5285 CurrentSource = L;
5286 return CMP3<PT_IntAPS>(S, CodePtr(), A0);
5287}
5288bool EvalEmitter::emitCMP3Bool( const ComparisonCategoryInfo * A0, SourceInfo L) {
5289 if (!isActive()) return true;
5290 CurrentSource = L;
5291 return CMP3<PT_Bool>(S, CodePtr(), A0);
5292}
5293bool EvalEmitter::emitCMP3FixedPoint( const ComparisonCategoryInfo * A0, SourceInfo L) {
5294 if (!isActive()) return true;
5295 CurrentSource = L;
5296 return CMP3<PT_FixedPoint>(S, CodePtr(), A0);
5297}
5298bool EvalEmitter::emitCMP3Ptr( const ComparisonCategoryInfo * A0, SourceInfo L) {
5299 if (!isActive()) return true;
5300 CurrentSource = L;
5301 return CMP3<PT_Ptr>(S, CodePtr(), A0);
5302}
5303bool EvalEmitter::emitCMP3Float( const ComparisonCategoryInfo * A0, SourceInfo L) {
5304 if (!isActive()) return true;
5305 CurrentSource = L;
5306 return CMP3<PT_Float>(S, CodePtr(), A0);
5307}
5308#endif
5309#ifdef GET_OPCODE_NAMES
5310OP_Call,
5311#endif
5312#ifdef GET_INTERPFN_LIST
5313&Interp_Call,
5314#endif
5315#ifdef GET_INTERPFN_DISPATCHERS
5316PRESERVE_NONE
5317static bool Interp_Call(InterpState &S) {
5318 {
5319 CodePtr OpPC = S.PC;
5320 const auto V0 = ReadArg<const Function *>(S, S.PC);
5321 const auto V1 = ReadArg<uint32_t>(S, S.PC);
5322 if (!Call(S, OpPC, V0, V1)) return false;
5323 }
5324#if USE_TAILCALLS
5325 MUSTTAIL return InterpNext(S);
5326#else
5327 return true;
5328#endif
5329}
5330#endif
5331#ifdef GET_DISASM
5332case OP_Call:
5333 Text.Op = PrintName("Call");
5334 Text.Args.push_back(printArg<const Function *>(PC));
5335 Text.Args.push_back(printArg<uint32_t>(PC));
5336 break;
5337#endif
5338#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5339bool emitCall( const Function * , uint32_t , SourceInfo);
5340#endif
5341#ifdef GET_LINK_IMPL
5342bool ByteCodeEmitter::emitCall( const Function * A0, uint32_t A1, SourceInfo L) {
5343 return emitOp<const Function *, uint32_t>(OP_Call, A0, A1, L);
5344}
5345#endif
5346#ifdef GET_EVAL_IMPL
5347bool EvalEmitter::emitCall( const Function * A0, uint32_t A1, SourceInfo L) {
5348 if (!isActive()) return true;
5349 CurrentSource = L;
5350 return Call(S, CodePtr(), A0, A1);
5351}
5352#endif
5353#ifdef GET_OPCODE_NAMES
5354OP_CallBI,
5355#endif
5356#ifdef GET_INTERPFN_LIST
5357&Interp_CallBI,
5358#endif
5359#ifdef GET_INTERPFN_DISPATCHERS
5360PRESERVE_NONE
5361static bool Interp_CallBI(InterpState &S) {
5362 {
5363 CodePtr OpPC = S.PC;
5364 const auto V0 = ReadArg<const CallExpr *>(S, S.PC);
5365 const auto V1 = ReadArg<uint32_t>(S, S.PC);
5366 if (!CallBI(S, OpPC, V0, V1)) return false;
5367 }
5368#if USE_TAILCALLS
5369 MUSTTAIL return InterpNext(S);
5370#else
5371 return true;
5372#endif
5373}
5374#endif
5375#ifdef GET_DISASM
5376case OP_CallBI:
5377 Text.Op = PrintName("CallBI");
5378 Text.Args.push_back(printArg<const CallExpr *>(PC));
5379 Text.Args.push_back(printArg<uint32_t>(PC));
5380 break;
5381#endif
5382#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5383bool emitCallBI( const CallExpr * , uint32_t , SourceInfo);
5384#endif
5385#ifdef GET_LINK_IMPL
5386bool ByteCodeEmitter::emitCallBI( const CallExpr * A0, uint32_t A1, SourceInfo L) {
5387 return emitOp<const CallExpr *, uint32_t>(OP_CallBI, A0, A1, L);
5388}
5389#endif
5390#ifdef GET_EVAL_IMPL
5391bool EvalEmitter::emitCallBI( const CallExpr * A0, uint32_t A1, SourceInfo L) {
5392 if (!isActive()) return true;
5393 CurrentSource = L;
5394 return CallBI(S, CodePtr(), A0, A1);
5395}
5396#endif
5397#ifdef GET_OPCODE_NAMES
5398OP_CallPtr,
5399#endif
5400#ifdef GET_INTERPFN_LIST
5401&Interp_CallPtr,
5402#endif
5403#ifdef GET_INTERPFN_DISPATCHERS
5404PRESERVE_NONE
5405static bool Interp_CallPtr(InterpState &S) {
5406 {
5407 CodePtr OpPC = S.PC;
5408 const auto V0 = ReadArg<uint32_t>(S, S.PC);
5409 const auto V1 = ReadArg<const CallExpr *>(S, S.PC);
5410 if (!CallPtr(S, OpPC, V0, V1)) return false;
5411 }
5412#if USE_TAILCALLS
5413 MUSTTAIL return InterpNext(S);
5414#else
5415 return true;
5416#endif
5417}
5418#endif
5419#ifdef GET_DISASM
5420case OP_CallPtr:
5421 Text.Op = PrintName("CallPtr");
5422 Text.Args.push_back(printArg<uint32_t>(PC));
5423 Text.Args.push_back(printArg<const CallExpr *>(PC));
5424 break;
5425#endif
5426#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5427bool emitCallPtr( uint32_t , const CallExpr * , SourceInfo);
5428#endif
5429#ifdef GET_LINK_IMPL
5430bool ByteCodeEmitter::emitCallPtr( uint32_t A0, const CallExpr * A1, SourceInfo L) {
5431 return emitOp<uint32_t, const CallExpr *>(OP_CallPtr, A0, A1, L);
5432}
5433#endif
5434#ifdef GET_EVAL_IMPL
5435bool EvalEmitter::emitCallPtr( uint32_t A0, const CallExpr * A1, SourceInfo L) {
5436 if (!isActive()) return true;
5437 CurrentSource = L;
5438 return CallPtr(S, CodePtr(), A0, A1);
5439}
5440#endif
5441#ifdef GET_OPCODE_NAMES
5442OP_CallVar,
5443#endif
5444#ifdef GET_INTERPFN_LIST
5445&Interp_CallVar,
5446#endif
5447#ifdef GET_INTERPFN_DISPATCHERS
5448PRESERVE_NONE
5449static bool Interp_CallVar(InterpState &S) {
5450 {
5451 CodePtr OpPC = S.PC;
5452 const auto V0 = ReadArg<const Function *>(S, S.PC);
5453 const auto V1 = ReadArg<uint32_t>(S, S.PC);
5454 if (!CallVar(S, OpPC, V0, V1)) return false;
5455 }
5456#if USE_TAILCALLS
5457 MUSTTAIL return InterpNext(S);
5458#else
5459 return true;
5460#endif
5461}
5462#endif
5463#ifdef GET_DISASM
5464case OP_CallVar:
5465 Text.Op = PrintName("CallVar");
5466 Text.Args.push_back(printArg<const Function *>(PC));
5467 Text.Args.push_back(printArg<uint32_t>(PC));
5468 break;
5469#endif
5470#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5471bool emitCallVar( const Function * , uint32_t , SourceInfo);
5472#endif
5473#ifdef GET_LINK_IMPL
5474bool ByteCodeEmitter::emitCallVar( const Function * A0, uint32_t A1, SourceInfo L) {
5475 return emitOp<const Function *, uint32_t>(OP_CallVar, A0, A1, L);
5476}
5477#endif
5478#ifdef GET_EVAL_IMPL
5479bool EvalEmitter::emitCallVar( const Function * A0, uint32_t A1, SourceInfo L) {
5480 if (!isActive()) return true;
5481 CurrentSource = L;
5482 return CallVar(S, CodePtr(), A0, A1);
5483}
5484#endif
5485#ifdef GET_OPCODE_NAMES
5486OP_CallVirt,
5487#endif
5488#ifdef GET_INTERPFN_LIST
5489&Interp_CallVirt,
5490#endif
5491#ifdef GET_INTERPFN_DISPATCHERS
5492PRESERVE_NONE
5493static bool Interp_CallVirt(InterpState &S) {
5494 {
5495 CodePtr OpPC = S.PC;
5496 const auto V0 = ReadArg<const Function *>(S, S.PC);
5497 const auto V1 = ReadArg<uint32_t>(S, S.PC);
5498 if (!CallVirt(S, OpPC, V0, V1)) return false;
5499 }
5500#if USE_TAILCALLS
5501 MUSTTAIL return InterpNext(S);
5502#else
5503 return true;
5504#endif
5505}
5506#endif
5507#ifdef GET_DISASM
5508case OP_CallVirt:
5509 Text.Op = PrintName("CallVirt");
5510 Text.Args.push_back(printArg<const Function *>(PC));
5511 Text.Args.push_back(printArg<uint32_t>(PC));
5512 break;
5513#endif
5514#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
5515bool emitCallVirt( const Function * , uint32_t , SourceInfo);
5516#endif
5517#ifdef GET_LINK_IMPL
5518bool ByteCodeEmitter::emitCallVirt( const Function * A0, uint32_t A1, SourceInfo L) {
5519 return emitOp<const Function *, uint32_t>(OP_CallVirt, A0, A1, L);
5520}
5521#endif
5522#ifdef GET_EVAL_IMPL
5523bool EvalEmitter::emitCallVirt( const Function * A0, uint32_t A1, SourceInfo L) {
5524 if (!isActive()) return true;
5525 CurrentSource = L;
5526 return CallVirt(S, CodePtr(), A0, A1);
5527}
5528#endif
5529#ifdef GET_OPCODE_NAMES
5530OP_CastUint8Uint8,
5531OP_CastUint8Sint8,
5532OP_CastUint8Uint16,
5533OP_CastUint8Sint16,
5534OP_CastUint8Uint32,
5535OP_CastUint8Sint32,
5536OP_CastUint8Uint64,
5537OP_CastUint8Sint64,
5538OP_CastUint8Bool,
5539OP_CastSint8Uint8,
5540OP_CastSint8Sint8,
5541OP_CastSint8Uint16,
5542OP_CastSint8Sint16,
5543OP_CastSint8Uint32,
5544OP_CastSint8Sint32,
5545OP_CastSint8Uint64,
5546OP_CastSint8Sint64,
5547OP_CastSint8Bool,
5548OP_CastUint16Uint8,
5549OP_CastUint16Sint8,
5550OP_CastUint16Uint16,
5551OP_CastUint16Sint16,
5552OP_CastUint16Uint32,
5553OP_CastUint16Sint32,
5554OP_CastUint16Uint64,
5555OP_CastUint16Sint64,
5556OP_CastUint16Bool,
5557OP_CastSint16Uint8,
5558OP_CastSint16Sint8,
5559OP_CastSint16Uint16,
5560OP_CastSint16Sint16,
5561OP_CastSint16Uint32,
5562OP_CastSint16Sint32,
5563OP_CastSint16Uint64,
5564OP_CastSint16Sint64,
5565OP_CastSint16Bool,
5566OP_CastUint32Uint8,
5567OP_CastUint32Sint8,
5568OP_CastUint32Uint16,
5569OP_CastUint32Sint16,
5570OP_CastUint32Uint32,
5571OP_CastUint32Sint32,
5572OP_CastUint32Uint64,
5573OP_CastUint32Sint64,
5574OP_CastUint32Bool,
5575OP_CastSint32Uint8,
5576OP_CastSint32Sint8,
5577OP_CastSint32Uint16,
5578OP_CastSint32Sint16,
5579OP_CastSint32Uint32,
5580OP_CastSint32Sint32,
5581OP_CastSint32Uint64,
5582OP_CastSint32Sint64,
5583OP_CastSint32Bool,
5584OP_CastUint64Uint8,
5585OP_CastUint64Sint8,
5586OP_CastUint64Uint16,
5587OP_CastUint64Sint16,
5588OP_CastUint64Uint32,
5589OP_CastUint64Sint32,
5590OP_CastUint64Uint64,
5591OP_CastUint64Sint64,
5592OP_CastUint64Bool,
5593OP_CastSint64Uint8,
5594OP_CastSint64Sint8,
5595OP_CastSint64Uint16,
5596OP_CastSint64Sint16,
5597OP_CastSint64Uint32,
5598OP_CastSint64Sint32,
5599OP_CastSint64Uint64,
5600OP_CastSint64Sint64,
5601OP_CastSint64Bool,
5602OP_CastBoolUint8,
5603OP_CastBoolSint8,
5604OP_CastBoolUint16,
5605OP_CastBoolSint16,
5606OP_CastBoolUint32,
5607OP_CastBoolSint32,
5608OP_CastBoolUint64,
5609OP_CastBoolSint64,
5610OP_CastBoolBool,
5611OP_CastIntAPUint8,
5612OP_CastIntAPSint8,
5613OP_CastIntAPUint16,
5614OP_CastIntAPSint16,
5615OP_CastIntAPUint32,
5616OP_CastIntAPSint32,
5617OP_CastIntAPUint64,
5618OP_CastIntAPSint64,
5619OP_CastIntAPBool,
5620OP_CastIntAPSUint8,
5621OP_CastIntAPSSint8,
5622OP_CastIntAPSUint16,
5623OP_CastIntAPSSint16,
5624OP_CastIntAPSUint32,
5625OP_CastIntAPSSint32,
5626OP_CastIntAPSUint64,
5627OP_CastIntAPSSint64,
5628OP_CastIntAPSBool,
5629OP_CastFixedPointUint8,
5630OP_CastFixedPointSint8,
5631OP_CastFixedPointUint16,
5632OP_CastFixedPointSint16,
5633OP_CastFixedPointUint32,
5634OP_CastFixedPointSint32,
5635OP_CastFixedPointUint64,
5636OP_CastFixedPointSint64,
5637OP_CastFixedPointBool,
5638#endif
5639#ifdef GET_INTERPFN_LIST
5640&Interp_CastUint8Uint8,
5641&Interp_CastUint8Sint8,
5642&Interp_CastUint8Uint16,
5643&Interp_CastUint8Sint16,
5644&Interp_CastUint8Uint32,
5645&Interp_CastUint8Sint32,
5646&Interp_CastUint8Uint64,
5647&Interp_CastUint8Sint64,
5648&Interp_CastUint8Bool,
5649&Interp_CastSint8Uint8,
5650&Interp_CastSint8Sint8,
5651&Interp_CastSint8Uint16,
5652&Interp_CastSint8Sint16,
5653&Interp_CastSint8Uint32,
5654&Interp_CastSint8Sint32,
5655&Interp_CastSint8Uint64,
5656&Interp_CastSint8Sint64,
5657&Interp_CastSint8Bool,
5658&Interp_CastUint16Uint8,
5659&Interp_CastUint16Sint8,
5660&Interp_CastUint16Uint16,
5661&Interp_CastUint16Sint16,
5662&Interp_CastUint16Uint32,
5663&Interp_CastUint16Sint32,
5664&Interp_CastUint16Uint64,
5665&Interp_CastUint16Sint64,
5666&Interp_CastUint16Bool,
5667&Interp_CastSint16Uint8,
5668&Interp_CastSint16Sint8,
5669&Interp_CastSint16Uint16,
5670&Interp_CastSint16Sint16,
5671&Interp_CastSint16Uint32,
5672&Interp_CastSint16Sint32,
5673&Interp_CastSint16Uint64,
5674&Interp_CastSint16Sint64,
5675&Interp_CastSint16Bool,
5676&Interp_CastUint32Uint8,
5677&Interp_CastUint32Sint8,
5678&Interp_CastUint32Uint16,
5679&Interp_CastUint32Sint16,
5680&Interp_CastUint32Uint32,
5681&Interp_CastUint32Sint32,
5682&Interp_CastUint32Uint64,
5683&Interp_CastUint32Sint64,
5684&Interp_CastUint32Bool,
5685&Interp_CastSint32Uint8,
5686&Interp_CastSint32Sint8,
5687&Interp_CastSint32Uint16,
5688&Interp_CastSint32Sint16,
5689&Interp_CastSint32Uint32,
5690&Interp_CastSint32Sint32,
5691&Interp_CastSint32Uint64,
5692&Interp_CastSint32Sint64,
5693&Interp_CastSint32Bool,
5694&Interp_CastUint64Uint8,
5695&Interp_CastUint64Sint8,
5696&Interp_CastUint64Uint16,
5697&Interp_CastUint64Sint16,
5698&Interp_CastUint64Uint32,
5699&Interp_CastUint64Sint32,
5700&Interp_CastUint64Uint64,
5701&Interp_CastUint64Sint64,
5702&Interp_CastUint64Bool,
5703&Interp_CastSint64Uint8,
5704&Interp_CastSint64Sint8,
5705&Interp_CastSint64Uint16,
5706&Interp_CastSint64Sint16,
5707&Interp_CastSint64Uint32,
5708&Interp_CastSint64Sint32,
5709&Interp_CastSint64Uint64,
5710&Interp_CastSint64Sint64,
5711&Interp_CastSint64Bool,
5712&Interp_CastBoolUint8,
5713&Interp_CastBoolSint8,
5714&Interp_CastBoolUint16,
5715&Interp_CastBoolSint16,
5716&Interp_CastBoolUint32,
5717&Interp_CastBoolSint32,
5718&Interp_CastBoolUint64,
5719&Interp_CastBoolSint64,
5720&Interp_CastBoolBool,
5721&Interp_CastIntAPUint8,
5722&Interp_CastIntAPSint8,
5723&Interp_CastIntAPUint16,
5724&Interp_CastIntAPSint16,
5725&Interp_CastIntAPUint32,
5726&Interp_CastIntAPSint32,
5727&Interp_CastIntAPUint64,
5728&Interp_CastIntAPSint64,
5729&Interp_CastIntAPBool,
5730&Interp_CastIntAPSUint8,
5731&Interp_CastIntAPSSint8,
5732&Interp_CastIntAPSUint16,
5733&Interp_CastIntAPSSint16,
5734&Interp_CastIntAPSUint32,
5735&Interp_CastIntAPSSint32,
5736&Interp_CastIntAPSUint64,
5737&Interp_CastIntAPSSint64,
5738&Interp_CastIntAPSBool,
5739&Interp_CastFixedPointUint8,
5740&Interp_CastFixedPointSint8,
5741&Interp_CastFixedPointUint16,
5742&Interp_CastFixedPointSint16,
5743&Interp_CastFixedPointUint32,
5744&Interp_CastFixedPointSint32,
5745&Interp_CastFixedPointUint64,
5746&Interp_CastFixedPointSint64,
5747&Interp_CastFixedPointBool,
5748#endif
5749#ifdef GET_INTERPFN_DISPATCHERS
5750PRESERVE_NONE
5751static bool Interp_CastUint8Uint8(InterpState &S) {
5752 if (!Cast<PT_Uint8, PT_Uint8>(S, S.PC)) return false;
5753#if USE_TAILCALLS
5754 MUSTTAIL return InterpNext(S);
5755#else
5756 return true;
5757#endif
5758}
5759PRESERVE_NONE
5760static bool Interp_CastUint8Sint8(InterpState &S) {
5761 if (!Cast<PT_Uint8, PT_Sint8>(S, S.PC)) return false;
5762#if USE_TAILCALLS
5763 MUSTTAIL return InterpNext(S);
5764#else
5765 return true;
5766#endif
5767}
5768PRESERVE_NONE
5769static bool Interp_CastUint8Uint16(InterpState &S) {
5770 if (!Cast<PT_Uint8, PT_Uint16>(S, S.PC)) return false;
5771#if USE_TAILCALLS
5772 MUSTTAIL return InterpNext(S);
5773#else
5774 return true;
5775#endif
5776}
5777PRESERVE_NONE
5778static bool Interp_CastUint8Sint16(InterpState &S) {
5779 if (!Cast<PT_Uint8, PT_Sint16>(S, S.PC)) return false;
5780#if USE_TAILCALLS
5781 MUSTTAIL return InterpNext(S);
5782#else
5783 return true;
5784#endif
5785}
5786PRESERVE_NONE
5787static bool Interp_CastUint8Uint32(InterpState &S) {
5788 if (!Cast<PT_Uint8, PT_Uint32>(S, S.PC)) return false;
5789#if USE_TAILCALLS
5790 MUSTTAIL return InterpNext(S);
5791#else
5792 return true;
5793#endif
5794}
5795PRESERVE_NONE
5796static bool Interp_CastUint8Sint32(InterpState &S) {
5797 if (!Cast<PT_Uint8, PT_Sint32>(S, S.PC)) return false;
5798#if USE_TAILCALLS
5799 MUSTTAIL return InterpNext(S);
5800#else
5801 return true;
5802#endif
5803}
5804PRESERVE_NONE
5805static bool Interp_CastUint8Uint64(InterpState &S) {
5806 if (!Cast<PT_Uint8, PT_Uint64>(S, S.PC)) return false;
5807#if USE_TAILCALLS
5808 MUSTTAIL return InterpNext(S);
5809#else
5810 return true;
5811#endif
5812}
5813PRESERVE_NONE
5814static bool Interp_CastUint8Sint64(InterpState &S) {
5815 if (!Cast<PT_Uint8, PT_Sint64>(S, S.PC)) return false;
5816#if USE_TAILCALLS
5817 MUSTTAIL return InterpNext(S);
5818#else
5819 return true;
5820#endif
5821}
5822PRESERVE_NONE
5823static bool Interp_CastUint8Bool(InterpState &S) {
5824 if (!Cast<PT_Uint8, PT_Bool>(S, S.PC)) return false;
5825#if USE_TAILCALLS
5826 MUSTTAIL return InterpNext(S);
5827#else
5828 return true;
5829#endif
5830}
5831PRESERVE_NONE
5832static bool Interp_CastSint8Uint8(InterpState &S) {
5833 if (!Cast<PT_Sint8, PT_Uint8>(S, S.PC)) return false;
5834#if USE_TAILCALLS
5835 MUSTTAIL return InterpNext(S);
5836#else
5837 return true;
5838#endif
5839}
5840PRESERVE_NONE
5841static bool Interp_CastSint8Sint8(InterpState &S) {
5842 if (!Cast<PT_Sint8, PT_Sint8>(S, S.PC)) return false;
5843#if USE_TAILCALLS
5844 MUSTTAIL return InterpNext(S);
5845#else
5846 return true;
5847#endif
5848}
5849PRESERVE_NONE
5850static bool Interp_CastSint8Uint16(InterpState &S) {
5851 if (!Cast<PT_Sint8, PT_Uint16>(S, S.PC)) return false;
5852#if USE_TAILCALLS
5853 MUSTTAIL return InterpNext(S);
5854#else
5855 return true;
5856#endif
5857}
5858PRESERVE_NONE
5859static bool Interp_CastSint8Sint16(InterpState &S) {
5860 if (!Cast<PT_Sint8, PT_Sint16>(S, S.PC)) return false;
5861#if USE_TAILCALLS
5862 MUSTTAIL return InterpNext(S);
5863#else
5864 return true;
5865#endif
5866}
5867PRESERVE_NONE
5868static bool Interp_CastSint8Uint32(InterpState &S) {
5869 if (!Cast<PT_Sint8, PT_Uint32>(S, S.PC)) return false;
5870#if USE_TAILCALLS
5871 MUSTTAIL return InterpNext(S);
5872#else
5873 return true;
5874#endif
5875}
5876PRESERVE_NONE
5877static bool Interp_CastSint8Sint32(InterpState &S) {
5878 if (!Cast<PT_Sint8, PT_Sint32>(S, S.PC)) return false;
5879#if USE_TAILCALLS
5880 MUSTTAIL return InterpNext(S);
5881#else
5882 return true;
5883#endif
5884}
5885PRESERVE_NONE
5886static bool Interp_CastSint8Uint64(InterpState &S) {
5887 if (!Cast<PT_Sint8, PT_Uint64>(S, S.PC)) return false;
5888#if USE_TAILCALLS
5889 MUSTTAIL return InterpNext(S);
5890#else
5891 return true;
5892#endif
5893}
5894PRESERVE_NONE
5895static bool Interp_CastSint8Sint64(InterpState &S) {
5896 if (!Cast<PT_Sint8, PT_Sint64>(S, S.PC)) return false;
5897#if USE_TAILCALLS
5898 MUSTTAIL return InterpNext(S);
5899#else
5900 return true;
5901#endif
5902}
5903PRESERVE_NONE
5904static bool Interp_CastSint8Bool(InterpState &S) {
5905 if (!Cast<PT_Sint8, PT_Bool>(S, S.PC)) return false;
5906#if USE_TAILCALLS
5907 MUSTTAIL return InterpNext(S);
5908#else
5909 return true;
5910#endif
5911}
5912PRESERVE_NONE
5913static bool Interp_CastUint16Uint8(InterpState &S) {
5914 if (!Cast<PT_Uint16, PT_Uint8>(S, S.PC)) return false;
5915#if USE_TAILCALLS
5916 MUSTTAIL return InterpNext(S);
5917#else
5918 return true;
5919#endif
5920}
5921PRESERVE_NONE
5922static bool Interp_CastUint16Sint8(InterpState &S) {
5923 if (!Cast<PT_Uint16, PT_Sint8>(S, S.PC)) return false;
5924#if USE_TAILCALLS
5925 MUSTTAIL return InterpNext(S);
5926#else
5927 return true;
5928#endif
5929}
5930PRESERVE_NONE
5931static bool Interp_CastUint16Uint16(InterpState &S) {
5932 if (!Cast<PT_Uint16, PT_Uint16>(S, S.PC)) return false;
5933#if USE_TAILCALLS
5934 MUSTTAIL return InterpNext(S);
5935#else
5936 return true;
5937#endif
5938}
5939PRESERVE_NONE
5940static bool Interp_CastUint16Sint16(InterpState &S) {
5941 if (!Cast<PT_Uint16, PT_Sint16>(S, S.PC)) return false;
5942#if USE_TAILCALLS
5943 MUSTTAIL return InterpNext(S);
5944#else
5945 return true;
5946#endif
5947}
5948PRESERVE_NONE
5949static bool Interp_CastUint16Uint32(InterpState &S) {
5950 if (!Cast<PT_Uint16, PT_Uint32>(S, S.PC)) return false;
5951#if USE_TAILCALLS
5952 MUSTTAIL return InterpNext(S);
5953#else
5954 return true;
5955#endif
5956}
5957PRESERVE_NONE
5958static bool Interp_CastUint16Sint32(InterpState &S) {
5959 if (!Cast<PT_Uint16, PT_Sint32>(S, S.PC)) return false;
5960#if USE_TAILCALLS
5961 MUSTTAIL return InterpNext(S);
5962#else
5963 return true;
5964#endif
5965}
5966PRESERVE_NONE
5967static bool Interp_CastUint16Uint64(InterpState &S) {
5968 if (!Cast<PT_Uint16, PT_Uint64>(S, S.PC)) return false;
5969#if USE_TAILCALLS
5970 MUSTTAIL return InterpNext(S);
5971#else
5972 return true;
5973#endif
5974}
5975PRESERVE_NONE
5976static bool Interp_CastUint16Sint64(InterpState &S) {
5977 if (!Cast<PT_Uint16, PT_Sint64>(S, S.PC)) return false;
5978#if USE_TAILCALLS
5979 MUSTTAIL return InterpNext(S);
5980#else
5981 return true;
5982#endif
5983}
5984PRESERVE_NONE
5985static bool Interp_CastUint16Bool(InterpState &S) {
5986 if (!Cast<PT_Uint16, PT_Bool>(S, S.PC)) return false;
5987#if USE_TAILCALLS
5988 MUSTTAIL return InterpNext(S);
5989#else
5990 return true;
5991#endif
5992}
5993PRESERVE_NONE
5994static bool Interp_CastSint16Uint8(InterpState &S) {
5995 if (!Cast<PT_Sint16, PT_Uint8>(S, S.PC)) return false;
5996#if USE_TAILCALLS
5997 MUSTTAIL return InterpNext(S);
5998#else
5999 return true;
6000#endif
6001}
6002PRESERVE_NONE
6003static bool Interp_CastSint16Sint8(InterpState &S) {
6004 if (!Cast<PT_Sint16, PT_Sint8>(S, S.PC)) return false;
6005#if USE_TAILCALLS
6006 MUSTTAIL return InterpNext(S);
6007#else
6008 return true;
6009#endif
6010}
6011PRESERVE_NONE
6012static bool Interp_CastSint16Uint16(InterpState &S) {
6013 if (!Cast<PT_Sint16, PT_Uint16>(S, S.PC)) return false;
6014#if USE_TAILCALLS
6015 MUSTTAIL return InterpNext(S);
6016#else
6017 return true;
6018#endif
6019}
6020PRESERVE_NONE
6021static bool Interp_CastSint16Sint16(InterpState &S) {
6022 if (!Cast<PT_Sint16, PT_Sint16>(S, S.PC)) return false;
6023#if USE_TAILCALLS
6024 MUSTTAIL return InterpNext(S);
6025#else
6026 return true;
6027#endif
6028}
6029PRESERVE_NONE
6030static bool Interp_CastSint16Uint32(InterpState &S) {
6031 if (!Cast<PT_Sint16, PT_Uint32>(S, S.PC)) return false;
6032#if USE_TAILCALLS
6033 MUSTTAIL return InterpNext(S);
6034#else
6035 return true;
6036#endif
6037}
6038PRESERVE_NONE
6039static bool Interp_CastSint16Sint32(InterpState &S) {
6040 if (!Cast<PT_Sint16, PT_Sint32>(S, S.PC)) return false;
6041#if USE_TAILCALLS
6042 MUSTTAIL return InterpNext(S);
6043#else
6044 return true;
6045#endif
6046}
6047PRESERVE_NONE
6048static bool Interp_CastSint16Uint64(InterpState &S) {
6049 if (!Cast<PT_Sint16, PT_Uint64>(S, S.PC)) return false;
6050#if USE_TAILCALLS
6051 MUSTTAIL return InterpNext(S);
6052#else
6053 return true;
6054#endif
6055}
6056PRESERVE_NONE
6057static bool Interp_CastSint16Sint64(InterpState &S) {
6058 if (!Cast<PT_Sint16, PT_Sint64>(S, S.PC)) return false;
6059#if USE_TAILCALLS
6060 MUSTTAIL return InterpNext(S);
6061#else
6062 return true;
6063#endif
6064}
6065PRESERVE_NONE
6066static bool Interp_CastSint16Bool(InterpState &S) {
6067 if (!Cast<PT_Sint16, PT_Bool>(S, S.PC)) return false;
6068#if USE_TAILCALLS
6069 MUSTTAIL return InterpNext(S);
6070#else
6071 return true;
6072#endif
6073}
6074PRESERVE_NONE
6075static bool Interp_CastUint32Uint8(InterpState &S) {
6076 if (!Cast<PT_Uint32, PT_Uint8>(S, S.PC)) return false;
6077#if USE_TAILCALLS
6078 MUSTTAIL return InterpNext(S);
6079#else
6080 return true;
6081#endif
6082}
6083PRESERVE_NONE
6084static bool Interp_CastUint32Sint8(InterpState &S) {
6085 if (!Cast<PT_Uint32, PT_Sint8>(S, S.PC)) return false;
6086#if USE_TAILCALLS
6087 MUSTTAIL return InterpNext(S);
6088#else
6089 return true;
6090#endif
6091}
6092PRESERVE_NONE
6093static bool Interp_CastUint32Uint16(InterpState &S) {
6094 if (!Cast<PT_Uint32, PT_Uint16>(S, S.PC)) return false;
6095#if USE_TAILCALLS
6096 MUSTTAIL return InterpNext(S);
6097#else
6098 return true;
6099#endif
6100}
6101PRESERVE_NONE
6102static bool Interp_CastUint32Sint16(InterpState &S) {
6103 if (!Cast<PT_Uint32, PT_Sint16>(S, S.PC)) return false;
6104#if USE_TAILCALLS
6105 MUSTTAIL return InterpNext(S);
6106#else
6107 return true;
6108#endif
6109}
6110PRESERVE_NONE
6111static bool Interp_CastUint32Uint32(InterpState &S) {
6112 if (!Cast<PT_Uint32, PT_Uint32>(S, S.PC)) return false;
6113#if USE_TAILCALLS
6114 MUSTTAIL return InterpNext(S);
6115#else
6116 return true;
6117#endif
6118}
6119PRESERVE_NONE
6120static bool Interp_CastUint32Sint32(InterpState &S) {
6121 if (!Cast<PT_Uint32, PT_Sint32>(S, S.PC)) return false;
6122#if USE_TAILCALLS
6123 MUSTTAIL return InterpNext(S);
6124#else
6125 return true;
6126#endif
6127}
6128PRESERVE_NONE
6129static bool Interp_CastUint32Uint64(InterpState &S) {
6130 if (!Cast<PT_Uint32, PT_Uint64>(S, S.PC)) return false;
6131#if USE_TAILCALLS
6132 MUSTTAIL return InterpNext(S);
6133#else
6134 return true;
6135#endif
6136}
6137PRESERVE_NONE
6138static bool Interp_CastUint32Sint64(InterpState &S) {
6139 if (!Cast<PT_Uint32, PT_Sint64>(S, S.PC)) return false;
6140#if USE_TAILCALLS
6141 MUSTTAIL return InterpNext(S);
6142#else
6143 return true;
6144#endif
6145}
6146PRESERVE_NONE
6147static bool Interp_CastUint32Bool(InterpState &S) {
6148 if (!Cast<PT_Uint32, PT_Bool>(S, S.PC)) return false;
6149#if USE_TAILCALLS
6150 MUSTTAIL return InterpNext(S);
6151#else
6152 return true;
6153#endif
6154}
6155PRESERVE_NONE
6156static bool Interp_CastSint32Uint8(InterpState &S) {
6157 if (!Cast<PT_Sint32, PT_Uint8>(S, S.PC)) return false;
6158#if USE_TAILCALLS
6159 MUSTTAIL return InterpNext(S);
6160#else
6161 return true;
6162#endif
6163}
6164PRESERVE_NONE
6165static bool Interp_CastSint32Sint8(InterpState &S) {
6166 if (!Cast<PT_Sint32, PT_Sint8>(S, S.PC)) return false;
6167#if USE_TAILCALLS
6168 MUSTTAIL return InterpNext(S);
6169#else
6170 return true;
6171#endif
6172}
6173PRESERVE_NONE
6174static bool Interp_CastSint32Uint16(InterpState &S) {
6175 if (!Cast<PT_Sint32, PT_Uint16>(S, S.PC)) return false;
6176#if USE_TAILCALLS
6177 MUSTTAIL return InterpNext(S);
6178#else
6179 return true;
6180#endif
6181}
6182PRESERVE_NONE
6183static bool Interp_CastSint32Sint16(InterpState &S) {
6184 if (!Cast<PT_Sint32, PT_Sint16>(S, S.PC)) return false;
6185#if USE_TAILCALLS
6186 MUSTTAIL return InterpNext(S);
6187#else
6188 return true;
6189#endif
6190}
6191PRESERVE_NONE
6192static bool Interp_CastSint32Uint32(InterpState &S) {
6193 if (!Cast<PT_Sint32, PT_Uint32>(S, S.PC)) return false;
6194#if USE_TAILCALLS
6195 MUSTTAIL return InterpNext(S);
6196#else
6197 return true;
6198#endif
6199}
6200PRESERVE_NONE
6201static bool Interp_CastSint32Sint32(InterpState &S) {
6202 if (!Cast<PT_Sint32, PT_Sint32>(S, S.PC)) return false;
6203#if USE_TAILCALLS
6204 MUSTTAIL return InterpNext(S);
6205#else
6206 return true;
6207#endif
6208}
6209PRESERVE_NONE
6210static bool Interp_CastSint32Uint64(InterpState &S) {
6211 if (!Cast<PT_Sint32, PT_Uint64>(S, S.PC)) return false;
6212#if USE_TAILCALLS
6213 MUSTTAIL return InterpNext(S);
6214#else
6215 return true;
6216#endif
6217}
6218PRESERVE_NONE
6219static bool Interp_CastSint32Sint64(InterpState &S) {
6220 if (!Cast<PT_Sint32, PT_Sint64>(S, S.PC)) return false;
6221#if USE_TAILCALLS
6222 MUSTTAIL return InterpNext(S);
6223#else
6224 return true;
6225#endif
6226}
6227PRESERVE_NONE
6228static bool Interp_CastSint32Bool(InterpState &S) {
6229 if (!Cast<PT_Sint32, PT_Bool>(S, S.PC)) return false;
6230#if USE_TAILCALLS
6231 MUSTTAIL return InterpNext(S);
6232#else
6233 return true;
6234#endif
6235}
6236PRESERVE_NONE
6237static bool Interp_CastUint64Uint8(InterpState &S) {
6238 if (!Cast<PT_Uint64, PT_Uint8>(S, S.PC)) return false;
6239#if USE_TAILCALLS
6240 MUSTTAIL return InterpNext(S);
6241#else
6242 return true;
6243#endif
6244}
6245PRESERVE_NONE
6246static bool Interp_CastUint64Sint8(InterpState &S) {
6247 if (!Cast<PT_Uint64, PT_Sint8>(S, S.PC)) return false;
6248#if USE_TAILCALLS
6249 MUSTTAIL return InterpNext(S);
6250#else
6251 return true;
6252#endif
6253}
6254PRESERVE_NONE
6255static bool Interp_CastUint64Uint16(InterpState &S) {
6256 if (!Cast<PT_Uint64, PT_Uint16>(S, S.PC)) return false;
6257#if USE_TAILCALLS
6258 MUSTTAIL return InterpNext(S);
6259#else
6260 return true;
6261#endif
6262}
6263PRESERVE_NONE
6264static bool Interp_CastUint64Sint16(InterpState &S) {
6265 if (!Cast<PT_Uint64, PT_Sint16>(S, S.PC)) return false;
6266#if USE_TAILCALLS
6267 MUSTTAIL return InterpNext(S);
6268#else
6269 return true;
6270#endif
6271}
6272PRESERVE_NONE
6273static bool Interp_CastUint64Uint32(InterpState &S) {
6274 if (!Cast<PT_Uint64, PT_Uint32>(S, S.PC)) return false;
6275#if USE_TAILCALLS
6276 MUSTTAIL return InterpNext(S);
6277#else
6278 return true;
6279#endif
6280}
6281PRESERVE_NONE
6282static bool Interp_CastUint64Sint32(InterpState &S) {
6283 if (!Cast<PT_Uint64, PT_Sint32>(S, S.PC)) return false;
6284#if USE_TAILCALLS
6285 MUSTTAIL return InterpNext(S);
6286#else
6287 return true;
6288#endif
6289}
6290PRESERVE_NONE
6291static bool Interp_CastUint64Uint64(InterpState &S) {
6292 if (!Cast<PT_Uint64, PT_Uint64>(S, S.PC)) return false;
6293#if USE_TAILCALLS
6294 MUSTTAIL return InterpNext(S);
6295#else
6296 return true;
6297#endif
6298}
6299PRESERVE_NONE
6300static bool Interp_CastUint64Sint64(InterpState &S) {
6301 if (!Cast<PT_Uint64, PT_Sint64>(S, S.PC)) return false;
6302#if USE_TAILCALLS
6303 MUSTTAIL return InterpNext(S);
6304#else
6305 return true;
6306#endif
6307}
6308PRESERVE_NONE
6309static bool Interp_CastUint64Bool(InterpState &S) {
6310 if (!Cast<PT_Uint64, PT_Bool>(S, S.PC)) return false;
6311#if USE_TAILCALLS
6312 MUSTTAIL return InterpNext(S);
6313#else
6314 return true;
6315#endif
6316}
6317PRESERVE_NONE
6318static bool Interp_CastSint64Uint8(InterpState &S) {
6319 if (!Cast<PT_Sint64, PT_Uint8>(S, S.PC)) return false;
6320#if USE_TAILCALLS
6321 MUSTTAIL return InterpNext(S);
6322#else
6323 return true;
6324#endif
6325}
6326PRESERVE_NONE
6327static bool Interp_CastSint64Sint8(InterpState &S) {
6328 if (!Cast<PT_Sint64, PT_Sint8>(S, S.PC)) return false;
6329#if USE_TAILCALLS
6330 MUSTTAIL return InterpNext(S);
6331#else
6332 return true;
6333#endif
6334}
6335PRESERVE_NONE
6336static bool Interp_CastSint64Uint16(InterpState &S) {
6337 if (!Cast<PT_Sint64, PT_Uint16>(S, S.PC)) return false;
6338#if USE_TAILCALLS
6339 MUSTTAIL return InterpNext(S);
6340#else
6341 return true;
6342#endif
6343}
6344PRESERVE_NONE
6345static bool Interp_CastSint64Sint16(InterpState &S) {
6346 if (!Cast<PT_Sint64, PT_Sint16>(S, S.PC)) return false;
6347#if USE_TAILCALLS
6348 MUSTTAIL return InterpNext(S);
6349#else
6350 return true;
6351#endif
6352}
6353PRESERVE_NONE
6354static bool Interp_CastSint64Uint32(InterpState &S) {
6355 if (!Cast<PT_Sint64, PT_Uint32>(S, S.PC)) return false;
6356#if USE_TAILCALLS
6357 MUSTTAIL return InterpNext(S);
6358#else
6359 return true;
6360#endif
6361}
6362PRESERVE_NONE
6363static bool Interp_CastSint64Sint32(InterpState &S) {
6364 if (!Cast<PT_Sint64, PT_Sint32>(S, S.PC)) return false;
6365#if USE_TAILCALLS
6366 MUSTTAIL return InterpNext(S);
6367#else
6368 return true;
6369#endif
6370}
6371PRESERVE_NONE
6372static bool Interp_CastSint64Uint64(InterpState &S) {
6373 if (!Cast<PT_Sint64, PT_Uint64>(S, S.PC)) return false;
6374#if USE_TAILCALLS
6375 MUSTTAIL return InterpNext(S);
6376#else
6377 return true;
6378#endif
6379}
6380PRESERVE_NONE
6381static bool Interp_CastSint64Sint64(InterpState &S) {
6382 if (!Cast<PT_Sint64, PT_Sint64>(S, S.PC)) return false;
6383#if USE_TAILCALLS
6384 MUSTTAIL return InterpNext(S);
6385#else
6386 return true;
6387#endif
6388}
6389PRESERVE_NONE
6390static bool Interp_CastSint64Bool(InterpState &S) {
6391 if (!Cast<PT_Sint64, PT_Bool>(S, S.PC)) return false;
6392#if USE_TAILCALLS
6393 MUSTTAIL return InterpNext(S);
6394#else
6395 return true;
6396#endif
6397}
6398PRESERVE_NONE
6399static bool Interp_CastBoolUint8(InterpState &S) {
6400 if (!Cast<PT_Bool, PT_Uint8>(S, S.PC)) return false;
6401#if USE_TAILCALLS
6402 MUSTTAIL return InterpNext(S);
6403#else
6404 return true;
6405#endif
6406}
6407PRESERVE_NONE
6408static bool Interp_CastBoolSint8(InterpState &S) {
6409 if (!Cast<PT_Bool, PT_Sint8>(S, S.PC)) return false;
6410#if USE_TAILCALLS
6411 MUSTTAIL return InterpNext(S);
6412#else
6413 return true;
6414#endif
6415}
6416PRESERVE_NONE
6417static bool Interp_CastBoolUint16(InterpState &S) {
6418 if (!Cast<PT_Bool, PT_Uint16>(S, S.PC)) return false;
6419#if USE_TAILCALLS
6420 MUSTTAIL return InterpNext(S);
6421#else
6422 return true;
6423#endif
6424}
6425PRESERVE_NONE
6426static bool Interp_CastBoolSint16(InterpState &S) {
6427 if (!Cast<PT_Bool, PT_Sint16>(S, S.PC)) return false;
6428#if USE_TAILCALLS
6429 MUSTTAIL return InterpNext(S);
6430#else
6431 return true;
6432#endif
6433}
6434PRESERVE_NONE
6435static bool Interp_CastBoolUint32(InterpState &S) {
6436 if (!Cast<PT_Bool, PT_Uint32>(S, S.PC)) return false;
6437#if USE_TAILCALLS
6438 MUSTTAIL return InterpNext(S);
6439#else
6440 return true;
6441#endif
6442}
6443PRESERVE_NONE
6444static bool Interp_CastBoolSint32(InterpState &S) {
6445 if (!Cast<PT_Bool, PT_Sint32>(S, S.PC)) return false;
6446#if USE_TAILCALLS
6447 MUSTTAIL return InterpNext(S);
6448#else
6449 return true;
6450#endif
6451}
6452PRESERVE_NONE
6453static bool Interp_CastBoolUint64(InterpState &S) {
6454 if (!Cast<PT_Bool, PT_Uint64>(S, S.PC)) return false;
6455#if USE_TAILCALLS
6456 MUSTTAIL return InterpNext(S);
6457#else
6458 return true;
6459#endif
6460}
6461PRESERVE_NONE
6462static bool Interp_CastBoolSint64(InterpState &S) {
6463 if (!Cast<PT_Bool, PT_Sint64>(S, S.PC)) return false;
6464#if USE_TAILCALLS
6465 MUSTTAIL return InterpNext(S);
6466#else
6467 return true;
6468#endif
6469}
6470PRESERVE_NONE
6471static bool Interp_CastBoolBool(InterpState &S) {
6472 if (!Cast<PT_Bool, PT_Bool>(S, S.PC)) return false;
6473#if USE_TAILCALLS
6474 MUSTTAIL return InterpNext(S);
6475#else
6476 return true;
6477#endif
6478}
6479PRESERVE_NONE
6480static bool Interp_CastIntAPUint8(InterpState &S) {
6481 if (!Cast<PT_IntAP, PT_Uint8>(S, S.PC)) return false;
6482#if USE_TAILCALLS
6483 MUSTTAIL return InterpNext(S);
6484#else
6485 return true;
6486#endif
6487}
6488PRESERVE_NONE
6489static bool Interp_CastIntAPSint8(InterpState &S) {
6490 if (!Cast<PT_IntAP, PT_Sint8>(S, S.PC)) return false;
6491#if USE_TAILCALLS
6492 MUSTTAIL return InterpNext(S);
6493#else
6494 return true;
6495#endif
6496}
6497PRESERVE_NONE
6498static bool Interp_CastIntAPUint16(InterpState &S) {
6499 if (!Cast<PT_IntAP, PT_Uint16>(S, S.PC)) return false;
6500#if USE_TAILCALLS
6501 MUSTTAIL return InterpNext(S);
6502#else
6503 return true;
6504#endif
6505}
6506PRESERVE_NONE
6507static bool Interp_CastIntAPSint16(InterpState &S) {
6508 if (!Cast<PT_IntAP, PT_Sint16>(S, S.PC)) return false;
6509#if USE_TAILCALLS
6510 MUSTTAIL return InterpNext(S);
6511#else
6512 return true;
6513#endif
6514}
6515PRESERVE_NONE
6516static bool Interp_CastIntAPUint32(InterpState &S) {
6517 if (!Cast<PT_IntAP, PT_Uint32>(S, S.PC)) return false;
6518#if USE_TAILCALLS
6519 MUSTTAIL return InterpNext(S);
6520#else
6521 return true;
6522#endif
6523}
6524PRESERVE_NONE
6525static bool Interp_CastIntAPSint32(InterpState &S) {
6526 if (!Cast<PT_IntAP, PT_Sint32>(S, S.PC)) return false;
6527#if USE_TAILCALLS
6528 MUSTTAIL return InterpNext(S);
6529#else
6530 return true;
6531#endif
6532}
6533PRESERVE_NONE
6534static bool Interp_CastIntAPUint64(InterpState &S) {
6535 if (!Cast<PT_IntAP, PT_Uint64>(S, S.PC)) return false;
6536#if USE_TAILCALLS
6537 MUSTTAIL return InterpNext(S);
6538#else
6539 return true;
6540#endif
6541}
6542PRESERVE_NONE
6543static bool Interp_CastIntAPSint64(InterpState &S) {
6544 if (!Cast<PT_IntAP, PT_Sint64>(S, S.PC)) return false;
6545#if USE_TAILCALLS
6546 MUSTTAIL return InterpNext(S);
6547#else
6548 return true;
6549#endif
6550}
6551PRESERVE_NONE
6552static bool Interp_CastIntAPBool(InterpState &S) {
6553 if (!Cast<PT_IntAP, PT_Bool>(S, S.PC)) return false;
6554#if USE_TAILCALLS
6555 MUSTTAIL return InterpNext(S);
6556#else
6557 return true;
6558#endif
6559}
6560PRESERVE_NONE
6561static bool Interp_CastIntAPSUint8(InterpState &S) {
6562 if (!Cast<PT_IntAPS, PT_Uint8>(S, S.PC)) return false;
6563#if USE_TAILCALLS
6564 MUSTTAIL return InterpNext(S);
6565#else
6566 return true;
6567#endif
6568}
6569PRESERVE_NONE
6570static bool Interp_CastIntAPSSint8(InterpState &S) {
6571 if (!Cast<PT_IntAPS, PT_Sint8>(S, S.PC)) return false;
6572#if USE_TAILCALLS
6573 MUSTTAIL return InterpNext(S);
6574#else
6575 return true;
6576#endif
6577}
6578PRESERVE_NONE
6579static bool Interp_CastIntAPSUint16(InterpState &S) {
6580 if (!Cast<PT_IntAPS, PT_Uint16>(S, S.PC)) return false;
6581#if USE_TAILCALLS
6582 MUSTTAIL return InterpNext(S);
6583#else
6584 return true;
6585#endif
6586}
6587PRESERVE_NONE
6588static bool Interp_CastIntAPSSint16(InterpState &S) {
6589 if (!Cast<PT_IntAPS, PT_Sint16>(S, S.PC)) return false;
6590#if USE_TAILCALLS
6591 MUSTTAIL return InterpNext(S);
6592#else
6593 return true;
6594#endif
6595}
6596PRESERVE_NONE
6597static bool Interp_CastIntAPSUint32(InterpState &S) {
6598 if (!Cast<PT_IntAPS, PT_Uint32>(S, S.PC)) return false;
6599#if USE_TAILCALLS
6600 MUSTTAIL return InterpNext(S);
6601#else
6602 return true;
6603#endif
6604}
6605PRESERVE_NONE
6606static bool Interp_CastIntAPSSint32(InterpState &S) {
6607 if (!Cast<PT_IntAPS, PT_Sint32>(S, S.PC)) return false;
6608#if USE_TAILCALLS
6609 MUSTTAIL return InterpNext(S);
6610#else
6611 return true;
6612#endif
6613}
6614PRESERVE_NONE
6615static bool Interp_CastIntAPSUint64(InterpState &S) {
6616 if (!Cast<PT_IntAPS, PT_Uint64>(S, S.PC)) return false;
6617#if USE_TAILCALLS
6618 MUSTTAIL return InterpNext(S);
6619#else
6620 return true;
6621#endif
6622}
6623PRESERVE_NONE
6624static bool Interp_CastIntAPSSint64(InterpState &S) {
6625 if (!Cast<PT_IntAPS, PT_Sint64>(S, S.PC)) return false;
6626#if USE_TAILCALLS
6627 MUSTTAIL return InterpNext(S);
6628#else
6629 return true;
6630#endif
6631}
6632PRESERVE_NONE
6633static bool Interp_CastIntAPSBool(InterpState &S) {
6634 if (!Cast<PT_IntAPS, PT_Bool>(S, S.PC)) return false;
6635#if USE_TAILCALLS
6636 MUSTTAIL return InterpNext(S);
6637#else
6638 return true;
6639#endif
6640}
6641PRESERVE_NONE
6642static bool Interp_CastFixedPointUint8(InterpState &S) {
6643 if (!Cast<PT_FixedPoint, PT_Uint8>(S, S.PC)) return false;
6644#if USE_TAILCALLS
6645 MUSTTAIL return InterpNext(S);
6646#else
6647 return true;
6648#endif
6649}
6650PRESERVE_NONE
6651static bool Interp_CastFixedPointSint8(InterpState &S) {
6652 if (!Cast<PT_FixedPoint, PT_Sint8>(S, S.PC)) return false;
6653#if USE_TAILCALLS
6654 MUSTTAIL return InterpNext(S);
6655#else
6656 return true;
6657#endif
6658}
6659PRESERVE_NONE
6660static bool Interp_CastFixedPointUint16(InterpState &S) {
6661 if (!Cast<PT_FixedPoint, PT_Uint16>(S, S.PC)) return false;
6662#if USE_TAILCALLS
6663 MUSTTAIL return InterpNext(S);
6664#else
6665 return true;
6666#endif
6667}
6668PRESERVE_NONE
6669static bool Interp_CastFixedPointSint16(InterpState &S) {
6670 if (!Cast<PT_FixedPoint, PT_Sint16>(S, S.PC)) return false;
6671#if USE_TAILCALLS
6672 MUSTTAIL return InterpNext(S);
6673#else
6674 return true;
6675#endif
6676}
6677PRESERVE_NONE
6678static bool Interp_CastFixedPointUint32(InterpState &S) {
6679 if (!Cast<PT_FixedPoint, PT_Uint32>(S, S.PC)) return false;
6680#if USE_TAILCALLS
6681 MUSTTAIL return InterpNext(S);
6682#else
6683 return true;
6684#endif
6685}
6686PRESERVE_NONE
6687static bool Interp_CastFixedPointSint32(InterpState &S) {
6688 if (!Cast<PT_FixedPoint, PT_Sint32>(S, S.PC)) return false;
6689#if USE_TAILCALLS
6690 MUSTTAIL return InterpNext(S);
6691#else
6692 return true;
6693#endif
6694}
6695PRESERVE_NONE
6696static bool Interp_CastFixedPointUint64(InterpState &S) {
6697 if (!Cast<PT_FixedPoint, PT_Uint64>(S, S.PC)) return false;
6698#if USE_TAILCALLS
6699 MUSTTAIL return InterpNext(S);
6700#else
6701 return true;
6702#endif
6703}
6704PRESERVE_NONE
6705static bool Interp_CastFixedPointSint64(InterpState &S) {
6706 if (!Cast<PT_FixedPoint, PT_Sint64>(S, S.PC)) return false;
6707#if USE_TAILCALLS
6708 MUSTTAIL return InterpNext(S);
6709#else
6710 return true;
6711#endif
6712}
6713PRESERVE_NONE
6714static bool Interp_CastFixedPointBool(InterpState &S) {
6715 if (!Cast<PT_FixedPoint, PT_Bool>(S, S.PC)) return false;
6716#if USE_TAILCALLS
6717 MUSTTAIL return InterpNext(S);
6718#else
6719 return true;
6720#endif
6721}
6722#endif
6723#ifdef GET_DISASM
6724case OP_CastUint8Uint8:
6725 Text.Op = PrintName("CastUint8Uint8");
6726 break;
6727case OP_CastUint8Sint8:
6728 Text.Op = PrintName("CastUint8Sint8");
6729 break;
6730case OP_CastUint8Uint16:
6731 Text.Op = PrintName("CastUint8Uint16");
6732 break;
6733case OP_CastUint8Sint16:
6734 Text.Op = PrintName("CastUint8Sint16");
6735 break;
6736case OP_CastUint8Uint32:
6737 Text.Op = PrintName("CastUint8Uint32");
6738 break;
6739case OP_CastUint8Sint32:
6740 Text.Op = PrintName("CastUint8Sint32");
6741 break;
6742case OP_CastUint8Uint64:
6743 Text.Op = PrintName("CastUint8Uint64");
6744 break;
6745case OP_CastUint8Sint64:
6746 Text.Op = PrintName("CastUint8Sint64");
6747 break;
6748case OP_CastUint8Bool:
6749 Text.Op = PrintName("CastUint8Bool");
6750 break;
6751case OP_CastSint8Uint8:
6752 Text.Op = PrintName("CastSint8Uint8");
6753 break;
6754case OP_CastSint8Sint8:
6755 Text.Op = PrintName("CastSint8Sint8");
6756 break;
6757case OP_CastSint8Uint16:
6758 Text.Op = PrintName("CastSint8Uint16");
6759 break;
6760case OP_CastSint8Sint16:
6761 Text.Op = PrintName("CastSint8Sint16");
6762 break;
6763case OP_CastSint8Uint32:
6764 Text.Op = PrintName("CastSint8Uint32");
6765 break;
6766case OP_CastSint8Sint32:
6767 Text.Op = PrintName("CastSint8Sint32");
6768 break;
6769case OP_CastSint8Uint64:
6770 Text.Op = PrintName("CastSint8Uint64");
6771 break;
6772case OP_CastSint8Sint64:
6773 Text.Op = PrintName("CastSint8Sint64");
6774 break;
6775case OP_CastSint8Bool:
6776 Text.Op = PrintName("CastSint8Bool");
6777 break;
6778case OP_CastUint16Uint8:
6779 Text.Op = PrintName("CastUint16Uint8");
6780 break;
6781case OP_CastUint16Sint8:
6782 Text.Op = PrintName("CastUint16Sint8");
6783 break;
6784case OP_CastUint16Uint16:
6785 Text.Op = PrintName("CastUint16Uint16");
6786 break;
6787case OP_CastUint16Sint16:
6788 Text.Op = PrintName("CastUint16Sint16");
6789 break;
6790case OP_CastUint16Uint32:
6791 Text.Op = PrintName("CastUint16Uint32");
6792 break;
6793case OP_CastUint16Sint32:
6794 Text.Op = PrintName("CastUint16Sint32");
6795 break;
6796case OP_CastUint16Uint64:
6797 Text.Op = PrintName("CastUint16Uint64");
6798 break;
6799case OP_CastUint16Sint64:
6800 Text.Op = PrintName("CastUint16Sint64");
6801 break;
6802case OP_CastUint16Bool:
6803 Text.Op = PrintName("CastUint16Bool");
6804 break;
6805case OP_CastSint16Uint8:
6806 Text.Op = PrintName("CastSint16Uint8");
6807 break;
6808case OP_CastSint16Sint8:
6809 Text.Op = PrintName("CastSint16Sint8");
6810 break;
6811case OP_CastSint16Uint16:
6812 Text.Op = PrintName("CastSint16Uint16");
6813 break;
6814case OP_CastSint16Sint16:
6815 Text.Op = PrintName("CastSint16Sint16");
6816 break;
6817case OP_CastSint16Uint32:
6818 Text.Op = PrintName("CastSint16Uint32");
6819 break;
6820case OP_CastSint16Sint32:
6821 Text.Op = PrintName("CastSint16Sint32");
6822 break;
6823case OP_CastSint16Uint64:
6824 Text.Op = PrintName("CastSint16Uint64");
6825 break;
6826case OP_CastSint16Sint64:
6827 Text.Op = PrintName("CastSint16Sint64");
6828 break;
6829case OP_CastSint16Bool:
6830 Text.Op = PrintName("CastSint16Bool");
6831 break;
6832case OP_CastUint32Uint8:
6833 Text.Op = PrintName("CastUint32Uint8");
6834 break;
6835case OP_CastUint32Sint8:
6836 Text.Op = PrintName("CastUint32Sint8");
6837 break;
6838case OP_CastUint32Uint16:
6839 Text.Op = PrintName("CastUint32Uint16");
6840 break;
6841case OP_CastUint32Sint16:
6842 Text.Op = PrintName("CastUint32Sint16");
6843 break;
6844case OP_CastUint32Uint32:
6845 Text.Op = PrintName("CastUint32Uint32");
6846 break;
6847case OP_CastUint32Sint32:
6848 Text.Op = PrintName("CastUint32Sint32");
6849 break;
6850case OP_CastUint32Uint64:
6851 Text.Op = PrintName("CastUint32Uint64");
6852 break;
6853case OP_CastUint32Sint64:
6854 Text.Op = PrintName("CastUint32Sint64");
6855 break;
6856case OP_CastUint32Bool:
6857 Text.Op = PrintName("CastUint32Bool");
6858 break;
6859case OP_CastSint32Uint8:
6860 Text.Op = PrintName("CastSint32Uint8");
6861 break;
6862case OP_CastSint32Sint8:
6863 Text.Op = PrintName("CastSint32Sint8");
6864 break;
6865case OP_CastSint32Uint16:
6866 Text.Op = PrintName("CastSint32Uint16");
6867 break;
6868case OP_CastSint32Sint16:
6869 Text.Op = PrintName("CastSint32Sint16");
6870 break;
6871case OP_CastSint32Uint32:
6872 Text.Op = PrintName("CastSint32Uint32");
6873 break;
6874case OP_CastSint32Sint32:
6875 Text.Op = PrintName("CastSint32Sint32");
6876 break;
6877case OP_CastSint32Uint64:
6878 Text.Op = PrintName("CastSint32Uint64");
6879 break;
6880case OP_CastSint32Sint64:
6881 Text.Op = PrintName("CastSint32Sint64");
6882 break;
6883case OP_CastSint32Bool:
6884 Text.Op = PrintName("CastSint32Bool");
6885 break;
6886case OP_CastUint64Uint8:
6887 Text.Op = PrintName("CastUint64Uint8");
6888 break;
6889case OP_CastUint64Sint8:
6890 Text.Op = PrintName("CastUint64Sint8");
6891 break;
6892case OP_CastUint64Uint16:
6893 Text.Op = PrintName("CastUint64Uint16");
6894 break;
6895case OP_CastUint64Sint16:
6896 Text.Op = PrintName("CastUint64Sint16");
6897 break;
6898case OP_CastUint64Uint32:
6899 Text.Op = PrintName("CastUint64Uint32");
6900 break;
6901case OP_CastUint64Sint32:
6902 Text.Op = PrintName("CastUint64Sint32");
6903 break;
6904case OP_CastUint64Uint64:
6905 Text.Op = PrintName("CastUint64Uint64");
6906 break;
6907case OP_CastUint64Sint64:
6908 Text.Op = PrintName("CastUint64Sint64");
6909 break;
6910case OP_CastUint64Bool:
6911 Text.Op = PrintName("CastUint64Bool");
6912 break;
6913case OP_CastSint64Uint8:
6914 Text.Op = PrintName("CastSint64Uint8");
6915 break;
6916case OP_CastSint64Sint8:
6917 Text.Op = PrintName("CastSint64Sint8");
6918 break;
6919case OP_CastSint64Uint16:
6920 Text.Op = PrintName("CastSint64Uint16");
6921 break;
6922case OP_CastSint64Sint16:
6923 Text.Op = PrintName("CastSint64Sint16");
6924 break;
6925case OP_CastSint64Uint32:
6926 Text.Op = PrintName("CastSint64Uint32");
6927 break;
6928case OP_CastSint64Sint32:
6929 Text.Op = PrintName("CastSint64Sint32");
6930 break;
6931case OP_CastSint64Uint64:
6932 Text.Op = PrintName("CastSint64Uint64");
6933 break;
6934case OP_CastSint64Sint64:
6935 Text.Op = PrintName("CastSint64Sint64");
6936 break;
6937case OP_CastSint64Bool:
6938 Text.Op = PrintName("CastSint64Bool");
6939 break;
6940case OP_CastBoolUint8:
6941 Text.Op = PrintName("CastBoolUint8");
6942 break;
6943case OP_CastBoolSint8:
6944 Text.Op = PrintName("CastBoolSint8");
6945 break;
6946case OP_CastBoolUint16:
6947 Text.Op = PrintName("CastBoolUint16");
6948 break;
6949case OP_CastBoolSint16:
6950 Text.Op = PrintName("CastBoolSint16");
6951 break;
6952case OP_CastBoolUint32:
6953 Text.Op = PrintName("CastBoolUint32");
6954 break;
6955case OP_CastBoolSint32:
6956 Text.Op = PrintName("CastBoolSint32");
6957 break;
6958case OP_CastBoolUint64:
6959 Text.Op = PrintName("CastBoolUint64");
6960 break;
6961case OP_CastBoolSint64:
6962 Text.Op = PrintName("CastBoolSint64");
6963 break;
6964case OP_CastBoolBool:
6965 Text.Op = PrintName("CastBoolBool");
6966 break;
6967case OP_CastIntAPUint8:
6968 Text.Op = PrintName("CastIntAPUint8");
6969 break;
6970case OP_CastIntAPSint8:
6971 Text.Op = PrintName("CastIntAPSint8");
6972 break;
6973case OP_CastIntAPUint16:
6974 Text.Op = PrintName("CastIntAPUint16");
6975 break;
6976case OP_CastIntAPSint16:
6977 Text.Op = PrintName("CastIntAPSint16");
6978 break;
6979case OP_CastIntAPUint32:
6980 Text.Op = PrintName("CastIntAPUint32");
6981 break;
6982case OP_CastIntAPSint32:
6983 Text.Op = PrintName("CastIntAPSint32");
6984 break;
6985case OP_CastIntAPUint64:
6986 Text.Op = PrintName("CastIntAPUint64");
6987 break;
6988case OP_CastIntAPSint64:
6989 Text.Op = PrintName("CastIntAPSint64");
6990 break;
6991case OP_CastIntAPBool:
6992 Text.Op = PrintName("CastIntAPBool");
6993 break;
6994case OP_CastIntAPSUint8:
6995 Text.Op = PrintName("CastIntAPSUint8");
6996 break;
6997case OP_CastIntAPSSint8:
6998 Text.Op = PrintName("CastIntAPSSint8");
6999 break;
7000case OP_CastIntAPSUint16:
7001 Text.Op = PrintName("CastIntAPSUint16");
7002 break;
7003case OP_CastIntAPSSint16:
7004 Text.Op = PrintName("CastIntAPSSint16");
7005 break;
7006case OP_CastIntAPSUint32:
7007 Text.Op = PrintName("CastIntAPSUint32");
7008 break;
7009case OP_CastIntAPSSint32:
7010 Text.Op = PrintName("CastIntAPSSint32");
7011 break;
7012case OP_CastIntAPSUint64:
7013 Text.Op = PrintName("CastIntAPSUint64");
7014 break;
7015case OP_CastIntAPSSint64:
7016 Text.Op = PrintName("CastIntAPSSint64");
7017 break;
7018case OP_CastIntAPSBool:
7019 Text.Op = PrintName("CastIntAPSBool");
7020 break;
7021case OP_CastFixedPointUint8:
7022 Text.Op = PrintName("CastFixedPointUint8");
7023 break;
7024case OP_CastFixedPointSint8:
7025 Text.Op = PrintName("CastFixedPointSint8");
7026 break;
7027case OP_CastFixedPointUint16:
7028 Text.Op = PrintName("CastFixedPointUint16");
7029 break;
7030case OP_CastFixedPointSint16:
7031 Text.Op = PrintName("CastFixedPointSint16");
7032 break;
7033case OP_CastFixedPointUint32:
7034 Text.Op = PrintName("CastFixedPointUint32");
7035 break;
7036case OP_CastFixedPointSint32:
7037 Text.Op = PrintName("CastFixedPointSint32");
7038 break;
7039case OP_CastFixedPointUint64:
7040 Text.Op = PrintName("CastFixedPointUint64");
7041 break;
7042case OP_CastFixedPointSint64:
7043 Text.Op = PrintName("CastFixedPointSint64");
7044 break;
7045case OP_CastFixedPointBool:
7046 Text.Op = PrintName("CastFixedPointBool");
7047 break;
7048#endif
7049#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7050bool emitCastUint8Uint8(SourceInfo);
7051bool emitCastUint8Sint8(SourceInfo);
7052bool emitCastUint8Uint16(SourceInfo);
7053bool emitCastUint8Sint16(SourceInfo);
7054bool emitCastUint8Uint32(SourceInfo);
7055bool emitCastUint8Sint32(SourceInfo);
7056bool emitCastUint8Uint64(SourceInfo);
7057bool emitCastUint8Sint64(SourceInfo);
7058bool emitCastUint8Bool(SourceInfo);
7059bool emitCastSint8Uint8(SourceInfo);
7060bool emitCastSint8Sint8(SourceInfo);
7061bool emitCastSint8Uint16(SourceInfo);
7062bool emitCastSint8Sint16(SourceInfo);
7063bool emitCastSint8Uint32(SourceInfo);
7064bool emitCastSint8Sint32(SourceInfo);
7065bool emitCastSint8Uint64(SourceInfo);
7066bool emitCastSint8Sint64(SourceInfo);
7067bool emitCastSint8Bool(SourceInfo);
7068bool emitCastUint16Uint8(SourceInfo);
7069bool emitCastUint16Sint8(SourceInfo);
7070bool emitCastUint16Uint16(SourceInfo);
7071bool emitCastUint16Sint16(SourceInfo);
7072bool emitCastUint16Uint32(SourceInfo);
7073bool emitCastUint16Sint32(SourceInfo);
7074bool emitCastUint16Uint64(SourceInfo);
7075bool emitCastUint16Sint64(SourceInfo);
7076bool emitCastUint16Bool(SourceInfo);
7077bool emitCastSint16Uint8(SourceInfo);
7078bool emitCastSint16Sint8(SourceInfo);
7079bool emitCastSint16Uint16(SourceInfo);
7080bool emitCastSint16Sint16(SourceInfo);
7081bool emitCastSint16Uint32(SourceInfo);
7082bool emitCastSint16Sint32(SourceInfo);
7083bool emitCastSint16Uint64(SourceInfo);
7084bool emitCastSint16Sint64(SourceInfo);
7085bool emitCastSint16Bool(SourceInfo);
7086bool emitCastUint32Uint8(SourceInfo);
7087bool emitCastUint32Sint8(SourceInfo);
7088bool emitCastUint32Uint16(SourceInfo);
7089bool emitCastUint32Sint16(SourceInfo);
7090bool emitCastUint32Uint32(SourceInfo);
7091bool emitCastUint32Sint32(SourceInfo);
7092bool emitCastUint32Uint64(SourceInfo);
7093bool emitCastUint32Sint64(SourceInfo);
7094bool emitCastUint32Bool(SourceInfo);
7095bool emitCastSint32Uint8(SourceInfo);
7096bool emitCastSint32Sint8(SourceInfo);
7097bool emitCastSint32Uint16(SourceInfo);
7098bool emitCastSint32Sint16(SourceInfo);
7099bool emitCastSint32Uint32(SourceInfo);
7100bool emitCastSint32Sint32(SourceInfo);
7101bool emitCastSint32Uint64(SourceInfo);
7102bool emitCastSint32Sint64(SourceInfo);
7103bool emitCastSint32Bool(SourceInfo);
7104bool emitCastUint64Uint8(SourceInfo);
7105bool emitCastUint64Sint8(SourceInfo);
7106bool emitCastUint64Uint16(SourceInfo);
7107bool emitCastUint64Sint16(SourceInfo);
7108bool emitCastUint64Uint32(SourceInfo);
7109bool emitCastUint64Sint32(SourceInfo);
7110bool emitCastUint64Uint64(SourceInfo);
7111bool emitCastUint64Sint64(SourceInfo);
7112bool emitCastUint64Bool(SourceInfo);
7113bool emitCastSint64Uint8(SourceInfo);
7114bool emitCastSint64Sint8(SourceInfo);
7115bool emitCastSint64Uint16(SourceInfo);
7116bool emitCastSint64Sint16(SourceInfo);
7117bool emitCastSint64Uint32(SourceInfo);
7118bool emitCastSint64Sint32(SourceInfo);
7119bool emitCastSint64Uint64(SourceInfo);
7120bool emitCastSint64Sint64(SourceInfo);
7121bool emitCastSint64Bool(SourceInfo);
7122bool emitCastBoolUint8(SourceInfo);
7123bool emitCastBoolSint8(SourceInfo);
7124bool emitCastBoolUint16(SourceInfo);
7125bool emitCastBoolSint16(SourceInfo);
7126bool emitCastBoolUint32(SourceInfo);
7127bool emitCastBoolSint32(SourceInfo);
7128bool emitCastBoolUint64(SourceInfo);
7129bool emitCastBoolSint64(SourceInfo);
7130bool emitCastBoolBool(SourceInfo);
7131bool emitCastIntAPUint8(SourceInfo);
7132bool emitCastIntAPSint8(SourceInfo);
7133bool emitCastIntAPUint16(SourceInfo);
7134bool emitCastIntAPSint16(SourceInfo);
7135bool emitCastIntAPUint32(SourceInfo);
7136bool emitCastIntAPSint32(SourceInfo);
7137bool emitCastIntAPUint64(SourceInfo);
7138bool emitCastIntAPSint64(SourceInfo);
7139bool emitCastIntAPBool(SourceInfo);
7140bool emitCastIntAPSUint8(SourceInfo);
7141bool emitCastIntAPSSint8(SourceInfo);
7142bool emitCastIntAPSUint16(SourceInfo);
7143bool emitCastIntAPSSint16(SourceInfo);
7144bool emitCastIntAPSUint32(SourceInfo);
7145bool emitCastIntAPSSint32(SourceInfo);
7146bool emitCastIntAPSUint64(SourceInfo);
7147bool emitCastIntAPSSint64(SourceInfo);
7148bool emitCastIntAPSBool(SourceInfo);
7149bool emitCastFixedPointUint8(SourceInfo);
7150bool emitCastFixedPointSint8(SourceInfo);
7151bool emitCastFixedPointUint16(SourceInfo);
7152bool emitCastFixedPointSint16(SourceInfo);
7153bool emitCastFixedPointUint32(SourceInfo);
7154bool emitCastFixedPointSint32(SourceInfo);
7155bool emitCastFixedPointUint64(SourceInfo);
7156bool emitCastFixedPointSint64(SourceInfo);
7157bool emitCastFixedPointBool(SourceInfo);
7158#endif
7159#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
7160[[nodiscard]] bool emitCast(PrimType, PrimType, SourceInfo I);
7161#endif
7162#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
7163bool
7164#if defined(GET_EVAL_IMPL)
7165EvalEmitter
7166#else
7167ByteCodeEmitter
7168#endif
7169::emitCast(PrimType T0, PrimType T1, SourceInfo I) {
7170 switch (T0) {
7171 case PT_Uint8:
7172 switch (T1) {
7173 case PT_Uint8:
7174 return emitCastUint8Uint8(I);
7175 case PT_Sint8:
7176 return emitCastUint8Sint8(I);
7177 case PT_Uint16:
7178 return emitCastUint8Uint16(I);
7179 case PT_Sint16:
7180 return emitCastUint8Sint16(I);
7181 case PT_Uint32:
7182 return emitCastUint8Uint32(I);
7183 case PT_Sint32:
7184 return emitCastUint8Sint32(I);
7185 case PT_Uint64:
7186 return emitCastUint8Uint64(I);
7187 case PT_Sint64:
7188 return emitCastUint8Sint64(I);
7189 case PT_Bool:
7190 return emitCastUint8Bool(I);
7191 default: llvm_unreachable("invalid type: emitCast");
7192 }
7193 llvm_unreachable("invalid enum value");
7194 case PT_Sint8:
7195 switch (T1) {
7196 case PT_Uint8:
7197 return emitCastSint8Uint8(I);
7198 case PT_Sint8:
7199 return emitCastSint8Sint8(I);
7200 case PT_Uint16:
7201 return emitCastSint8Uint16(I);
7202 case PT_Sint16:
7203 return emitCastSint8Sint16(I);
7204 case PT_Uint32:
7205 return emitCastSint8Uint32(I);
7206 case PT_Sint32:
7207 return emitCastSint8Sint32(I);
7208 case PT_Uint64:
7209 return emitCastSint8Uint64(I);
7210 case PT_Sint64:
7211 return emitCastSint8Sint64(I);
7212 case PT_Bool:
7213 return emitCastSint8Bool(I);
7214 default: llvm_unreachable("invalid type: emitCast");
7215 }
7216 llvm_unreachable("invalid enum value");
7217 case PT_Uint16:
7218 switch (T1) {
7219 case PT_Uint8:
7220 return emitCastUint16Uint8(I);
7221 case PT_Sint8:
7222 return emitCastUint16Sint8(I);
7223 case PT_Uint16:
7224 return emitCastUint16Uint16(I);
7225 case PT_Sint16:
7226 return emitCastUint16Sint16(I);
7227 case PT_Uint32:
7228 return emitCastUint16Uint32(I);
7229 case PT_Sint32:
7230 return emitCastUint16Sint32(I);
7231 case PT_Uint64:
7232 return emitCastUint16Uint64(I);
7233 case PT_Sint64:
7234 return emitCastUint16Sint64(I);
7235 case PT_Bool:
7236 return emitCastUint16Bool(I);
7237 default: llvm_unreachable("invalid type: emitCast");
7238 }
7239 llvm_unreachable("invalid enum value");
7240 case PT_Sint16:
7241 switch (T1) {
7242 case PT_Uint8:
7243 return emitCastSint16Uint8(I);
7244 case PT_Sint8:
7245 return emitCastSint16Sint8(I);
7246 case PT_Uint16:
7247 return emitCastSint16Uint16(I);
7248 case PT_Sint16:
7249 return emitCastSint16Sint16(I);
7250 case PT_Uint32:
7251 return emitCastSint16Uint32(I);
7252 case PT_Sint32:
7253 return emitCastSint16Sint32(I);
7254 case PT_Uint64:
7255 return emitCastSint16Uint64(I);
7256 case PT_Sint64:
7257 return emitCastSint16Sint64(I);
7258 case PT_Bool:
7259 return emitCastSint16Bool(I);
7260 default: llvm_unreachable("invalid type: emitCast");
7261 }
7262 llvm_unreachable("invalid enum value");
7263 case PT_Uint32:
7264 switch (T1) {
7265 case PT_Uint8:
7266 return emitCastUint32Uint8(I);
7267 case PT_Sint8:
7268 return emitCastUint32Sint8(I);
7269 case PT_Uint16:
7270 return emitCastUint32Uint16(I);
7271 case PT_Sint16:
7272 return emitCastUint32Sint16(I);
7273 case PT_Uint32:
7274 return emitCastUint32Uint32(I);
7275 case PT_Sint32:
7276 return emitCastUint32Sint32(I);
7277 case PT_Uint64:
7278 return emitCastUint32Uint64(I);
7279 case PT_Sint64:
7280 return emitCastUint32Sint64(I);
7281 case PT_Bool:
7282 return emitCastUint32Bool(I);
7283 default: llvm_unreachable("invalid type: emitCast");
7284 }
7285 llvm_unreachable("invalid enum value");
7286 case PT_Sint32:
7287 switch (T1) {
7288 case PT_Uint8:
7289 return emitCastSint32Uint8(I);
7290 case PT_Sint8:
7291 return emitCastSint32Sint8(I);
7292 case PT_Uint16:
7293 return emitCastSint32Uint16(I);
7294 case PT_Sint16:
7295 return emitCastSint32Sint16(I);
7296 case PT_Uint32:
7297 return emitCastSint32Uint32(I);
7298 case PT_Sint32:
7299 return emitCastSint32Sint32(I);
7300 case PT_Uint64:
7301 return emitCastSint32Uint64(I);
7302 case PT_Sint64:
7303 return emitCastSint32Sint64(I);
7304 case PT_Bool:
7305 return emitCastSint32Bool(I);
7306 default: llvm_unreachable("invalid type: emitCast");
7307 }
7308 llvm_unreachable("invalid enum value");
7309 case PT_Uint64:
7310 switch (T1) {
7311 case PT_Uint8:
7312 return emitCastUint64Uint8(I);
7313 case PT_Sint8:
7314 return emitCastUint64Sint8(I);
7315 case PT_Uint16:
7316 return emitCastUint64Uint16(I);
7317 case PT_Sint16:
7318 return emitCastUint64Sint16(I);
7319 case PT_Uint32:
7320 return emitCastUint64Uint32(I);
7321 case PT_Sint32:
7322 return emitCastUint64Sint32(I);
7323 case PT_Uint64:
7324 return emitCastUint64Uint64(I);
7325 case PT_Sint64:
7326 return emitCastUint64Sint64(I);
7327 case PT_Bool:
7328 return emitCastUint64Bool(I);
7329 default: llvm_unreachable("invalid type: emitCast");
7330 }
7331 llvm_unreachable("invalid enum value");
7332 case PT_Sint64:
7333 switch (T1) {
7334 case PT_Uint8:
7335 return emitCastSint64Uint8(I);
7336 case PT_Sint8:
7337 return emitCastSint64Sint8(I);
7338 case PT_Uint16:
7339 return emitCastSint64Uint16(I);
7340 case PT_Sint16:
7341 return emitCastSint64Sint16(I);
7342 case PT_Uint32:
7343 return emitCastSint64Uint32(I);
7344 case PT_Sint32:
7345 return emitCastSint64Sint32(I);
7346 case PT_Uint64:
7347 return emitCastSint64Uint64(I);
7348 case PT_Sint64:
7349 return emitCastSint64Sint64(I);
7350 case PT_Bool:
7351 return emitCastSint64Bool(I);
7352 default: llvm_unreachable("invalid type: emitCast");
7353 }
7354 llvm_unreachable("invalid enum value");
7355 case PT_Bool:
7356 switch (T1) {
7357 case PT_Uint8:
7358 return emitCastBoolUint8(I);
7359 case PT_Sint8:
7360 return emitCastBoolSint8(I);
7361 case PT_Uint16:
7362 return emitCastBoolUint16(I);
7363 case PT_Sint16:
7364 return emitCastBoolSint16(I);
7365 case PT_Uint32:
7366 return emitCastBoolUint32(I);
7367 case PT_Sint32:
7368 return emitCastBoolSint32(I);
7369 case PT_Uint64:
7370 return emitCastBoolUint64(I);
7371 case PT_Sint64:
7372 return emitCastBoolSint64(I);
7373 case PT_Bool:
7374 return emitCastBoolBool(I);
7375 default: llvm_unreachable("invalid type: emitCast");
7376 }
7377 llvm_unreachable("invalid enum value");
7378 case PT_IntAP:
7379 switch (T1) {
7380 case PT_Uint8:
7381 return emitCastIntAPUint8(I);
7382 case PT_Sint8:
7383 return emitCastIntAPSint8(I);
7384 case PT_Uint16:
7385 return emitCastIntAPUint16(I);
7386 case PT_Sint16:
7387 return emitCastIntAPSint16(I);
7388 case PT_Uint32:
7389 return emitCastIntAPUint32(I);
7390 case PT_Sint32:
7391 return emitCastIntAPSint32(I);
7392 case PT_Uint64:
7393 return emitCastIntAPUint64(I);
7394 case PT_Sint64:
7395 return emitCastIntAPSint64(I);
7396 case PT_Bool:
7397 return emitCastIntAPBool(I);
7398 default: llvm_unreachable("invalid type: emitCast");
7399 }
7400 llvm_unreachable("invalid enum value");
7401 case PT_IntAPS:
7402 switch (T1) {
7403 case PT_Uint8:
7404 return emitCastIntAPSUint8(I);
7405 case PT_Sint8:
7406 return emitCastIntAPSSint8(I);
7407 case PT_Uint16:
7408 return emitCastIntAPSUint16(I);
7409 case PT_Sint16:
7410 return emitCastIntAPSSint16(I);
7411 case PT_Uint32:
7412 return emitCastIntAPSUint32(I);
7413 case PT_Sint32:
7414 return emitCastIntAPSSint32(I);
7415 case PT_Uint64:
7416 return emitCastIntAPSUint64(I);
7417 case PT_Sint64:
7418 return emitCastIntAPSSint64(I);
7419 case PT_Bool:
7420 return emitCastIntAPSBool(I);
7421 default: llvm_unreachable("invalid type: emitCast");
7422 }
7423 llvm_unreachable("invalid enum value");
7424 case PT_FixedPoint:
7425 switch (T1) {
7426 case PT_Uint8:
7427 return emitCastFixedPointUint8(I);
7428 case PT_Sint8:
7429 return emitCastFixedPointSint8(I);
7430 case PT_Uint16:
7431 return emitCastFixedPointUint16(I);
7432 case PT_Sint16:
7433 return emitCastFixedPointSint16(I);
7434 case PT_Uint32:
7435 return emitCastFixedPointUint32(I);
7436 case PT_Sint32:
7437 return emitCastFixedPointSint32(I);
7438 case PT_Uint64:
7439 return emitCastFixedPointUint64(I);
7440 case PT_Sint64:
7441 return emitCastFixedPointSint64(I);
7442 case PT_Bool:
7443 return emitCastFixedPointBool(I);
7444 default: llvm_unreachable("invalid type: emitCast");
7445 }
7446 llvm_unreachable("invalid enum value");
7447 default: llvm_unreachable("invalid type: emitCast");
7448 }
7449 llvm_unreachable("invalid enum value");
7450}
7451#endif
7452#ifdef GET_LINK_IMPL
7453bool ByteCodeEmitter::emitCastUint8Uint8(SourceInfo L) {
7454 return emitOp<>(OP_CastUint8Uint8, L);
7455}
7456bool ByteCodeEmitter::emitCastUint8Sint8(SourceInfo L) {
7457 return emitOp<>(OP_CastUint8Sint8, L);
7458}
7459bool ByteCodeEmitter::emitCastUint8Uint16(SourceInfo L) {
7460 return emitOp<>(OP_CastUint8Uint16, L);
7461}
7462bool ByteCodeEmitter::emitCastUint8Sint16(SourceInfo L) {
7463 return emitOp<>(OP_CastUint8Sint16, L);
7464}
7465bool ByteCodeEmitter::emitCastUint8Uint32(SourceInfo L) {
7466 return emitOp<>(OP_CastUint8Uint32, L);
7467}
7468bool ByteCodeEmitter::emitCastUint8Sint32(SourceInfo L) {
7469 return emitOp<>(OP_CastUint8Sint32, L);
7470}
7471bool ByteCodeEmitter::emitCastUint8Uint64(SourceInfo L) {
7472 return emitOp<>(OP_CastUint8Uint64, L);
7473}
7474bool ByteCodeEmitter::emitCastUint8Sint64(SourceInfo L) {
7475 return emitOp<>(OP_CastUint8Sint64, L);
7476}
7477bool ByteCodeEmitter::emitCastUint8Bool(SourceInfo L) {
7478 return emitOp<>(OP_CastUint8Bool, L);
7479}
7480bool ByteCodeEmitter::emitCastSint8Uint8(SourceInfo L) {
7481 return emitOp<>(OP_CastSint8Uint8, L);
7482}
7483bool ByteCodeEmitter::emitCastSint8Sint8(SourceInfo L) {
7484 return emitOp<>(OP_CastSint8Sint8, L);
7485}
7486bool ByteCodeEmitter::emitCastSint8Uint16(SourceInfo L) {
7487 return emitOp<>(OP_CastSint8Uint16, L);
7488}
7489bool ByteCodeEmitter::emitCastSint8Sint16(SourceInfo L) {
7490 return emitOp<>(OP_CastSint8Sint16, L);
7491}
7492bool ByteCodeEmitter::emitCastSint8Uint32(SourceInfo L) {
7493 return emitOp<>(OP_CastSint8Uint32, L);
7494}
7495bool ByteCodeEmitter::emitCastSint8Sint32(SourceInfo L) {
7496 return emitOp<>(OP_CastSint8Sint32, L);
7497}
7498bool ByteCodeEmitter::emitCastSint8Uint64(SourceInfo L) {
7499 return emitOp<>(OP_CastSint8Uint64, L);
7500}
7501bool ByteCodeEmitter::emitCastSint8Sint64(SourceInfo L) {
7502 return emitOp<>(OP_CastSint8Sint64, L);
7503}
7504bool ByteCodeEmitter::emitCastSint8Bool(SourceInfo L) {
7505 return emitOp<>(OP_CastSint8Bool, L);
7506}
7507bool ByteCodeEmitter::emitCastUint16Uint8(SourceInfo L) {
7508 return emitOp<>(OP_CastUint16Uint8, L);
7509}
7510bool ByteCodeEmitter::emitCastUint16Sint8(SourceInfo L) {
7511 return emitOp<>(OP_CastUint16Sint8, L);
7512}
7513bool ByteCodeEmitter::emitCastUint16Uint16(SourceInfo L) {
7514 return emitOp<>(OP_CastUint16Uint16, L);
7515}
7516bool ByteCodeEmitter::emitCastUint16Sint16(SourceInfo L) {
7517 return emitOp<>(OP_CastUint16Sint16, L);
7518}
7519bool ByteCodeEmitter::emitCastUint16Uint32(SourceInfo L) {
7520 return emitOp<>(OP_CastUint16Uint32, L);
7521}
7522bool ByteCodeEmitter::emitCastUint16Sint32(SourceInfo L) {
7523 return emitOp<>(OP_CastUint16Sint32, L);
7524}
7525bool ByteCodeEmitter::emitCastUint16Uint64(SourceInfo L) {
7526 return emitOp<>(OP_CastUint16Uint64, L);
7527}
7528bool ByteCodeEmitter::emitCastUint16Sint64(SourceInfo L) {
7529 return emitOp<>(OP_CastUint16Sint64, L);
7530}
7531bool ByteCodeEmitter::emitCastUint16Bool(SourceInfo L) {
7532 return emitOp<>(OP_CastUint16Bool, L);
7533}
7534bool ByteCodeEmitter::emitCastSint16Uint8(SourceInfo L) {
7535 return emitOp<>(OP_CastSint16Uint8, L);
7536}
7537bool ByteCodeEmitter::emitCastSint16Sint8(SourceInfo L) {
7538 return emitOp<>(OP_CastSint16Sint8, L);
7539}
7540bool ByteCodeEmitter::emitCastSint16Uint16(SourceInfo L) {
7541 return emitOp<>(OP_CastSint16Uint16, L);
7542}
7543bool ByteCodeEmitter::emitCastSint16Sint16(SourceInfo L) {
7544 return emitOp<>(OP_CastSint16Sint16, L);
7545}
7546bool ByteCodeEmitter::emitCastSint16Uint32(SourceInfo L) {
7547 return emitOp<>(OP_CastSint16Uint32, L);
7548}
7549bool ByteCodeEmitter::emitCastSint16Sint32(SourceInfo L) {
7550 return emitOp<>(OP_CastSint16Sint32, L);
7551}
7552bool ByteCodeEmitter::emitCastSint16Uint64(SourceInfo L) {
7553 return emitOp<>(OP_CastSint16Uint64, L);
7554}
7555bool ByteCodeEmitter::emitCastSint16Sint64(SourceInfo L) {
7556 return emitOp<>(OP_CastSint16Sint64, L);
7557}
7558bool ByteCodeEmitter::emitCastSint16Bool(SourceInfo L) {
7559 return emitOp<>(OP_CastSint16Bool, L);
7560}
7561bool ByteCodeEmitter::emitCastUint32Uint8(SourceInfo L) {
7562 return emitOp<>(OP_CastUint32Uint8, L);
7563}
7564bool ByteCodeEmitter::emitCastUint32Sint8(SourceInfo L) {
7565 return emitOp<>(OP_CastUint32Sint8, L);
7566}
7567bool ByteCodeEmitter::emitCastUint32Uint16(SourceInfo L) {
7568 return emitOp<>(OP_CastUint32Uint16, L);
7569}
7570bool ByteCodeEmitter::emitCastUint32Sint16(SourceInfo L) {
7571 return emitOp<>(OP_CastUint32Sint16, L);
7572}
7573bool ByteCodeEmitter::emitCastUint32Uint32(SourceInfo L) {
7574 return emitOp<>(OP_CastUint32Uint32, L);
7575}
7576bool ByteCodeEmitter::emitCastUint32Sint32(SourceInfo L) {
7577 return emitOp<>(OP_CastUint32Sint32, L);
7578}
7579bool ByteCodeEmitter::emitCastUint32Uint64(SourceInfo L) {
7580 return emitOp<>(OP_CastUint32Uint64, L);
7581}
7582bool ByteCodeEmitter::emitCastUint32Sint64(SourceInfo L) {
7583 return emitOp<>(OP_CastUint32Sint64, L);
7584}
7585bool ByteCodeEmitter::emitCastUint32Bool(SourceInfo L) {
7586 return emitOp<>(OP_CastUint32Bool, L);
7587}
7588bool ByteCodeEmitter::emitCastSint32Uint8(SourceInfo L) {
7589 return emitOp<>(OP_CastSint32Uint8, L);
7590}
7591bool ByteCodeEmitter::emitCastSint32Sint8(SourceInfo L) {
7592 return emitOp<>(OP_CastSint32Sint8, L);
7593}
7594bool ByteCodeEmitter::emitCastSint32Uint16(SourceInfo L) {
7595 return emitOp<>(OP_CastSint32Uint16, L);
7596}
7597bool ByteCodeEmitter::emitCastSint32Sint16(SourceInfo L) {
7598 return emitOp<>(OP_CastSint32Sint16, L);
7599}
7600bool ByteCodeEmitter::emitCastSint32Uint32(SourceInfo L) {
7601 return emitOp<>(OP_CastSint32Uint32, L);
7602}
7603bool ByteCodeEmitter::emitCastSint32Sint32(SourceInfo L) {
7604 return emitOp<>(OP_CastSint32Sint32, L);
7605}
7606bool ByteCodeEmitter::emitCastSint32Uint64(SourceInfo L) {
7607 return emitOp<>(OP_CastSint32Uint64, L);
7608}
7609bool ByteCodeEmitter::emitCastSint32Sint64(SourceInfo L) {
7610 return emitOp<>(OP_CastSint32Sint64, L);
7611}
7612bool ByteCodeEmitter::emitCastSint32Bool(SourceInfo L) {
7613 return emitOp<>(OP_CastSint32Bool, L);
7614}
7615bool ByteCodeEmitter::emitCastUint64Uint8(SourceInfo L) {
7616 return emitOp<>(OP_CastUint64Uint8, L);
7617}
7618bool ByteCodeEmitter::emitCastUint64Sint8(SourceInfo L) {
7619 return emitOp<>(OP_CastUint64Sint8, L);
7620}
7621bool ByteCodeEmitter::emitCastUint64Uint16(SourceInfo L) {
7622 return emitOp<>(OP_CastUint64Uint16, L);
7623}
7624bool ByteCodeEmitter::emitCastUint64Sint16(SourceInfo L) {
7625 return emitOp<>(OP_CastUint64Sint16, L);
7626}
7627bool ByteCodeEmitter::emitCastUint64Uint32(SourceInfo L) {
7628 return emitOp<>(OP_CastUint64Uint32, L);
7629}
7630bool ByteCodeEmitter::emitCastUint64Sint32(SourceInfo L) {
7631 return emitOp<>(OP_CastUint64Sint32, L);
7632}
7633bool ByteCodeEmitter::emitCastUint64Uint64(SourceInfo L) {
7634 return emitOp<>(OP_CastUint64Uint64, L);
7635}
7636bool ByteCodeEmitter::emitCastUint64Sint64(SourceInfo L) {
7637 return emitOp<>(OP_CastUint64Sint64, L);
7638}
7639bool ByteCodeEmitter::emitCastUint64Bool(SourceInfo L) {
7640 return emitOp<>(OP_CastUint64Bool, L);
7641}
7642bool ByteCodeEmitter::emitCastSint64Uint8(SourceInfo L) {
7643 return emitOp<>(OP_CastSint64Uint8, L);
7644}
7645bool ByteCodeEmitter::emitCastSint64Sint8(SourceInfo L) {
7646 return emitOp<>(OP_CastSint64Sint8, L);
7647}
7648bool ByteCodeEmitter::emitCastSint64Uint16(SourceInfo L) {
7649 return emitOp<>(OP_CastSint64Uint16, L);
7650}
7651bool ByteCodeEmitter::emitCastSint64Sint16(SourceInfo L) {
7652 return emitOp<>(OP_CastSint64Sint16, L);
7653}
7654bool ByteCodeEmitter::emitCastSint64Uint32(SourceInfo L) {
7655 return emitOp<>(OP_CastSint64Uint32, L);
7656}
7657bool ByteCodeEmitter::emitCastSint64Sint32(SourceInfo L) {
7658 return emitOp<>(OP_CastSint64Sint32, L);
7659}
7660bool ByteCodeEmitter::emitCastSint64Uint64(SourceInfo L) {
7661 return emitOp<>(OP_CastSint64Uint64, L);
7662}
7663bool ByteCodeEmitter::emitCastSint64Sint64(SourceInfo L) {
7664 return emitOp<>(OP_CastSint64Sint64, L);
7665}
7666bool ByteCodeEmitter::emitCastSint64Bool(SourceInfo L) {
7667 return emitOp<>(OP_CastSint64Bool, L);
7668}
7669bool ByteCodeEmitter::emitCastBoolUint8(SourceInfo L) {
7670 return emitOp<>(OP_CastBoolUint8, L);
7671}
7672bool ByteCodeEmitter::emitCastBoolSint8(SourceInfo L) {
7673 return emitOp<>(OP_CastBoolSint8, L);
7674}
7675bool ByteCodeEmitter::emitCastBoolUint16(SourceInfo L) {
7676 return emitOp<>(OP_CastBoolUint16, L);
7677}
7678bool ByteCodeEmitter::emitCastBoolSint16(SourceInfo L) {
7679 return emitOp<>(OP_CastBoolSint16, L);
7680}
7681bool ByteCodeEmitter::emitCastBoolUint32(SourceInfo L) {
7682 return emitOp<>(OP_CastBoolUint32, L);
7683}
7684bool ByteCodeEmitter::emitCastBoolSint32(SourceInfo L) {
7685 return emitOp<>(OP_CastBoolSint32, L);
7686}
7687bool ByteCodeEmitter::emitCastBoolUint64(SourceInfo L) {
7688 return emitOp<>(OP_CastBoolUint64, L);
7689}
7690bool ByteCodeEmitter::emitCastBoolSint64(SourceInfo L) {
7691 return emitOp<>(OP_CastBoolSint64, L);
7692}
7693bool ByteCodeEmitter::emitCastBoolBool(SourceInfo L) {
7694 return emitOp<>(OP_CastBoolBool, L);
7695}
7696bool ByteCodeEmitter::emitCastIntAPUint8(SourceInfo L) {
7697 return emitOp<>(OP_CastIntAPUint8, L);
7698}
7699bool ByteCodeEmitter::emitCastIntAPSint8(SourceInfo L) {
7700 return emitOp<>(OP_CastIntAPSint8, L);
7701}
7702bool ByteCodeEmitter::emitCastIntAPUint16(SourceInfo L) {
7703 return emitOp<>(OP_CastIntAPUint16, L);
7704}
7705bool ByteCodeEmitter::emitCastIntAPSint16(SourceInfo L) {
7706 return emitOp<>(OP_CastIntAPSint16, L);
7707}
7708bool ByteCodeEmitter::emitCastIntAPUint32(SourceInfo L) {
7709 return emitOp<>(OP_CastIntAPUint32, L);
7710}
7711bool ByteCodeEmitter::emitCastIntAPSint32(SourceInfo L) {
7712 return emitOp<>(OP_CastIntAPSint32, L);
7713}
7714bool ByteCodeEmitter::emitCastIntAPUint64(SourceInfo L) {
7715 return emitOp<>(OP_CastIntAPUint64, L);
7716}
7717bool ByteCodeEmitter::emitCastIntAPSint64(SourceInfo L) {
7718 return emitOp<>(OP_CastIntAPSint64, L);
7719}
7720bool ByteCodeEmitter::emitCastIntAPBool(SourceInfo L) {
7721 return emitOp<>(OP_CastIntAPBool, L);
7722}
7723bool ByteCodeEmitter::emitCastIntAPSUint8(SourceInfo L) {
7724 return emitOp<>(OP_CastIntAPSUint8, L);
7725}
7726bool ByteCodeEmitter::emitCastIntAPSSint8(SourceInfo L) {
7727 return emitOp<>(OP_CastIntAPSSint8, L);
7728}
7729bool ByteCodeEmitter::emitCastIntAPSUint16(SourceInfo L) {
7730 return emitOp<>(OP_CastIntAPSUint16, L);
7731}
7732bool ByteCodeEmitter::emitCastIntAPSSint16(SourceInfo L) {
7733 return emitOp<>(OP_CastIntAPSSint16, L);
7734}
7735bool ByteCodeEmitter::emitCastIntAPSUint32(SourceInfo L) {
7736 return emitOp<>(OP_CastIntAPSUint32, L);
7737}
7738bool ByteCodeEmitter::emitCastIntAPSSint32(SourceInfo L) {
7739 return emitOp<>(OP_CastIntAPSSint32, L);
7740}
7741bool ByteCodeEmitter::emitCastIntAPSUint64(SourceInfo L) {
7742 return emitOp<>(OP_CastIntAPSUint64, L);
7743}
7744bool ByteCodeEmitter::emitCastIntAPSSint64(SourceInfo L) {
7745 return emitOp<>(OP_CastIntAPSSint64, L);
7746}
7747bool ByteCodeEmitter::emitCastIntAPSBool(SourceInfo L) {
7748 return emitOp<>(OP_CastIntAPSBool, L);
7749}
7750bool ByteCodeEmitter::emitCastFixedPointUint8(SourceInfo L) {
7751 return emitOp<>(OP_CastFixedPointUint8, L);
7752}
7753bool ByteCodeEmitter::emitCastFixedPointSint8(SourceInfo L) {
7754 return emitOp<>(OP_CastFixedPointSint8, L);
7755}
7756bool ByteCodeEmitter::emitCastFixedPointUint16(SourceInfo L) {
7757 return emitOp<>(OP_CastFixedPointUint16, L);
7758}
7759bool ByteCodeEmitter::emitCastFixedPointSint16(SourceInfo L) {
7760 return emitOp<>(OP_CastFixedPointSint16, L);
7761}
7762bool ByteCodeEmitter::emitCastFixedPointUint32(SourceInfo L) {
7763 return emitOp<>(OP_CastFixedPointUint32, L);
7764}
7765bool ByteCodeEmitter::emitCastFixedPointSint32(SourceInfo L) {
7766 return emitOp<>(OP_CastFixedPointSint32, L);
7767}
7768bool ByteCodeEmitter::emitCastFixedPointUint64(SourceInfo L) {
7769 return emitOp<>(OP_CastFixedPointUint64, L);
7770}
7771bool ByteCodeEmitter::emitCastFixedPointSint64(SourceInfo L) {
7772 return emitOp<>(OP_CastFixedPointSint64, L);
7773}
7774bool ByteCodeEmitter::emitCastFixedPointBool(SourceInfo L) {
7775 return emitOp<>(OP_CastFixedPointBool, L);
7776}
7777#endif
7778#ifdef GET_EVAL_IMPL
7779bool EvalEmitter::emitCastUint8Uint8(SourceInfo L) {
7780 if (!isActive()) return true;
7781 CurrentSource = L;
7782 return Cast<PT_Uint8, PT_Uint8>(S, CodePtr());
7783}
7784bool EvalEmitter::emitCastUint8Sint8(SourceInfo L) {
7785 if (!isActive()) return true;
7786 CurrentSource = L;
7787 return Cast<PT_Uint8, PT_Sint8>(S, CodePtr());
7788}
7789bool EvalEmitter::emitCastUint8Uint16(SourceInfo L) {
7790 if (!isActive()) return true;
7791 CurrentSource = L;
7792 return Cast<PT_Uint8, PT_Uint16>(S, CodePtr());
7793}
7794bool EvalEmitter::emitCastUint8Sint16(SourceInfo L) {
7795 if (!isActive()) return true;
7796 CurrentSource = L;
7797 return Cast<PT_Uint8, PT_Sint16>(S, CodePtr());
7798}
7799bool EvalEmitter::emitCastUint8Uint32(SourceInfo L) {
7800 if (!isActive()) return true;
7801 CurrentSource = L;
7802 return Cast<PT_Uint8, PT_Uint32>(S, CodePtr());
7803}
7804bool EvalEmitter::emitCastUint8Sint32(SourceInfo L) {
7805 if (!isActive()) return true;
7806 CurrentSource = L;
7807 return Cast<PT_Uint8, PT_Sint32>(S, CodePtr());
7808}
7809bool EvalEmitter::emitCastUint8Uint64(SourceInfo L) {
7810 if (!isActive()) return true;
7811 CurrentSource = L;
7812 return Cast<PT_Uint8, PT_Uint64>(S, CodePtr());
7813}
7814bool EvalEmitter::emitCastUint8Sint64(SourceInfo L) {
7815 if (!isActive()) return true;
7816 CurrentSource = L;
7817 return Cast<PT_Uint8, PT_Sint64>(S, CodePtr());
7818}
7819bool EvalEmitter::emitCastUint8Bool(SourceInfo L) {
7820 if (!isActive()) return true;
7821 CurrentSource = L;
7822 return Cast<PT_Uint8, PT_Bool>(S, CodePtr());
7823}
7824bool EvalEmitter::emitCastSint8Uint8(SourceInfo L) {
7825 if (!isActive()) return true;
7826 CurrentSource = L;
7827 return Cast<PT_Sint8, PT_Uint8>(S, CodePtr());
7828}
7829bool EvalEmitter::emitCastSint8Sint8(SourceInfo L) {
7830 if (!isActive()) return true;
7831 CurrentSource = L;
7832 return Cast<PT_Sint8, PT_Sint8>(S, CodePtr());
7833}
7834bool EvalEmitter::emitCastSint8Uint16(SourceInfo L) {
7835 if (!isActive()) return true;
7836 CurrentSource = L;
7837 return Cast<PT_Sint8, PT_Uint16>(S, CodePtr());
7838}
7839bool EvalEmitter::emitCastSint8Sint16(SourceInfo L) {
7840 if (!isActive()) return true;
7841 CurrentSource = L;
7842 return Cast<PT_Sint8, PT_Sint16>(S, CodePtr());
7843}
7844bool EvalEmitter::emitCastSint8Uint32(SourceInfo L) {
7845 if (!isActive()) return true;
7846 CurrentSource = L;
7847 return Cast<PT_Sint8, PT_Uint32>(S, CodePtr());
7848}
7849bool EvalEmitter::emitCastSint8Sint32(SourceInfo L) {
7850 if (!isActive()) return true;
7851 CurrentSource = L;
7852 return Cast<PT_Sint8, PT_Sint32>(S, CodePtr());
7853}
7854bool EvalEmitter::emitCastSint8Uint64(SourceInfo L) {
7855 if (!isActive()) return true;
7856 CurrentSource = L;
7857 return Cast<PT_Sint8, PT_Uint64>(S, CodePtr());
7858}
7859bool EvalEmitter::emitCastSint8Sint64(SourceInfo L) {
7860 if (!isActive()) return true;
7861 CurrentSource = L;
7862 return Cast<PT_Sint8, PT_Sint64>(S, CodePtr());
7863}
7864bool EvalEmitter::emitCastSint8Bool(SourceInfo L) {
7865 if (!isActive()) return true;
7866 CurrentSource = L;
7867 return Cast<PT_Sint8, PT_Bool>(S, CodePtr());
7868}
7869bool EvalEmitter::emitCastUint16Uint8(SourceInfo L) {
7870 if (!isActive()) return true;
7871 CurrentSource = L;
7872 return Cast<PT_Uint16, PT_Uint8>(S, CodePtr());
7873}
7874bool EvalEmitter::emitCastUint16Sint8(SourceInfo L) {
7875 if (!isActive()) return true;
7876 CurrentSource = L;
7877 return Cast<PT_Uint16, PT_Sint8>(S, CodePtr());
7878}
7879bool EvalEmitter::emitCastUint16Uint16(SourceInfo L) {
7880 if (!isActive()) return true;
7881 CurrentSource = L;
7882 return Cast<PT_Uint16, PT_Uint16>(S, CodePtr());
7883}
7884bool EvalEmitter::emitCastUint16Sint16(SourceInfo L) {
7885 if (!isActive()) return true;
7886 CurrentSource = L;
7887 return Cast<PT_Uint16, PT_Sint16>(S, CodePtr());
7888}
7889bool EvalEmitter::emitCastUint16Uint32(SourceInfo L) {
7890 if (!isActive()) return true;
7891 CurrentSource = L;
7892 return Cast<PT_Uint16, PT_Uint32>(S, CodePtr());
7893}
7894bool EvalEmitter::emitCastUint16Sint32(SourceInfo L) {
7895 if (!isActive()) return true;
7896 CurrentSource = L;
7897 return Cast<PT_Uint16, PT_Sint32>(S, CodePtr());
7898}
7899bool EvalEmitter::emitCastUint16Uint64(SourceInfo L) {
7900 if (!isActive()) return true;
7901 CurrentSource = L;
7902 return Cast<PT_Uint16, PT_Uint64>(S, CodePtr());
7903}
7904bool EvalEmitter::emitCastUint16Sint64(SourceInfo L) {
7905 if (!isActive()) return true;
7906 CurrentSource = L;
7907 return Cast<PT_Uint16, PT_Sint64>(S, CodePtr());
7908}
7909bool EvalEmitter::emitCastUint16Bool(SourceInfo L) {
7910 if (!isActive()) return true;
7911 CurrentSource = L;
7912 return Cast<PT_Uint16, PT_Bool>(S, CodePtr());
7913}
7914bool EvalEmitter::emitCastSint16Uint8(SourceInfo L) {
7915 if (!isActive()) return true;
7916 CurrentSource = L;
7917 return Cast<PT_Sint16, PT_Uint8>(S, CodePtr());
7918}
7919bool EvalEmitter::emitCastSint16Sint8(SourceInfo L) {
7920 if (!isActive()) return true;
7921 CurrentSource = L;
7922 return Cast<PT_Sint16, PT_Sint8>(S, CodePtr());
7923}
7924bool EvalEmitter::emitCastSint16Uint16(SourceInfo L) {
7925 if (!isActive()) return true;
7926 CurrentSource = L;
7927 return Cast<PT_Sint16, PT_Uint16>(S, CodePtr());
7928}
7929bool EvalEmitter::emitCastSint16Sint16(SourceInfo L) {
7930 if (!isActive()) return true;
7931 CurrentSource = L;
7932 return Cast<PT_Sint16, PT_Sint16>(S, CodePtr());
7933}
7934bool EvalEmitter::emitCastSint16Uint32(SourceInfo L) {
7935 if (!isActive()) return true;
7936 CurrentSource = L;
7937 return Cast<PT_Sint16, PT_Uint32>(S, CodePtr());
7938}
7939bool EvalEmitter::emitCastSint16Sint32(SourceInfo L) {
7940 if (!isActive()) return true;
7941 CurrentSource = L;
7942 return Cast<PT_Sint16, PT_Sint32>(S, CodePtr());
7943}
7944bool EvalEmitter::emitCastSint16Uint64(SourceInfo L) {
7945 if (!isActive()) return true;
7946 CurrentSource = L;
7947 return Cast<PT_Sint16, PT_Uint64>(S, CodePtr());
7948}
7949bool EvalEmitter::emitCastSint16Sint64(SourceInfo L) {
7950 if (!isActive()) return true;
7951 CurrentSource = L;
7952 return Cast<PT_Sint16, PT_Sint64>(S, CodePtr());
7953}
7954bool EvalEmitter::emitCastSint16Bool(SourceInfo L) {
7955 if (!isActive()) return true;
7956 CurrentSource = L;
7957 return Cast<PT_Sint16, PT_Bool>(S, CodePtr());
7958}
7959bool EvalEmitter::emitCastUint32Uint8(SourceInfo L) {
7960 if (!isActive()) return true;
7961 CurrentSource = L;
7962 return Cast<PT_Uint32, PT_Uint8>(S, CodePtr());
7963}
7964bool EvalEmitter::emitCastUint32Sint8(SourceInfo L) {
7965 if (!isActive()) return true;
7966 CurrentSource = L;
7967 return Cast<PT_Uint32, PT_Sint8>(S, CodePtr());
7968}
7969bool EvalEmitter::emitCastUint32Uint16(SourceInfo L) {
7970 if (!isActive()) return true;
7971 CurrentSource = L;
7972 return Cast<PT_Uint32, PT_Uint16>(S, CodePtr());
7973}
7974bool EvalEmitter::emitCastUint32Sint16(SourceInfo L) {
7975 if (!isActive()) return true;
7976 CurrentSource = L;
7977 return Cast<PT_Uint32, PT_Sint16>(S, CodePtr());
7978}
7979bool EvalEmitter::emitCastUint32Uint32(SourceInfo L) {
7980 if (!isActive()) return true;
7981 CurrentSource = L;
7982 return Cast<PT_Uint32, PT_Uint32>(S, CodePtr());
7983}
7984bool EvalEmitter::emitCastUint32Sint32(SourceInfo L) {
7985 if (!isActive()) return true;
7986 CurrentSource = L;
7987 return Cast<PT_Uint32, PT_Sint32>(S, CodePtr());
7988}
7989bool EvalEmitter::emitCastUint32Uint64(SourceInfo L) {
7990 if (!isActive()) return true;
7991 CurrentSource = L;
7992 return Cast<PT_Uint32, PT_Uint64>(S, CodePtr());
7993}
7994bool EvalEmitter::emitCastUint32Sint64(SourceInfo L) {
7995 if (!isActive()) return true;
7996 CurrentSource = L;
7997 return Cast<PT_Uint32, PT_Sint64>(S, CodePtr());
7998}
7999bool EvalEmitter::emitCastUint32Bool(SourceInfo L) {
8000 if (!isActive()) return true;
8001 CurrentSource = L;
8002 return Cast<PT_Uint32, PT_Bool>(S, CodePtr());
8003}
8004bool EvalEmitter::emitCastSint32Uint8(SourceInfo L) {
8005 if (!isActive()) return true;
8006 CurrentSource = L;
8007 return Cast<PT_Sint32, PT_Uint8>(S, CodePtr());
8008}
8009bool EvalEmitter::emitCastSint32Sint8(SourceInfo L) {
8010 if (!isActive()) return true;
8011 CurrentSource = L;
8012 return Cast<PT_Sint32, PT_Sint8>(S, CodePtr());
8013}
8014bool EvalEmitter::emitCastSint32Uint16(SourceInfo L) {
8015 if (!isActive()) return true;
8016 CurrentSource = L;
8017 return Cast<PT_Sint32, PT_Uint16>(S, CodePtr());
8018}
8019bool EvalEmitter::emitCastSint32Sint16(SourceInfo L) {
8020 if (!isActive()) return true;
8021 CurrentSource = L;
8022 return Cast<PT_Sint32, PT_Sint16>(S, CodePtr());
8023}
8024bool EvalEmitter::emitCastSint32Uint32(SourceInfo L) {
8025 if (!isActive()) return true;
8026 CurrentSource = L;
8027 return Cast<PT_Sint32, PT_Uint32>(S, CodePtr());
8028}
8029bool EvalEmitter::emitCastSint32Sint32(SourceInfo L) {
8030 if (!isActive()) return true;
8031 CurrentSource = L;
8032 return Cast<PT_Sint32, PT_Sint32>(S, CodePtr());
8033}
8034bool EvalEmitter::emitCastSint32Uint64(SourceInfo L) {
8035 if (!isActive()) return true;
8036 CurrentSource = L;
8037 return Cast<PT_Sint32, PT_Uint64>(S, CodePtr());
8038}
8039bool EvalEmitter::emitCastSint32Sint64(SourceInfo L) {
8040 if (!isActive()) return true;
8041 CurrentSource = L;
8042 return Cast<PT_Sint32, PT_Sint64>(S, CodePtr());
8043}
8044bool EvalEmitter::emitCastSint32Bool(SourceInfo L) {
8045 if (!isActive()) return true;
8046 CurrentSource = L;
8047 return Cast<PT_Sint32, PT_Bool>(S, CodePtr());
8048}
8049bool EvalEmitter::emitCastUint64Uint8(SourceInfo L) {
8050 if (!isActive()) return true;
8051 CurrentSource = L;
8052 return Cast<PT_Uint64, PT_Uint8>(S, CodePtr());
8053}
8054bool EvalEmitter::emitCastUint64Sint8(SourceInfo L) {
8055 if (!isActive()) return true;
8056 CurrentSource = L;
8057 return Cast<PT_Uint64, PT_Sint8>(S, CodePtr());
8058}
8059bool EvalEmitter::emitCastUint64Uint16(SourceInfo L) {
8060 if (!isActive()) return true;
8061 CurrentSource = L;
8062 return Cast<PT_Uint64, PT_Uint16>(S, CodePtr());
8063}
8064bool EvalEmitter::emitCastUint64Sint16(SourceInfo L) {
8065 if (!isActive()) return true;
8066 CurrentSource = L;
8067 return Cast<PT_Uint64, PT_Sint16>(S, CodePtr());
8068}
8069bool EvalEmitter::emitCastUint64Uint32(SourceInfo L) {
8070 if (!isActive()) return true;
8071 CurrentSource = L;
8072 return Cast<PT_Uint64, PT_Uint32>(S, CodePtr());
8073}
8074bool EvalEmitter::emitCastUint64Sint32(SourceInfo L) {
8075 if (!isActive()) return true;
8076 CurrentSource = L;
8077 return Cast<PT_Uint64, PT_Sint32>(S, CodePtr());
8078}
8079bool EvalEmitter::emitCastUint64Uint64(SourceInfo L) {
8080 if (!isActive()) return true;
8081 CurrentSource = L;
8082 return Cast<PT_Uint64, PT_Uint64>(S, CodePtr());
8083}
8084bool EvalEmitter::emitCastUint64Sint64(SourceInfo L) {
8085 if (!isActive()) return true;
8086 CurrentSource = L;
8087 return Cast<PT_Uint64, PT_Sint64>(S, CodePtr());
8088}
8089bool EvalEmitter::emitCastUint64Bool(SourceInfo L) {
8090 if (!isActive()) return true;
8091 CurrentSource = L;
8092 return Cast<PT_Uint64, PT_Bool>(S, CodePtr());
8093}
8094bool EvalEmitter::emitCastSint64Uint8(SourceInfo L) {
8095 if (!isActive()) return true;
8096 CurrentSource = L;
8097 return Cast<PT_Sint64, PT_Uint8>(S, CodePtr());
8098}
8099bool EvalEmitter::emitCastSint64Sint8(SourceInfo L) {
8100 if (!isActive()) return true;
8101 CurrentSource = L;
8102 return Cast<PT_Sint64, PT_Sint8>(S, CodePtr());
8103}
8104bool EvalEmitter::emitCastSint64Uint16(SourceInfo L) {
8105 if (!isActive()) return true;
8106 CurrentSource = L;
8107 return Cast<PT_Sint64, PT_Uint16>(S, CodePtr());
8108}
8109bool EvalEmitter::emitCastSint64Sint16(SourceInfo L) {
8110 if (!isActive()) return true;
8111 CurrentSource = L;
8112 return Cast<PT_Sint64, PT_Sint16>(S, CodePtr());
8113}
8114bool EvalEmitter::emitCastSint64Uint32(SourceInfo L) {
8115 if (!isActive()) return true;
8116 CurrentSource = L;
8117 return Cast<PT_Sint64, PT_Uint32>(S, CodePtr());
8118}
8119bool EvalEmitter::emitCastSint64Sint32(SourceInfo L) {
8120 if (!isActive()) return true;
8121 CurrentSource = L;
8122 return Cast<PT_Sint64, PT_Sint32>(S, CodePtr());
8123}
8124bool EvalEmitter::emitCastSint64Uint64(SourceInfo L) {
8125 if (!isActive()) return true;
8126 CurrentSource = L;
8127 return Cast<PT_Sint64, PT_Uint64>(S, CodePtr());
8128}
8129bool EvalEmitter::emitCastSint64Sint64(SourceInfo L) {
8130 if (!isActive()) return true;
8131 CurrentSource = L;
8132 return Cast<PT_Sint64, PT_Sint64>(S, CodePtr());
8133}
8134bool EvalEmitter::emitCastSint64Bool(SourceInfo L) {
8135 if (!isActive()) return true;
8136 CurrentSource = L;
8137 return Cast<PT_Sint64, PT_Bool>(S, CodePtr());
8138}
8139bool EvalEmitter::emitCastBoolUint8(SourceInfo L) {
8140 if (!isActive()) return true;
8141 CurrentSource = L;
8142 return Cast<PT_Bool, PT_Uint8>(S, CodePtr());
8143}
8144bool EvalEmitter::emitCastBoolSint8(SourceInfo L) {
8145 if (!isActive()) return true;
8146 CurrentSource = L;
8147 return Cast<PT_Bool, PT_Sint8>(S, CodePtr());
8148}
8149bool EvalEmitter::emitCastBoolUint16(SourceInfo L) {
8150 if (!isActive()) return true;
8151 CurrentSource = L;
8152 return Cast<PT_Bool, PT_Uint16>(S, CodePtr());
8153}
8154bool EvalEmitter::emitCastBoolSint16(SourceInfo L) {
8155 if (!isActive()) return true;
8156 CurrentSource = L;
8157 return Cast<PT_Bool, PT_Sint16>(S, CodePtr());
8158}
8159bool EvalEmitter::emitCastBoolUint32(SourceInfo L) {
8160 if (!isActive()) return true;
8161 CurrentSource = L;
8162 return Cast<PT_Bool, PT_Uint32>(S, CodePtr());
8163}
8164bool EvalEmitter::emitCastBoolSint32(SourceInfo L) {
8165 if (!isActive()) return true;
8166 CurrentSource = L;
8167 return Cast<PT_Bool, PT_Sint32>(S, CodePtr());
8168}
8169bool EvalEmitter::emitCastBoolUint64(SourceInfo L) {
8170 if (!isActive()) return true;
8171 CurrentSource = L;
8172 return Cast<PT_Bool, PT_Uint64>(S, CodePtr());
8173}
8174bool EvalEmitter::emitCastBoolSint64(SourceInfo L) {
8175 if (!isActive()) return true;
8176 CurrentSource = L;
8177 return Cast<PT_Bool, PT_Sint64>(S, CodePtr());
8178}
8179bool EvalEmitter::emitCastBoolBool(SourceInfo L) {
8180 if (!isActive()) return true;
8181 CurrentSource = L;
8182 return Cast<PT_Bool, PT_Bool>(S, CodePtr());
8183}
8184bool EvalEmitter::emitCastIntAPUint8(SourceInfo L) {
8185 if (!isActive()) return true;
8186 CurrentSource = L;
8187 return Cast<PT_IntAP, PT_Uint8>(S, CodePtr());
8188}
8189bool EvalEmitter::emitCastIntAPSint8(SourceInfo L) {
8190 if (!isActive()) return true;
8191 CurrentSource = L;
8192 return Cast<PT_IntAP, PT_Sint8>(S, CodePtr());
8193}
8194bool EvalEmitter::emitCastIntAPUint16(SourceInfo L) {
8195 if (!isActive()) return true;
8196 CurrentSource = L;
8197 return Cast<PT_IntAP, PT_Uint16>(S, CodePtr());
8198}
8199bool EvalEmitter::emitCastIntAPSint16(SourceInfo L) {
8200 if (!isActive()) return true;
8201 CurrentSource = L;
8202 return Cast<PT_IntAP, PT_Sint16>(S, CodePtr());
8203}
8204bool EvalEmitter::emitCastIntAPUint32(SourceInfo L) {
8205 if (!isActive()) return true;
8206 CurrentSource = L;
8207 return Cast<PT_IntAP, PT_Uint32>(S, CodePtr());
8208}
8209bool EvalEmitter::emitCastIntAPSint32(SourceInfo L) {
8210 if (!isActive()) return true;
8211 CurrentSource = L;
8212 return Cast<PT_IntAP, PT_Sint32>(S, CodePtr());
8213}
8214bool EvalEmitter::emitCastIntAPUint64(SourceInfo L) {
8215 if (!isActive()) return true;
8216 CurrentSource = L;
8217 return Cast<PT_IntAP, PT_Uint64>(S, CodePtr());
8218}
8219bool EvalEmitter::emitCastIntAPSint64(SourceInfo L) {
8220 if (!isActive()) return true;
8221 CurrentSource = L;
8222 return Cast<PT_IntAP, PT_Sint64>(S, CodePtr());
8223}
8224bool EvalEmitter::emitCastIntAPBool(SourceInfo L) {
8225 if (!isActive()) return true;
8226 CurrentSource = L;
8227 return Cast<PT_IntAP, PT_Bool>(S, CodePtr());
8228}
8229bool EvalEmitter::emitCastIntAPSUint8(SourceInfo L) {
8230 if (!isActive()) return true;
8231 CurrentSource = L;
8232 return Cast<PT_IntAPS, PT_Uint8>(S, CodePtr());
8233}
8234bool EvalEmitter::emitCastIntAPSSint8(SourceInfo L) {
8235 if (!isActive()) return true;
8236 CurrentSource = L;
8237 return Cast<PT_IntAPS, PT_Sint8>(S, CodePtr());
8238}
8239bool EvalEmitter::emitCastIntAPSUint16(SourceInfo L) {
8240 if (!isActive()) return true;
8241 CurrentSource = L;
8242 return Cast<PT_IntAPS, PT_Uint16>(S, CodePtr());
8243}
8244bool EvalEmitter::emitCastIntAPSSint16(SourceInfo L) {
8245 if (!isActive()) return true;
8246 CurrentSource = L;
8247 return Cast<PT_IntAPS, PT_Sint16>(S, CodePtr());
8248}
8249bool EvalEmitter::emitCastIntAPSUint32(SourceInfo L) {
8250 if (!isActive()) return true;
8251 CurrentSource = L;
8252 return Cast<PT_IntAPS, PT_Uint32>(S, CodePtr());
8253}
8254bool EvalEmitter::emitCastIntAPSSint32(SourceInfo L) {
8255 if (!isActive()) return true;
8256 CurrentSource = L;
8257 return Cast<PT_IntAPS, PT_Sint32>(S, CodePtr());
8258}
8259bool EvalEmitter::emitCastIntAPSUint64(SourceInfo L) {
8260 if (!isActive()) return true;
8261 CurrentSource = L;
8262 return Cast<PT_IntAPS, PT_Uint64>(S, CodePtr());
8263}
8264bool EvalEmitter::emitCastIntAPSSint64(SourceInfo L) {
8265 if (!isActive()) return true;
8266 CurrentSource = L;
8267 return Cast<PT_IntAPS, PT_Sint64>(S, CodePtr());
8268}
8269bool EvalEmitter::emitCastIntAPSBool(SourceInfo L) {
8270 if (!isActive()) return true;
8271 CurrentSource = L;
8272 return Cast<PT_IntAPS, PT_Bool>(S, CodePtr());
8273}
8274bool EvalEmitter::emitCastFixedPointUint8(SourceInfo L) {
8275 if (!isActive()) return true;
8276 CurrentSource = L;
8277 return Cast<PT_FixedPoint, PT_Uint8>(S, CodePtr());
8278}
8279bool EvalEmitter::emitCastFixedPointSint8(SourceInfo L) {
8280 if (!isActive()) return true;
8281 CurrentSource = L;
8282 return Cast<PT_FixedPoint, PT_Sint8>(S, CodePtr());
8283}
8284bool EvalEmitter::emitCastFixedPointUint16(SourceInfo L) {
8285 if (!isActive()) return true;
8286 CurrentSource = L;
8287 return Cast<PT_FixedPoint, PT_Uint16>(S, CodePtr());
8288}
8289bool EvalEmitter::emitCastFixedPointSint16(SourceInfo L) {
8290 if (!isActive()) return true;
8291 CurrentSource = L;
8292 return Cast<PT_FixedPoint, PT_Sint16>(S, CodePtr());
8293}
8294bool EvalEmitter::emitCastFixedPointUint32(SourceInfo L) {
8295 if (!isActive()) return true;
8296 CurrentSource = L;
8297 return Cast<PT_FixedPoint, PT_Uint32>(S, CodePtr());
8298}
8299bool EvalEmitter::emitCastFixedPointSint32(SourceInfo L) {
8300 if (!isActive()) return true;
8301 CurrentSource = L;
8302 return Cast<PT_FixedPoint, PT_Sint32>(S, CodePtr());
8303}
8304bool EvalEmitter::emitCastFixedPointUint64(SourceInfo L) {
8305 if (!isActive()) return true;
8306 CurrentSource = L;
8307 return Cast<PT_FixedPoint, PT_Uint64>(S, CodePtr());
8308}
8309bool EvalEmitter::emitCastFixedPointSint64(SourceInfo L) {
8310 if (!isActive()) return true;
8311 CurrentSource = L;
8312 return Cast<PT_FixedPoint, PT_Sint64>(S, CodePtr());
8313}
8314bool EvalEmitter::emitCastFixedPointBool(SourceInfo L) {
8315 if (!isActive()) return true;
8316 CurrentSource = L;
8317 return Cast<PT_FixedPoint, PT_Bool>(S, CodePtr());
8318}
8319#endif
8320#ifdef GET_OPCODE_NAMES
8321OP_CastAPSint8,
8322OP_CastAPUint8,
8323OP_CastAPSint16,
8324OP_CastAPUint16,
8325OP_CastAPSint32,
8326OP_CastAPUint32,
8327OP_CastAPSint64,
8328OP_CastAPUint64,
8329OP_CastAPIntAP,
8330OP_CastAPIntAPS,
8331OP_CastAPBool,
8332OP_CastAPFixedPoint,
8333#endif
8334#ifdef GET_INTERPFN_LIST
8335&Interp_CastAPSint8,
8336&Interp_CastAPUint8,
8337&Interp_CastAPSint16,
8338&Interp_CastAPUint16,
8339&Interp_CastAPSint32,
8340&Interp_CastAPUint32,
8341&Interp_CastAPSint64,
8342&Interp_CastAPUint64,
8343&Interp_CastAPIntAP,
8344&Interp_CastAPIntAPS,
8345&Interp_CastAPBool,
8346&Interp_CastAPFixedPoint,
8347#endif
8348#ifdef GET_INTERPFN_DISPATCHERS
8349PRESERVE_NONE
8350static bool Interp_CastAPSint8(InterpState &S) {
8351 {
8352 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8353 if (!CastAP<PT_Sint8>(S, V0)) return false;
8354 }
8355#if USE_TAILCALLS
8356 MUSTTAIL return InterpNext(S);
8357#else
8358 return true;
8359#endif
8360}
8361PRESERVE_NONE
8362static bool Interp_CastAPUint8(InterpState &S) {
8363 {
8364 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8365 if (!CastAP<PT_Uint8>(S, V0)) return false;
8366 }
8367#if USE_TAILCALLS
8368 MUSTTAIL return InterpNext(S);
8369#else
8370 return true;
8371#endif
8372}
8373PRESERVE_NONE
8374static bool Interp_CastAPSint16(InterpState &S) {
8375 {
8376 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8377 if (!CastAP<PT_Sint16>(S, V0)) return false;
8378 }
8379#if USE_TAILCALLS
8380 MUSTTAIL return InterpNext(S);
8381#else
8382 return true;
8383#endif
8384}
8385PRESERVE_NONE
8386static bool Interp_CastAPUint16(InterpState &S) {
8387 {
8388 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8389 if (!CastAP<PT_Uint16>(S, V0)) return false;
8390 }
8391#if USE_TAILCALLS
8392 MUSTTAIL return InterpNext(S);
8393#else
8394 return true;
8395#endif
8396}
8397PRESERVE_NONE
8398static bool Interp_CastAPSint32(InterpState &S) {
8399 {
8400 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8401 if (!CastAP<PT_Sint32>(S, V0)) return false;
8402 }
8403#if USE_TAILCALLS
8404 MUSTTAIL return InterpNext(S);
8405#else
8406 return true;
8407#endif
8408}
8409PRESERVE_NONE
8410static bool Interp_CastAPUint32(InterpState &S) {
8411 {
8412 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8413 if (!CastAP<PT_Uint32>(S, V0)) return false;
8414 }
8415#if USE_TAILCALLS
8416 MUSTTAIL return InterpNext(S);
8417#else
8418 return true;
8419#endif
8420}
8421PRESERVE_NONE
8422static bool Interp_CastAPSint64(InterpState &S) {
8423 {
8424 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8425 if (!CastAP<PT_Sint64>(S, V0)) return false;
8426 }
8427#if USE_TAILCALLS
8428 MUSTTAIL return InterpNext(S);
8429#else
8430 return true;
8431#endif
8432}
8433PRESERVE_NONE
8434static bool Interp_CastAPUint64(InterpState &S) {
8435 {
8436 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8437 if (!CastAP<PT_Uint64>(S, V0)) return false;
8438 }
8439#if USE_TAILCALLS
8440 MUSTTAIL return InterpNext(S);
8441#else
8442 return true;
8443#endif
8444}
8445PRESERVE_NONE
8446static bool Interp_CastAPIntAP(InterpState &S) {
8447 {
8448 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8449 if (!CastAP<PT_IntAP>(S, V0)) return false;
8450 }
8451#if USE_TAILCALLS
8452 MUSTTAIL return InterpNext(S);
8453#else
8454 return true;
8455#endif
8456}
8457PRESERVE_NONE
8458static bool Interp_CastAPIntAPS(InterpState &S) {
8459 {
8460 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8461 if (!CastAP<PT_IntAPS>(S, V0)) return false;
8462 }
8463#if USE_TAILCALLS
8464 MUSTTAIL return InterpNext(S);
8465#else
8466 return true;
8467#endif
8468}
8469PRESERVE_NONE
8470static bool Interp_CastAPBool(InterpState &S) {
8471 {
8472 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8473 if (!CastAP<PT_Bool>(S, V0)) return false;
8474 }
8475#if USE_TAILCALLS
8476 MUSTTAIL return InterpNext(S);
8477#else
8478 return true;
8479#endif
8480}
8481PRESERVE_NONE
8482static bool Interp_CastAPFixedPoint(InterpState &S) {
8483 {
8484 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8485 if (!CastAP<PT_FixedPoint>(S, V0)) return false;
8486 }
8487#if USE_TAILCALLS
8488 MUSTTAIL return InterpNext(S);
8489#else
8490 return true;
8491#endif
8492}
8493#endif
8494#ifdef GET_DISASM
8495case OP_CastAPSint8:
8496 Text.Op = PrintName("CastAPSint8");
8497 Text.Args.push_back(printArg<uint32_t>(PC));
8498 break;
8499case OP_CastAPUint8:
8500 Text.Op = PrintName("CastAPUint8");
8501 Text.Args.push_back(printArg<uint32_t>(PC));
8502 break;
8503case OP_CastAPSint16:
8504 Text.Op = PrintName("CastAPSint16");
8505 Text.Args.push_back(printArg<uint32_t>(PC));
8506 break;
8507case OP_CastAPUint16:
8508 Text.Op = PrintName("CastAPUint16");
8509 Text.Args.push_back(printArg<uint32_t>(PC));
8510 break;
8511case OP_CastAPSint32:
8512 Text.Op = PrintName("CastAPSint32");
8513 Text.Args.push_back(printArg<uint32_t>(PC));
8514 break;
8515case OP_CastAPUint32:
8516 Text.Op = PrintName("CastAPUint32");
8517 Text.Args.push_back(printArg<uint32_t>(PC));
8518 break;
8519case OP_CastAPSint64:
8520 Text.Op = PrintName("CastAPSint64");
8521 Text.Args.push_back(printArg<uint32_t>(PC));
8522 break;
8523case OP_CastAPUint64:
8524 Text.Op = PrintName("CastAPUint64");
8525 Text.Args.push_back(printArg<uint32_t>(PC));
8526 break;
8527case OP_CastAPIntAP:
8528 Text.Op = PrintName("CastAPIntAP");
8529 Text.Args.push_back(printArg<uint32_t>(PC));
8530 break;
8531case OP_CastAPIntAPS:
8532 Text.Op = PrintName("CastAPIntAPS");
8533 Text.Args.push_back(printArg<uint32_t>(PC));
8534 break;
8535case OP_CastAPBool:
8536 Text.Op = PrintName("CastAPBool");
8537 Text.Args.push_back(printArg<uint32_t>(PC));
8538 break;
8539case OP_CastAPFixedPoint:
8540 Text.Op = PrintName("CastAPFixedPoint");
8541 Text.Args.push_back(printArg<uint32_t>(PC));
8542 break;
8543#endif
8544#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8545bool emitCastAPSint8( uint32_t , SourceInfo);
8546bool emitCastAPUint8( uint32_t , SourceInfo);
8547bool emitCastAPSint16( uint32_t , SourceInfo);
8548bool emitCastAPUint16( uint32_t , SourceInfo);
8549bool emitCastAPSint32( uint32_t , SourceInfo);
8550bool emitCastAPUint32( uint32_t , SourceInfo);
8551bool emitCastAPSint64( uint32_t , SourceInfo);
8552bool emitCastAPUint64( uint32_t , SourceInfo);
8553bool emitCastAPIntAP( uint32_t , SourceInfo);
8554bool emitCastAPIntAPS( uint32_t , SourceInfo);
8555bool emitCastAPBool( uint32_t , SourceInfo);
8556bool emitCastAPFixedPoint( uint32_t , SourceInfo);
8557#endif
8558#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8559[[nodiscard]] bool emitCastAP(PrimType, uint32_t, SourceInfo I);
8560#endif
8561#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
8562bool
8563#if defined(GET_EVAL_IMPL)
8564EvalEmitter
8565#else
8566ByteCodeEmitter
8567#endif
8568::emitCastAP(PrimType T0, uint32_t A0, SourceInfo I) {
8569 switch (T0) {
8570 case PT_Sint8:
8571 return emitCastAPSint8(A0, I);
8572 case PT_Uint8:
8573 return emitCastAPUint8(A0, I);
8574 case PT_Sint16:
8575 return emitCastAPSint16(A0, I);
8576 case PT_Uint16:
8577 return emitCastAPUint16(A0, I);
8578 case PT_Sint32:
8579 return emitCastAPSint32(A0, I);
8580 case PT_Uint32:
8581 return emitCastAPUint32(A0, I);
8582 case PT_Sint64:
8583 return emitCastAPSint64(A0, I);
8584 case PT_Uint64:
8585 return emitCastAPUint64(A0, I);
8586 case PT_IntAP:
8587 return emitCastAPIntAP(A0, I);
8588 case PT_IntAPS:
8589 return emitCastAPIntAPS(A0, I);
8590 case PT_Bool:
8591 return emitCastAPBool(A0, I);
8592 case PT_FixedPoint:
8593 return emitCastAPFixedPoint(A0, I);
8594 default: llvm_unreachable("invalid type: emitCastAP");
8595 }
8596 llvm_unreachable("invalid enum value");
8597}
8598#endif
8599#ifdef GET_LINK_IMPL
8600bool ByteCodeEmitter::emitCastAPSint8( uint32_t A0, SourceInfo L) {
8601 return emitOp<uint32_t>(OP_CastAPSint8, A0, L);
8602}
8603bool ByteCodeEmitter::emitCastAPUint8( uint32_t A0, SourceInfo L) {
8604 return emitOp<uint32_t>(OP_CastAPUint8, A0, L);
8605}
8606bool ByteCodeEmitter::emitCastAPSint16( uint32_t A0, SourceInfo L) {
8607 return emitOp<uint32_t>(OP_CastAPSint16, A0, L);
8608}
8609bool ByteCodeEmitter::emitCastAPUint16( uint32_t A0, SourceInfo L) {
8610 return emitOp<uint32_t>(OP_CastAPUint16, A0, L);
8611}
8612bool ByteCodeEmitter::emitCastAPSint32( uint32_t A0, SourceInfo L) {
8613 return emitOp<uint32_t>(OP_CastAPSint32, A0, L);
8614}
8615bool ByteCodeEmitter::emitCastAPUint32( uint32_t A0, SourceInfo L) {
8616 return emitOp<uint32_t>(OP_CastAPUint32, A0, L);
8617}
8618bool ByteCodeEmitter::emitCastAPSint64( uint32_t A0, SourceInfo L) {
8619 return emitOp<uint32_t>(OP_CastAPSint64, A0, L);
8620}
8621bool ByteCodeEmitter::emitCastAPUint64( uint32_t A0, SourceInfo L) {
8622 return emitOp<uint32_t>(OP_CastAPUint64, A0, L);
8623}
8624bool ByteCodeEmitter::emitCastAPIntAP( uint32_t A0, SourceInfo L) {
8625 return emitOp<uint32_t>(OP_CastAPIntAP, A0, L);
8626}
8627bool ByteCodeEmitter::emitCastAPIntAPS( uint32_t A0, SourceInfo L) {
8628 return emitOp<uint32_t>(OP_CastAPIntAPS, A0, L);
8629}
8630bool ByteCodeEmitter::emitCastAPBool( uint32_t A0, SourceInfo L) {
8631 return emitOp<uint32_t>(OP_CastAPBool, A0, L);
8632}
8633bool ByteCodeEmitter::emitCastAPFixedPoint( uint32_t A0, SourceInfo L) {
8634 return emitOp<uint32_t>(OP_CastAPFixedPoint, A0, L);
8635}
8636#endif
8637#ifdef GET_EVAL_IMPL
8638bool EvalEmitter::emitCastAPSint8( uint32_t A0, SourceInfo L) {
8639 if (!isActive()) return true;
8640 CurrentSource = L;
8641 return CastAP<PT_Sint8>(S, A0);
8642}
8643bool EvalEmitter::emitCastAPUint8( uint32_t A0, SourceInfo L) {
8644 if (!isActive()) return true;
8645 CurrentSource = L;
8646 return CastAP<PT_Uint8>(S, A0);
8647}
8648bool EvalEmitter::emitCastAPSint16( uint32_t A0, SourceInfo L) {
8649 if (!isActive()) return true;
8650 CurrentSource = L;
8651 return CastAP<PT_Sint16>(S, A0);
8652}
8653bool EvalEmitter::emitCastAPUint16( uint32_t A0, SourceInfo L) {
8654 if (!isActive()) return true;
8655 CurrentSource = L;
8656 return CastAP<PT_Uint16>(S, A0);
8657}
8658bool EvalEmitter::emitCastAPSint32( uint32_t A0, SourceInfo L) {
8659 if (!isActive()) return true;
8660 CurrentSource = L;
8661 return CastAP<PT_Sint32>(S, A0);
8662}
8663bool EvalEmitter::emitCastAPUint32( uint32_t A0, SourceInfo L) {
8664 if (!isActive()) return true;
8665 CurrentSource = L;
8666 return CastAP<PT_Uint32>(S, A0);
8667}
8668bool EvalEmitter::emitCastAPSint64( uint32_t A0, SourceInfo L) {
8669 if (!isActive()) return true;
8670 CurrentSource = L;
8671 return CastAP<PT_Sint64>(S, A0);
8672}
8673bool EvalEmitter::emitCastAPUint64( uint32_t A0, SourceInfo L) {
8674 if (!isActive()) return true;
8675 CurrentSource = L;
8676 return CastAP<PT_Uint64>(S, A0);
8677}
8678bool EvalEmitter::emitCastAPIntAP( uint32_t A0, SourceInfo L) {
8679 if (!isActive()) return true;
8680 CurrentSource = L;
8681 return CastAP<PT_IntAP>(S, A0);
8682}
8683bool EvalEmitter::emitCastAPIntAPS( uint32_t A0, SourceInfo L) {
8684 if (!isActive()) return true;
8685 CurrentSource = L;
8686 return CastAP<PT_IntAPS>(S, A0);
8687}
8688bool EvalEmitter::emitCastAPBool( uint32_t A0, SourceInfo L) {
8689 if (!isActive()) return true;
8690 CurrentSource = L;
8691 return CastAP<PT_Bool>(S, A0);
8692}
8693bool EvalEmitter::emitCastAPFixedPoint( uint32_t A0, SourceInfo L) {
8694 if (!isActive()) return true;
8695 CurrentSource = L;
8696 return CastAP<PT_FixedPoint>(S, A0);
8697}
8698#endif
8699#ifdef GET_OPCODE_NAMES
8700OP_CastAPSSint8,
8701OP_CastAPSUint8,
8702OP_CastAPSSint16,
8703OP_CastAPSUint16,
8704OP_CastAPSSint32,
8705OP_CastAPSUint32,
8706OP_CastAPSSint64,
8707OP_CastAPSUint64,
8708OP_CastAPSIntAP,
8709OP_CastAPSIntAPS,
8710OP_CastAPSBool,
8711OP_CastAPSFixedPoint,
8712#endif
8713#ifdef GET_INTERPFN_LIST
8714&Interp_CastAPSSint8,
8715&Interp_CastAPSUint8,
8716&Interp_CastAPSSint16,
8717&Interp_CastAPSUint16,
8718&Interp_CastAPSSint32,
8719&Interp_CastAPSUint32,
8720&Interp_CastAPSSint64,
8721&Interp_CastAPSUint64,
8722&Interp_CastAPSIntAP,
8723&Interp_CastAPSIntAPS,
8724&Interp_CastAPSBool,
8725&Interp_CastAPSFixedPoint,
8726#endif
8727#ifdef GET_INTERPFN_DISPATCHERS
8728PRESERVE_NONE
8729static bool Interp_CastAPSSint8(InterpState &S) {
8730 {
8731 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8732 if (!CastAPS<PT_Sint8>(S, V0)) return false;
8733 }
8734#if USE_TAILCALLS
8735 MUSTTAIL return InterpNext(S);
8736#else
8737 return true;
8738#endif
8739}
8740PRESERVE_NONE
8741static bool Interp_CastAPSUint8(InterpState &S) {
8742 {
8743 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8744 if (!CastAPS<PT_Uint8>(S, V0)) return false;
8745 }
8746#if USE_TAILCALLS
8747 MUSTTAIL return InterpNext(S);
8748#else
8749 return true;
8750#endif
8751}
8752PRESERVE_NONE
8753static bool Interp_CastAPSSint16(InterpState &S) {
8754 {
8755 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8756 if (!CastAPS<PT_Sint16>(S, V0)) return false;
8757 }
8758#if USE_TAILCALLS
8759 MUSTTAIL return InterpNext(S);
8760#else
8761 return true;
8762#endif
8763}
8764PRESERVE_NONE
8765static bool Interp_CastAPSUint16(InterpState &S) {
8766 {
8767 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8768 if (!CastAPS<PT_Uint16>(S, V0)) return false;
8769 }
8770#if USE_TAILCALLS
8771 MUSTTAIL return InterpNext(S);
8772#else
8773 return true;
8774#endif
8775}
8776PRESERVE_NONE
8777static bool Interp_CastAPSSint32(InterpState &S) {
8778 {
8779 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8780 if (!CastAPS<PT_Sint32>(S, V0)) return false;
8781 }
8782#if USE_TAILCALLS
8783 MUSTTAIL return InterpNext(S);
8784#else
8785 return true;
8786#endif
8787}
8788PRESERVE_NONE
8789static bool Interp_CastAPSUint32(InterpState &S) {
8790 {
8791 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8792 if (!CastAPS<PT_Uint32>(S, V0)) return false;
8793 }
8794#if USE_TAILCALLS
8795 MUSTTAIL return InterpNext(S);
8796#else
8797 return true;
8798#endif
8799}
8800PRESERVE_NONE
8801static bool Interp_CastAPSSint64(InterpState &S) {
8802 {
8803 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8804 if (!CastAPS<PT_Sint64>(S, V0)) return false;
8805 }
8806#if USE_TAILCALLS
8807 MUSTTAIL return InterpNext(S);
8808#else
8809 return true;
8810#endif
8811}
8812PRESERVE_NONE
8813static bool Interp_CastAPSUint64(InterpState &S) {
8814 {
8815 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8816 if (!CastAPS<PT_Uint64>(S, V0)) return false;
8817 }
8818#if USE_TAILCALLS
8819 MUSTTAIL return InterpNext(S);
8820#else
8821 return true;
8822#endif
8823}
8824PRESERVE_NONE
8825static bool Interp_CastAPSIntAP(InterpState &S) {
8826 {
8827 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8828 if (!CastAPS<PT_IntAP>(S, V0)) return false;
8829 }
8830#if USE_TAILCALLS
8831 MUSTTAIL return InterpNext(S);
8832#else
8833 return true;
8834#endif
8835}
8836PRESERVE_NONE
8837static bool Interp_CastAPSIntAPS(InterpState &S) {
8838 {
8839 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8840 if (!CastAPS<PT_IntAPS>(S, V0)) return false;
8841 }
8842#if USE_TAILCALLS
8843 MUSTTAIL return InterpNext(S);
8844#else
8845 return true;
8846#endif
8847}
8848PRESERVE_NONE
8849static bool Interp_CastAPSBool(InterpState &S) {
8850 {
8851 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8852 if (!CastAPS<PT_Bool>(S, V0)) return false;
8853 }
8854#if USE_TAILCALLS
8855 MUSTTAIL return InterpNext(S);
8856#else
8857 return true;
8858#endif
8859}
8860PRESERVE_NONE
8861static bool Interp_CastAPSFixedPoint(InterpState &S) {
8862 {
8863 const auto V0 = ReadArg<uint32_t>(S, S.PC);
8864 if (!CastAPS<PT_FixedPoint>(S, V0)) return false;
8865 }
8866#if USE_TAILCALLS
8867 MUSTTAIL return InterpNext(S);
8868#else
8869 return true;
8870#endif
8871}
8872#endif
8873#ifdef GET_DISASM
8874case OP_CastAPSSint8:
8875 Text.Op = PrintName("CastAPSSint8");
8876 Text.Args.push_back(printArg<uint32_t>(PC));
8877 break;
8878case OP_CastAPSUint8:
8879 Text.Op = PrintName("CastAPSUint8");
8880 Text.Args.push_back(printArg<uint32_t>(PC));
8881 break;
8882case OP_CastAPSSint16:
8883 Text.Op = PrintName("CastAPSSint16");
8884 Text.Args.push_back(printArg<uint32_t>(PC));
8885 break;
8886case OP_CastAPSUint16:
8887 Text.Op = PrintName("CastAPSUint16");
8888 Text.Args.push_back(printArg<uint32_t>(PC));
8889 break;
8890case OP_CastAPSSint32:
8891 Text.Op = PrintName("CastAPSSint32");
8892 Text.Args.push_back(printArg<uint32_t>(PC));
8893 break;
8894case OP_CastAPSUint32:
8895 Text.Op = PrintName("CastAPSUint32");
8896 Text.Args.push_back(printArg<uint32_t>(PC));
8897 break;
8898case OP_CastAPSSint64:
8899 Text.Op = PrintName("CastAPSSint64");
8900 Text.Args.push_back(printArg<uint32_t>(PC));
8901 break;
8902case OP_CastAPSUint64:
8903 Text.Op = PrintName("CastAPSUint64");
8904 Text.Args.push_back(printArg<uint32_t>(PC));
8905 break;
8906case OP_CastAPSIntAP:
8907 Text.Op = PrintName("CastAPSIntAP");
8908 Text.Args.push_back(printArg<uint32_t>(PC));
8909 break;
8910case OP_CastAPSIntAPS:
8911 Text.Op = PrintName("CastAPSIntAPS");
8912 Text.Args.push_back(printArg<uint32_t>(PC));
8913 break;
8914case OP_CastAPSBool:
8915 Text.Op = PrintName("CastAPSBool");
8916 Text.Args.push_back(printArg<uint32_t>(PC));
8917 break;
8918case OP_CastAPSFixedPoint:
8919 Text.Op = PrintName("CastAPSFixedPoint");
8920 Text.Args.push_back(printArg<uint32_t>(PC));
8921 break;
8922#endif
8923#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8924bool emitCastAPSSint8( uint32_t , SourceInfo);
8925bool emitCastAPSUint8( uint32_t , SourceInfo);
8926bool emitCastAPSSint16( uint32_t , SourceInfo);
8927bool emitCastAPSUint16( uint32_t , SourceInfo);
8928bool emitCastAPSSint32( uint32_t , SourceInfo);
8929bool emitCastAPSUint32( uint32_t , SourceInfo);
8930bool emitCastAPSSint64( uint32_t , SourceInfo);
8931bool emitCastAPSUint64( uint32_t , SourceInfo);
8932bool emitCastAPSIntAP( uint32_t , SourceInfo);
8933bool emitCastAPSIntAPS( uint32_t , SourceInfo);
8934bool emitCastAPSBool( uint32_t , SourceInfo);
8935bool emitCastAPSFixedPoint( uint32_t , SourceInfo);
8936#endif
8937#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
8938[[nodiscard]] bool emitCastAPS(PrimType, uint32_t, SourceInfo I);
8939#endif
8940#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
8941bool
8942#if defined(GET_EVAL_IMPL)
8943EvalEmitter
8944#else
8945ByteCodeEmitter
8946#endif
8947::emitCastAPS(PrimType T0, uint32_t A0, SourceInfo I) {
8948 switch (T0) {
8949 case PT_Sint8:
8950 return emitCastAPSSint8(A0, I);
8951 case PT_Uint8:
8952 return emitCastAPSUint8(A0, I);
8953 case PT_Sint16:
8954 return emitCastAPSSint16(A0, I);
8955 case PT_Uint16:
8956 return emitCastAPSUint16(A0, I);
8957 case PT_Sint32:
8958 return emitCastAPSSint32(A0, I);
8959 case PT_Uint32:
8960 return emitCastAPSUint32(A0, I);
8961 case PT_Sint64:
8962 return emitCastAPSSint64(A0, I);
8963 case PT_Uint64:
8964 return emitCastAPSUint64(A0, I);
8965 case PT_IntAP:
8966 return emitCastAPSIntAP(A0, I);
8967 case PT_IntAPS:
8968 return emitCastAPSIntAPS(A0, I);
8969 case PT_Bool:
8970 return emitCastAPSBool(A0, I);
8971 case PT_FixedPoint:
8972 return emitCastAPSFixedPoint(A0, I);
8973 default: llvm_unreachable("invalid type: emitCastAPS");
8974 }
8975 llvm_unreachable("invalid enum value");
8976}
8977#endif
8978#ifdef GET_LINK_IMPL
8979bool ByteCodeEmitter::emitCastAPSSint8( uint32_t A0, SourceInfo L) {
8980 return emitOp<uint32_t>(OP_CastAPSSint8, A0, L);
8981}
8982bool ByteCodeEmitter::emitCastAPSUint8( uint32_t A0, SourceInfo L) {
8983 return emitOp<uint32_t>(OP_CastAPSUint8, A0, L);
8984}
8985bool ByteCodeEmitter::emitCastAPSSint16( uint32_t A0, SourceInfo L) {
8986 return emitOp<uint32_t>(OP_CastAPSSint16, A0, L);
8987}
8988bool ByteCodeEmitter::emitCastAPSUint16( uint32_t A0, SourceInfo L) {
8989 return emitOp<uint32_t>(OP_CastAPSUint16, A0, L);
8990}
8991bool ByteCodeEmitter::emitCastAPSSint32( uint32_t A0, SourceInfo L) {
8992 return emitOp<uint32_t>(OP_CastAPSSint32, A0, L);
8993}
8994bool ByteCodeEmitter::emitCastAPSUint32( uint32_t A0, SourceInfo L) {
8995 return emitOp<uint32_t>(OP_CastAPSUint32, A0, L);
8996}
8997bool ByteCodeEmitter::emitCastAPSSint64( uint32_t A0, SourceInfo L) {
8998 return emitOp<uint32_t>(OP_CastAPSSint64, A0, L);
8999}
9000bool ByteCodeEmitter::emitCastAPSUint64( uint32_t A0, SourceInfo L) {
9001 return emitOp<uint32_t>(OP_CastAPSUint64, A0, L);
9002}
9003bool ByteCodeEmitter::emitCastAPSIntAP( uint32_t A0, SourceInfo L) {
9004 return emitOp<uint32_t>(OP_CastAPSIntAP, A0, L);
9005}
9006bool ByteCodeEmitter::emitCastAPSIntAPS( uint32_t A0, SourceInfo L) {
9007 return emitOp<uint32_t>(OP_CastAPSIntAPS, A0, L);
9008}
9009bool ByteCodeEmitter::emitCastAPSBool( uint32_t A0, SourceInfo L) {
9010 return emitOp<uint32_t>(OP_CastAPSBool, A0, L);
9011}
9012bool ByteCodeEmitter::emitCastAPSFixedPoint( uint32_t A0, SourceInfo L) {
9013 return emitOp<uint32_t>(OP_CastAPSFixedPoint, A0, L);
9014}
9015#endif
9016#ifdef GET_EVAL_IMPL
9017bool EvalEmitter::emitCastAPSSint8( uint32_t A0, SourceInfo L) {
9018 if (!isActive()) return true;
9019 CurrentSource = L;
9020 return CastAPS<PT_Sint8>(S, A0);
9021}
9022bool EvalEmitter::emitCastAPSUint8( uint32_t A0, SourceInfo L) {
9023 if (!isActive()) return true;
9024 CurrentSource = L;
9025 return CastAPS<PT_Uint8>(S, A0);
9026}
9027bool EvalEmitter::emitCastAPSSint16( uint32_t A0, SourceInfo L) {
9028 if (!isActive()) return true;
9029 CurrentSource = L;
9030 return CastAPS<PT_Sint16>(S, A0);
9031}
9032bool EvalEmitter::emitCastAPSUint16( uint32_t A0, SourceInfo L) {
9033 if (!isActive()) return true;
9034 CurrentSource = L;
9035 return CastAPS<PT_Uint16>(S, A0);
9036}
9037bool EvalEmitter::emitCastAPSSint32( uint32_t A0, SourceInfo L) {
9038 if (!isActive()) return true;
9039 CurrentSource = L;
9040 return CastAPS<PT_Sint32>(S, A0);
9041}
9042bool EvalEmitter::emitCastAPSUint32( uint32_t A0, SourceInfo L) {
9043 if (!isActive()) return true;
9044 CurrentSource = L;
9045 return CastAPS<PT_Uint32>(S, A0);
9046}
9047bool EvalEmitter::emitCastAPSSint64( uint32_t A0, SourceInfo L) {
9048 if (!isActive()) return true;
9049 CurrentSource = L;
9050 return CastAPS<PT_Sint64>(S, A0);
9051}
9052bool EvalEmitter::emitCastAPSUint64( uint32_t A0, SourceInfo L) {
9053 if (!isActive()) return true;
9054 CurrentSource = L;
9055 return CastAPS<PT_Uint64>(S, A0);
9056}
9057bool EvalEmitter::emitCastAPSIntAP( uint32_t A0, SourceInfo L) {
9058 if (!isActive()) return true;
9059 CurrentSource = L;
9060 return CastAPS<PT_IntAP>(S, A0);
9061}
9062bool EvalEmitter::emitCastAPSIntAPS( uint32_t A0, SourceInfo L) {
9063 if (!isActive()) return true;
9064 CurrentSource = L;
9065 return CastAPS<PT_IntAPS>(S, A0);
9066}
9067bool EvalEmitter::emitCastAPSBool( uint32_t A0, SourceInfo L) {
9068 if (!isActive()) return true;
9069 CurrentSource = L;
9070 return CastAPS<PT_Bool>(S, A0);
9071}
9072bool EvalEmitter::emitCastAPSFixedPoint( uint32_t A0, SourceInfo L) {
9073 if (!isActive()) return true;
9074 CurrentSource = L;
9075 return CastAPS<PT_FixedPoint>(S, A0);
9076}
9077#endif
9078#ifdef GET_OPCODE_NAMES
9079OP_CastAPToOffsetIndexIntAP,
9080OP_CastAPToOffsetIndexIntAPS,
9081#endif
9082#ifdef GET_INTERPFN_LIST
9083&Interp_CastAPToOffsetIndexIntAP,
9084&Interp_CastAPToOffsetIndexIntAPS,
9085#endif
9086#ifdef GET_INTERPFN_DISPATCHERS
9087PRESERVE_NONE
9088static bool Interp_CastAPToOffsetIndexIntAP(InterpState &S) {
9089 if (!CastAPToOffsetIndex<PT_IntAP>(S, S.PC)) return false;
9090#if USE_TAILCALLS
9091 MUSTTAIL return InterpNext(S);
9092#else
9093 return true;
9094#endif
9095}
9096PRESERVE_NONE
9097static bool Interp_CastAPToOffsetIndexIntAPS(InterpState &S) {
9098 if (!CastAPToOffsetIndex<PT_IntAPS>(S, S.PC)) return false;
9099#if USE_TAILCALLS
9100 MUSTTAIL return InterpNext(S);
9101#else
9102 return true;
9103#endif
9104}
9105#endif
9106#ifdef GET_DISASM
9107case OP_CastAPToOffsetIndexIntAP:
9108 Text.Op = PrintName("CastAPToOffsetIndexIntAP");
9109 break;
9110case OP_CastAPToOffsetIndexIntAPS:
9111 Text.Op = PrintName("CastAPToOffsetIndexIntAPS");
9112 break;
9113#endif
9114#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9115bool emitCastAPToOffsetIndexIntAP(SourceInfo);
9116bool emitCastAPToOffsetIndexIntAPS(SourceInfo);
9117#endif
9118#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9119[[nodiscard]] bool emitCastAPToOffsetIndex(PrimType, SourceInfo I);
9120#endif
9121#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
9122bool
9123#if defined(GET_EVAL_IMPL)
9124EvalEmitter
9125#else
9126ByteCodeEmitter
9127#endif
9128::emitCastAPToOffsetIndex(PrimType T0, SourceInfo I) {
9129 switch (T0) {
9130 case PT_IntAP:
9131 return emitCastAPToOffsetIndexIntAP(I);
9132 case PT_IntAPS:
9133 return emitCastAPToOffsetIndexIntAPS(I);
9134 default: llvm_unreachable("invalid type: emitCastAPToOffsetIndex");
9135 }
9136 llvm_unreachable("invalid enum value");
9137}
9138#endif
9139#ifdef GET_LINK_IMPL
9140bool ByteCodeEmitter::emitCastAPToOffsetIndexIntAP(SourceInfo L) {
9141 return emitOp<>(OP_CastAPToOffsetIndexIntAP, L);
9142}
9143bool ByteCodeEmitter::emitCastAPToOffsetIndexIntAPS(SourceInfo L) {
9144 return emitOp<>(OP_CastAPToOffsetIndexIntAPS, L);
9145}
9146#endif
9147#ifdef GET_EVAL_IMPL
9148bool EvalEmitter::emitCastAPToOffsetIndexIntAP(SourceInfo L) {
9149 if (!isActive()) return true;
9150 CurrentSource = L;
9151 return CastAPToOffsetIndex<PT_IntAP>(S, CodePtr());
9152}
9153bool EvalEmitter::emitCastAPToOffsetIndexIntAPS(SourceInfo L) {
9154 if (!isActive()) return true;
9155 CurrentSource = L;
9156 return CastAPToOffsetIndex<PT_IntAPS>(S, CodePtr());
9157}
9158#endif
9159#ifdef GET_OPCODE_NAMES
9160OP_CastAddressSpace,
9161#endif
9162#ifdef GET_INTERPFN_LIST
9163&Interp_CastAddressSpace,
9164#endif
9165#ifdef GET_INTERPFN_DISPATCHERS
9166PRESERVE_NONE
9167static bool Interp_CastAddressSpace(InterpState &S) {
9168 {
9169 CodePtr OpPC = S.PC;
9170 const auto V0 = ReadArg<uint64_t>(S, S.PC);
9171 const auto V1 = ReadArg<const Type *>(S, S.PC);
9172 if (!CastAddressSpace(S, OpPC, V0, V1)) return false;
9173 }
9174#if USE_TAILCALLS
9175 MUSTTAIL return InterpNext(S);
9176#else
9177 return true;
9178#endif
9179}
9180#endif
9181#ifdef GET_DISASM
9182case OP_CastAddressSpace:
9183 Text.Op = PrintName("CastAddressSpace");
9184 Text.Args.push_back(printArg<uint64_t>(PC));
9185 Text.Args.push_back(printArg<const Type *>(PC));
9186 break;
9187#endif
9188#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9189bool emitCastAddressSpace( uint64_t , const Type * , SourceInfo);
9190#endif
9191#ifdef GET_LINK_IMPL
9192bool ByteCodeEmitter::emitCastAddressSpace( uint64_t A0, const Type * A1, SourceInfo L) {
9193 return emitOp<uint64_t, const Type *>(OP_CastAddressSpace, A0, A1, L);
9194}
9195#endif
9196#ifdef GET_EVAL_IMPL
9197bool EvalEmitter::emitCastAddressSpace( uint64_t A0, const Type * A1, SourceInfo L) {
9198 if (!isActive()) return true;
9199 CurrentSource = L;
9200 return CastAddressSpace(S, CodePtr(), A0, A1);
9201}
9202#endif
9203#ifdef GET_OPCODE_NAMES
9204OP_CastFP,
9205#endif
9206#ifdef GET_INTERPFN_LIST
9207&Interp_CastFP,
9208#endif
9209#ifdef GET_INTERPFN_DISPATCHERS
9210PRESERVE_NONE
9211static bool Interp_CastFP(InterpState &S) {
9212 {
9213 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
9214 const auto V1 = ReadArg<llvm::RoundingMode>(S, S.PC);
9215 if (!CastFP(S, V0, V1)) return false;
9216 }
9217#if USE_TAILCALLS
9218 MUSTTAIL return InterpNext(S);
9219#else
9220 return true;
9221#endif
9222}
9223#endif
9224#ifdef GET_DISASM
9225case OP_CastFP:
9226 Text.Op = PrintName("CastFP");
9227 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
9228 Text.Args.push_back(printArg<llvm::RoundingMode>(PC));
9229 break;
9230#endif
9231#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9232bool emitCastFP( const llvm::fltSemantics * , llvm::RoundingMode , SourceInfo);
9233#endif
9234#ifdef GET_LINK_IMPL
9235bool ByteCodeEmitter::emitCastFP( const llvm::fltSemantics * A0, llvm::RoundingMode A1, SourceInfo L) {
9236 return emitOp<const llvm::fltSemantics *, llvm::RoundingMode>(OP_CastFP, A0, A1, L);
9237}
9238#endif
9239#ifdef GET_EVAL_IMPL
9240bool EvalEmitter::emitCastFP( const llvm::fltSemantics * A0, llvm::RoundingMode A1, SourceInfo L) {
9241 if (!isActive()) return true;
9242 CurrentSource = L;
9243 return CastFP(S, A0, A1);
9244}
9245#endif
9246#ifdef GET_OPCODE_NAMES
9247OP_CastFixedPoint,
9248#endif
9249#ifdef GET_INTERPFN_LIST
9250&Interp_CastFixedPoint,
9251#endif
9252#ifdef GET_INTERPFN_DISPATCHERS
9253PRESERVE_NONE
9254static bool Interp_CastFixedPoint(InterpState &S) {
9255 {
9256 CodePtr OpPC = S.PC;
9257 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9258 if (!CastFixedPoint(S, OpPC, V0)) return false;
9259 }
9260#if USE_TAILCALLS
9261 MUSTTAIL return InterpNext(S);
9262#else
9263 return true;
9264#endif
9265}
9266#endif
9267#ifdef GET_DISASM
9268case OP_CastFixedPoint:
9269 Text.Op = PrintName("CastFixedPoint");
9270 Text.Args.push_back(printArg<uint32_t>(PC));
9271 break;
9272#endif
9273#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9274bool emitCastFixedPoint( uint32_t , SourceInfo);
9275#endif
9276#ifdef GET_LINK_IMPL
9277bool ByteCodeEmitter::emitCastFixedPoint( uint32_t A0, SourceInfo L) {
9278 return emitOp<uint32_t>(OP_CastFixedPoint, A0, L);
9279}
9280#endif
9281#ifdef GET_EVAL_IMPL
9282bool EvalEmitter::emitCastFixedPoint( uint32_t A0, SourceInfo L) {
9283 if (!isActive()) return true;
9284 CurrentSource = L;
9285 return CastFixedPoint(S, CodePtr(), A0);
9286}
9287#endif
9288#ifdef GET_OPCODE_NAMES
9289OP_CastFixedPointFloating,
9290#endif
9291#ifdef GET_INTERPFN_LIST
9292&Interp_CastFixedPointFloating,
9293#endif
9294#ifdef GET_INTERPFN_DISPATCHERS
9295PRESERVE_NONE
9296static bool Interp_CastFixedPointFloating(InterpState &S) {
9297 {
9298 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
9299 if (!CastFixedPointFloating(S, V0)) return false;
9300 }
9301#if USE_TAILCALLS
9302 MUSTTAIL return InterpNext(S);
9303#else
9304 return true;
9305#endif
9306}
9307#endif
9308#ifdef GET_DISASM
9309case OP_CastFixedPointFloating:
9310 Text.Op = PrintName("CastFixedPointFloating");
9311 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
9312 break;
9313#endif
9314#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9315bool emitCastFixedPointFloating( const llvm::fltSemantics * , SourceInfo);
9316#endif
9317#ifdef GET_LINK_IMPL
9318bool ByteCodeEmitter::emitCastFixedPointFloating( const llvm::fltSemantics * A0, SourceInfo L) {
9319 return emitOp<const llvm::fltSemantics *>(OP_CastFixedPointFloating, A0, L);
9320}
9321#endif
9322#ifdef GET_EVAL_IMPL
9323bool EvalEmitter::emitCastFixedPointFloating( const llvm::fltSemantics * A0, SourceInfo L) {
9324 if (!isActive()) return true;
9325 CurrentSource = L;
9326 return CastFixedPointFloating(S, A0);
9327}
9328#endif
9329#ifdef GET_OPCODE_NAMES
9330OP_CastFixedPointIntegralSint8,
9331OP_CastFixedPointIntegralUint8,
9332OP_CastFixedPointIntegralSint16,
9333OP_CastFixedPointIntegralUint16,
9334OP_CastFixedPointIntegralSint32,
9335OP_CastFixedPointIntegralUint32,
9336OP_CastFixedPointIntegralSint64,
9337OP_CastFixedPointIntegralUint64,
9338#endif
9339#ifdef GET_INTERPFN_LIST
9340&Interp_CastFixedPointIntegralSint8,
9341&Interp_CastFixedPointIntegralUint8,
9342&Interp_CastFixedPointIntegralSint16,
9343&Interp_CastFixedPointIntegralUint16,
9344&Interp_CastFixedPointIntegralSint32,
9345&Interp_CastFixedPointIntegralUint32,
9346&Interp_CastFixedPointIntegralSint64,
9347&Interp_CastFixedPointIntegralUint64,
9348#endif
9349#ifdef GET_INTERPFN_DISPATCHERS
9350PRESERVE_NONE
9351static bool Interp_CastFixedPointIntegralSint8(InterpState &S) {
9352 if (!CastFixedPointIntegral<PT_Sint8>(S, S.PC)) return false;
9353#if USE_TAILCALLS
9354 MUSTTAIL return InterpNext(S);
9355#else
9356 return true;
9357#endif
9358}
9359PRESERVE_NONE
9360static bool Interp_CastFixedPointIntegralUint8(InterpState &S) {
9361 if (!CastFixedPointIntegral<PT_Uint8>(S, S.PC)) return false;
9362#if USE_TAILCALLS
9363 MUSTTAIL return InterpNext(S);
9364#else
9365 return true;
9366#endif
9367}
9368PRESERVE_NONE
9369static bool Interp_CastFixedPointIntegralSint16(InterpState &S) {
9370 if (!CastFixedPointIntegral<PT_Sint16>(S, S.PC)) return false;
9371#if USE_TAILCALLS
9372 MUSTTAIL return InterpNext(S);
9373#else
9374 return true;
9375#endif
9376}
9377PRESERVE_NONE
9378static bool Interp_CastFixedPointIntegralUint16(InterpState &S) {
9379 if (!CastFixedPointIntegral<PT_Uint16>(S, S.PC)) return false;
9380#if USE_TAILCALLS
9381 MUSTTAIL return InterpNext(S);
9382#else
9383 return true;
9384#endif
9385}
9386PRESERVE_NONE
9387static bool Interp_CastFixedPointIntegralSint32(InterpState &S) {
9388 if (!CastFixedPointIntegral<PT_Sint32>(S, S.PC)) return false;
9389#if USE_TAILCALLS
9390 MUSTTAIL return InterpNext(S);
9391#else
9392 return true;
9393#endif
9394}
9395PRESERVE_NONE
9396static bool Interp_CastFixedPointIntegralUint32(InterpState &S) {
9397 if (!CastFixedPointIntegral<PT_Uint32>(S, S.PC)) return false;
9398#if USE_TAILCALLS
9399 MUSTTAIL return InterpNext(S);
9400#else
9401 return true;
9402#endif
9403}
9404PRESERVE_NONE
9405static bool Interp_CastFixedPointIntegralSint64(InterpState &S) {
9406 if (!CastFixedPointIntegral<PT_Sint64>(S, S.PC)) return false;
9407#if USE_TAILCALLS
9408 MUSTTAIL return InterpNext(S);
9409#else
9410 return true;
9411#endif
9412}
9413PRESERVE_NONE
9414static bool Interp_CastFixedPointIntegralUint64(InterpState &S) {
9415 if (!CastFixedPointIntegral<PT_Uint64>(S, S.PC)) return false;
9416#if USE_TAILCALLS
9417 MUSTTAIL return InterpNext(S);
9418#else
9419 return true;
9420#endif
9421}
9422#endif
9423#ifdef GET_DISASM
9424case OP_CastFixedPointIntegralSint8:
9425 Text.Op = PrintName("CastFixedPointIntegralSint8");
9426 break;
9427case OP_CastFixedPointIntegralUint8:
9428 Text.Op = PrintName("CastFixedPointIntegralUint8");
9429 break;
9430case OP_CastFixedPointIntegralSint16:
9431 Text.Op = PrintName("CastFixedPointIntegralSint16");
9432 break;
9433case OP_CastFixedPointIntegralUint16:
9434 Text.Op = PrintName("CastFixedPointIntegralUint16");
9435 break;
9436case OP_CastFixedPointIntegralSint32:
9437 Text.Op = PrintName("CastFixedPointIntegralSint32");
9438 break;
9439case OP_CastFixedPointIntegralUint32:
9440 Text.Op = PrintName("CastFixedPointIntegralUint32");
9441 break;
9442case OP_CastFixedPointIntegralSint64:
9443 Text.Op = PrintName("CastFixedPointIntegralSint64");
9444 break;
9445case OP_CastFixedPointIntegralUint64:
9446 Text.Op = PrintName("CastFixedPointIntegralUint64");
9447 break;
9448#endif
9449#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9450bool emitCastFixedPointIntegralSint8(SourceInfo);
9451bool emitCastFixedPointIntegralUint8(SourceInfo);
9452bool emitCastFixedPointIntegralSint16(SourceInfo);
9453bool emitCastFixedPointIntegralUint16(SourceInfo);
9454bool emitCastFixedPointIntegralSint32(SourceInfo);
9455bool emitCastFixedPointIntegralUint32(SourceInfo);
9456bool emitCastFixedPointIntegralSint64(SourceInfo);
9457bool emitCastFixedPointIntegralUint64(SourceInfo);
9458#endif
9459#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9460[[nodiscard]] bool emitCastFixedPointIntegral(PrimType, SourceInfo I);
9461#endif
9462#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
9463bool
9464#if defined(GET_EVAL_IMPL)
9465EvalEmitter
9466#else
9467ByteCodeEmitter
9468#endif
9469::emitCastFixedPointIntegral(PrimType T0, SourceInfo I) {
9470 switch (T0) {
9471 case PT_Sint8:
9472 return emitCastFixedPointIntegralSint8(I);
9473 case PT_Uint8:
9474 return emitCastFixedPointIntegralUint8(I);
9475 case PT_Sint16:
9476 return emitCastFixedPointIntegralSint16(I);
9477 case PT_Uint16:
9478 return emitCastFixedPointIntegralUint16(I);
9479 case PT_Sint32:
9480 return emitCastFixedPointIntegralSint32(I);
9481 case PT_Uint32:
9482 return emitCastFixedPointIntegralUint32(I);
9483 case PT_Sint64:
9484 return emitCastFixedPointIntegralSint64(I);
9485 case PT_Uint64:
9486 return emitCastFixedPointIntegralUint64(I);
9487 default: llvm_unreachable("invalid type: emitCastFixedPointIntegral");
9488 }
9489 llvm_unreachable("invalid enum value");
9490}
9491#endif
9492#ifdef GET_LINK_IMPL
9493bool ByteCodeEmitter::emitCastFixedPointIntegralSint8(SourceInfo L) {
9494 return emitOp<>(OP_CastFixedPointIntegralSint8, L);
9495}
9496bool ByteCodeEmitter::emitCastFixedPointIntegralUint8(SourceInfo L) {
9497 return emitOp<>(OP_CastFixedPointIntegralUint8, L);
9498}
9499bool ByteCodeEmitter::emitCastFixedPointIntegralSint16(SourceInfo L) {
9500 return emitOp<>(OP_CastFixedPointIntegralSint16, L);
9501}
9502bool ByteCodeEmitter::emitCastFixedPointIntegralUint16(SourceInfo L) {
9503 return emitOp<>(OP_CastFixedPointIntegralUint16, L);
9504}
9505bool ByteCodeEmitter::emitCastFixedPointIntegralSint32(SourceInfo L) {
9506 return emitOp<>(OP_CastFixedPointIntegralSint32, L);
9507}
9508bool ByteCodeEmitter::emitCastFixedPointIntegralUint32(SourceInfo L) {
9509 return emitOp<>(OP_CastFixedPointIntegralUint32, L);
9510}
9511bool ByteCodeEmitter::emitCastFixedPointIntegralSint64(SourceInfo L) {
9512 return emitOp<>(OP_CastFixedPointIntegralSint64, L);
9513}
9514bool ByteCodeEmitter::emitCastFixedPointIntegralUint64(SourceInfo L) {
9515 return emitOp<>(OP_CastFixedPointIntegralUint64, L);
9516}
9517#endif
9518#ifdef GET_EVAL_IMPL
9519bool EvalEmitter::emitCastFixedPointIntegralSint8(SourceInfo L) {
9520 if (!isActive()) return true;
9521 CurrentSource = L;
9522 return CastFixedPointIntegral<PT_Sint8>(S, CodePtr());
9523}
9524bool EvalEmitter::emitCastFixedPointIntegralUint8(SourceInfo L) {
9525 if (!isActive()) return true;
9526 CurrentSource = L;
9527 return CastFixedPointIntegral<PT_Uint8>(S, CodePtr());
9528}
9529bool EvalEmitter::emitCastFixedPointIntegralSint16(SourceInfo L) {
9530 if (!isActive()) return true;
9531 CurrentSource = L;
9532 return CastFixedPointIntegral<PT_Sint16>(S, CodePtr());
9533}
9534bool EvalEmitter::emitCastFixedPointIntegralUint16(SourceInfo L) {
9535 if (!isActive()) return true;
9536 CurrentSource = L;
9537 return CastFixedPointIntegral<PT_Uint16>(S, CodePtr());
9538}
9539bool EvalEmitter::emitCastFixedPointIntegralSint32(SourceInfo L) {
9540 if (!isActive()) return true;
9541 CurrentSource = L;
9542 return CastFixedPointIntegral<PT_Sint32>(S, CodePtr());
9543}
9544bool EvalEmitter::emitCastFixedPointIntegralUint32(SourceInfo L) {
9545 if (!isActive()) return true;
9546 CurrentSource = L;
9547 return CastFixedPointIntegral<PT_Uint32>(S, CodePtr());
9548}
9549bool EvalEmitter::emitCastFixedPointIntegralSint64(SourceInfo L) {
9550 if (!isActive()) return true;
9551 CurrentSource = L;
9552 return CastFixedPointIntegral<PT_Sint64>(S, CodePtr());
9553}
9554bool EvalEmitter::emitCastFixedPointIntegralUint64(SourceInfo L) {
9555 if (!isActive()) return true;
9556 CurrentSource = L;
9557 return CastFixedPointIntegral<PT_Uint64>(S, CodePtr());
9558}
9559#endif
9560#ifdef GET_OPCODE_NAMES
9561OP_CastFloatingFixedPoint,
9562#endif
9563#ifdef GET_INTERPFN_LIST
9564&Interp_CastFloatingFixedPoint,
9565#endif
9566#ifdef GET_INTERPFN_DISPATCHERS
9567PRESERVE_NONE
9568static bool Interp_CastFloatingFixedPoint(InterpState &S) {
9569 {
9570 CodePtr OpPC = S.PC;
9571 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9572 if (!CastFloatingFixedPoint(S, OpPC, V0)) return false;
9573 }
9574#if USE_TAILCALLS
9575 MUSTTAIL return InterpNext(S);
9576#else
9577 return true;
9578#endif
9579}
9580#endif
9581#ifdef GET_DISASM
9582case OP_CastFloatingFixedPoint:
9583 Text.Op = PrintName("CastFloatingFixedPoint");
9584 Text.Args.push_back(printArg<uint32_t>(PC));
9585 break;
9586#endif
9587#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9588bool emitCastFloatingFixedPoint( uint32_t , SourceInfo);
9589#endif
9590#ifdef GET_LINK_IMPL
9591bool ByteCodeEmitter::emitCastFloatingFixedPoint( uint32_t A0, SourceInfo L) {
9592 return emitOp<uint32_t>(OP_CastFloatingFixedPoint, A0, L);
9593}
9594#endif
9595#ifdef GET_EVAL_IMPL
9596bool EvalEmitter::emitCastFloatingFixedPoint( uint32_t A0, SourceInfo L) {
9597 if (!isActive()) return true;
9598 CurrentSource = L;
9599 return CastFloatingFixedPoint(S, CodePtr(), A0);
9600}
9601#endif
9602#ifdef GET_OPCODE_NAMES
9603OP_CastFloatingIntegralSint8,
9604OP_CastFloatingIntegralUint8,
9605OP_CastFloatingIntegralSint16,
9606OP_CastFloatingIntegralUint16,
9607OP_CastFloatingIntegralSint32,
9608OP_CastFloatingIntegralUint32,
9609OP_CastFloatingIntegralSint64,
9610OP_CastFloatingIntegralUint64,
9611OP_CastFloatingIntegralBool,
9612#endif
9613#ifdef GET_INTERPFN_LIST
9614&Interp_CastFloatingIntegralSint8,
9615&Interp_CastFloatingIntegralUint8,
9616&Interp_CastFloatingIntegralSint16,
9617&Interp_CastFloatingIntegralUint16,
9618&Interp_CastFloatingIntegralSint32,
9619&Interp_CastFloatingIntegralUint32,
9620&Interp_CastFloatingIntegralSint64,
9621&Interp_CastFloatingIntegralUint64,
9622&Interp_CastFloatingIntegralBool,
9623#endif
9624#ifdef GET_INTERPFN_DISPATCHERS
9625PRESERVE_NONE
9626static bool Interp_CastFloatingIntegralSint8(InterpState &S) {
9627 {
9628 CodePtr OpPC = S.PC;
9629 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9630 if (!CastFloatingIntegral<PT_Sint8>(S, OpPC, V0)) return false;
9631 }
9632#if USE_TAILCALLS
9633 MUSTTAIL return InterpNext(S);
9634#else
9635 return true;
9636#endif
9637}
9638PRESERVE_NONE
9639static bool Interp_CastFloatingIntegralUint8(InterpState &S) {
9640 {
9641 CodePtr OpPC = S.PC;
9642 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9643 if (!CastFloatingIntegral<PT_Uint8>(S, OpPC, V0)) return false;
9644 }
9645#if USE_TAILCALLS
9646 MUSTTAIL return InterpNext(S);
9647#else
9648 return true;
9649#endif
9650}
9651PRESERVE_NONE
9652static bool Interp_CastFloatingIntegralSint16(InterpState &S) {
9653 {
9654 CodePtr OpPC = S.PC;
9655 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9656 if (!CastFloatingIntegral<PT_Sint16>(S, OpPC, V0)) return false;
9657 }
9658#if USE_TAILCALLS
9659 MUSTTAIL return InterpNext(S);
9660#else
9661 return true;
9662#endif
9663}
9664PRESERVE_NONE
9665static bool Interp_CastFloatingIntegralUint16(InterpState &S) {
9666 {
9667 CodePtr OpPC = S.PC;
9668 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9669 if (!CastFloatingIntegral<PT_Uint16>(S, OpPC, V0)) return false;
9670 }
9671#if USE_TAILCALLS
9672 MUSTTAIL return InterpNext(S);
9673#else
9674 return true;
9675#endif
9676}
9677PRESERVE_NONE
9678static bool Interp_CastFloatingIntegralSint32(InterpState &S) {
9679 {
9680 CodePtr OpPC = S.PC;
9681 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9682 if (!CastFloatingIntegral<PT_Sint32>(S, OpPC, V0)) return false;
9683 }
9684#if USE_TAILCALLS
9685 MUSTTAIL return InterpNext(S);
9686#else
9687 return true;
9688#endif
9689}
9690PRESERVE_NONE
9691static bool Interp_CastFloatingIntegralUint32(InterpState &S) {
9692 {
9693 CodePtr OpPC = S.PC;
9694 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9695 if (!CastFloatingIntegral<PT_Uint32>(S, OpPC, V0)) return false;
9696 }
9697#if USE_TAILCALLS
9698 MUSTTAIL return InterpNext(S);
9699#else
9700 return true;
9701#endif
9702}
9703PRESERVE_NONE
9704static bool Interp_CastFloatingIntegralSint64(InterpState &S) {
9705 {
9706 CodePtr OpPC = S.PC;
9707 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9708 if (!CastFloatingIntegral<PT_Sint64>(S, OpPC, V0)) return false;
9709 }
9710#if USE_TAILCALLS
9711 MUSTTAIL return InterpNext(S);
9712#else
9713 return true;
9714#endif
9715}
9716PRESERVE_NONE
9717static bool Interp_CastFloatingIntegralUint64(InterpState &S) {
9718 {
9719 CodePtr OpPC = S.PC;
9720 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9721 if (!CastFloatingIntegral<PT_Uint64>(S, OpPC, V0)) return false;
9722 }
9723#if USE_TAILCALLS
9724 MUSTTAIL return InterpNext(S);
9725#else
9726 return true;
9727#endif
9728}
9729PRESERVE_NONE
9730static bool Interp_CastFloatingIntegralBool(InterpState &S) {
9731 {
9732 CodePtr OpPC = S.PC;
9733 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9734 if (!CastFloatingIntegral<PT_Bool>(S, OpPC, V0)) return false;
9735 }
9736#if USE_TAILCALLS
9737 MUSTTAIL return InterpNext(S);
9738#else
9739 return true;
9740#endif
9741}
9742#endif
9743#ifdef GET_DISASM
9744case OP_CastFloatingIntegralSint8:
9745 Text.Op = PrintName("CastFloatingIntegralSint8");
9746 Text.Args.push_back(printArg<uint32_t>(PC));
9747 break;
9748case OP_CastFloatingIntegralUint8:
9749 Text.Op = PrintName("CastFloatingIntegralUint8");
9750 Text.Args.push_back(printArg<uint32_t>(PC));
9751 break;
9752case OP_CastFloatingIntegralSint16:
9753 Text.Op = PrintName("CastFloatingIntegralSint16");
9754 Text.Args.push_back(printArg<uint32_t>(PC));
9755 break;
9756case OP_CastFloatingIntegralUint16:
9757 Text.Op = PrintName("CastFloatingIntegralUint16");
9758 Text.Args.push_back(printArg<uint32_t>(PC));
9759 break;
9760case OP_CastFloatingIntegralSint32:
9761 Text.Op = PrintName("CastFloatingIntegralSint32");
9762 Text.Args.push_back(printArg<uint32_t>(PC));
9763 break;
9764case OP_CastFloatingIntegralUint32:
9765 Text.Op = PrintName("CastFloatingIntegralUint32");
9766 Text.Args.push_back(printArg<uint32_t>(PC));
9767 break;
9768case OP_CastFloatingIntegralSint64:
9769 Text.Op = PrintName("CastFloatingIntegralSint64");
9770 Text.Args.push_back(printArg<uint32_t>(PC));
9771 break;
9772case OP_CastFloatingIntegralUint64:
9773 Text.Op = PrintName("CastFloatingIntegralUint64");
9774 Text.Args.push_back(printArg<uint32_t>(PC));
9775 break;
9776case OP_CastFloatingIntegralBool:
9777 Text.Op = PrintName("CastFloatingIntegralBool");
9778 Text.Args.push_back(printArg<uint32_t>(PC));
9779 break;
9780#endif
9781#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9782bool emitCastFloatingIntegralSint8( uint32_t , SourceInfo);
9783bool emitCastFloatingIntegralUint8( uint32_t , SourceInfo);
9784bool emitCastFloatingIntegralSint16( uint32_t , SourceInfo);
9785bool emitCastFloatingIntegralUint16( uint32_t , SourceInfo);
9786bool emitCastFloatingIntegralSint32( uint32_t , SourceInfo);
9787bool emitCastFloatingIntegralUint32( uint32_t , SourceInfo);
9788bool emitCastFloatingIntegralSint64( uint32_t , SourceInfo);
9789bool emitCastFloatingIntegralUint64( uint32_t , SourceInfo);
9790bool emitCastFloatingIntegralBool( uint32_t , SourceInfo);
9791#endif
9792#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9793[[nodiscard]] bool emitCastFloatingIntegral(PrimType, uint32_t, SourceInfo I);
9794#endif
9795#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
9796bool
9797#if defined(GET_EVAL_IMPL)
9798EvalEmitter
9799#else
9800ByteCodeEmitter
9801#endif
9802::emitCastFloatingIntegral(PrimType T0, uint32_t A0, SourceInfo I) {
9803 switch (T0) {
9804 case PT_Sint8:
9805 return emitCastFloatingIntegralSint8(A0, I);
9806 case PT_Uint8:
9807 return emitCastFloatingIntegralUint8(A0, I);
9808 case PT_Sint16:
9809 return emitCastFloatingIntegralSint16(A0, I);
9810 case PT_Uint16:
9811 return emitCastFloatingIntegralUint16(A0, I);
9812 case PT_Sint32:
9813 return emitCastFloatingIntegralSint32(A0, I);
9814 case PT_Uint32:
9815 return emitCastFloatingIntegralUint32(A0, I);
9816 case PT_Sint64:
9817 return emitCastFloatingIntegralSint64(A0, I);
9818 case PT_Uint64:
9819 return emitCastFloatingIntegralUint64(A0, I);
9820 case PT_Bool:
9821 return emitCastFloatingIntegralBool(A0, I);
9822 default: llvm_unreachable("invalid type: emitCastFloatingIntegral");
9823 }
9824 llvm_unreachable("invalid enum value");
9825}
9826#endif
9827#ifdef GET_LINK_IMPL
9828bool ByteCodeEmitter::emitCastFloatingIntegralSint8( uint32_t A0, SourceInfo L) {
9829 return emitOp<uint32_t>(OP_CastFloatingIntegralSint8, A0, L);
9830}
9831bool ByteCodeEmitter::emitCastFloatingIntegralUint8( uint32_t A0, SourceInfo L) {
9832 return emitOp<uint32_t>(OP_CastFloatingIntegralUint8, A0, L);
9833}
9834bool ByteCodeEmitter::emitCastFloatingIntegralSint16( uint32_t A0, SourceInfo L) {
9835 return emitOp<uint32_t>(OP_CastFloatingIntegralSint16, A0, L);
9836}
9837bool ByteCodeEmitter::emitCastFloatingIntegralUint16( uint32_t A0, SourceInfo L) {
9838 return emitOp<uint32_t>(OP_CastFloatingIntegralUint16, A0, L);
9839}
9840bool ByteCodeEmitter::emitCastFloatingIntegralSint32( uint32_t A0, SourceInfo L) {
9841 return emitOp<uint32_t>(OP_CastFloatingIntegralSint32, A0, L);
9842}
9843bool ByteCodeEmitter::emitCastFloatingIntegralUint32( uint32_t A0, SourceInfo L) {
9844 return emitOp<uint32_t>(OP_CastFloatingIntegralUint32, A0, L);
9845}
9846bool ByteCodeEmitter::emitCastFloatingIntegralSint64( uint32_t A0, SourceInfo L) {
9847 return emitOp<uint32_t>(OP_CastFloatingIntegralSint64, A0, L);
9848}
9849bool ByteCodeEmitter::emitCastFloatingIntegralUint64( uint32_t A0, SourceInfo L) {
9850 return emitOp<uint32_t>(OP_CastFloatingIntegralUint64, A0, L);
9851}
9852bool ByteCodeEmitter::emitCastFloatingIntegralBool( uint32_t A0, SourceInfo L) {
9853 return emitOp<uint32_t>(OP_CastFloatingIntegralBool, A0, L);
9854}
9855#endif
9856#ifdef GET_EVAL_IMPL
9857bool EvalEmitter::emitCastFloatingIntegralSint8( uint32_t A0, SourceInfo L) {
9858 if (!isActive()) return true;
9859 CurrentSource = L;
9860 return CastFloatingIntegral<PT_Sint8>(S, CodePtr(), A0);
9861}
9862bool EvalEmitter::emitCastFloatingIntegralUint8( uint32_t A0, SourceInfo L) {
9863 if (!isActive()) return true;
9864 CurrentSource = L;
9865 return CastFloatingIntegral<PT_Uint8>(S, CodePtr(), A0);
9866}
9867bool EvalEmitter::emitCastFloatingIntegralSint16( uint32_t A0, SourceInfo L) {
9868 if (!isActive()) return true;
9869 CurrentSource = L;
9870 return CastFloatingIntegral<PT_Sint16>(S, CodePtr(), A0);
9871}
9872bool EvalEmitter::emitCastFloatingIntegralUint16( uint32_t A0, SourceInfo L) {
9873 if (!isActive()) return true;
9874 CurrentSource = L;
9875 return CastFloatingIntegral<PT_Uint16>(S, CodePtr(), A0);
9876}
9877bool EvalEmitter::emitCastFloatingIntegralSint32( uint32_t A0, SourceInfo L) {
9878 if (!isActive()) return true;
9879 CurrentSource = L;
9880 return CastFloatingIntegral<PT_Sint32>(S, CodePtr(), A0);
9881}
9882bool EvalEmitter::emitCastFloatingIntegralUint32( uint32_t A0, SourceInfo L) {
9883 if (!isActive()) return true;
9884 CurrentSource = L;
9885 return CastFloatingIntegral<PT_Uint32>(S, CodePtr(), A0);
9886}
9887bool EvalEmitter::emitCastFloatingIntegralSint64( uint32_t A0, SourceInfo L) {
9888 if (!isActive()) return true;
9889 CurrentSource = L;
9890 return CastFloatingIntegral<PT_Sint64>(S, CodePtr(), A0);
9891}
9892bool EvalEmitter::emitCastFloatingIntegralUint64( uint32_t A0, SourceInfo L) {
9893 if (!isActive()) return true;
9894 CurrentSource = L;
9895 return CastFloatingIntegral<PT_Uint64>(S, CodePtr(), A0);
9896}
9897bool EvalEmitter::emitCastFloatingIntegralBool( uint32_t A0, SourceInfo L) {
9898 if (!isActive()) return true;
9899 CurrentSource = L;
9900 return CastFloatingIntegral<PT_Bool>(S, CodePtr(), A0);
9901}
9902#endif
9903#ifdef GET_OPCODE_NAMES
9904OP_CastFloatingIntegralAP,
9905#endif
9906#ifdef GET_INTERPFN_LIST
9907&Interp_CastFloatingIntegralAP,
9908#endif
9909#ifdef GET_INTERPFN_DISPATCHERS
9910PRESERVE_NONE
9911static bool Interp_CastFloatingIntegralAP(InterpState &S) {
9912 {
9913 CodePtr OpPC = S.PC;
9914 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9915 const auto V1 = ReadArg<uint32_t>(S, S.PC);
9916 if (!CastFloatingIntegralAP(S, OpPC, V0, V1)) return false;
9917 }
9918#if USE_TAILCALLS
9919 MUSTTAIL return InterpNext(S);
9920#else
9921 return true;
9922#endif
9923}
9924#endif
9925#ifdef GET_DISASM
9926case OP_CastFloatingIntegralAP:
9927 Text.Op = PrintName("CastFloatingIntegralAP");
9928 Text.Args.push_back(printArg<uint32_t>(PC));
9929 Text.Args.push_back(printArg<uint32_t>(PC));
9930 break;
9931#endif
9932#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9933bool emitCastFloatingIntegralAP( uint32_t , uint32_t , SourceInfo);
9934#endif
9935#ifdef GET_LINK_IMPL
9936bool ByteCodeEmitter::emitCastFloatingIntegralAP( uint32_t A0, uint32_t A1, SourceInfo L) {
9937 return emitOp<uint32_t, uint32_t>(OP_CastFloatingIntegralAP, A0, A1, L);
9938}
9939#endif
9940#ifdef GET_EVAL_IMPL
9941bool EvalEmitter::emitCastFloatingIntegralAP( uint32_t A0, uint32_t A1, SourceInfo L) {
9942 if (!isActive()) return true;
9943 CurrentSource = L;
9944 return CastFloatingIntegralAP(S, CodePtr(), A0, A1);
9945}
9946#endif
9947#ifdef GET_OPCODE_NAMES
9948OP_CastFloatingIntegralAPS,
9949#endif
9950#ifdef GET_INTERPFN_LIST
9951&Interp_CastFloatingIntegralAPS,
9952#endif
9953#ifdef GET_INTERPFN_DISPATCHERS
9954PRESERVE_NONE
9955static bool Interp_CastFloatingIntegralAPS(InterpState &S) {
9956 {
9957 CodePtr OpPC = S.PC;
9958 const auto V0 = ReadArg<uint32_t>(S, S.PC);
9959 const auto V1 = ReadArg<uint32_t>(S, S.PC);
9960 if (!CastFloatingIntegralAPS(S, OpPC, V0, V1)) return false;
9961 }
9962#if USE_TAILCALLS
9963 MUSTTAIL return InterpNext(S);
9964#else
9965 return true;
9966#endif
9967}
9968#endif
9969#ifdef GET_DISASM
9970case OP_CastFloatingIntegralAPS:
9971 Text.Op = PrintName("CastFloatingIntegralAPS");
9972 Text.Args.push_back(printArg<uint32_t>(PC));
9973 Text.Args.push_back(printArg<uint32_t>(PC));
9974 break;
9975#endif
9976#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
9977bool emitCastFloatingIntegralAPS( uint32_t , uint32_t , SourceInfo);
9978#endif
9979#ifdef GET_LINK_IMPL
9980bool ByteCodeEmitter::emitCastFloatingIntegralAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
9981 return emitOp<uint32_t, uint32_t>(OP_CastFloatingIntegralAPS, A0, A1, L);
9982}
9983#endif
9984#ifdef GET_EVAL_IMPL
9985bool EvalEmitter::emitCastFloatingIntegralAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
9986 if (!isActive()) return true;
9987 CurrentSource = L;
9988 return CastFloatingIntegralAPS(S, CodePtr(), A0, A1);
9989}
9990#endif
9991#ifdef GET_OPCODE_NAMES
9992OP_CastIntegralFixedPointSint8,
9993OP_CastIntegralFixedPointUint8,
9994OP_CastIntegralFixedPointSint16,
9995OP_CastIntegralFixedPointUint16,
9996OP_CastIntegralFixedPointSint32,
9997OP_CastIntegralFixedPointUint32,
9998OP_CastIntegralFixedPointSint64,
9999OP_CastIntegralFixedPointUint64,
10000OP_CastIntegralFixedPointIntAP,
10001OP_CastIntegralFixedPointIntAPS,
10002OP_CastIntegralFixedPointBool,
10003#endif
10004#ifdef GET_INTERPFN_LIST
10005&Interp_CastIntegralFixedPointSint8,
10006&Interp_CastIntegralFixedPointUint8,
10007&Interp_CastIntegralFixedPointSint16,
10008&Interp_CastIntegralFixedPointUint16,
10009&Interp_CastIntegralFixedPointSint32,
10010&Interp_CastIntegralFixedPointUint32,
10011&Interp_CastIntegralFixedPointSint64,
10012&Interp_CastIntegralFixedPointUint64,
10013&Interp_CastIntegralFixedPointIntAP,
10014&Interp_CastIntegralFixedPointIntAPS,
10015&Interp_CastIntegralFixedPointBool,
10016#endif
10017#ifdef GET_INTERPFN_DISPATCHERS
10018PRESERVE_NONE
10019static bool Interp_CastIntegralFixedPointSint8(InterpState &S) {
10020 {
10021 CodePtr OpPC = S.PC;
10022 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10023 if (!CastIntegralFixedPoint<PT_Sint8>(S, OpPC, V0)) return false;
10024 }
10025#if USE_TAILCALLS
10026 MUSTTAIL return InterpNext(S);
10027#else
10028 return true;
10029#endif
10030}
10031PRESERVE_NONE
10032static bool Interp_CastIntegralFixedPointUint8(InterpState &S) {
10033 {
10034 CodePtr OpPC = S.PC;
10035 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10036 if (!CastIntegralFixedPoint<PT_Uint8>(S, OpPC, V0)) return false;
10037 }
10038#if USE_TAILCALLS
10039 MUSTTAIL return InterpNext(S);
10040#else
10041 return true;
10042#endif
10043}
10044PRESERVE_NONE
10045static bool Interp_CastIntegralFixedPointSint16(InterpState &S) {
10046 {
10047 CodePtr OpPC = S.PC;
10048 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10049 if (!CastIntegralFixedPoint<PT_Sint16>(S, OpPC, V0)) return false;
10050 }
10051#if USE_TAILCALLS
10052 MUSTTAIL return InterpNext(S);
10053#else
10054 return true;
10055#endif
10056}
10057PRESERVE_NONE
10058static bool Interp_CastIntegralFixedPointUint16(InterpState &S) {
10059 {
10060 CodePtr OpPC = S.PC;
10061 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10062 if (!CastIntegralFixedPoint<PT_Uint16>(S, OpPC, V0)) return false;
10063 }
10064#if USE_TAILCALLS
10065 MUSTTAIL return InterpNext(S);
10066#else
10067 return true;
10068#endif
10069}
10070PRESERVE_NONE
10071static bool Interp_CastIntegralFixedPointSint32(InterpState &S) {
10072 {
10073 CodePtr OpPC = S.PC;
10074 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10075 if (!CastIntegralFixedPoint<PT_Sint32>(S, OpPC, V0)) return false;
10076 }
10077#if USE_TAILCALLS
10078 MUSTTAIL return InterpNext(S);
10079#else
10080 return true;
10081#endif
10082}
10083PRESERVE_NONE
10084static bool Interp_CastIntegralFixedPointUint32(InterpState &S) {
10085 {
10086 CodePtr OpPC = S.PC;
10087 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10088 if (!CastIntegralFixedPoint<PT_Uint32>(S, OpPC, V0)) return false;
10089 }
10090#if USE_TAILCALLS
10091 MUSTTAIL return InterpNext(S);
10092#else
10093 return true;
10094#endif
10095}
10096PRESERVE_NONE
10097static bool Interp_CastIntegralFixedPointSint64(InterpState &S) {
10098 {
10099 CodePtr OpPC = S.PC;
10100 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10101 if (!CastIntegralFixedPoint<PT_Sint64>(S, OpPC, V0)) return false;
10102 }
10103#if USE_TAILCALLS
10104 MUSTTAIL return InterpNext(S);
10105#else
10106 return true;
10107#endif
10108}
10109PRESERVE_NONE
10110static bool Interp_CastIntegralFixedPointUint64(InterpState &S) {
10111 {
10112 CodePtr OpPC = S.PC;
10113 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10114 if (!CastIntegralFixedPoint<PT_Uint64>(S, OpPC, V0)) return false;
10115 }
10116#if USE_TAILCALLS
10117 MUSTTAIL return InterpNext(S);
10118#else
10119 return true;
10120#endif
10121}
10122PRESERVE_NONE
10123static bool Interp_CastIntegralFixedPointIntAP(InterpState &S) {
10124 {
10125 CodePtr OpPC = S.PC;
10126 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10127 if (!CastIntegralFixedPoint<PT_IntAP>(S, OpPC, V0)) return false;
10128 }
10129#if USE_TAILCALLS
10130 MUSTTAIL return InterpNext(S);
10131#else
10132 return true;
10133#endif
10134}
10135PRESERVE_NONE
10136static bool Interp_CastIntegralFixedPointIntAPS(InterpState &S) {
10137 {
10138 CodePtr OpPC = S.PC;
10139 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10140 if (!CastIntegralFixedPoint<PT_IntAPS>(S, OpPC, V0)) return false;
10141 }
10142#if USE_TAILCALLS
10143 MUSTTAIL return InterpNext(S);
10144#else
10145 return true;
10146#endif
10147}
10148PRESERVE_NONE
10149static bool Interp_CastIntegralFixedPointBool(InterpState &S) {
10150 {
10151 CodePtr OpPC = S.PC;
10152 const auto V0 = ReadArg<uint32_t>(S, S.PC);
10153 if (!CastIntegralFixedPoint<PT_Bool>(S, OpPC, V0)) return false;
10154 }
10155#if USE_TAILCALLS
10156 MUSTTAIL return InterpNext(S);
10157#else
10158 return true;
10159#endif
10160}
10161#endif
10162#ifdef GET_DISASM
10163case OP_CastIntegralFixedPointSint8:
10164 Text.Op = PrintName("CastIntegralFixedPointSint8");
10165 Text.Args.push_back(printArg<uint32_t>(PC));
10166 break;
10167case OP_CastIntegralFixedPointUint8:
10168 Text.Op = PrintName("CastIntegralFixedPointUint8");
10169 Text.Args.push_back(printArg<uint32_t>(PC));
10170 break;
10171case OP_CastIntegralFixedPointSint16:
10172 Text.Op = PrintName("CastIntegralFixedPointSint16");
10173 Text.Args.push_back(printArg<uint32_t>(PC));
10174 break;
10175case OP_CastIntegralFixedPointUint16:
10176 Text.Op = PrintName("CastIntegralFixedPointUint16");
10177 Text.Args.push_back(printArg<uint32_t>(PC));
10178 break;
10179case OP_CastIntegralFixedPointSint32:
10180 Text.Op = PrintName("CastIntegralFixedPointSint32");
10181 Text.Args.push_back(printArg<uint32_t>(PC));
10182 break;
10183case OP_CastIntegralFixedPointUint32:
10184 Text.Op = PrintName("CastIntegralFixedPointUint32");
10185 Text.Args.push_back(printArg<uint32_t>(PC));
10186 break;
10187case OP_CastIntegralFixedPointSint64:
10188 Text.Op = PrintName("CastIntegralFixedPointSint64");
10189 Text.Args.push_back(printArg<uint32_t>(PC));
10190 break;
10191case OP_CastIntegralFixedPointUint64:
10192 Text.Op = PrintName("CastIntegralFixedPointUint64");
10193 Text.Args.push_back(printArg<uint32_t>(PC));
10194 break;
10195case OP_CastIntegralFixedPointIntAP:
10196 Text.Op = PrintName("CastIntegralFixedPointIntAP");
10197 Text.Args.push_back(printArg<uint32_t>(PC));
10198 break;
10199case OP_CastIntegralFixedPointIntAPS:
10200 Text.Op = PrintName("CastIntegralFixedPointIntAPS");
10201 Text.Args.push_back(printArg<uint32_t>(PC));
10202 break;
10203case OP_CastIntegralFixedPointBool:
10204 Text.Op = PrintName("CastIntegralFixedPointBool");
10205 Text.Args.push_back(printArg<uint32_t>(PC));
10206 break;
10207#endif
10208#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10209bool emitCastIntegralFixedPointSint8( uint32_t , SourceInfo);
10210bool emitCastIntegralFixedPointUint8( uint32_t , SourceInfo);
10211bool emitCastIntegralFixedPointSint16( uint32_t , SourceInfo);
10212bool emitCastIntegralFixedPointUint16( uint32_t , SourceInfo);
10213bool emitCastIntegralFixedPointSint32( uint32_t , SourceInfo);
10214bool emitCastIntegralFixedPointUint32( uint32_t , SourceInfo);
10215bool emitCastIntegralFixedPointSint64( uint32_t , SourceInfo);
10216bool emitCastIntegralFixedPointUint64( uint32_t , SourceInfo);
10217bool emitCastIntegralFixedPointIntAP( uint32_t , SourceInfo);
10218bool emitCastIntegralFixedPointIntAPS( uint32_t , SourceInfo);
10219bool emitCastIntegralFixedPointBool( uint32_t , SourceInfo);
10220#endif
10221#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10222[[nodiscard]] bool emitCastIntegralFixedPoint(PrimType, uint32_t, SourceInfo I);
10223#endif
10224#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
10225bool
10226#if defined(GET_EVAL_IMPL)
10227EvalEmitter
10228#else
10229ByteCodeEmitter
10230#endif
10231::emitCastIntegralFixedPoint(PrimType T0, uint32_t A0, SourceInfo I) {
10232 switch (T0) {
10233 case PT_Sint8:
10234 return emitCastIntegralFixedPointSint8(A0, I);
10235 case PT_Uint8:
10236 return emitCastIntegralFixedPointUint8(A0, I);
10237 case PT_Sint16:
10238 return emitCastIntegralFixedPointSint16(A0, I);
10239 case PT_Uint16:
10240 return emitCastIntegralFixedPointUint16(A0, I);
10241 case PT_Sint32:
10242 return emitCastIntegralFixedPointSint32(A0, I);
10243 case PT_Uint32:
10244 return emitCastIntegralFixedPointUint32(A0, I);
10245 case PT_Sint64:
10246 return emitCastIntegralFixedPointSint64(A0, I);
10247 case PT_Uint64:
10248 return emitCastIntegralFixedPointUint64(A0, I);
10249 case PT_IntAP:
10250 return emitCastIntegralFixedPointIntAP(A0, I);
10251 case PT_IntAPS:
10252 return emitCastIntegralFixedPointIntAPS(A0, I);
10253 case PT_Bool:
10254 return emitCastIntegralFixedPointBool(A0, I);
10255 default: llvm_unreachable("invalid type: emitCastIntegralFixedPoint");
10256 }
10257 llvm_unreachable("invalid enum value");
10258}
10259#endif
10260#ifdef GET_LINK_IMPL
10261bool ByteCodeEmitter::emitCastIntegralFixedPointSint8( uint32_t A0, SourceInfo L) {
10262 return emitOp<uint32_t>(OP_CastIntegralFixedPointSint8, A0, L);
10263}
10264bool ByteCodeEmitter::emitCastIntegralFixedPointUint8( uint32_t A0, SourceInfo L) {
10265 return emitOp<uint32_t>(OP_CastIntegralFixedPointUint8, A0, L);
10266}
10267bool ByteCodeEmitter::emitCastIntegralFixedPointSint16( uint32_t A0, SourceInfo L) {
10268 return emitOp<uint32_t>(OP_CastIntegralFixedPointSint16, A0, L);
10269}
10270bool ByteCodeEmitter::emitCastIntegralFixedPointUint16( uint32_t A0, SourceInfo L) {
10271 return emitOp<uint32_t>(OP_CastIntegralFixedPointUint16, A0, L);
10272}
10273bool ByteCodeEmitter::emitCastIntegralFixedPointSint32( uint32_t A0, SourceInfo L) {
10274 return emitOp<uint32_t>(OP_CastIntegralFixedPointSint32, A0, L);
10275}
10276bool ByteCodeEmitter::emitCastIntegralFixedPointUint32( uint32_t A0, SourceInfo L) {
10277 return emitOp<uint32_t>(OP_CastIntegralFixedPointUint32, A0, L);
10278}
10279bool ByteCodeEmitter::emitCastIntegralFixedPointSint64( uint32_t A0, SourceInfo L) {
10280 return emitOp<uint32_t>(OP_CastIntegralFixedPointSint64, A0, L);
10281}
10282bool ByteCodeEmitter::emitCastIntegralFixedPointUint64( uint32_t A0, SourceInfo L) {
10283 return emitOp<uint32_t>(OP_CastIntegralFixedPointUint64, A0, L);
10284}
10285bool ByteCodeEmitter::emitCastIntegralFixedPointIntAP( uint32_t A0, SourceInfo L) {
10286 return emitOp<uint32_t>(OP_CastIntegralFixedPointIntAP, A0, L);
10287}
10288bool ByteCodeEmitter::emitCastIntegralFixedPointIntAPS( uint32_t A0, SourceInfo L) {
10289 return emitOp<uint32_t>(OP_CastIntegralFixedPointIntAPS, A0, L);
10290}
10291bool ByteCodeEmitter::emitCastIntegralFixedPointBool( uint32_t A0, SourceInfo L) {
10292 return emitOp<uint32_t>(OP_CastIntegralFixedPointBool, A0, L);
10293}
10294#endif
10295#ifdef GET_EVAL_IMPL
10296bool EvalEmitter::emitCastIntegralFixedPointSint8( uint32_t A0, SourceInfo L) {
10297 if (!isActive()) return true;
10298 CurrentSource = L;
10299 return CastIntegralFixedPoint<PT_Sint8>(S, CodePtr(), A0);
10300}
10301bool EvalEmitter::emitCastIntegralFixedPointUint8( uint32_t A0, SourceInfo L) {
10302 if (!isActive()) return true;
10303 CurrentSource = L;
10304 return CastIntegralFixedPoint<PT_Uint8>(S, CodePtr(), A0);
10305}
10306bool EvalEmitter::emitCastIntegralFixedPointSint16( uint32_t A0, SourceInfo L) {
10307 if (!isActive()) return true;
10308 CurrentSource = L;
10309 return CastIntegralFixedPoint<PT_Sint16>(S, CodePtr(), A0);
10310}
10311bool EvalEmitter::emitCastIntegralFixedPointUint16( uint32_t A0, SourceInfo L) {
10312 if (!isActive()) return true;
10313 CurrentSource = L;
10314 return CastIntegralFixedPoint<PT_Uint16>(S, CodePtr(), A0);
10315}
10316bool EvalEmitter::emitCastIntegralFixedPointSint32( uint32_t A0, SourceInfo L) {
10317 if (!isActive()) return true;
10318 CurrentSource = L;
10319 return CastIntegralFixedPoint<PT_Sint32>(S, CodePtr(), A0);
10320}
10321bool EvalEmitter::emitCastIntegralFixedPointUint32( uint32_t A0, SourceInfo L) {
10322 if (!isActive()) return true;
10323 CurrentSource = L;
10324 return CastIntegralFixedPoint<PT_Uint32>(S, CodePtr(), A0);
10325}
10326bool EvalEmitter::emitCastIntegralFixedPointSint64( uint32_t A0, SourceInfo L) {
10327 if (!isActive()) return true;
10328 CurrentSource = L;
10329 return CastIntegralFixedPoint<PT_Sint64>(S, CodePtr(), A0);
10330}
10331bool EvalEmitter::emitCastIntegralFixedPointUint64( uint32_t A0, SourceInfo L) {
10332 if (!isActive()) return true;
10333 CurrentSource = L;
10334 return CastIntegralFixedPoint<PT_Uint64>(S, CodePtr(), A0);
10335}
10336bool EvalEmitter::emitCastIntegralFixedPointIntAP( uint32_t A0, SourceInfo L) {
10337 if (!isActive()) return true;
10338 CurrentSource = L;
10339 return CastIntegralFixedPoint<PT_IntAP>(S, CodePtr(), A0);
10340}
10341bool EvalEmitter::emitCastIntegralFixedPointIntAPS( uint32_t A0, SourceInfo L) {
10342 if (!isActive()) return true;
10343 CurrentSource = L;
10344 return CastIntegralFixedPoint<PT_IntAPS>(S, CodePtr(), A0);
10345}
10346bool EvalEmitter::emitCastIntegralFixedPointBool( uint32_t A0, SourceInfo L) {
10347 if (!isActive()) return true;
10348 CurrentSource = L;
10349 return CastIntegralFixedPoint<PT_Bool>(S, CodePtr(), A0);
10350}
10351#endif
10352#ifdef GET_OPCODE_NAMES
10353OP_CastIntegralFloatingSint8,
10354OP_CastIntegralFloatingUint8,
10355OP_CastIntegralFloatingSint16,
10356OP_CastIntegralFloatingUint16,
10357OP_CastIntegralFloatingSint32,
10358OP_CastIntegralFloatingUint32,
10359OP_CastIntegralFloatingSint64,
10360OP_CastIntegralFloatingUint64,
10361OP_CastIntegralFloatingIntAP,
10362OP_CastIntegralFloatingIntAPS,
10363OP_CastIntegralFloatingBool,
10364OP_CastIntegralFloatingFixedPoint,
10365#endif
10366#ifdef GET_INTERPFN_LIST
10367&Interp_CastIntegralFloatingSint8,
10368&Interp_CastIntegralFloatingUint8,
10369&Interp_CastIntegralFloatingSint16,
10370&Interp_CastIntegralFloatingUint16,
10371&Interp_CastIntegralFloatingSint32,
10372&Interp_CastIntegralFloatingUint32,
10373&Interp_CastIntegralFloatingSint64,
10374&Interp_CastIntegralFloatingUint64,
10375&Interp_CastIntegralFloatingIntAP,
10376&Interp_CastIntegralFloatingIntAPS,
10377&Interp_CastIntegralFloatingBool,
10378&Interp_CastIntegralFloatingFixedPoint,
10379#endif
10380#ifdef GET_INTERPFN_DISPATCHERS
10381PRESERVE_NONE
10382static bool Interp_CastIntegralFloatingSint8(InterpState &S) {
10383 {
10384 CodePtr OpPC = S.PC;
10385 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10386 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10387 if (!CastIntegralFloating<PT_Sint8>(S, OpPC, V0, V1)) return false;
10388 }
10389#if USE_TAILCALLS
10390 MUSTTAIL return InterpNext(S);
10391#else
10392 return true;
10393#endif
10394}
10395PRESERVE_NONE
10396static bool Interp_CastIntegralFloatingUint8(InterpState &S) {
10397 {
10398 CodePtr OpPC = S.PC;
10399 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10400 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10401 if (!CastIntegralFloating<PT_Uint8>(S, OpPC, V0, V1)) return false;
10402 }
10403#if USE_TAILCALLS
10404 MUSTTAIL return InterpNext(S);
10405#else
10406 return true;
10407#endif
10408}
10409PRESERVE_NONE
10410static bool Interp_CastIntegralFloatingSint16(InterpState &S) {
10411 {
10412 CodePtr OpPC = S.PC;
10413 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10414 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10415 if (!CastIntegralFloating<PT_Sint16>(S, OpPC, V0, V1)) return false;
10416 }
10417#if USE_TAILCALLS
10418 MUSTTAIL return InterpNext(S);
10419#else
10420 return true;
10421#endif
10422}
10423PRESERVE_NONE
10424static bool Interp_CastIntegralFloatingUint16(InterpState &S) {
10425 {
10426 CodePtr OpPC = S.PC;
10427 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10428 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10429 if (!CastIntegralFloating<PT_Uint16>(S, OpPC, V0, V1)) return false;
10430 }
10431#if USE_TAILCALLS
10432 MUSTTAIL return InterpNext(S);
10433#else
10434 return true;
10435#endif
10436}
10437PRESERVE_NONE
10438static bool Interp_CastIntegralFloatingSint32(InterpState &S) {
10439 {
10440 CodePtr OpPC = S.PC;
10441 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10442 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10443 if (!CastIntegralFloating<PT_Sint32>(S, OpPC, V0, V1)) return false;
10444 }
10445#if USE_TAILCALLS
10446 MUSTTAIL return InterpNext(S);
10447#else
10448 return true;
10449#endif
10450}
10451PRESERVE_NONE
10452static bool Interp_CastIntegralFloatingUint32(InterpState &S) {
10453 {
10454 CodePtr OpPC = S.PC;
10455 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10456 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10457 if (!CastIntegralFloating<PT_Uint32>(S, OpPC, V0, V1)) return false;
10458 }
10459#if USE_TAILCALLS
10460 MUSTTAIL return InterpNext(S);
10461#else
10462 return true;
10463#endif
10464}
10465PRESERVE_NONE
10466static bool Interp_CastIntegralFloatingSint64(InterpState &S) {
10467 {
10468 CodePtr OpPC = S.PC;
10469 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10470 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10471 if (!CastIntegralFloating<PT_Sint64>(S, OpPC, V0, V1)) return false;
10472 }
10473#if USE_TAILCALLS
10474 MUSTTAIL return InterpNext(S);
10475#else
10476 return true;
10477#endif
10478}
10479PRESERVE_NONE
10480static bool Interp_CastIntegralFloatingUint64(InterpState &S) {
10481 {
10482 CodePtr OpPC = S.PC;
10483 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10484 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10485 if (!CastIntegralFloating<PT_Uint64>(S, OpPC, V0, V1)) return false;
10486 }
10487#if USE_TAILCALLS
10488 MUSTTAIL return InterpNext(S);
10489#else
10490 return true;
10491#endif
10492}
10493PRESERVE_NONE
10494static bool Interp_CastIntegralFloatingIntAP(InterpState &S) {
10495 {
10496 CodePtr OpPC = S.PC;
10497 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10498 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10499 if (!CastIntegralFloating<PT_IntAP>(S, OpPC, V0, V1)) return false;
10500 }
10501#if USE_TAILCALLS
10502 MUSTTAIL return InterpNext(S);
10503#else
10504 return true;
10505#endif
10506}
10507PRESERVE_NONE
10508static bool Interp_CastIntegralFloatingIntAPS(InterpState &S) {
10509 {
10510 CodePtr OpPC = S.PC;
10511 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10512 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10513 if (!CastIntegralFloating<PT_IntAPS>(S, OpPC, V0, V1)) return false;
10514 }
10515#if USE_TAILCALLS
10516 MUSTTAIL return InterpNext(S);
10517#else
10518 return true;
10519#endif
10520}
10521PRESERVE_NONE
10522static bool Interp_CastIntegralFloatingBool(InterpState &S) {
10523 {
10524 CodePtr OpPC = S.PC;
10525 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10526 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10527 if (!CastIntegralFloating<PT_Bool>(S, OpPC, V0, V1)) return false;
10528 }
10529#if USE_TAILCALLS
10530 MUSTTAIL return InterpNext(S);
10531#else
10532 return true;
10533#endif
10534}
10535PRESERVE_NONE
10536static bool Interp_CastIntegralFloatingFixedPoint(InterpState &S) {
10537 {
10538 CodePtr OpPC = S.PC;
10539 const auto V0 = ReadArg<const llvm::fltSemantics *>(S, S.PC);
10540 const auto V1 = ReadArg<uint32_t>(S, S.PC);
10541 if (!CastIntegralFloating<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
10542 }
10543#if USE_TAILCALLS
10544 MUSTTAIL return InterpNext(S);
10545#else
10546 return true;
10547#endif
10548}
10549#endif
10550#ifdef GET_DISASM
10551case OP_CastIntegralFloatingSint8:
10552 Text.Op = PrintName("CastIntegralFloatingSint8");
10553 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10554 Text.Args.push_back(printArg<uint32_t>(PC));
10555 break;
10556case OP_CastIntegralFloatingUint8:
10557 Text.Op = PrintName("CastIntegralFloatingUint8");
10558 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10559 Text.Args.push_back(printArg<uint32_t>(PC));
10560 break;
10561case OP_CastIntegralFloatingSint16:
10562 Text.Op = PrintName("CastIntegralFloatingSint16");
10563 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10564 Text.Args.push_back(printArg<uint32_t>(PC));
10565 break;
10566case OP_CastIntegralFloatingUint16:
10567 Text.Op = PrintName("CastIntegralFloatingUint16");
10568 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10569 Text.Args.push_back(printArg<uint32_t>(PC));
10570 break;
10571case OP_CastIntegralFloatingSint32:
10572 Text.Op = PrintName("CastIntegralFloatingSint32");
10573 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10574 Text.Args.push_back(printArg<uint32_t>(PC));
10575 break;
10576case OP_CastIntegralFloatingUint32:
10577 Text.Op = PrintName("CastIntegralFloatingUint32");
10578 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10579 Text.Args.push_back(printArg<uint32_t>(PC));
10580 break;
10581case OP_CastIntegralFloatingSint64:
10582 Text.Op = PrintName("CastIntegralFloatingSint64");
10583 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10584 Text.Args.push_back(printArg<uint32_t>(PC));
10585 break;
10586case OP_CastIntegralFloatingUint64:
10587 Text.Op = PrintName("CastIntegralFloatingUint64");
10588 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10589 Text.Args.push_back(printArg<uint32_t>(PC));
10590 break;
10591case OP_CastIntegralFloatingIntAP:
10592 Text.Op = PrintName("CastIntegralFloatingIntAP");
10593 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10594 Text.Args.push_back(printArg<uint32_t>(PC));
10595 break;
10596case OP_CastIntegralFloatingIntAPS:
10597 Text.Op = PrintName("CastIntegralFloatingIntAPS");
10598 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10599 Text.Args.push_back(printArg<uint32_t>(PC));
10600 break;
10601case OP_CastIntegralFloatingBool:
10602 Text.Op = PrintName("CastIntegralFloatingBool");
10603 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10604 Text.Args.push_back(printArg<uint32_t>(PC));
10605 break;
10606case OP_CastIntegralFloatingFixedPoint:
10607 Text.Op = PrintName("CastIntegralFloatingFixedPoint");
10608 Text.Args.push_back(printArg<const llvm::fltSemantics *>(PC));
10609 Text.Args.push_back(printArg<uint32_t>(PC));
10610 break;
10611#endif
10612#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10613bool emitCastIntegralFloatingSint8( const llvm::fltSemantics * , uint32_t , SourceInfo);
10614bool emitCastIntegralFloatingUint8( const llvm::fltSemantics * , uint32_t , SourceInfo);
10615bool emitCastIntegralFloatingSint16( const llvm::fltSemantics * , uint32_t , SourceInfo);
10616bool emitCastIntegralFloatingUint16( const llvm::fltSemantics * , uint32_t , SourceInfo);
10617bool emitCastIntegralFloatingSint32( const llvm::fltSemantics * , uint32_t , SourceInfo);
10618bool emitCastIntegralFloatingUint32( const llvm::fltSemantics * , uint32_t , SourceInfo);
10619bool emitCastIntegralFloatingSint64( const llvm::fltSemantics * , uint32_t , SourceInfo);
10620bool emitCastIntegralFloatingUint64( const llvm::fltSemantics * , uint32_t , SourceInfo);
10621bool emitCastIntegralFloatingIntAP( const llvm::fltSemantics * , uint32_t , SourceInfo);
10622bool emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * , uint32_t , SourceInfo);
10623bool emitCastIntegralFloatingBool( const llvm::fltSemantics * , uint32_t , SourceInfo);
10624bool emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * , uint32_t , SourceInfo);
10625#endif
10626#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10627[[nodiscard]] bool emitCastIntegralFloating(PrimType, const llvm::fltSemantics *, uint32_t, SourceInfo I);
10628#endif
10629#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
10630bool
10631#if defined(GET_EVAL_IMPL)
10632EvalEmitter
10633#else
10634ByteCodeEmitter
10635#endif
10636::emitCastIntegralFloating(PrimType T0, const llvm::fltSemantics * A0, uint32_t A1, SourceInfo I) {
10637 switch (T0) {
10638 case PT_Sint8:
10639 return emitCastIntegralFloatingSint8(A0, A1, I);
10640 case PT_Uint8:
10641 return emitCastIntegralFloatingUint8(A0, A1, I);
10642 case PT_Sint16:
10643 return emitCastIntegralFloatingSint16(A0, A1, I);
10644 case PT_Uint16:
10645 return emitCastIntegralFloatingUint16(A0, A1, I);
10646 case PT_Sint32:
10647 return emitCastIntegralFloatingSint32(A0, A1, I);
10648 case PT_Uint32:
10649 return emitCastIntegralFloatingUint32(A0, A1, I);
10650 case PT_Sint64:
10651 return emitCastIntegralFloatingSint64(A0, A1, I);
10652 case PT_Uint64:
10653 return emitCastIntegralFloatingUint64(A0, A1, I);
10654 case PT_IntAP:
10655 return emitCastIntegralFloatingIntAP(A0, A1, I);
10656 case PT_IntAPS:
10657 return emitCastIntegralFloatingIntAPS(A0, A1, I);
10658 case PT_Bool:
10659 return emitCastIntegralFloatingBool(A0, A1, I);
10660 case PT_FixedPoint:
10661 return emitCastIntegralFloatingFixedPoint(A0, A1, I);
10662 default: llvm_unreachable("invalid type: emitCastIntegralFloating");
10663 }
10664 llvm_unreachable("invalid enum value");
10665}
10666#endif
10667#ifdef GET_LINK_IMPL
10668bool ByteCodeEmitter::emitCastIntegralFloatingSint8( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10669 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingSint8, A0, A1, L);
10670}
10671bool ByteCodeEmitter::emitCastIntegralFloatingUint8( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10672 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingUint8, A0, A1, L);
10673}
10674bool ByteCodeEmitter::emitCastIntegralFloatingSint16( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10675 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingSint16, A0, A1, L);
10676}
10677bool ByteCodeEmitter::emitCastIntegralFloatingUint16( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10678 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingUint16, A0, A1, L);
10679}
10680bool ByteCodeEmitter::emitCastIntegralFloatingSint32( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10681 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingSint32, A0, A1, L);
10682}
10683bool ByteCodeEmitter::emitCastIntegralFloatingUint32( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10684 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingUint32, A0, A1, L);
10685}
10686bool ByteCodeEmitter::emitCastIntegralFloatingSint64( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10687 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingSint64, A0, A1, L);
10688}
10689bool ByteCodeEmitter::emitCastIntegralFloatingUint64( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10690 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingUint64, A0, A1, L);
10691}
10692bool ByteCodeEmitter::emitCastIntegralFloatingIntAP( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10693 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingIntAP, A0, A1, L);
10694}
10695bool ByteCodeEmitter::emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10696 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingIntAPS, A0, A1, L);
10697}
10698bool ByteCodeEmitter::emitCastIntegralFloatingBool( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10699 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingBool, A0, A1, L);
10700}
10701bool ByteCodeEmitter::emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10702 return emitOp<const llvm::fltSemantics *, uint32_t>(OP_CastIntegralFloatingFixedPoint, A0, A1, L);
10703}
10704#endif
10705#ifdef GET_EVAL_IMPL
10706bool EvalEmitter::emitCastIntegralFloatingSint8( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10707 if (!isActive()) return true;
10708 CurrentSource = L;
10709 return CastIntegralFloating<PT_Sint8>(S, CodePtr(), A0, A1);
10710}
10711bool EvalEmitter::emitCastIntegralFloatingUint8( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10712 if (!isActive()) return true;
10713 CurrentSource = L;
10714 return CastIntegralFloating<PT_Uint8>(S, CodePtr(), A0, A1);
10715}
10716bool EvalEmitter::emitCastIntegralFloatingSint16( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10717 if (!isActive()) return true;
10718 CurrentSource = L;
10719 return CastIntegralFloating<PT_Sint16>(S, CodePtr(), A0, A1);
10720}
10721bool EvalEmitter::emitCastIntegralFloatingUint16( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10722 if (!isActive()) return true;
10723 CurrentSource = L;
10724 return CastIntegralFloating<PT_Uint16>(S, CodePtr(), A0, A1);
10725}
10726bool EvalEmitter::emitCastIntegralFloatingSint32( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10727 if (!isActive()) return true;
10728 CurrentSource = L;
10729 return CastIntegralFloating<PT_Sint32>(S, CodePtr(), A0, A1);
10730}
10731bool EvalEmitter::emitCastIntegralFloatingUint32( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10732 if (!isActive()) return true;
10733 CurrentSource = L;
10734 return CastIntegralFloating<PT_Uint32>(S, CodePtr(), A0, A1);
10735}
10736bool EvalEmitter::emitCastIntegralFloatingSint64( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10737 if (!isActive()) return true;
10738 CurrentSource = L;
10739 return CastIntegralFloating<PT_Sint64>(S, CodePtr(), A0, A1);
10740}
10741bool EvalEmitter::emitCastIntegralFloatingUint64( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10742 if (!isActive()) return true;
10743 CurrentSource = L;
10744 return CastIntegralFloating<PT_Uint64>(S, CodePtr(), A0, A1);
10745}
10746bool EvalEmitter::emitCastIntegralFloatingIntAP( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10747 if (!isActive()) return true;
10748 CurrentSource = L;
10749 return CastIntegralFloating<PT_IntAP>(S, CodePtr(), A0, A1);
10750}
10751bool EvalEmitter::emitCastIntegralFloatingIntAPS( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10752 if (!isActive()) return true;
10753 CurrentSource = L;
10754 return CastIntegralFloating<PT_IntAPS>(S, CodePtr(), A0, A1);
10755}
10756bool EvalEmitter::emitCastIntegralFloatingBool( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10757 if (!isActive()) return true;
10758 CurrentSource = L;
10759 return CastIntegralFloating<PT_Bool>(S, CodePtr(), A0, A1);
10760}
10761bool EvalEmitter::emitCastIntegralFloatingFixedPoint( const llvm::fltSemantics * A0, uint32_t A1, SourceInfo L) {
10762 if (!isActive()) return true;
10763 CurrentSource = L;
10764 return CastIntegralFloating<PT_FixedPoint>(S, CodePtr(), A0, A1);
10765}
10766#endif
10767#ifdef GET_OPCODE_NAMES
10768OP_CastMemberPtrBasePop,
10769#endif
10770#ifdef GET_INTERPFN_LIST
10771&Interp_CastMemberPtrBasePop,
10772#endif
10773#ifdef GET_INTERPFN_DISPATCHERS
10774PRESERVE_NONE
10775static bool Interp_CastMemberPtrBasePop(InterpState &S) {
10776 {
10777 const auto V0 = ReadArg<int32_t>(S, S.PC);
10778 const auto V1 = ReadArg<const RecordDecl *>(S, S.PC);
10779 if (!CastMemberPtrBasePop(S, V0, V1)) return false;
10780 }
10781#if USE_TAILCALLS
10782 MUSTTAIL return InterpNext(S);
10783#else
10784 return true;
10785#endif
10786}
10787#endif
10788#ifdef GET_DISASM
10789case OP_CastMemberPtrBasePop:
10790 Text.Op = PrintName("CastMemberPtrBasePop");
10791 Text.Args.push_back(printArg<int32_t>(PC));
10792 Text.Args.push_back(printArg<const RecordDecl *>(PC));
10793 break;
10794#endif
10795#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10796bool emitCastMemberPtrBasePop( int32_t , const RecordDecl * , SourceInfo);
10797#endif
10798#ifdef GET_LINK_IMPL
10799bool ByteCodeEmitter::emitCastMemberPtrBasePop( int32_t A0, const RecordDecl * A1, SourceInfo L) {
10800 return emitOp<int32_t, const RecordDecl *>(OP_CastMemberPtrBasePop, A0, A1, L);
10801}
10802#endif
10803#ifdef GET_EVAL_IMPL
10804bool EvalEmitter::emitCastMemberPtrBasePop( int32_t A0, const RecordDecl * A1, SourceInfo L) {
10805 if (!isActive()) return true;
10806 CurrentSource = L;
10807 return CastMemberPtrBasePop(S, A0, A1);
10808}
10809#endif
10810#ifdef GET_OPCODE_NAMES
10811OP_CastMemberPtrDerivedPop,
10812#endif
10813#ifdef GET_INTERPFN_LIST
10814&Interp_CastMemberPtrDerivedPop,
10815#endif
10816#ifdef GET_INTERPFN_DISPATCHERS
10817PRESERVE_NONE
10818static bool Interp_CastMemberPtrDerivedPop(InterpState &S) {
10819 {
10820 const auto V0 = ReadArg<int32_t>(S, S.PC);
10821 const auto V1 = ReadArg<const RecordDecl *>(S, S.PC);
10822 if (!CastMemberPtrDerivedPop(S, V0, V1)) return false;
10823 }
10824#if USE_TAILCALLS
10825 MUSTTAIL return InterpNext(S);
10826#else
10827 return true;
10828#endif
10829}
10830#endif
10831#ifdef GET_DISASM
10832case OP_CastMemberPtrDerivedPop:
10833 Text.Op = PrintName("CastMemberPtrDerivedPop");
10834 Text.Args.push_back(printArg<int32_t>(PC));
10835 Text.Args.push_back(printArg<const RecordDecl *>(PC));
10836 break;
10837#endif
10838#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10839bool emitCastMemberPtrDerivedPop( int32_t , const RecordDecl * , SourceInfo);
10840#endif
10841#ifdef GET_LINK_IMPL
10842bool ByteCodeEmitter::emitCastMemberPtrDerivedPop( int32_t A0, const RecordDecl * A1, SourceInfo L) {
10843 return emitOp<int32_t, const RecordDecl *>(OP_CastMemberPtrDerivedPop, A0, A1, L);
10844}
10845#endif
10846#ifdef GET_EVAL_IMPL
10847bool EvalEmitter::emitCastMemberPtrDerivedPop( int32_t A0, const RecordDecl * A1, SourceInfo L) {
10848 if (!isActive()) return true;
10849 CurrentSource = L;
10850 return CastMemberPtrDerivedPop(S, A0, A1);
10851}
10852#endif
10853#ifdef GET_OPCODE_NAMES
10854OP_CastMemberPtrPtr,
10855#endif
10856#ifdef GET_INTERPFN_LIST
10857&Interp_CastMemberPtrPtr,
10858#endif
10859#ifdef GET_INTERPFN_DISPATCHERS
10860PRESERVE_NONE
10861static bool Interp_CastMemberPtrPtr(InterpState &S) {
10862 if (!CastMemberPtrPtr(S, S.PC)) return false;
10863#if USE_TAILCALLS
10864 MUSTTAIL return InterpNext(S);
10865#else
10866 return true;
10867#endif
10868}
10869#endif
10870#ifdef GET_DISASM
10871case OP_CastMemberPtrPtr:
10872 Text.Op = PrintName("CastMemberPtrPtr");
10873 break;
10874#endif
10875#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
10876bool emitCastMemberPtrPtr(SourceInfo);
10877#endif
10878#ifdef GET_LINK_IMPL
10879bool ByteCodeEmitter::emitCastMemberPtrPtr(SourceInfo L) {
10880 return emitOp<>(OP_CastMemberPtrPtr, L);
10881}
10882#endif
10883#ifdef GET_EVAL_IMPL
10884bool EvalEmitter::emitCastMemberPtrPtr(SourceInfo L) {
10885 if (!isActive()) return true;
10886 CurrentSource = L;
10887 return CastMemberPtrPtr(S, CodePtr());
10888}
10889#endif
10890#ifdef GET_OPCODE_NAMES
10891OP_CastPointerIntegralSint8,
10892OP_CastPointerIntegralUint8,
10893OP_CastPointerIntegralSint16,
10894OP_CastPointerIntegralUint16,
10895OP_CastPointerIntegralSint32,
10896OP_CastPointerIntegralUint32,
10897OP_CastPointerIntegralSint64,
10898OP_CastPointerIntegralUint64,
10899OP_CastPointerIntegralBool,
10900#endif
10901#ifdef GET_INTERPFN_LIST
10902&Interp_CastPointerIntegralSint8,
10903&Interp_CastPointerIntegralUint8,
10904&Interp_CastPointerIntegralSint16,
10905&Interp_CastPointerIntegralUint16,
10906&Interp_CastPointerIntegralSint32,
10907&Interp_CastPointerIntegralUint32,
10908&Interp_CastPointerIntegralSint64,
10909&Interp_CastPointerIntegralUint64,
10910&Interp_CastPointerIntegralBool,
10911#endif
10912#ifdef GET_INTERPFN_DISPATCHERS
10913PRESERVE_NONE
10914static bool Interp_CastPointerIntegralSint8(InterpState &S) {
10915 if (!CastPointerIntegral<PT_Sint8>(S, S.PC)) return false;
10916#if USE_TAILCALLS
10917 MUSTTAIL return InterpNext(S);
10918#else
10919 return true;
10920#endif
10921}
10922PRESERVE_NONE
10923static bool Interp_CastPointerIntegralUint8(InterpState &S) {
10924 if (!CastPointerIntegral<PT_Uint8>(S, S.PC)) return false;
10925#if USE_TAILCALLS
10926 MUSTTAIL return InterpNext(S);
10927#else
10928 return true;
10929#endif
10930}
10931PRESERVE_NONE
10932static bool Interp_CastPointerIntegralSint16(InterpState &S) {
10933 if (!CastPointerIntegral<PT_Sint16>(S, S.PC)) return false;
10934#if USE_TAILCALLS
10935 MUSTTAIL return InterpNext(S);
10936#else
10937 return true;
10938#endif
10939}
10940PRESERVE_NONE
10941static bool Interp_CastPointerIntegralUint16(InterpState &S) {
10942 if (!CastPointerIntegral<PT_Uint16>(S, S.PC)) return false;
10943#if USE_TAILCALLS
10944 MUSTTAIL return InterpNext(S);
10945#else
10946 return true;
10947#endif
10948}
10949PRESERVE_NONE
10950static bool Interp_CastPointerIntegralSint32(InterpState &S) {
10951 if (!CastPointerIntegral<PT_Sint32>(S, S.PC)) return false;
10952#if USE_TAILCALLS
10953 MUSTTAIL return InterpNext(S);
10954#else
10955 return true;
10956#endif
10957}
10958PRESERVE_NONE
10959static bool Interp_CastPointerIntegralUint32(InterpState &S) {
10960 if (!CastPointerIntegral<PT_Uint32>(S, S.PC)) return false;
10961#if USE_TAILCALLS
10962 MUSTTAIL return InterpNext(S);
10963#else
10964 return true;
10965#endif
10966}
10967PRESERVE_NONE
10968static bool Interp_CastPointerIntegralSint64(InterpState &S) {
10969 if (!CastPointerIntegral<PT_Sint64>(S, S.PC)) return false;
10970#if USE_TAILCALLS
10971 MUSTTAIL return InterpNext(S);
10972#else
10973 return true;
10974#endif
10975}
10976PRESERVE_NONE
10977static bool Interp_CastPointerIntegralUint64(InterpState &S) {
10978 if (!CastPointerIntegral<PT_Uint64>(S, S.PC)) return false;
10979#if USE_TAILCALLS
10980 MUSTTAIL return InterpNext(S);
10981#else
10982 return true;
10983#endif
10984}
10985PRESERVE_NONE
10986static bool Interp_CastPointerIntegralBool(InterpState &S) {
10987 if (!CastPointerIntegral<PT_Bool>(S, S.PC)) return false;
10988#if USE_TAILCALLS
10989 MUSTTAIL return InterpNext(S);
10990#else
10991 return true;
10992#endif
10993}
10994#endif
10995#ifdef GET_DISASM
10996case OP_CastPointerIntegralSint8:
10997 Text.Op = PrintName("CastPointerIntegralSint8");
10998 break;
10999case OP_CastPointerIntegralUint8:
11000 Text.Op = PrintName("CastPointerIntegralUint8");
11001 break;
11002case OP_CastPointerIntegralSint16:
11003 Text.Op = PrintName("CastPointerIntegralSint16");
11004 break;
11005case OP_CastPointerIntegralUint16:
11006 Text.Op = PrintName("CastPointerIntegralUint16");
11007 break;
11008case OP_CastPointerIntegralSint32:
11009 Text.Op = PrintName("CastPointerIntegralSint32");
11010 break;
11011case OP_CastPointerIntegralUint32:
11012 Text.Op = PrintName("CastPointerIntegralUint32");
11013 break;
11014case OP_CastPointerIntegralSint64:
11015 Text.Op = PrintName("CastPointerIntegralSint64");
11016 break;
11017case OP_CastPointerIntegralUint64:
11018 Text.Op = PrintName("CastPointerIntegralUint64");
11019 break;
11020case OP_CastPointerIntegralBool:
11021 Text.Op = PrintName("CastPointerIntegralBool");
11022 break;
11023#endif
11024#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11025bool emitCastPointerIntegralSint8(SourceInfo);
11026bool emitCastPointerIntegralUint8(SourceInfo);
11027bool emitCastPointerIntegralSint16(SourceInfo);
11028bool emitCastPointerIntegralUint16(SourceInfo);
11029bool emitCastPointerIntegralSint32(SourceInfo);
11030bool emitCastPointerIntegralUint32(SourceInfo);
11031bool emitCastPointerIntegralSint64(SourceInfo);
11032bool emitCastPointerIntegralUint64(SourceInfo);
11033bool emitCastPointerIntegralBool(SourceInfo);
11034#endif
11035#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11036[[nodiscard]] bool emitCastPointerIntegral(PrimType, SourceInfo I);
11037#endif
11038#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
11039bool
11040#if defined(GET_EVAL_IMPL)
11041EvalEmitter
11042#else
11043ByteCodeEmitter
11044#endif
11045::emitCastPointerIntegral(PrimType T0, SourceInfo I) {
11046 switch (T0) {
11047 case PT_Sint8:
11048 return emitCastPointerIntegralSint8(I);
11049 case PT_Uint8:
11050 return emitCastPointerIntegralUint8(I);
11051 case PT_Sint16:
11052 return emitCastPointerIntegralSint16(I);
11053 case PT_Uint16:
11054 return emitCastPointerIntegralUint16(I);
11055 case PT_Sint32:
11056 return emitCastPointerIntegralSint32(I);
11057 case PT_Uint32:
11058 return emitCastPointerIntegralUint32(I);
11059 case PT_Sint64:
11060 return emitCastPointerIntegralSint64(I);
11061 case PT_Uint64:
11062 return emitCastPointerIntegralUint64(I);
11063 case PT_Bool:
11064 return emitCastPointerIntegralBool(I);
11065 default: llvm_unreachable("invalid type: emitCastPointerIntegral");
11066 }
11067 llvm_unreachable("invalid enum value");
11068}
11069#endif
11070#ifdef GET_LINK_IMPL
11071bool ByteCodeEmitter::emitCastPointerIntegralSint8(SourceInfo L) {
11072 return emitOp<>(OP_CastPointerIntegralSint8, L);
11073}
11074bool ByteCodeEmitter::emitCastPointerIntegralUint8(SourceInfo L) {
11075 return emitOp<>(OP_CastPointerIntegralUint8, L);
11076}
11077bool ByteCodeEmitter::emitCastPointerIntegralSint16(SourceInfo L) {
11078 return emitOp<>(OP_CastPointerIntegralSint16, L);
11079}
11080bool ByteCodeEmitter::emitCastPointerIntegralUint16(SourceInfo L) {
11081 return emitOp<>(OP_CastPointerIntegralUint16, L);
11082}
11083bool ByteCodeEmitter::emitCastPointerIntegralSint32(SourceInfo L) {
11084 return emitOp<>(OP_CastPointerIntegralSint32, L);
11085}
11086bool ByteCodeEmitter::emitCastPointerIntegralUint32(SourceInfo L) {
11087 return emitOp<>(OP_CastPointerIntegralUint32, L);
11088}
11089bool ByteCodeEmitter::emitCastPointerIntegralSint64(SourceInfo L) {
11090 return emitOp<>(OP_CastPointerIntegralSint64, L);
11091}
11092bool ByteCodeEmitter::emitCastPointerIntegralUint64(SourceInfo L) {
11093 return emitOp<>(OP_CastPointerIntegralUint64, L);
11094}
11095bool ByteCodeEmitter::emitCastPointerIntegralBool(SourceInfo L) {
11096 return emitOp<>(OP_CastPointerIntegralBool, L);
11097}
11098#endif
11099#ifdef GET_EVAL_IMPL
11100bool EvalEmitter::emitCastPointerIntegralSint8(SourceInfo L) {
11101 if (!isActive()) return true;
11102 CurrentSource = L;
11103 return CastPointerIntegral<PT_Sint8>(S, CodePtr());
11104}
11105bool EvalEmitter::emitCastPointerIntegralUint8(SourceInfo L) {
11106 if (!isActive()) return true;
11107 CurrentSource = L;
11108 return CastPointerIntegral<PT_Uint8>(S, CodePtr());
11109}
11110bool EvalEmitter::emitCastPointerIntegralSint16(SourceInfo L) {
11111 if (!isActive()) return true;
11112 CurrentSource = L;
11113 return CastPointerIntegral<PT_Sint16>(S, CodePtr());
11114}
11115bool EvalEmitter::emitCastPointerIntegralUint16(SourceInfo L) {
11116 if (!isActive()) return true;
11117 CurrentSource = L;
11118 return CastPointerIntegral<PT_Uint16>(S, CodePtr());
11119}
11120bool EvalEmitter::emitCastPointerIntegralSint32(SourceInfo L) {
11121 if (!isActive()) return true;
11122 CurrentSource = L;
11123 return CastPointerIntegral<PT_Sint32>(S, CodePtr());
11124}
11125bool EvalEmitter::emitCastPointerIntegralUint32(SourceInfo L) {
11126 if (!isActive()) return true;
11127 CurrentSource = L;
11128 return CastPointerIntegral<PT_Uint32>(S, CodePtr());
11129}
11130bool EvalEmitter::emitCastPointerIntegralSint64(SourceInfo L) {
11131 if (!isActive()) return true;
11132 CurrentSource = L;
11133 return CastPointerIntegral<PT_Sint64>(S, CodePtr());
11134}
11135bool EvalEmitter::emitCastPointerIntegralUint64(SourceInfo L) {
11136 if (!isActive()) return true;
11137 CurrentSource = L;
11138 return CastPointerIntegral<PT_Uint64>(S, CodePtr());
11139}
11140bool EvalEmitter::emitCastPointerIntegralBool(SourceInfo L) {
11141 if (!isActive()) return true;
11142 CurrentSource = L;
11143 return CastPointerIntegral<PT_Bool>(S, CodePtr());
11144}
11145#endif
11146#ifdef GET_OPCODE_NAMES
11147OP_CastPointerIntegralAP,
11148#endif
11149#ifdef GET_INTERPFN_LIST
11150&Interp_CastPointerIntegralAP,
11151#endif
11152#ifdef GET_INTERPFN_DISPATCHERS
11153PRESERVE_NONE
11154static bool Interp_CastPointerIntegralAP(InterpState &S) {
11155 {
11156 CodePtr OpPC = S.PC;
11157 const auto V0 = ReadArg<uint32_t>(S, S.PC);
11158 if (!CastPointerIntegralAP(S, OpPC, V0)) return false;
11159 }
11160#if USE_TAILCALLS
11161 MUSTTAIL return InterpNext(S);
11162#else
11163 return true;
11164#endif
11165}
11166#endif
11167#ifdef GET_DISASM
11168case OP_CastPointerIntegralAP:
11169 Text.Op = PrintName("CastPointerIntegralAP");
11170 Text.Args.push_back(printArg<uint32_t>(PC));
11171 break;
11172#endif
11173#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11174bool emitCastPointerIntegralAP( uint32_t , SourceInfo);
11175#endif
11176#ifdef GET_LINK_IMPL
11177bool ByteCodeEmitter::emitCastPointerIntegralAP( uint32_t A0, SourceInfo L) {
11178 return emitOp<uint32_t>(OP_CastPointerIntegralAP, A0, L);
11179}
11180#endif
11181#ifdef GET_EVAL_IMPL
11182bool EvalEmitter::emitCastPointerIntegralAP( uint32_t A0, SourceInfo L) {
11183 if (!isActive()) return true;
11184 CurrentSource = L;
11185 return CastPointerIntegralAP(S, CodePtr(), A0);
11186}
11187#endif
11188#ifdef GET_OPCODE_NAMES
11189OP_CastPointerIntegralAPS,
11190#endif
11191#ifdef GET_INTERPFN_LIST
11192&Interp_CastPointerIntegralAPS,
11193#endif
11194#ifdef GET_INTERPFN_DISPATCHERS
11195PRESERVE_NONE
11196static bool Interp_CastPointerIntegralAPS(InterpState &S) {
11197 {
11198 CodePtr OpPC = S.PC;
11199 const auto V0 = ReadArg<uint32_t>(S, S.PC);
11200 if (!CastPointerIntegralAPS(S, OpPC, V0)) return false;
11201 }
11202#if USE_TAILCALLS
11203 MUSTTAIL return InterpNext(S);
11204#else
11205 return true;
11206#endif
11207}
11208#endif
11209#ifdef GET_DISASM
11210case OP_CastPointerIntegralAPS:
11211 Text.Op = PrintName("CastPointerIntegralAPS");
11212 Text.Args.push_back(printArg<uint32_t>(PC));
11213 break;
11214#endif
11215#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11216bool emitCastPointerIntegralAPS( uint32_t , SourceInfo);
11217#endif
11218#ifdef GET_LINK_IMPL
11219bool ByteCodeEmitter::emitCastPointerIntegralAPS( uint32_t A0, SourceInfo L) {
11220 return emitOp<uint32_t>(OP_CastPointerIntegralAPS, A0, L);
11221}
11222#endif
11223#ifdef GET_EVAL_IMPL
11224bool EvalEmitter::emitCastPointerIntegralAPS( uint32_t A0, SourceInfo L) {
11225 if (!isActive()) return true;
11226 CurrentSource = L;
11227 return CastPointerIntegralAPS(S, CodePtr(), A0);
11228}
11229#endif
11230#ifdef GET_OPCODE_NAMES
11231OP_CheckAllocations,
11232#endif
11233#ifdef GET_INTERPFN_LIST
11234&Interp_CheckAllocations,
11235#endif
11236#ifdef GET_INTERPFN_DISPATCHERS
11237PRESERVE_NONE
11238static bool Interp_CheckAllocations(InterpState &S) {
11239 if (!CheckAllocations(S)) return false;
11240#if USE_TAILCALLS
11241 MUSTTAIL return InterpNext(S);
11242#else
11243 return true;
11244#endif
11245}
11246#endif
11247#ifdef GET_DISASM
11248case OP_CheckAllocations:
11249 Text.Op = PrintName("CheckAllocations");
11250 break;
11251#endif
11252#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11253bool emitCheckAllocations(SourceInfo);
11254#endif
11255#ifdef GET_LINK_IMPL
11256bool ByteCodeEmitter::emitCheckAllocations(SourceInfo L) {
11257 return emitOp<>(OP_CheckAllocations, L);
11258}
11259#endif
11260#ifdef GET_EVAL_IMPL
11261bool EvalEmitter::emitCheckAllocations(SourceInfo L) {
11262 if (!isActive()) return true;
11263 CurrentSource = L;
11264 return CheckAllocations(S);
11265}
11266#endif
11267#ifdef GET_OPCODE_NAMES
11268OP_CheckArrayDestSize,
11269#endif
11270#ifdef GET_INTERPFN_LIST
11271&Interp_CheckArrayDestSize,
11272#endif
11273#ifdef GET_INTERPFN_DISPATCHERS
11274PRESERVE_NONE
11275static bool Interp_CheckArrayDestSize(InterpState &S) {
11276 {
11277 CodePtr OpPC = S.PC;
11278 const auto V0 = ReadArg<uint64_t>(S, S.PC);
11279 if (!CheckArrayDestSize(S, OpPC, V0)) return false;
11280 }
11281#if USE_TAILCALLS
11282 MUSTTAIL return InterpNext(S);
11283#else
11284 return true;
11285#endif
11286}
11287#endif
11288#ifdef GET_DISASM
11289case OP_CheckArrayDestSize:
11290 Text.Op = PrintName("CheckArrayDestSize");
11291 Text.Args.push_back(printArg<uint64_t>(PC));
11292 break;
11293#endif
11294#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11295bool emitCheckArrayDestSize( uint64_t , SourceInfo);
11296#endif
11297#ifdef GET_LINK_IMPL
11298bool ByteCodeEmitter::emitCheckArrayDestSize( uint64_t A0, SourceInfo L) {
11299 return emitOp<uint64_t>(OP_CheckArrayDestSize, A0, L);
11300}
11301#endif
11302#ifdef GET_EVAL_IMPL
11303bool EvalEmitter::emitCheckArrayDestSize( uint64_t A0, SourceInfo L) {
11304 if (!isActive()) return true;
11305 CurrentSource = L;
11306 return CheckArrayDestSize(S, CodePtr(), A0);
11307}
11308#endif
11309#ifdef GET_OPCODE_NAMES
11310OP_CheckArraySize,
11311#endif
11312#ifdef GET_INTERPFN_LIST
11313&Interp_CheckArraySize,
11314#endif
11315#ifdef GET_INTERPFN_DISPATCHERS
11316PRESERVE_NONE
11317static bool Interp_CheckArraySize(InterpState &S) {
11318 {
11319 CodePtr OpPC = S.PC;
11320 const auto V0 = ReadArg<uint64_t>(S, S.PC);
11321 if (!CheckArraySize(S, OpPC, V0)) return false;
11322 }
11323#if USE_TAILCALLS
11324 MUSTTAIL return InterpNext(S);
11325#else
11326 return true;
11327#endif
11328}
11329#endif
11330#ifdef GET_DISASM
11331case OP_CheckArraySize:
11332 Text.Op = PrintName("CheckArraySize");
11333 Text.Args.push_back(printArg<uint64_t>(PC));
11334 break;
11335#endif
11336#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11337bool emitCheckArraySize( uint64_t , SourceInfo);
11338#endif
11339#ifdef GET_LINK_IMPL
11340bool ByteCodeEmitter::emitCheckArraySize( uint64_t A0, SourceInfo L) {
11341 return emitOp<uint64_t>(OP_CheckArraySize, A0, L);
11342}
11343#endif
11344#ifdef GET_EVAL_IMPL
11345bool EvalEmitter::emitCheckArraySize( uint64_t A0, SourceInfo L) {
11346 if (!isActive()) return true;
11347 CurrentSource = L;
11348 return CheckArraySize(S, CodePtr(), A0);
11349}
11350#endif
11351#ifdef GET_OPCODE_NAMES
11352OP_CheckBitCast,
11353#endif
11354#ifdef GET_INTERPFN_LIST
11355&Interp_CheckBitCast,
11356#endif
11357#ifdef GET_INTERPFN_DISPATCHERS
11358PRESERVE_NONE
11359static bool Interp_CheckBitCast(InterpState &S) {
11360 {
11361 CodePtr OpPC = S.PC;
11362 const auto V0 = ReadArg<const Type *>(S, S.PC);
11363 const auto V1 = ReadArg<bool>(S, S.PC);
11364 if (!CheckBitCast(S, OpPC, V0, V1)) return false;
11365 }
11366#if USE_TAILCALLS
11367 MUSTTAIL return InterpNext(S);
11368#else
11369 return true;
11370#endif
11371}
11372#endif
11373#ifdef GET_DISASM
11374case OP_CheckBitCast:
11375 Text.Op = PrintName("CheckBitCast");
11376 Text.Args.push_back(printArg<const Type *>(PC));
11377 Text.Args.push_back(printArg<bool>(PC));
11378 break;
11379#endif
11380#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11381bool emitCheckBitCast( const Type * , bool , SourceInfo);
11382#endif
11383#ifdef GET_LINK_IMPL
11384bool ByteCodeEmitter::emitCheckBitCast( const Type * A0, bool A1, SourceInfo L) {
11385 return emitOp<const Type *, bool>(OP_CheckBitCast, A0, A1, L);
11386}
11387#endif
11388#ifdef GET_EVAL_IMPL
11389bool EvalEmitter::emitCheckBitCast( const Type * A0, bool A1, SourceInfo L) {
11390 if (!isActive()) return true;
11391 CurrentSource = L;
11392 return CheckBitCast(S, CodePtr(), A0, A1);
11393}
11394#endif
11395#ifdef GET_OPCODE_NAMES
11396OP_CheckDecl,
11397#endif
11398#ifdef GET_INTERPFN_LIST
11399&Interp_CheckDecl,
11400#endif
11401#ifdef GET_INTERPFN_DISPATCHERS
11402PRESERVE_NONE
11403static bool Interp_CheckDecl(InterpState &S) {
11404 {
11405 const auto V0 = ReadArg<const VarDecl*>(S, S.PC);
11406 if (!CheckDecl(S, V0)) return false;
11407 }
11408#if USE_TAILCALLS
11409 MUSTTAIL return InterpNext(S);
11410#else
11411 return true;
11412#endif
11413}
11414#endif
11415#ifdef GET_DISASM
11416case OP_CheckDecl:
11417 Text.Op = PrintName("CheckDecl");
11418 Text.Args.push_back(printArg<const VarDecl*>(PC));
11419 break;
11420#endif
11421#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11422bool emitCheckDecl( const VarDecl* , SourceInfo);
11423#endif
11424#ifdef GET_LINK_IMPL
11425bool ByteCodeEmitter::emitCheckDecl( const VarDecl* A0, SourceInfo L) {
11426 return emitOp<const VarDecl*>(OP_CheckDecl, A0, L);
11427}
11428#endif
11429#ifdef GET_EVAL_IMPL
11430bool EvalEmitter::emitCheckDecl( const VarDecl* A0, SourceInfo L) {
11431 if (!isActive()) return true;
11432 CurrentSource = L;
11433 return CheckDecl(S, A0);
11434}
11435#endif
11436#ifdef GET_OPCODE_NAMES
11437OP_CheckDestruction,
11438#endif
11439#ifdef GET_INTERPFN_LIST
11440&Interp_CheckDestruction,
11441#endif
11442#ifdef GET_INTERPFN_DISPATCHERS
11443PRESERVE_NONE
11444static bool Interp_CheckDestruction(InterpState &S) {
11445 if (!CheckDestruction(S, S.PC)) return false;
11446#if USE_TAILCALLS
11447 MUSTTAIL return InterpNext(S);
11448#else
11449 return true;
11450#endif
11451}
11452#endif
11453#ifdef GET_DISASM
11454case OP_CheckDestruction:
11455 Text.Op = PrintName("CheckDestruction");
11456 break;
11457#endif
11458#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11459bool emitCheckDestruction(SourceInfo);
11460#endif
11461#ifdef GET_LINK_IMPL
11462bool ByteCodeEmitter::emitCheckDestruction(SourceInfo L) {
11463 return emitOp<>(OP_CheckDestruction, L);
11464}
11465#endif
11466#ifdef GET_EVAL_IMPL
11467bool EvalEmitter::emitCheckDestruction(SourceInfo L) {
11468 if (!isActive()) return true;
11469 CurrentSource = L;
11470 return CheckDestruction(S, CodePtr());
11471}
11472#endif
11473#ifdef GET_OPCODE_NAMES
11474OP_CheckEnumValueSint8,
11475OP_CheckEnumValueUint8,
11476OP_CheckEnumValueSint16,
11477OP_CheckEnumValueUint16,
11478OP_CheckEnumValueSint32,
11479OP_CheckEnumValueUint32,
11480OP_CheckEnumValueSint64,
11481OP_CheckEnumValueUint64,
11482OP_CheckEnumValueIntAP,
11483OP_CheckEnumValueIntAPS,
11484OP_CheckEnumValueBool,
11485#endif
11486#ifdef GET_INTERPFN_LIST
11487&Interp_CheckEnumValueSint8,
11488&Interp_CheckEnumValueUint8,
11489&Interp_CheckEnumValueSint16,
11490&Interp_CheckEnumValueUint16,
11491&Interp_CheckEnumValueSint32,
11492&Interp_CheckEnumValueUint32,
11493&Interp_CheckEnumValueSint64,
11494&Interp_CheckEnumValueUint64,
11495&Interp_CheckEnumValueIntAP,
11496&Interp_CheckEnumValueIntAPS,
11497&Interp_CheckEnumValueBool,
11498#endif
11499#ifdef GET_INTERPFN_DISPATCHERS
11500PRESERVE_NONE
11501static bool Interp_CheckEnumValueSint8(InterpState &S) {
11502 {
11503 CodePtr OpPC = S.PC;
11504 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11505 CheckEnumValue<PT_Sint8>(S, OpPC, V0);
11506 }
11507#if USE_TAILCALLS
11508 MUSTTAIL return InterpNext(S);
11509#else
11510 return true;
11511#endif
11512}
11513PRESERVE_NONE
11514static bool Interp_CheckEnumValueUint8(InterpState &S) {
11515 {
11516 CodePtr OpPC = S.PC;
11517 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11518 CheckEnumValue<PT_Uint8>(S, OpPC, V0);
11519 }
11520#if USE_TAILCALLS
11521 MUSTTAIL return InterpNext(S);
11522#else
11523 return true;
11524#endif
11525}
11526PRESERVE_NONE
11527static bool Interp_CheckEnumValueSint16(InterpState &S) {
11528 {
11529 CodePtr OpPC = S.PC;
11530 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11531 CheckEnumValue<PT_Sint16>(S, OpPC, V0);
11532 }
11533#if USE_TAILCALLS
11534 MUSTTAIL return InterpNext(S);
11535#else
11536 return true;
11537#endif
11538}
11539PRESERVE_NONE
11540static bool Interp_CheckEnumValueUint16(InterpState &S) {
11541 {
11542 CodePtr OpPC = S.PC;
11543 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11544 CheckEnumValue<PT_Uint16>(S, OpPC, V0);
11545 }
11546#if USE_TAILCALLS
11547 MUSTTAIL return InterpNext(S);
11548#else
11549 return true;
11550#endif
11551}
11552PRESERVE_NONE
11553static bool Interp_CheckEnumValueSint32(InterpState &S) {
11554 {
11555 CodePtr OpPC = S.PC;
11556 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11557 CheckEnumValue<PT_Sint32>(S, OpPC, V0);
11558 }
11559#if USE_TAILCALLS
11560 MUSTTAIL return InterpNext(S);
11561#else
11562 return true;
11563#endif
11564}
11565PRESERVE_NONE
11566static bool Interp_CheckEnumValueUint32(InterpState &S) {
11567 {
11568 CodePtr OpPC = S.PC;
11569 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11570 CheckEnumValue<PT_Uint32>(S, OpPC, V0);
11571 }
11572#if USE_TAILCALLS
11573 MUSTTAIL return InterpNext(S);
11574#else
11575 return true;
11576#endif
11577}
11578PRESERVE_NONE
11579static bool Interp_CheckEnumValueSint64(InterpState &S) {
11580 {
11581 CodePtr OpPC = S.PC;
11582 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11583 CheckEnumValue<PT_Sint64>(S, OpPC, V0);
11584 }
11585#if USE_TAILCALLS
11586 MUSTTAIL return InterpNext(S);
11587#else
11588 return true;
11589#endif
11590}
11591PRESERVE_NONE
11592static bool Interp_CheckEnumValueUint64(InterpState &S) {
11593 {
11594 CodePtr OpPC = S.PC;
11595 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11596 CheckEnumValue<PT_Uint64>(S, OpPC, V0);
11597 }
11598#if USE_TAILCALLS
11599 MUSTTAIL return InterpNext(S);
11600#else
11601 return true;
11602#endif
11603}
11604PRESERVE_NONE
11605static bool Interp_CheckEnumValueIntAP(InterpState &S) {
11606 {
11607 CodePtr OpPC = S.PC;
11608 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11609 CheckEnumValue<PT_IntAP>(S, OpPC, V0);
11610 }
11611#if USE_TAILCALLS
11612 MUSTTAIL return InterpNext(S);
11613#else
11614 return true;
11615#endif
11616}
11617PRESERVE_NONE
11618static bool Interp_CheckEnumValueIntAPS(InterpState &S) {
11619 {
11620 CodePtr OpPC = S.PC;
11621 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11622 CheckEnumValue<PT_IntAPS>(S, OpPC, V0);
11623 }
11624#if USE_TAILCALLS
11625 MUSTTAIL return InterpNext(S);
11626#else
11627 return true;
11628#endif
11629}
11630PRESERVE_NONE
11631static bool Interp_CheckEnumValueBool(InterpState &S) {
11632 {
11633 CodePtr OpPC = S.PC;
11634 const auto V0 = ReadArg<const EnumDecl *>(S, S.PC);
11635 CheckEnumValue<PT_Bool>(S, OpPC, V0);
11636 }
11637#if USE_TAILCALLS
11638 MUSTTAIL return InterpNext(S);
11639#else
11640 return true;
11641#endif
11642}
11643#endif
11644#ifdef GET_DISASM
11645case OP_CheckEnumValueSint8:
11646 Text.Op = PrintName("CheckEnumValueSint8");
11647 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11648 break;
11649case OP_CheckEnumValueUint8:
11650 Text.Op = PrintName("CheckEnumValueUint8");
11651 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11652 break;
11653case OP_CheckEnumValueSint16:
11654 Text.Op = PrintName("CheckEnumValueSint16");
11655 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11656 break;
11657case OP_CheckEnumValueUint16:
11658 Text.Op = PrintName("CheckEnumValueUint16");
11659 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11660 break;
11661case OP_CheckEnumValueSint32:
11662 Text.Op = PrintName("CheckEnumValueSint32");
11663 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11664 break;
11665case OP_CheckEnumValueUint32:
11666 Text.Op = PrintName("CheckEnumValueUint32");
11667 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11668 break;
11669case OP_CheckEnumValueSint64:
11670 Text.Op = PrintName("CheckEnumValueSint64");
11671 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11672 break;
11673case OP_CheckEnumValueUint64:
11674 Text.Op = PrintName("CheckEnumValueUint64");
11675 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11676 break;
11677case OP_CheckEnumValueIntAP:
11678 Text.Op = PrintName("CheckEnumValueIntAP");
11679 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11680 break;
11681case OP_CheckEnumValueIntAPS:
11682 Text.Op = PrintName("CheckEnumValueIntAPS");
11683 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11684 break;
11685case OP_CheckEnumValueBool:
11686 Text.Op = PrintName("CheckEnumValueBool");
11687 Text.Args.push_back(printArg<const EnumDecl *>(PC));
11688 break;
11689#endif
11690#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11691bool emitCheckEnumValueSint8( const EnumDecl * , SourceInfo);
11692bool emitCheckEnumValueUint8( const EnumDecl * , SourceInfo);
11693bool emitCheckEnumValueSint16( const EnumDecl * , SourceInfo);
11694bool emitCheckEnumValueUint16( const EnumDecl * , SourceInfo);
11695bool emitCheckEnumValueSint32( const EnumDecl * , SourceInfo);
11696bool emitCheckEnumValueUint32( const EnumDecl * , SourceInfo);
11697bool emitCheckEnumValueSint64( const EnumDecl * , SourceInfo);
11698bool emitCheckEnumValueUint64( const EnumDecl * , SourceInfo);
11699bool emitCheckEnumValueIntAP( const EnumDecl * , SourceInfo);
11700bool emitCheckEnumValueIntAPS( const EnumDecl * , SourceInfo);
11701bool emitCheckEnumValueBool( const EnumDecl * , SourceInfo);
11702#endif
11703#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11704[[nodiscard]] bool emitCheckEnumValue(PrimType, const EnumDecl *, SourceInfo I);
11705#endif
11706#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
11707bool
11708#if defined(GET_EVAL_IMPL)
11709EvalEmitter
11710#else
11711ByteCodeEmitter
11712#endif
11713::emitCheckEnumValue(PrimType T0, const EnumDecl * A0, SourceInfo I) {
11714 switch (T0) {
11715 case PT_Sint8:
11716 return emitCheckEnumValueSint8(A0, I);
11717 case PT_Uint8:
11718 return emitCheckEnumValueUint8(A0, I);
11719 case PT_Sint16:
11720 return emitCheckEnumValueSint16(A0, I);
11721 case PT_Uint16:
11722 return emitCheckEnumValueUint16(A0, I);
11723 case PT_Sint32:
11724 return emitCheckEnumValueSint32(A0, I);
11725 case PT_Uint32:
11726 return emitCheckEnumValueUint32(A0, I);
11727 case PT_Sint64:
11728 return emitCheckEnumValueSint64(A0, I);
11729 case PT_Uint64:
11730 return emitCheckEnumValueUint64(A0, I);
11731 case PT_IntAP:
11732 return emitCheckEnumValueIntAP(A0, I);
11733 case PT_IntAPS:
11734 return emitCheckEnumValueIntAPS(A0, I);
11735 case PT_Bool:
11736 return emitCheckEnumValueBool(A0, I);
11737 default: llvm_unreachable("invalid type: emitCheckEnumValue");
11738 }
11739 llvm_unreachable("invalid enum value");
11740}
11741#endif
11742#ifdef GET_LINK_IMPL
11743bool ByteCodeEmitter::emitCheckEnumValueSint8( const EnumDecl * A0, SourceInfo L) {
11744 return emitOp<const EnumDecl *>(OP_CheckEnumValueSint8, A0, L);
11745}
11746bool ByteCodeEmitter::emitCheckEnumValueUint8( const EnumDecl * A0, SourceInfo L) {
11747 return emitOp<const EnumDecl *>(OP_CheckEnumValueUint8, A0, L);
11748}
11749bool ByteCodeEmitter::emitCheckEnumValueSint16( const EnumDecl * A0, SourceInfo L) {
11750 return emitOp<const EnumDecl *>(OP_CheckEnumValueSint16, A0, L);
11751}
11752bool ByteCodeEmitter::emitCheckEnumValueUint16( const EnumDecl * A0, SourceInfo L) {
11753 return emitOp<const EnumDecl *>(OP_CheckEnumValueUint16, A0, L);
11754}
11755bool ByteCodeEmitter::emitCheckEnumValueSint32( const EnumDecl * A0, SourceInfo L) {
11756 return emitOp<const EnumDecl *>(OP_CheckEnumValueSint32, A0, L);
11757}
11758bool ByteCodeEmitter::emitCheckEnumValueUint32( const EnumDecl * A0, SourceInfo L) {
11759 return emitOp<const EnumDecl *>(OP_CheckEnumValueUint32, A0, L);
11760}
11761bool ByteCodeEmitter::emitCheckEnumValueSint64( const EnumDecl * A0, SourceInfo L) {
11762 return emitOp<const EnumDecl *>(OP_CheckEnumValueSint64, A0, L);
11763}
11764bool ByteCodeEmitter::emitCheckEnumValueUint64( const EnumDecl * A0, SourceInfo L) {
11765 return emitOp<const EnumDecl *>(OP_CheckEnumValueUint64, A0, L);
11766}
11767bool ByteCodeEmitter::emitCheckEnumValueIntAP( const EnumDecl * A0, SourceInfo L) {
11768 return emitOp<const EnumDecl *>(OP_CheckEnumValueIntAP, A0, L);
11769}
11770bool ByteCodeEmitter::emitCheckEnumValueIntAPS( const EnumDecl * A0, SourceInfo L) {
11771 return emitOp<const EnumDecl *>(OP_CheckEnumValueIntAPS, A0, L);
11772}
11773bool ByteCodeEmitter::emitCheckEnumValueBool( const EnumDecl * A0, SourceInfo L) {
11774 return emitOp<const EnumDecl *>(OP_CheckEnumValueBool, A0, L);
11775}
11776#endif
11777#ifdef GET_EVAL_IMPL
11778bool EvalEmitter::emitCheckEnumValueSint8( const EnumDecl * A0, SourceInfo L) {
11779 if (!isActive()) return true;
11780 CurrentSource = L;
11781 return CheckEnumValue<PT_Sint8>(S, CodePtr(), A0);
11782}
11783bool EvalEmitter::emitCheckEnumValueUint8( const EnumDecl * A0, SourceInfo L) {
11784 if (!isActive()) return true;
11785 CurrentSource = L;
11786 return CheckEnumValue<PT_Uint8>(S, CodePtr(), A0);
11787}
11788bool EvalEmitter::emitCheckEnumValueSint16( const EnumDecl * A0, SourceInfo L) {
11789 if (!isActive()) return true;
11790 CurrentSource = L;
11791 return CheckEnumValue<PT_Sint16>(S, CodePtr(), A0);
11792}
11793bool EvalEmitter::emitCheckEnumValueUint16( const EnumDecl * A0, SourceInfo L) {
11794 if (!isActive()) return true;
11795 CurrentSource = L;
11796 return CheckEnumValue<PT_Uint16>(S, CodePtr(), A0);
11797}
11798bool EvalEmitter::emitCheckEnumValueSint32( const EnumDecl * A0, SourceInfo L) {
11799 if (!isActive()) return true;
11800 CurrentSource = L;
11801 return CheckEnumValue<PT_Sint32>(S, CodePtr(), A0);
11802}
11803bool EvalEmitter::emitCheckEnumValueUint32( const EnumDecl * A0, SourceInfo L) {
11804 if (!isActive()) return true;
11805 CurrentSource = L;
11806 return CheckEnumValue<PT_Uint32>(S, CodePtr(), A0);
11807}
11808bool EvalEmitter::emitCheckEnumValueSint64( const EnumDecl * A0, SourceInfo L) {
11809 if (!isActive()) return true;
11810 CurrentSource = L;
11811 return CheckEnumValue<PT_Sint64>(S, CodePtr(), A0);
11812}
11813bool EvalEmitter::emitCheckEnumValueUint64( const EnumDecl * A0, SourceInfo L) {
11814 if (!isActive()) return true;
11815 CurrentSource = L;
11816 return CheckEnumValue<PT_Uint64>(S, CodePtr(), A0);
11817}
11818bool EvalEmitter::emitCheckEnumValueIntAP( const EnumDecl * A0, SourceInfo L) {
11819 if (!isActive()) return true;
11820 CurrentSource = L;
11821 return CheckEnumValue<PT_IntAP>(S, CodePtr(), A0);
11822}
11823bool EvalEmitter::emitCheckEnumValueIntAPS( const EnumDecl * A0, SourceInfo L) {
11824 if (!isActive()) return true;
11825 CurrentSource = L;
11826 return CheckEnumValue<PT_IntAPS>(S, CodePtr(), A0);
11827}
11828bool EvalEmitter::emitCheckEnumValueBool( const EnumDecl * A0, SourceInfo L) {
11829 if (!isActive()) return true;
11830 CurrentSource = L;
11831 return CheckEnumValue<PT_Bool>(S, CodePtr(), A0);
11832}
11833#endif
11834#ifdef GET_OPCODE_NAMES
11835OP_CheckFunctionDecl,
11836#endif
11837#ifdef GET_INTERPFN_LIST
11838&Interp_CheckFunctionDecl,
11839#endif
11840#ifdef GET_INTERPFN_DISPATCHERS
11841PRESERVE_NONE
11842static bool Interp_CheckFunctionDecl(InterpState &S) {
11843 {
11844 CodePtr OpPC = S.PC;
11845 const auto V0 = ReadArg<const FunctionDecl *>(S, S.PC);
11846 if (!CheckFunctionDecl(S, OpPC, V0)) return false;
11847 }
11848#if USE_TAILCALLS
11849 MUSTTAIL return InterpNext(S);
11850#else
11851 return true;
11852#endif
11853}
11854#endif
11855#ifdef GET_DISASM
11856case OP_CheckFunctionDecl:
11857 Text.Op = PrintName("CheckFunctionDecl");
11858 Text.Args.push_back(printArg<const FunctionDecl *>(PC));
11859 break;
11860#endif
11861#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11862bool emitCheckFunctionDecl( const FunctionDecl * , SourceInfo);
11863#endif
11864#ifdef GET_LINK_IMPL
11865bool ByteCodeEmitter::emitCheckFunctionDecl( const FunctionDecl * A0, SourceInfo L) {
11866 return emitOp<const FunctionDecl *>(OP_CheckFunctionDecl, A0, L);
11867}
11868#endif
11869#ifdef GET_EVAL_IMPL
11870bool EvalEmitter::emitCheckFunctionDecl( const FunctionDecl * A0, SourceInfo L) {
11871 if (!isActive()) return true;
11872 CurrentSource = L;
11873 return CheckFunctionDecl(S, CodePtr(), A0);
11874}
11875#endif
11876#ifdef GET_OPCODE_NAMES
11877OP_CheckLiteralType,
11878#endif
11879#ifdef GET_INTERPFN_LIST
11880&Interp_CheckLiteralType,
11881#endif
11882#ifdef GET_INTERPFN_DISPATCHERS
11883PRESERVE_NONE
11884static bool Interp_CheckLiteralType(InterpState &S) {
11885 {
11886 CodePtr OpPC = S.PC;
11887 const auto V0 = ReadArg<const Type *>(S, S.PC);
11888 if (!CheckLiteralType(S, OpPC, V0)) return false;
11889 }
11890#if USE_TAILCALLS
11891 MUSTTAIL return InterpNext(S);
11892#else
11893 return true;
11894#endif
11895}
11896#endif
11897#ifdef GET_DISASM
11898case OP_CheckLiteralType:
11899 Text.Op = PrintName("CheckLiteralType");
11900 Text.Args.push_back(printArg<const Type *>(PC));
11901 break;
11902#endif
11903#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11904bool emitCheckLiteralType( const Type * , SourceInfo);
11905#endif
11906#ifdef GET_LINK_IMPL
11907bool ByteCodeEmitter::emitCheckLiteralType( const Type * A0, SourceInfo L) {
11908 return emitOp<const Type *>(OP_CheckLiteralType, A0, L);
11909}
11910#endif
11911#ifdef GET_EVAL_IMPL
11912bool EvalEmitter::emitCheckLiteralType( const Type * A0, SourceInfo L) {
11913 if (!isActive()) return true;
11914 CurrentSource = L;
11915 return CheckLiteralType(S, CodePtr(), A0);
11916}
11917#endif
11918#ifdef GET_OPCODE_NAMES
11919OP_CheckNewTypeMismatch,
11920#endif
11921#ifdef GET_INTERPFN_LIST
11922&Interp_CheckNewTypeMismatch,
11923#endif
11924#ifdef GET_INTERPFN_DISPATCHERS
11925PRESERVE_NONE
11926static bool Interp_CheckNewTypeMismatch(InterpState &S) {
11927 {
11928 CodePtr OpPC = S.PC;
11929 const auto V0 = ReadArg<const Expr *>(S, S.PC);
11930 if (!CheckNewTypeMismatch(S, OpPC, V0)) return false;
11931 }
11932#if USE_TAILCALLS
11933 MUSTTAIL return InterpNext(S);
11934#else
11935 return true;
11936#endif
11937}
11938#endif
11939#ifdef GET_DISASM
11940case OP_CheckNewTypeMismatch:
11941 Text.Op = PrintName("CheckNewTypeMismatch");
11942 Text.Args.push_back(printArg<const Expr *>(PC));
11943 break;
11944#endif
11945#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
11946bool emitCheckNewTypeMismatch( const Expr * , SourceInfo);
11947#endif
11948#ifdef GET_LINK_IMPL
11949bool ByteCodeEmitter::emitCheckNewTypeMismatch( const Expr * A0, SourceInfo L) {
11950 return emitOp<const Expr *>(OP_CheckNewTypeMismatch, A0, L);
11951}
11952#endif
11953#ifdef GET_EVAL_IMPL
11954bool EvalEmitter::emitCheckNewTypeMismatch( const Expr * A0, SourceInfo L) {
11955 if (!isActive()) return true;
11956 CurrentSource = L;
11957 return CheckNewTypeMismatch(S, CodePtr(), A0);
11958}
11959#endif
11960#ifdef GET_OPCODE_NAMES
11961OP_CheckNewTypeMismatchArraySint8,
11962OP_CheckNewTypeMismatchArrayUint8,
11963OP_CheckNewTypeMismatchArraySint16,
11964OP_CheckNewTypeMismatchArrayUint16,
11965OP_CheckNewTypeMismatchArraySint32,
11966OP_CheckNewTypeMismatchArrayUint32,
11967OP_CheckNewTypeMismatchArraySint64,
11968OP_CheckNewTypeMismatchArrayUint64,
11969OP_CheckNewTypeMismatchArrayIntAP,
11970OP_CheckNewTypeMismatchArrayIntAPS,
11971#endif
11972#ifdef GET_INTERPFN_LIST
11973&Interp_CheckNewTypeMismatchArraySint8,
11974&Interp_CheckNewTypeMismatchArrayUint8,
11975&Interp_CheckNewTypeMismatchArraySint16,
11976&Interp_CheckNewTypeMismatchArrayUint16,
11977&Interp_CheckNewTypeMismatchArraySint32,
11978&Interp_CheckNewTypeMismatchArrayUint32,
11979&Interp_CheckNewTypeMismatchArraySint64,
11980&Interp_CheckNewTypeMismatchArrayUint64,
11981&Interp_CheckNewTypeMismatchArrayIntAP,
11982&Interp_CheckNewTypeMismatchArrayIntAPS,
11983#endif
11984#ifdef GET_INTERPFN_DISPATCHERS
11985PRESERVE_NONE
11986static bool Interp_CheckNewTypeMismatchArraySint8(InterpState &S) {
11987 {
11988 CodePtr OpPC = S.PC;
11989 const auto V0 = ReadArg<const Expr *>(S, S.PC);
11990 if (!CheckNewTypeMismatchArray<PT_Sint8>(S, OpPC, V0)) return false;
11991 }
11992#if USE_TAILCALLS
11993 MUSTTAIL return InterpNext(S);
11994#else
11995 return true;
11996#endif
11997}
11998PRESERVE_NONE
11999static bool Interp_CheckNewTypeMismatchArrayUint8(InterpState &S) {
12000 {
12001 CodePtr OpPC = S.PC;
12002 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12003 if (!CheckNewTypeMismatchArray<PT_Uint8>(S, OpPC, V0)) return false;
12004 }
12005#if USE_TAILCALLS
12006 MUSTTAIL return InterpNext(S);
12007#else
12008 return true;
12009#endif
12010}
12011PRESERVE_NONE
12012static bool Interp_CheckNewTypeMismatchArraySint16(InterpState &S) {
12013 {
12014 CodePtr OpPC = S.PC;
12015 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12016 if (!CheckNewTypeMismatchArray<PT_Sint16>(S, OpPC, V0)) return false;
12017 }
12018#if USE_TAILCALLS
12019 MUSTTAIL return InterpNext(S);
12020#else
12021 return true;
12022#endif
12023}
12024PRESERVE_NONE
12025static bool Interp_CheckNewTypeMismatchArrayUint16(InterpState &S) {
12026 {
12027 CodePtr OpPC = S.PC;
12028 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12029 if (!CheckNewTypeMismatchArray<PT_Uint16>(S, OpPC, V0)) return false;
12030 }
12031#if USE_TAILCALLS
12032 MUSTTAIL return InterpNext(S);
12033#else
12034 return true;
12035#endif
12036}
12037PRESERVE_NONE
12038static bool Interp_CheckNewTypeMismatchArraySint32(InterpState &S) {
12039 {
12040 CodePtr OpPC = S.PC;
12041 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12042 if (!CheckNewTypeMismatchArray<PT_Sint32>(S, OpPC, V0)) return false;
12043 }
12044#if USE_TAILCALLS
12045 MUSTTAIL return InterpNext(S);
12046#else
12047 return true;
12048#endif
12049}
12050PRESERVE_NONE
12051static bool Interp_CheckNewTypeMismatchArrayUint32(InterpState &S) {
12052 {
12053 CodePtr OpPC = S.PC;
12054 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12055 if (!CheckNewTypeMismatchArray<PT_Uint32>(S, OpPC, V0)) return false;
12056 }
12057#if USE_TAILCALLS
12058 MUSTTAIL return InterpNext(S);
12059#else
12060 return true;
12061#endif
12062}
12063PRESERVE_NONE
12064static bool Interp_CheckNewTypeMismatchArraySint64(InterpState &S) {
12065 {
12066 CodePtr OpPC = S.PC;
12067 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12068 if (!CheckNewTypeMismatchArray<PT_Sint64>(S, OpPC, V0)) return false;
12069 }
12070#if USE_TAILCALLS
12071 MUSTTAIL return InterpNext(S);
12072#else
12073 return true;
12074#endif
12075}
12076PRESERVE_NONE
12077static bool Interp_CheckNewTypeMismatchArrayUint64(InterpState &S) {
12078 {
12079 CodePtr OpPC = S.PC;
12080 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12081 if (!CheckNewTypeMismatchArray<PT_Uint64>(S, OpPC, V0)) return false;
12082 }
12083#if USE_TAILCALLS
12084 MUSTTAIL return InterpNext(S);
12085#else
12086 return true;
12087#endif
12088}
12089PRESERVE_NONE
12090static bool Interp_CheckNewTypeMismatchArrayIntAP(InterpState &S) {
12091 {
12092 CodePtr OpPC = S.PC;
12093 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12094 if (!CheckNewTypeMismatchArray<PT_IntAP>(S, OpPC, V0)) return false;
12095 }
12096#if USE_TAILCALLS
12097 MUSTTAIL return InterpNext(S);
12098#else
12099 return true;
12100#endif
12101}
12102PRESERVE_NONE
12103static bool Interp_CheckNewTypeMismatchArrayIntAPS(InterpState &S) {
12104 {
12105 CodePtr OpPC = S.PC;
12106 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12107 if (!CheckNewTypeMismatchArray<PT_IntAPS>(S, OpPC, V0)) return false;
12108 }
12109#if USE_TAILCALLS
12110 MUSTTAIL return InterpNext(S);
12111#else
12112 return true;
12113#endif
12114}
12115#endif
12116#ifdef GET_DISASM
12117case OP_CheckNewTypeMismatchArraySint8:
12118 Text.Op = PrintName("CheckNewTypeMismatchArraySint8");
12119 Text.Args.push_back(printArg<const Expr *>(PC));
12120 break;
12121case OP_CheckNewTypeMismatchArrayUint8:
12122 Text.Op = PrintName("CheckNewTypeMismatchArrayUint8");
12123 Text.Args.push_back(printArg<const Expr *>(PC));
12124 break;
12125case OP_CheckNewTypeMismatchArraySint16:
12126 Text.Op = PrintName("CheckNewTypeMismatchArraySint16");
12127 Text.Args.push_back(printArg<const Expr *>(PC));
12128 break;
12129case OP_CheckNewTypeMismatchArrayUint16:
12130 Text.Op = PrintName("CheckNewTypeMismatchArrayUint16");
12131 Text.Args.push_back(printArg<const Expr *>(PC));
12132 break;
12133case OP_CheckNewTypeMismatchArraySint32:
12134 Text.Op = PrintName("CheckNewTypeMismatchArraySint32");
12135 Text.Args.push_back(printArg<const Expr *>(PC));
12136 break;
12137case OP_CheckNewTypeMismatchArrayUint32:
12138 Text.Op = PrintName("CheckNewTypeMismatchArrayUint32");
12139 Text.Args.push_back(printArg<const Expr *>(PC));
12140 break;
12141case OP_CheckNewTypeMismatchArraySint64:
12142 Text.Op = PrintName("CheckNewTypeMismatchArraySint64");
12143 Text.Args.push_back(printArg<const Expr *>(PC));
12144 break;
12145case OP_CheckNewTypeMismatchArrayUint64:
12146 Text.Op = PrintName("CheckNewTypeMismatchArrayUint64");
12147 Text.Args.push_back(printArg<const Expr *>(PC));
12148 break;
12149case OP_CheckNewTypeMismatchArrayIntAP:
12150 Text.Op = PrintName("CheckNewTypeMismatchArrayIntAP");
12151 Text.Args.push_back(printArg<const Expr *>(PC));
12152 break;
12153case OP_CheckNewTypeMismatchArrayIntAPS:
12154 Text.Op = PrintName("CheckNewTypeMismatchArrayIntAPS");
12155 Text.Args.push_back(printArg<const Expr *>(PC));
12156 break;
12157#endif
12158#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12159bool emitCheckNewTypeMismatchArraySint8( const Expr * , SourceInfo);
12160bool emitCheckNewTypeMismatchArrayUint8( const Expr * , SourceInfo);
12161bool emitCheckNewTypeMismatchArraySint16( const Expr * , SourceInfo);
12162bool emitCheckNewTypeMismatchArrayUint16( const Expr * , SourceInfo);
12163bool emitCheckNewTypeMismatchArraySint32( const Expr * , SourceInfo);
12164bool emitCheckNewTypeMismatchArrayUint32( const Expr * , SourceInfo);
12165bool emitCheckNewTypeMismatchArraySint64( const Expr * , SourceInfo);
12166bool emitCheckNewTypeMismatchArrayUint64( const Expr * , SourceInfo);
12167bool emitCheckNewTypeMismatchArrayIntAP( const Expr * , SourceInfo);
12168bool emitCheckNewTypeMismatchArrayIntAPS( const Expr * , SourceInfo);
12169#endif
12170#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12171[[nodiscard]] bool emitCheckNewTypeMismatchArray(PrimType, const Expr *, SourceInfo I);
12172#endif
12173#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
12174bool
12175#if defined(GET_EVAL_IMPL)
12176EvalEmitter
12177#else
12178ByteCodeEmitter
12179#endif
12180::emitCheckNewTypeMismatchArray(PrimType T0, const Expr * A0, SourceInfo I) {
12181 switch (T0) {
12182 case PT_Sint8:
12183 return emitCheckNewTypeMismatchArraySint8(A0, I);
12184 case PT_Uint8:
12185 return emitCheckNewTypeMismatchArrayUint8(A0, I);
12186 case PT_Sint16:
12187 return emitCheckNewTypeMismatchArraySint16(A0, I);
12188 case PT_Uint16:
12189 return emitCheckNewTypeMismatchArrayUint16(A0, I);
12190 case PT_Sint32:
12191 return emitCheckNewTypeMismatchArraySint32(A0, I);
12192 case PT_Uint32:
12193 return emitCheckNewTypeMismatchArrayUint32(A0, I);
12194 case PT_Sint64:
12195 return emitCheckNewTypeMismatchArraySint64(A0, I);
12196 case PT_Uint64:
12197 return emitCheckNewTypeMismatchArrayUint64(A0, I);
12198 case PT_IntAP:
12199 return emitCheckNewTypeMismatchArrayIntAP(A0, I);
12200 case PT_IntAPS:
12201 return emitCheckNewTypeMismatchArrayIntAPS(A0, I);
12202 default: llvm_unreachable("invalid type: emitCheckNewTypeMismatchArray");
12203 }
12204 llvm_unreachable("invalid enum value");
12205}
12206#endif
12207#ifdef GET_LINK_IMPL
12208bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint8( const Expr * A0, SourceInfo L) {
12209 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArraySint8, A0, L);
12210}
12211bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint8( const Expr * A0, SourceInfo L) {
12212 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayUint8, A0, L);
12213}
12214bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint16( const Expr * A0, SourceInfo L) {
12215 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArraySint16, A0, L);
12216}
12217bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint16( const Expr * A0, SourceInfo L) {
12218 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayUint16, A0, L);
12219}
12220bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint32( const Expr * A0, SourceInfo L) {
12221 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArraySint32, A0, L);
12222}
12223bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint32( const Expr * A0, SourceInfo L) {
12224 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayUint32, A0, L);
12225}
12226bool ByteCodeEmitter::emitCheckNewTypeMismatchArraySint64( const Expr * A0, SourceInfo L) {
12227 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArraySint64, A0, L);
12228}
12229bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayUint64( const Expr * A0, SourceInfo L) {
12230 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayUint64, A0, L);
12231}
12232bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayIntAP( const Expr * A0, SourceInfo L) {
12233 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayIntAP, A0, L);
12234}
12235bool ByteCodeEmitter::emitCheckNewTypeMismatchArrayIntAPS( const Expr * A0, SourceInfo L) {
12236 return emitOp<const Expr *>(OP_CheckNewTypeMismatchArrayIntAPS, A0, L);
12237}
12238#endif
12239#ifdef GET_EVAL_IMPL
12240bool EvalEmitter::emitCheckNewTypeMismatchArraySint8( const Expr * A0, SourceInfo L) {
12241 if (!isActive()) return true;
12242 CurrentSource = L;
12243 return CheckNewTypeMismatchArray<PT_Sint8>(S, CodePtr(), A0);
12244}
12245bool EvalEmitter::emitCheckNewTypeMismatchArrayUint8( const Expr * A0, SourceInfo L) {
12246 if (!isActive()) return true;
12247 CurrentSource = L;
12248 return CheckNewTypeMismatchArray<PT_Uint8>(S, CodePtr(), A0);
12249}
12250bool EvalEmitter::emitCheckNewTypeMismatchArraySint16( const Expr * A0, SourceInfo L) {
12251 if (!isActive()) return true;
12252 CurrentSource = L;
12253 return CheckNewTypeMismatchArray<PT_Sint16>(S, CodePtr(), A0);
12254}
12255bool EvalEmitter::emitCheckNewTypeMismatchArrayUint16( const Expr * A0, SourceInfo L) {
12256 if (!isActive()) return true;
12257 CurrentSource = L;
12258 return CheckNewTypeMismatchArray<PT_Uint16>(S, CodePtr(), A0);
12259}
12260bool EvalEmitter::emitCheckNewTypeMismatchArraySint32( const Expr * A0, SourceInfo L) {
12261 if (!isActive()) return true;
12262 CurrentSource = L;
12263 return CheckNewTypeMismatchArray<PT_Sint32>(S, CodePtr(), A0);
12264}
12265bool EvalEmitter::emitCheckNewTypeMismatchArrayUint32( const Expr * A0, SourceInfo L) {
12266 if (!isActive()) return true;
12267 CurrentSource = L;
12268 return CheckNewTypeMismatchArray<PT_Uint32>(S, CodePtr(), A0);
12269}
12270bool EvalEmitter::emitCheckNewTypeMismatchArraySint64( const Expr * A0, SourceInfo L) {
12271 if (!isActive()) return true;
12272 CurrentSource = L;
12273 return CheckNewTypeMismatchArray<PT_Sint64>(S, CodePtr(), A0);
12274}
12275bool EvalEmitter::emitCheckNewTypeMismatchArrayUint64( const Expr * A0, SourceInfo L) {
12276 if (!isActive()) return true;
12277 CurrentSource = L;
12278 return CheckNewTypeMismatchArray<PT_Uint64>(S, CodePtr(), A0);
12279}
12280bool EvalEmitter::emitCheckNewTypeMismatchArrayIntAP( const Expr * A0, SourceInfo L) {
12281 if (!isActive()) return true;
12282 CurrentSource = L;
12283 return CheckNewTypeMismatchArray<PT_IntAP>(S, CodePtr(), A0);
12284}
12285bool EvalEmitter::emitCheckNewTypeMismatchArrayIntAPS( const Expr * A0, SourceInfo L) {
12286 if (!isActive()) return true;
12287 CurrentSource = L;
12288 return CheckNewTypeMismatchArray<PT_IntAPS>(S, CodePtr(), A0);
12289}
12290#endif
12291#ifdef GET_OPCODE_NAMES
12292OP_CheckNonNullArgPtr,
12293OP_CheckNonNullArgMemberPtr,
12294#endif
12295#ifdef GET_INTERPFN_LIST
12296&Interp_CheckNonNullArgPtr,
12297&Interp_CheckNonNullArgMemberPtr,
12298#endif
12299#ifdef GET_INTERPFN_DISPATCHERS
12300PRESERVE_NONE
12301static bool Interp_CheckNonNullArgPtr(InterpState &S) {
12302 if (!CheckNonNullArg<PT_Ptr>(S, S.PC)) return false;
12303#if USE_TAILCALLS
12304 MUSTTAIL return InterpNext(S);
12305#else
12306 return true;
12307#endif
12308}
12309PRESERVE_NONE
12310static bool Interp_CheckNonNullArgMemberPtr(InterpState &S) {
12311 if (!CheckNonNullArg<PT_MemberPtr>(S, S.PC)) return false;
12312#if USE_TAILCALLS
12313 MUSTTAIL return InterpNext(S);
12314#else
12315 return true;
12316#endif
12317}
12318#endif
12319#ifdef GET_DISASM
12320case OP_CheckNonNullArgPtr:
12321 Text.Op = PrintName("CheckNonNullArgPtr");
12322 break;
12323case OP_CheckNonNullArgMemberPtr:
12324 Text.Op = PrintName("CheckNonNullArgMemberPtr");
12325 break;
12326#endif
12327#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12328bool emitCheckNonNullArgPtr(SourceInfo);
12329bool emitCheckNonNullArgMemberPtr(SourceInfo);
12330#endif
12331#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12332[[nodiscard]] bool emitCheckNonNullArg(PrimType, SourceInfo I);
12333#endif
12334#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
12335bool
12336#if defined(GET_EVAL_IMPL)
12337EvalEmitter
12338#else
12339ByteCodeEmitter
12340#endif
12341::emitCheckNonNullArg(PrimType T0, SourceInfo I) {
12342 switch (T0) {
12343 case PT_Ptr:
12344 return emitCheckNonNullArgPtr(I);
12345 case PT_MemberPtr:
12346 return emitCheckNonNullArgMemberPtr(I);
12347 default: llvm_unreachable("invalid type: emitCheckNonNullArg");
12348 }
12349 llvm_unreachable("invalid enum value");
12350}
12351#endif
12352#ifdef GET_LINK_IMPL
12353bool ByteCodeEmitter::emitCheckNonNullArgPtr(SourceInfo L) {
12354 return emitOp<>(OP_CheckNonNullArgPtr, L);
12355}
12356bool ByteCodeEmitter::emitCheckNonNullArgMemberPtr(SourceInfo L) {
12357 return emitOp<>(OP_CheckNonNullArgMemberPtr, L);
12358}
12359#endif
12360#ifdef GET_EVAL_IMPL
12361bool EvalEmitter::emitCheckNonNullArgPtr(SourceInfo L) {
12362 if (!isActive()) return true;
12363 CurrentSource = L;
12364 return CheckNonNullArg<PT_Ptr>(S, CodePtr());
12365}
12366bool EvalEmitter::emitCheckNonNullArgMemberPtr(SourceInfo L) {
12367 if (!isActive()) return true;
12368 CurrentSource = L;
12369 return CheckNonNullArg<PT_MemberPtr>(S, CodePtr());
12370}
12371#endif
12372#ifdef GET_OPCODE_NAMES
12373OP_CheckNull,
12374#endif
12375#ifdef GET_INTERPFN_LIST
12376&Interp_CheckNull,
12377#endif
12378#ifdef GET_INTERPFN_DISPATCHERS
12379PRESERVE_NONE
12380static bool Interp_CheckNull(InterpState &S) {
12381 if (!CheckNull(S, S.PC)) return false;
12382#if USE_TAILCALLS
12383 MUSTTAIL return InterpNext(S);
12384#else
12385 return true;
12386#endif
12387}
12388#endif
12389#ifdef GET_DISASM
12390case OP_CheckNull:
12391 Text.Op = PrintName("CheckNull");
12392 break;
12393#endif
12394#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12395bool emitCheckNull(SourceInfo);
12396#endif
12397#ifdef GET_LINK_IMPL
12398bool ByteCodeEmitter::emitCheckNull(SourceInfo L) {
12399 return emitOp<>(OP_CheckNull, L);
12400}
12401#endif
12402#ifdef GET_EVAL_IMPL
12403bool EvalEmitter::emitCheckNull(SourceInfo L) {
12404 if (!isActive()) return true;
12405 CurrentSource = L;
12406 return CheckNull(S, CodePtr());
12407}
12408#endif
12409#ifdef GET_OPCODE_NAMES
12410OP_CheckPlacementNew,
12411#endif
12412#ifdef GET_INTERPFN_LIST
12413&Interp_CheckPlacementNew,
12414#endif
12415#ifdef GET_INTERPFN_DISPATCHERS
12416PRESERVE_NONE
12417static bool Interp_CheckPlacementNew(InterpState &S) {
12418 {
12419 CodePtr OpPC = S.PC;
12420 const auto V0 = ReadArg<const Expr *>(S, S.PC);
12421 if (!CheckPlacementNew(S, OpPC, V0)) return false;
12422 }
12423#if USE_TAILCALLS
12424 MUSTTAIL return InterpNext(S);
12425#else
12426 return true;
12427#endif
12428}
12429#endif
12430#ifdef GET_DISASM
12431case OP_CheckPlacementNew:
12432 Text.Op = PrintName("CheckPlacementNew");
12433 Text.Args.push_back(printArg<const Expr *>(PC));
12434 break;
12435#endif
12436#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12437bool emitCheckPlacementNew( const Expr * , SourceInfo);
12438#endif
12439#ifdef GET_LINK_IMPL
12440bool ByteCodeEmitter::emitCheckPlacementNew( const Expr * A0, SourceInfo L) {
12441 return emitOp<const Expr *>(OP_CheckPlacementNew, A0, L);
12442}
12443#endif
12444#ifdef GET_EVAL_IMPL
12445bool EvalEmitter::emitCheckPlacementNew( const Expr * A0, SourceInfo L) {
12446 if (!isActive()) return true;
12447 CurrentSource = L;
12448 return CheckPlacementNew(S, CodePtr(), A0);
12449}
12450#endif
12451#ifdef GET_OPCODE_NAMES
12452OP_CheckPseudoDtor,
12453#endif
12454#ifdef GET_INTERPFN_LIST
12455&Interp_CheckPseudoDtor,
12456#endif
12457#ifdef GET_INTERPFN_DISPATCHERS
12458PRESERVE_NONE
12459static bool Interp_CheckPseudoDtor(InterpState &S) {
12460 CheckPseudoDtor(S, S.PC);
12461#if USE_TAILCALLS
12462 MUSTTAIL return InterpNext(S);
12463#else
12464 return true;
12465#endif
12466}
12467#endif
12468#ifdef GET_DISASM
12469case OP_CheckPseudoDtor:
12470 Text.Op = PrintName("CheckPseudoDtor");
12471 break;
12472#endif
12473#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12474bool emitCheckPseudoDtor(SourceInfo);
12475#endif
12476#ifdef GET_LINK_IMPL
12477bool ByteCodeEmitter::emitCheckPseudoDtor(SourceInfo L) {
12478 return emitOp<>(OP_CheckPseudoDtor, L);
12479}
12480#endif
12481#ifdef GET_EVAL_IMPL
12482bool EvalEmitter::emitCheckPseudoDtor(SourceInfo L) {
12483 if (!isActive()) return true;
12484 CurrentSource = L;
12485 return CheckPseudoDtor(S, CodePtr());
12486}
12487#endif
12488#ifdef GET_OPCODE_NAMES
12489OP_CheckRefInit,
12490#endif
12491#ifdef GET_INTERPFN_LIST
12492&Interp_CheckRefInit,
12493#endif
12494#ifdef GET_INTERPFN_DISPATCHERS
12495PRESERVE_NONE
12496static bool Interp_CheckRefInit(InterpState &S) {
12497 if (!CheckRefInit(S, S.PC)) return false;
12498#if USE_TAILCALLS
12499 MUSTTAIL return InterpNext(S);
12500#else
12501 return true;
12502#endif
12503}
12504#endif
12505#ifdef GET_DISASM
12506case OP_CheckRefInit:
12507 Text.Op = PrintName("CheckRefInit");
12508 break;
12509#endif
12510#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12511bool emitCheckRefInit(SourceInfo);
12512#endif
12513#ifdef GET_LINK_IMPL
12514bool ByteCodeEmitter::emitCheckRefInit(SourceInfo L) {
12515 return emitOp<>(OP_CheckRefInit, L);
12516}
12517#endif
12518#ifdef GET_EVAL_IMPL
12519bool EvalEmitter::emitCheckRefInit(SourceInfo L) {
12520 if (!isActive()) return true;
12521 CurrentSource = L;
12522 return CheckRefInit(S, CodePtr());
12523}
12524#endif
12525#ifdef GET_OPCODE_NAMES
12526OP_CompSint8,
12527OP_CompUint8,
12528OP_CompSint16,
12529OP_CompUint16,
12530OP_CompSint32,
12531OP_CompUint32,
12532OP_CompSint64,
12533OP_CompUint64,
12534OP_CompIntAP,
12535OP_CompIntAPS,
12536#endif
12537#ifdef GET_INTERPFN_LIST
12538&Interp_CompSint8,
12539&Interp_CompUint8,
12540&Interp_CompSint16,
12541&Interp_CompUint16,
12542&Interp_CompSint32,
12543&Interp_CompUint32,
12544&Interp_CompSint64,
12545&Interp_CompUint64,
12546&Interp_CompIntAP,
12547&Interp_CompIntAPS,
12548#endif
12549#ifdef GET_INTERPFN_DISPATCHERS
12550PRESERVE_NONE
12551static bool Interp_CompSint8(InterpState &S) {
12552 if (!Comp<PT_Sint8>(S)) return false;
12553#if USE_TAILCALLS
12554 MUSTTAIL return InterpNext(S);
12555#else
12556 return true;
12557#endif
12558}
12559PRESERVE_NONE
12560static bool Interp_CompUint8(InterpState &S) {
12561 if (!Comp<PT_Uint8>(S)) return false;
12562#if USE_TAILCALLS
12563 MUSTTAIL return InterpNext(S);
12564#else
12565 return true;
12566#endif
12567}
12568PRESERVE_NONE
12569static bool Interp_CompSint16(InterpState &S) {
12570 if (!Comp<PT_Sint16>(S)) return false;
12571#if USE_TAILCALLS
12572 MUSTTAIL return InterpNext(S);
12573#else
12574 return true;
12575#endif
12576}
12577PRESERVE_NONE
12578static bool Interp_CompUint16(InterpState &S) {
12579 if (!Comp<PT_Uint16>(S)) return false;
12580#if USE_TAILCALLS
12581 MUSTTAIL return InterpNext(S);
12582#else
12583 return true;
12584#endif
12585}
12586PRESERVE_NONE
12587static bool Interp_CompSint32(InterpState &S) {
12588 if (!Comp<PT_Sint32>(S)) return false;
12589#if USE_TAILCALLS
12590 MUSTTAIL return InterpNext(S);
12591#else
12592 return true;
12593#endif
12594}
12595PRESERVE_NONE
12596static bool Interp_CompUint32(InterpState &S) {
12597 if (!Comp<PT_Uint32>(S)) return false;
12598#if USE_TAILCALLS
12599 MUSTTAIL return InterpNext(S);
12600#else
12601 return true;
12602#endif
12603}
12604PRESERVE_NONE
12605static bool Interp_CompSint64(InterpState &S) {
12606 if (!Comp<PT_Sint64>(S)) return false;
12607#if USE_TAILCALLS
12608 MUSTTAIL return InterpNext(S);
12609#else
12610 return true;
12611#endif
12612}
12613PRESERVE_NONE
12614static bool Interp_CompUint64(InterpState &S) {
12615 if (!Comp<PT_Uint64>(S)) return false;
12616#if USE_TAILCALLS
12617 MUSTTAIL return InterpNext(S);
12618#else
12619 return true;
12620#endif
12621}
12622PRESERVE_NONE
12623static bool Interp_CompIntAP(InterpState &S) {
12624 if (!Comp<PT_IntAP>(S)) return false;
12625#if USE_TAILCALLS
12626 MUSTTAIL return InterpNext(S);
12627#else
12628 return true;
12629#endif
12630}
12631PRESERVE_NONE
12632static bool Interp_CompIntAPS(InterpState &S) {
12633 if (!Comp<PT_IntAPS>(S)) return false;
12634#if USE_TAILCALLS
12635 MUSTTAIL return InterpNext(S);
12636#else
12637 return true;
12638#endif
12639}
12640#endif
12641#ifdef GET_DISASM
12642case OP_CompSint8:
12643 Text.Op = PrintName("CompSint8");
12644 break;
12645case OP_CompUint8:
12646 Text.Op = PrintName("CompUint8");
12647 break;
12648case OP_CompSint16:
12649 Text.Op = PrintName("CompSint16");
12650 break;
12651case OP_CompUint16:
12652 Text.Op = PrintName("CompUint16");
12653 break;
12654case OP_CompSint32:
12655 Text.Op = PrintName("CompSint32");
12656 break;
12657case OP_CompUint32:
12658 Text.Op = PrintName("CompUint32");
12659 break;
12660case OP_CompSint64:
12661 Text.Op = PrintName("CompSint64");
12662 break;
12663case OP_CompUint64:
12664 Text.Op = PrintName("CompUint64");
12665 break;
12666case OP_CompIntAP:
12667 Text.Op = PrintName("CompIntAP");
12668 break;
12669case OP_CompIntAPS:
12670 Text.Op = PrintName("CompIntAPS");
12671 break;
12672#endif
12673#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12674bool emitCompSint8(SourceInfo);
12675bool emitCompUint8(SourceInfo);
12676bool emitCompSint16(SourceInfo);
12677bool emitCompUint16(SourceInfo);
12678bool emitCompSint32(SourceInfo);
12679bool emitCompUint32(SourceInfo);
12680bool emitCompSint64(SourceInfo);
12681bool emitCompUint64(SourceInfo);
12682bool emitCompIntAP(SourceInfo);
12683bool emitCompIntAPS(SourceInfo);
12684#endif
12685#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12686[[nodiscard]] bool emitComp(PrimType, SourceInfo I);
12687#endif
12688#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
12689bool
12690#if defined(GET_EVAL_IMPL)
12691EvalEmitter
12692#else
12693ByteCodeEmitter
12694#endif
12695::emitComp(PrimType T0, SourceInfo I) {
12696 switch (T0) {
12697 case PT_Sint8:
12698 return emitCompSint8(I);
12699 case PT_Uint8:
12700 return emitCompUint8(I);
12701 case PT_Sint16:
12702 return emitCompSint16(I);
12703 case PT_Uint16:
12704 return emitCompUint16(I);
12705 case PT_Sint32:
12706 return emitCompSint32(I);
12707 case PT_Uint32:
12708 return emitCompUint32(I);
12709 case PT_Sint64:
12710 return emitCompSint64(I);
12711 case PT_Uint64:
12712 return emitCompUint64(I);
12713 case PT_IntAP:
12714 return emitCompIntAP(I);
12715 case PT_IntAPS:
12716 return emitCompIntAPS(I);
12717 default: llvm_unreachable("invalid type: emitComp");
12718 }
12719 llvm_unreachable("invalid enum value");
12720}
12721#endif
12722#ifdef GET_LINK_IMPL
12723bool ByteCodeEmitter::emitCompSint8(SourceInfo L) {
12724 return emitOp<>(OP_CompSint8, L);
12725}
12726bool ByteCodeEmitter::emitCompUint8(SourceInfo L) {
12727 return emitOp<>(OP_CompUint8, L);
12728}
12729bool ByteCodeEmitter::emitCompSint16(SourceInfo L) {
12730 return emitOp<>(OP_CompSint16, L);
12731}
12732bool ByteCodeEmitter::emitCompUint16(SourceInfo L) {
12733 return emitOp<>(OP_CompUint16, L);
12734}
12735bool ByteCodeEmitter::emitCompSint32(SourceInfo L) {
12736 return emitOp<>(OP_CompSint32, L);
12737}
12738bool ByteCodeEmitter::emitCompUint32(SourceInfo L) {
12739 return emitOp<>(OP_CompUint32, L);
12740}
12741bool ByteCodeEmitter::emitCompSint64(SourceInfo L) {
12742 return emitOp<>(OP_CompSint64, L);
12743}
12744bool ByteCodeEmitter::emitCompUint64(SourceInfo L) {
12745 return emitOp<>(OP_CompUint64, L);
12746}
12747bool ByteCodeEmitter::emitCompIntAP(SourceInfo L) {
12748 return emitOp<>(OP_CompIntAP, L);
12749}
12750bool ByteCodeEmitter::emitCompIntAPS(SourceInfo L) {
12751 return emitOp<>(OP_CompIntAPS, L);
12752}
12753#endif
12754#ifdef GET_EVAL_IMPL
12755bool EvalEmitter::emitCompSint8(SourceInfo L) {
12756 if (!isActive()) return true;
12757 CurrentSource = L;
12758 return Comp<PT_Sint8>(S);
12759}
12760bool EvalEmitter::emitCompUint8(SourceInfo L) {
12761 if (!isActive()) return true;
12762 CurrentSource = L;
12763 return Comp<PT_Uint8>(S);
12764}
12765bool EvalEmitter::emitCompSint16(SourceInfo L) {
12766 if (!isActive()) return true;
12767 CurrentSource = L;
12768 return Comp<PT_Sint16>(S);
12769}
12770bool EvalEmitter::emitCompUint16(SourceInfo L) {
12771 if (!isActive()) return true;
12772 CurrentSource = L;
12773 return Comp<PT_Uint16>(S);
12774}
12775bool EvalEmitter::emitCompSint32(SourceInfo L) {
12776 if (!isActive()) return true;
12777 CurrentSource = L;
12778 return Comp<PT_Sint32>(S);
12779}
12780bool EvalEmitter::emitCompUint32(SourceInfo L) {
12781 if (!isActive()) return true;
12782 CurrentSource = L;
12783 return Comp<PT_Uint32>(S);
12784}
12785bool EvalEmitter::emitCompSint64(SourceInfo L) {
12786 if (!isActive()) return true;
12787 CurrentSource = L;
12788 return Comp<PT_Sint64>(S);
12789}
12790bool EvalEmitter::emitCompUint64(SourceInfo L) {
12791 if (!isActive()) return true;
12792 CurrentSource = L;
12793 return Comp<PT_Uint64>(S);
12794}
12795bool EvalEmitter::emitCompIntAP(SourceInfo L) {
12796 if (!isActive()) return true;
12797 CurrentSource = L;
12798 return Comp<PT_IntAP>(S);
12799}
12800bool EvalEmitter::emitCompIntAPS(SourceInfo L) {
12801 if (!isActive()) return true;
12802 CurrentSource = L;
12803 return Comp<PT_IntAPS>(S);
12804}
12805#endif
12806#ifdef GET_OPCODE_NAMES
12807OP_ConstBool,
12808#endif
12809#ifdef GET_INTERPFN_LIST
12810&Interp_ConstBool,
12811#endif
12812#ifdef GET_INTERPFN_DISPATCHERS
12813PRESERVE_NONE
12814static bool Interp_ConstBool(InterpState &S) {
12815 {
12816 const auto V0 = ReadArg<bool>(S, S.PC);
12817 Const<PT_Bool>(S, V0);
12818 }
12819#if USE_TAILCALLS
12820 MUSTTAIL return InterpNext(S);
12821#else
12822 return true;
12823#endif
12824}
12825#endif
12826#ifdef GET_DISASM
12827case OP_ConstBool:
12828 Text.Op = PrintName("ConstBool");
12829 Text.Args.push_back(printArg<bool>(PC));
12830 break;
12831#endif
12832#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12833bool emitConstBool( bool , SourceInfo);
12834#endif
12835#ifdef GET_LINK_IMPL
12836bool ByteCodeEmitter::emitConstBool( bool A0, SourceInfo L) {
12837 return emitOp<bool>(OP_ConstBool, A0, L);
12838}
12839#endif
12840#ifdef GET_EVAL_IMPL
12841bool EvalEmitter::emitConstBool( bool A0, SourceInfo L) {
12842 if (!isActive()) return true;
12843 CurrentSource = L;
12844 return Const<PT_Bool>(S, A0);
12845}
12846#endif
12847#ifdef GET_OPCODE_NAMES
12848OP_ConstFixedPoint,
12849#endif
12850#ifdef GET_INTERPFN_LIST
12851&Interp_ConstFixedPoint,
12852#endif
12853#ifdef GET_INTERPFN_DISPATCHERS
12854PRESERVE_NONE
12855static bool Interp_ConstFixedPoint(InterpState &S) {
12856 {
12857 const auto &V0 = ReadArg<FixedPoint>(S, S.PC);
12858 Const<PT_FixedPoint>(S, V0);
12859 }
12860#if USE_TAILCALLS
12861 MUSTTAIL return InterpNext(S);
12862#else
12863 return true;
12864#endif
12865}
12866#endif
12867#ifdef GET_DISASM
12868case OP_ConstFixedPoint:
12869 Text.Op = PrintName("ConstFixedPoint");
12870 Text.Args.push_back(printArg<FixedPoint>(PC));
12871 break;
12872#endif
12873#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12874bool emitConstFixedPoint(const FixedPoint &, SourceInfo);
12875#endif
12876#ifdef GET_LINK_IMPL
12877bool ByteCodeEmitter::emitConstFixedPoint(const FixedPoint &A0, SourceInfo L) {
12878 return emitOp<FixedPoint>(OP_ConstFixedPoint, A0, L);
12879}
12880#endif
12881#ifdef GET_EVAL_IMPL
12882bool EvalEmitter::emitConstFixedPoint(const FixedPoint &A0, SourceInfo L) {
12883 if (!isActive()) return true;
12884 CurrentSource = L;
12885 return Const<PT_FixedPoint>(S, A0);
12886}
12887#endif
12888#ifdef GET_OPCODE_NAMES
12889OP_ConstFloat,
12890#endif
12891#ifdef GET_INTERPFN_LIST
12892&Interp_ConstFloat,
12893#endif
12894#ifdef GET_INTERPFN_DISPATCHERS
12895PRESERVE_NONE
12896static bool Interp_ConstFloat(InterpState &S) {
12897 {
12898 const auto &V0 = ReadArg<Floating>(S, S.PC);
12899 ConstFloat(S, V0);
12900 }
12901#if USE_TAILCALLS
12902 MUSTTAIL return InterpNext(S);
12903#else
12904 return true;
12905#endif
12906}
12907#endif
12908#ifdef GET_DISASM
12909case OP_ConstFloat:
12910 Text.Op = PrintName("ConstFloat");
12911 Text.Args.push_back(printArg<Floating>(PC));
12912 break;
12913#endif
12914#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12915bool emitConstFloat(const Floating &, SourceInfo);
12916#endif
12917#ifdef GET_LINK_IMPL
12918bool ByteCodeEmitter::emitConstFloat(const Floating &A0, SourceInfo L) {
12919 return emitOp<Floating>(OP_ConstFloat, A0, L);
12920}
12921#endif
12922#ifdef GET_EVAL_IMPL
12923bool EvalEmitter::emitConstFloat(const Floating &A0, SourceInfo L) {
12924 if (!isActive()) return true;
12925 CurrentSource = L;
12926 return ConstFloat(S, A0);
12927}
12928#endif
12929#ifdef GET_OPCODE_NAMES
12930OP_ConstIntAP,
12931#endif
12932#ifdef GET_INTERPFN_LIST
12933&Interp_ConstIntAP,
12934#endif
12935#ifdef GET_INTERPFN_DISPATCHERS
12936PRESERVE_NONE
12937static bool Interp_ConstIntAP(InterpState &S) {
12938 {
12939 const auto &V0 = ReadArg<IntegralAP<false>>(S, S.PC);
12940 Const<PT_IntAP>(S, V0);
12941 }
12942#if USE_TAILCALLS
12943 MUSTTAIL return InterpNext(S);
12944#else
12945 return true;
12946#endif
12947}
12948#endif
12949#ifdef GET_DISASM
12950case OP_ConstIntAP:
12951 Text.Op = PrintName("ConstIntAP");
12952 Text.Args.push_back(printArg<IntegralAP<false>>(PC));
12953 break;
12954#endif
12955#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12956bool emitConstIntAP(const IntegralAP<false> &, SourceInfo);
12957#endif
12958#ifdef GET_LINK_IMPL
12959bool ByteCodeEmitter::emitConstIntAP(const IntegralAP<false> &A0, SourceInfo L) {
12960 return emitOp<IntegralAP<false>>(OP_ConstIntAP, A0, L);
12961}
12962#endif
12963#ifdef GET_EVAL_IMPL
12964bool EvalEmitter::emitConstIntAP(const IntegralAP<false> &A0, SourceInfo L) {
12965 if (!isActive()) return true;
12966 CurrentSource = L;
12967 return Const<PT_IntAP>(S, A0);
12968}
12969#endif
12970#ifdef GET_OPCODE_NAMES
12971OP_ConstIntAPS,
12972#endif
12973#ifdef GET_INTERPFN_LIST
12974&Interp_ConstIntAPS,
12975#endif
12976#ifdef GET_INTERPFN_DISPATCHERS
12977PRESERVE_NONE
12978static bool Interp_ConstIntAPS(InterpState &S) {
12979 {
12980 const auto &V0 = ReadArg<IntegralAP<true>>(S, S.PC);
12981 Const<PT_IntAPS>(S, V0);
12982 }
12983#if USE_TAILCALLS
12984 MUSTTAIL return InterpNext(S);
12985#else
12986 return true;
12987#endif
12988}
12989#endif
12990#ifdef GET_DISASM
12991case OP_ConstIntAPS:
12992 Text.Op = PrintName("ConstIntAPS");
12993 Text.Args.push_back(printArg<IntegralAP<true>>(PC));
12994 break;
12995#endif
12996#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
12997bool emitConstIntAPS(const IntegralAP<true> &, SourceInfo);
12998#endif
12999#ifdef GET_LINK_IMPL
13000bool ByteCodeEmitter::emitConstIntAPS(const IntegralAP<true> &A0, SourceInfo L) {
13001 return emitOp<IntegralAP<true>>(OP_ConstIntAPS, A0, L);
13002}
13003#endif
13004#ifdef GET_EVAL_IMPL
13005bool EvalEmitter::emitConstIntAPS(const IntegralAP<true> &A0, SourceInfo L) {
13006 if (!isActive()) return true;
13007 CurrentSource = L;
13008 return Const<PT_IntAPS>(S, A0);
13009}
13010#endif
13011#ifdef GET_OPCODE_NAMES
13012OP_ConstSint8,
13013#endif
13014#ifdef GET_INTERPFN_LIST
13015&Interp_ConstSint8,
13016#endif
13017#ifdef GET_INTERPFN_DISPATCHERS
13018PRESERVE_NONE
13019static bool Interp_ConstSint8(InterpState &S) {
13020 {
13021 const auto V0 = ReadArg<int8_t>(S, S.PC);
13022 Const<PT_Sint8>(S, V0);
13023 }
13024#if USE_TAILCALLS
13025 MUSTTAIL return InterpNext(S);
13026#else
13027 return true;
13028#endif
13029}
13030#endif
13031#ifdef GET_DISASM
13032case OP_ConstSint8:
13033 Text.Op = PrintName("ConstSint8");
13034 Text.Args.push_back(printArg<int8_t>(PC));
13035 break;
13036#endif
13037#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13038bool emitConstSint8( int8_t , SourceInfo);
13039#endif
13040#ifdef GET_LINK_IMPL
13041bool ByteCodeEmitter::emitConstSint8( int8_t A0, SourceInfo L) {
13042 return emitOp<int8_t>(OP_ConstSint8, A0, L);
13043}
13044#endif
13045#ifdef GET_EVAL_IMPL
13046bool EvalEmitter::emitConstSint8( int8_t A0, SourceInfo L) {
13047 if (!isActive()) return true;
13048 CurrentSource = L;
13049 return Const<PT_Sint8>(S, A0);
13050}
13051#endif
13052#ifdef GET_OPCODE_NAMES
13053OP_ConstSint16,
13054#endif
13055#ifdef GET_INTERPFN_LIST
13056&Interp_ConstSint16,
13057#endif
13058#ifdef GET_INTERPFN_DISPATCHERS
13059PRESERVE_NONE
13060static bool Interp_ConstSint16(InterpState &S) {
13061 {
13062 const auto V0 = ReadArg<int16_t>(S, S.PC);
13063 Const<PT_Sint16>(S, V0);
13064 }
13065#if USE_TAILCALLS
13066 MUSTTAIL return InterpNext(S);
13067#else
13068 return true;
13069#endif
13070}
13071#endif
13072#ifdef GET_DISASM
13073case OP_ConstSint16:
13074 Text.Op = PrintName("ConstSint16");
13075 Text.Args.push_back(printArg<int16_t>(PC));
13076 break;
13077#endif
13078#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13079bool emitConstSint16( int16_t , SourceInfo);
13080#endif
13081#ifdef GET_LINK_IMPL
13082bool ByteCodeEmitter::emitConstSint16( int16_t A0, SourceInfo L) {
13083 return emitOp<int16_t>(OP_ConstSint16, A0, L);
13084}
13085#endif
13086#ifdef GET_EVAL_IMPL
13087bool EvalEmitter::emitConstSint16( int16_t A0, SourceInfo L) {
13088 if (!isActive()) return true;
13089 CurrentSource = L;
13090 return Const<PT_Sint16>(S, A0);
13091}
13092#endif
13093#ifdef GET_OPCODE_NAMES
13094OP_ConstSint32,
13095#endif
13096#ifdef GET_INTERPFN_LIST
13097&Interp_ConstSint32,
13098#endif
13099#ifdef GET_INTERPFN_DISPATCHERS
13100PRESERVE_NONE
13101static bool Interp_ConstSint32(InterpState &S) {
13102 {
13103 const auto V0 = ReadArg<int32_t>(S, S.PC);
13104 Const<PT_Sint32>(S, V0);
13105 }
13106#if USE_TAILCALLS
13107 MUSTTAIL return InterpNext(S);
13108#else
13109 return true;
13110#endif
13111}
13112#endif
13113#ifdef GET_DISASM
13114case OP_ConstSint32:
13115 Text.Op = PrintName("ConstSint32");
13116 Text.Args.push_back(printArg<int32_t>(PC));
13117 break;
13118#endif
13119#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13120bool emitConstSint32( int32_t , SourceInfo);
13121#endif
13122#ifdef GET_LINK_IMPL
13123bool ByteCodeEmitter::emitConstSint32( int32_t A0, SourceInfo L) {
13124 return emitOp<int32_t>(OP_ConstSint32, A0, L);
13125}
13126#endif
13127#ifdef GET_EVAL_IMPL
13128bool EvalEmitter::emitConstSint32( int32_t A0, SourceInfo L) {
13129 if (!isActive()) return true;
13130 CurrentSource = L;
13131 return Const<PT_Sint32>(S, A0);
13132}
13133#endif
13134#ifdef GET_OPCODE_NAMES
13135OP_ConstSint64,
13136#endif
13137#ifdef GET_INTERPFN_LIST
13138&Interp_ConstSint64,
13139#endif
13140#ifdef GET_INTERPFN_DISPATCHERS
13141PRESERVE_NONE
13142static bool Interp_ConstSint64(InterpState &S) {
13143 {
13144 const auto V0 = ReadArg<int64_t>(S, S.PC);
13145 Const<PT_Sint64>(S, V0);
13146 }
13147#if USE_TAILCALLS
13148 MUSTTAIL return InterpNext(S);
13149#else
13150 return true;
13151#endif
13152}
13153#endif
13154#ifdef GET_DISASM
13155case OP_ConstSint64:
13156 Text.Op = PrintName("ConstSint64");
13157 Text.Args.push_back(printArg<int64_t>(PC));
13158 break;
13159#endif
13160#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13161bool emitConstSint64( int64_t , SourceInfo);
13162#endif
13163#ifdef GET_LINK_IMPL
13164bool ByteCodeEmitter::emitConstSint64( int64_t A0, SourceInfo L) {
13165 return emitOp<int64_t>(OP_ConstSint64, A0, L);
13166}
13167#endif
13168#ifdef GET_EVAL_IMPL
13169bool EvalEmitter::emitConstSint64( int64_t A0, SourceInfo L) {
13170 if (!isActive()) return true;
13171 CurrentSource = L;
13172 return Const<PT_Sint64>(S, A0);
13173}
13174#endif
13175#ifdef GET_OPCODE_NAMES
13176OP_ConstUint8,
13177#endif
13178#ifdef GET_INTERPFN_LIST
13179&Interp_ConstUint8,
13180#endif
13181#ifdef GET_INTERPFN_DISPATCHERS
13182PRESERVE_NONE
13183static bool Interp_ConstUint8(InterpState &S) {
13184 {
13185 const auto V0 = ReadArg<uint8_t>(S, S.PC);
13186 Const<PT_Uint8>(S, V0);
13187 }
13188#if USE_TAILCALLS
13189 MUSTTAIL return InterpNext(S);
13190#else
13191 return true;
13192#endif
13193}
13194#endif
13195#ifdef GET_DISASM
13196case OP_ConstUint8:
13197 Text.Op = PrintName("ConstUint8");
13198 Text.Args.push_back(printArg<uint8_t>(PC));
13199 break;
13200#endif
13201#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13202bool emitConstUint8( uint8_t , SourceInfo);
13203#endif
13204#ifdef GET_LINK_IMPL
13205bool ByteCodeEmitter::emitConstUint8( uint8_t A0, SourceInfo L) {
13206 return emitOp<uint8_t>(OP_ConstUint8, A0, L);
13207}
13208#endif
13209#ifdef GET_EVAL_IMPL
13210bool EvalEmitter::emitConstUint8( uint8_t A0, SourceInfo L) {
13211 if (!isActive()) return true;
13212 CurrentSource = L;
13213 return Const<PT_Uint8>(S, A0);
13214}
13215#endif
13216#ifdef GET_OPCODE_NAMES
13217OP_ConstUint16,
13218#endif
13219#ifdef GET_INTERPFN_LIST
13220&Interp_ConstUint16,
13221#endif
13222#ifdef GET_INTERPFN_DISPATCHERS
13223PRESERVE_NONE
13224static bool Interp_ConstUint16(InterpState &S) {
13225 {
13226 const auto V0 = ReadArg<uint16_t>(S, S.PC);
13227 Const<PT_Uint16>(S, V0);
13228 }
13229#if USE_TAILCALLS
13230 MUSTTAIL return InterpNext(S);
13231#else
13232 return true;
13233#endif
13234}
13235#endif
13236#ifdef GET_DISASM
13237case OP_ConstUint16:
13238 Text.Op = PrintName("ConstUint16");
13239 Text.Args.push_back(printArg<uint16_t>(PC));
13240 break;
13241#endif
13242#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13243bool emitConstUint16( uint16_t , SourceInfo);
13244#endif
13245#ifdef GET_LINK_IMPL
13246bool ByteCodeEmitter::emitConstUint16( uint16_t A0, SourceInfo L) {
13247 return emitOp<uint16_t>(OP_ConstUint16, A0, L);
13248}
13249#endif
13250#ifdef GET_EVAL_IMPL
13251bool EvalEmitter::emitConstUint16( uint16_t A0, SourceInfo L) {
13252 if (!isActive()) return true;
13253 CurrentSource = L;
13254 return Const<PT_Uint16>(S, A0);
13255}
13256#endif
13257#ifdef GET_OPCODE_NAMES
13258OP_ConstUint32,
13259#endif
13260#ifdef GET_INTERPFN_LIST
13261&Interp_ConstUint32,
13262#endif
13263#ifdef GET_INTERPFN_DISPATCHERS
13264PRESERVE_NONE
13265static bool Interp_ConstUint32(InterpState &S) {
13266 {
13267 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13268 Const<PT_Uint32>(S, V0);
13269 }
13270#if USE_TAILCALLS
13271 MUSTTAIL return InterpNext(S);
13272#else
13273 return true;
13274#endif
13275}
13276#endif
13277#ifdef GET_DISASM
13278case OP_ConstUint32:
13279 Text.Op = PrintName("ConstUint32");
13280 Text.Args.push_back(printArg<uint32_t>(PC));
13281 break;
13282#endif
13283#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13284bool emitConstUint32( uint32_t , SourceInfo);
13285#endif
13286#ifdef GET_LINK_IMPL
13287bool ByteCodeEmitter::emitConstUint32( uint32_t A0, SourceInfo L) {
13288 return emitOp<uint32_t>(OP_ConstUint32, A0, L);
13289}
13290#endif
13291#ifdef GET_EVAL_IMPL
13292bool EvalEmitter::emitConstUint32( uint32_t A0, SourceInfo L) {
13293 if (!isActive()) return true;
13294 CurrentSource = L;
13295 return Const<PT_Uint32>(S, A0);
13296}
13297#endif
13298#ifdef GET_OPCODE_NAMES
13299OP_ConstUint64,
13300#endif
13301#ifdef GET_INTERPFN_LIST
13302&Interp_ConstUint64,
13303#endif
13304#ifdef GET_INTERPFN_DISPATCHERS
13305PRESERVE_NONE
13306static bool Interp_ConstUint64(InterpState &S) {
13307 {
13308 const auto V0 = ReadArg<uint64_t>(S, S.PC);
13309 Const<PT_Uint64>(S, V0);
13310 }
13311#if USE_TAILCALLS
13312 MUSTTAIL return InterpNext(S);
13313#else
13314 return true;
13315#endif
13316}
13317#endif
13318#ifdef GET_DISASM
13319case OP_ConstUint64:
13320 Text.Op = PrintName("ConstUint64");
13321 Text.Args.push_back(printArg<uint64_t>(PC));
13322 break;
13323#endif
13324#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13325bool emitConstUint64( uint64_t , SourceInfo);
13326#endif
13327#ifdef GET_LINK_IMPL
13328bool ByteCodeEmitter::emitConstUint64( uint64_t A0, SourceInfo L) {
13329 return emitOp<uint64_t>(OP_ConstUint64, A0, L);
13330}
13331#endif
13332#ifdef GET_EVAL_IMPL
13333bool EvalEmitter::emitConstUint64( uint64_t A0, SourceInfo L) {
13334 if (!isActive()) return true;
13335 CurrentSource = L;
13336 return Const<PT_Uint64>(S, A0);
13337}
13338#endif
13339#ifdef GET_OPCODE_NAMES
13340OP_CopyArraySint8,
13341OP_CopyArrayUint8,
13342OP_CopyArraySint16,
13343OP_CopyArrayUint16,
13344OP_CopyArraySint32,
13345OP_CopyArrayUint32,
13346OP_CopyArraySint64,
13347OP_CopyArrayUint64,
13348OP_CopyArrayIntAP,
13349OP_CopyArrayIntAPS,
13350OP_CopyArrayBool,
13351OP_CopyArrayFixedPoint,
13352OP_CopyArrayPtr,
13353OP_CopyArrayMemberPtr,
13354OP_CopyArrayFloat,
13355OP_CopyArrayReflect,
13356#endif
13357#ifdef GET_INTERPFN_LIST
13358&Interp_CopyArraySint8,
13359&Interp_CopyArrayUint8,
13360&Interp_CopyArraySint16,
13361&Interp_CopyArrayUint16,
13362&Interp_CopyArraySint32,
13363&Interp_CopyArrayUint32,
13364&Interp_CopyArraySint64,
13365&Interp_CopyArrayUint64,
13366&Interp_CopyArrayIntAP,
13367&Interp_CopyArrayIntAPS,
13368&Interp_CopyArrayBool,
13369&Interp_CopyArrayFixedPoint,
13370&Interp_CopyArrayPtr,
13371&Interp_CopyArrayMemberPtr,
13372&Interp_CopyArrayFloat,
13373&Interp_CopyArrayReflect,
13374#endif
13375#ifdef GET_INTERPFN_DISPATCHERS
13376PRESERVE_NONE
13377static bool Interp_CopyArraySint8(InterpState &S) {
13378 {
13379 CodePtr OpPC = S.PC;
13380 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13381 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13382 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13383 if (!CopyArray<PT_Sint8>(S, OpPC, V0, V1, V2)) return false;
13384 }
13385#if USE_TAILCALLS
13386 MUSTTAIL return InterpNext(S);
13387#else
13388 return true;
13389#endif
13390}
13391PRESERVE_NONE
13392static bool Interp_CopyArrayUint8(InterpState &S) {
13393 {
13394 CodePtr OpPC = S.PC;
13395 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13396 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13397 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13398 if (!CopyArray<PT_Uint8>(S, OpPC, V0, V1, V2)) return false;
13399 }
13400#if USE_TAILCALLS
13401 MUSTTAIL return InterpNext(S);
13402#else
13403 return true;
13404#endif
13405}
13406PRESERVE_NONE
13407static bool Interp_CopyArraySint16(InterpState &S) {
13408 {
13409 CodePtr OpPC = S.PC;
13410 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13411 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13412 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13413 if (!CopyArray<PT_Sint16>(S, OpPC, V0, V1, V2)) return false;
13414 }
13415#if USE_TAILCALLS
13416 MUSTTAIL return InterpNext(S);
13417#else
13418 return true;
13419#endif
13420}
13421PRESERVE_NONE
13422static bool Interp_CopyArrayUint16(InterpState &S) {
13423 {
13424 CodePtr OpPC = S.PC;
13425 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13426 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13427 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13428 if (!CopyArray<PT_Uint16>(S, OpPC, V0, V1, V2)) return false;
13429 }
13430#if USE_TAILCALLS
13431 MUSTTAIL return InterpNext(S);
13432#else
13433 return true;
13434#endif
13435}
13436PRESERVE_NONE
13437static bool Interp_CopyArraySint32(InterpState &S) {
13438 {
13439 CodePtr OpPC = S.PC;
13440 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13441 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13442 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13443 if (!CopyArray<PT_Sint32>(S, OpPC, V0, V1, V2)) return false;
13444 }
13445#if USE_TAILCALLS
13446 MUSTTAIL return InterpNext(S);
13447#else
13448 return true;
13449#endif
13450}
13451PRESERVE_NONE
13452static bool Interp_CopyArrayUint32(InterpState &S) {
13453 {
13454 CodePtr OpPC = S.PC;
13455 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13456 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13457 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13458 if (!CopyArray<PT_Uint32>(S, OpPC, V0, V1, V2)) return false;
13459 }
13460#if USE_TAILCALLS
13461 MUSTTAIL return InterpNext(S);
13462#else
13463 return true;
13464#endif
13465}
13466PRESERVE_NONE
13467static bool Interp_CopyArraySint64(InterpState &S) {
13468 {
13469 CodePtr OpPC = S.PC;
13470 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13471 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13472 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13473 if (!CopyArray<PT_Sint64>(S, OpPC, V0, V1, V2)) return false;
13474 }
13475#if USE_TAILCALLS
13476 MUSTTAIL return InterpNext(S);
13477#else
13478 return true;
13479#endif
13480}
13481PRESERVE_NONE
13482static bool Interp_CopyArrayUint64(InterpState &S) {
13483 {
13484 CodePtr OpPC = S.PC;
13485 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13486 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13487 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13488 if (!CopyArray<PT_Uint64>(S, OpPC, V0, V1, V2)) return false;
13489 }
13490#if USE_TAILCALLS
13491 MUSTTAIL return InterpNext(S);
13492#else
13493 return true;
13494#endif
13495}
13496PRESERVE_NONE
13497static bool Interp_CopyArrayIntAP(InterpState &S) {
13498 {
13499 CodePtr OpPC = S.PC;
13500 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13501 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13502 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13503 if (!CopyArray<PT_IntAP>(S, OpPC, V0, V1, V2)) return false;
13504 }
13505#if USE_TAILCALLS
13506 MUSTTAIL return InterpNext(S);
13507#else
13508 return true;
13509#endif
13510}
13511PRESERVE_NONE
13512static bool Interp_CopyArrayIntAPS(InterpState &S) {
13513 {
13514 CodePtr OpPC = S.PC;
13515 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13516 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13517 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13518 if (!CopyArray<PT_IntAPS>(S, OpPC, V0, V1, V2)) return false;
13519 }
13520#if USE_TAILCALLS
13521 MUSTTAIL return InterpNext(S);
13522#else
13523 return true;
13524#endif
13525}
13526PRESERVE_NONE
13527static bool Interp_CopyArrayBool(InterpState &S) {
13528 {
13529 CodePtr OpPC = S.PC;
13530 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13531 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13532 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13533 if (!CopyArray<PT_Bool>(S, OpPC, V0, V1, V2)) return false;
13534 }
13535#if USE_TAILCALLS
13536 MUSTTAIL return InterpNext(S);
13537#else
13538 return true;
13539#endif
13540}
13541PRESERVE_NONE
13542static bool Interp_CopyArrayFixedPoint(InterpState &S) {
13543 {
13544 CodePtr OpPC = S.PC;
13545 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13546 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13547 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13548 if (!CopyArray<PT_FixedPoint>(S, OpPC, V0, V1, V2)) return false;
13549 }
13550#if USE_TAILCALLS
13551 MUSTTAIL return InterpNext(S);
13552#else
13553 return true;
13554#endif
13555}
13556PRESERVE_NONE
13557static bool Interp_CopyArrayPtr(InterpState &S) {
13558 {
13559 CodePtr OpPC = S.PC;
13560 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13561 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13562 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13563 if (!CopyArray<PT_Ptr>(S, OpPC, V0, V1, V2)) return false;
13564 }
13565#if USE_TAILCALLS
13566 MUSTTAIL return InterpNext(S);
13567#else
13568 return true;
13569#endif
13570}
13571PRESERVE_NONE
13572static bool Interp_CopyArrayMemberPtr(InterpState &S) {
13573 {
13574 CodePtr OpPC = S.PC;
13575 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13576 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13577 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13578 if (!CopyArray<PT_MemberPtr>(S, OpPC, V0, V1, V2)) return false;
13579 }
13580#if USE_TAILCALLS
13581 MUSTTAIL return InterpNext(S);
13582#else
13583 return true;
13584#endif
13585}
13586PRESERVE_NONE
13587static bool Interp_CopyArrayFloat(InterpState &S) {
13588 {
13589 CodePtr OpPC = S.PC;
13590 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13591 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13592 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13593 if (!CopyArray<PT_Float>(S, OpPC, V0, V1, V2)) return false;
13594 }
13595#if USE_TAILCALLS
13596 MUSTTAIL return InterpNext(S);
13597#else
13598 return true;
13599#endif
13600}
13601PRESERVE_NONE
13602static bool Interp_CopyArrayReflect(InterpState &S) {
13603 {
13604 CodePtr OpPC = S.PC;
13605 const auto V0 = ReadArg<uint32_t>(S, S.PC);
13606 const auto V1 = ReadArg<uint32_t>(S, S.PC);
13607 const auto V2 = ReadArg<uint32_t>(S, S.PC);
13608 if (!CopyArray<PT_Reflect>(S, OpPC, V0, V1, V2)) return false;
13609 }
13610#if USE_TAILCALLS
13611 MUSTTAIL return InterpNext(S);
13612#else
13613 return true;
13614#endif
13615}
13616#endif
13617#ifdef GET_DISASM
13618case OP_CopyArraySint8:
13619 Text.Op = PrintName("CopyArraySint8");
13620 Text.Args.push_back(printArg<uint32_t>(PC));
13621 Text.Args.push_back(printArg<uint32_t>(PC));
13622 Text.Args.push_back(printArg<uint32_t>(PC));
13623 break;
13624case OP_CopyArrayUint8:
13625 Text.Op = PrintName("CopyArrayUint8");
13626 Text.Args.push_back(printArg<uint32_t>(PC));
13627 Text.Args.push_back(printArg<uint32_t>(PC));
13628 Text.Args.push_back(printArg<uint32_t>(PC));
13629 break;
13630case OP_CopyArraySint16:
13631 Text.Op = PrintName("CopyArraySint16");
13632 Text.Args.push_back(printArg<uint32_t>(PC));
13633 Text.Args.push_back(printArg<uint32_t>(PC));
13634 Text.Args.push_back(printArg<uint32_t>(PC));
13635 break;
13636case OP_CopyArrayUint16:
13637 Text.Op = PrintName("CopyArrayUint16");
13638 Text.Args.push_back(printArg<uint32_t>(PC));
13639 Text.Args.push_back(printArg<uint32_t>(PC));
13640 Text.Args.push_back(printArg<uint32_t>(PC));
13641 break;
13642case OP_CopyArraySint32:
13643 Text.Op = PrintName("CopyArraySint32");
13644 Text.Args.push_back(printArg<uint32_t>(PC));
13645 Text.Args.push_back(printArg<uint32_t>(PC));
13646 Text.Args.push_back(printArg<uint32_t>(PC));
13647 break;
13648case OP_CopyArrayUint32:
13649 Text.Op = PrintName("CopyArrayUint32");
13650 Text.Args.push_back(printArg<uint32_t>(PC));
13651 Text.Args.push_back(printArg<uint32_t>(PC));
13652 Text.Args.push_back(printArg<uint32_t>(PC));
13653 break;
13654case OP_CopyArraySint64:
13655 Text.Op = PrintName("CopyArraySint64");
13656 Text.Args.push_back(printArg<uint32_t>(PC));
13657 Text.Args.push_back(printArg<uint32_t>(PC));
13658 Text.Args.push_back(printArg<uint32_t>(PC));
13659 break;
13660case OP_CopyArrayUint64:
13661 Text.Op = PrintName("CopyArrayUint64");
13662 Text.Args.push_back(printArg<uint32_t>(PC));
13663 Text.Args.push_back(printArg<uint32_t>(PC));
13664 Text.Args.push_back(printArg<uint32_t>(PC));
13665 break;
13666case OP_CopyArrayIntAP:
13667 Text.Op = PrintName("CopyArrayIntAP");
13668 Text.Args.push_back(printArg<uint32_t>(PC));
13669 Text.Args.push_back(printArg<uint32_t>(PC));
13670 Text.Args.push_back(printArg<uint32_t>(PC));
13671 break;
13672case OP_CopyArrayIntAPS:
13673 Text.Op = PrintName("CopyArrayIntAPS");
13674 Text.Args.push_back(printArg<uint32_t>(PC));
13675 Text.Args.push_back(printArg<uint32_t>(PC));
13676 Text.Args.push_back(printArg<uint32_t>(PC));
13677 break;
13678case OP_CopyArrayBool:
13679 Text.Op = PrintName("CopyArrayBool");
13680 Text.Args.push_back(printArg<uint32_t>(PC));
13681 Text.Args.push_back(printArg<uint32_t>(PC));
13682 Text.Args.push_back(printArg<uint32_t>(PC));
13683 break;
13684case OP_CopyArrayFixedPoint:
13685 Text.Op = PrintName("CopyArrayFixedPoint");
13686 Text.Args.push_back(printArg<uint32_t>(PC));
13687 Text.Args.push_back(printArg<uint32_t>(PC));
13688 Text.Args.push_back(printArg<uint32_t>(PC));
13689 break;
13690case OP_CopyArrayPtr:
13691 Text.Op = PrintName("CopyArrayPtr");
13692 Text.Args.push_back(printArg<uint32_t>(PC));
13693 Text.Args.push_back(printArg<uint32_t>(PC));
13694 Text.Args.push_back(printArg<uint32_t>(PC));
13695 break;
13696case OP_CopyArrayMemberPtr:
13697 Text.Op = PrintName("CopyArrayMemberPtr");
13698 Text.Args.push_back(printArg<uint32_t>(PC));
13699 Text.Args.push_back(printArg<uint32_t>(PC));
13700 Text.Args.push_back(printArg<uint32_t>(PC));
13701 break;
13702case OP_CopyArrayFloat:
13703 Text.Op = PrintName("CopyArrayFloat");
13704 Text.Args.push_back(printArg<uint32_t>(PC));
13705 Text.Args.push_back(printArg<uint32_t>(PC));
13706 Text.Args.push_back(printArg<uint32_t>(PC));
13707 break;
13708case OP_CopyArrayReflect:
13709 Text.Op = PrintName("CopyArrayReflect");
13710 Text.Args.push_back(printArg<uint32_t>(PC));
13711 Text.Args.push_back(printArg<uint32_t>(PC));
13712 Text.Args.push_back(printArg<uint32_t>(PC));
13713 break;
13714#endif
13715#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13716bool emitCopyArraySint8( uint32_t , uint32_t , uint32_t , SourceInfo);
13717bool emitCopyArrayUint8( uint32_t , uint32_t , uint32_t , SourceInfo);
13718bool emitCopyArraySint16( uint32_t , uint32_t , uint32_t , SourceInfo);
13719bool emitCopyArrayUint16( uint32_t , uint32_t , uint32_t , SourceInfo);
13720bool emitCopyArraySint32( uint32_t , uint32_t , uint32_t , SourceInfo);
13721bool emitCopyArrayUint32( uint32_t , uint32_t , uint32_t , SourceInfo);
13722bool emitCopyArraySint64( uint32_t , uint32_t , uint32_t , SourceInfo);
13723bool emitCopyArrayUint64( uint32_t , uint32_t , uint32_t , SourceInfo);
13724bool emitCopyArrayIntAP( uint32_t , uint32_t , uint32_t , SourceInfo);
13725bool emitCopyArrayIntAPS( uint32_t , uint32_t , uint32_t , SourceInfo);
13726bool emitCopyArrayBool( uint32_t , uint32_t , uint32_t , SourceInfo);
13727bool emitCopyArrayFixedPoint( uint32_t , uint32_t , uint32_t , SourceInfo);
13728bool emitCopyArrayPtr( uint32_t , uint32_t , uint32_t , SourceInfo);
13729bool emitCopyArrayMemberPtr( uint32_t , uint32_t , uint32_t , SourceInfo);
13730bool emitCopyArrayFloat( uint32_t , uint32_t , uint32_t , SourceInfo);
13731bool emitCopyArrayReflect( uint32_t , uint32_t , uint32_t , SourceInfo);
13732#endif
13733#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13734[[nodiscard]] bool emitCopyArray(PrimType, uint32_t, uint32_t, uint32_t, SourceInfo I);
13735#endif
13736#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
13737bool
13738#if defined(GET_EVAL_IMPL)
13739EvalEmitter
13740#else
13741ByteCodeEmitter
13742#endif
13743::emitCopyArray(PrimType T0, uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo I) {
13744 switch (T0) {
13745 case PT_Sint8:
13746 return emitCopyArraySint8(A0, A1, A2, I);
13747 case PT_Uint8:
13748 return emitCopyArrayUint8(A0, A1, A2, I);
13749 case PT_Sint16:
13750 return emitCopyArraySint16(A0, A1, A2, I);
13751 case PT_Uint16:
13752 return emitCopyArrayUint16(A0, A1, A2, I);
13753 case PT_Sint32:
13754 return emitCopyArraySint32(A0, A1, A2, I);
13755 case PT_Uint32:
13756 return emitCopyArrayUint32(A0, A1, A2, I);
13757 case PT_Sint64:
13758 return emitCopyArraySint64(A0, A1, A2, I);
13759 case PT_Uint64:
13760 return emitCopyArrayUint64(A0, A1, A2, I);
13761 case PT_IntAP:
13762 return emitCopyArrayIntAP(A0, A1, A2, I);
13763 case PT_IntAPS:
13764 return emitCopyArrayIntAPS(A0, A1, A2, I);
13765 case PT_Bool:
13766 return emitCopyArrayBool(A0, A1, A2, I);
13767 case PT_FixedPoint:
13768 return emitCopyArrayFixedPoint(A0, A1, A2, I);
13769 case PT_Ptr:
13770 return emitCopyArrayPtr(A0, A1, A2, I);
13771 case PT_MemberPtr:
13772 return emitCopyArrayMemberPtr(A0, A1, A2, I);
13773 case PT_Float:
13774 return emitCopyArrayFloat(A0, A1, A2, I);
13775 case PT_Reflect:
13776 return emitCopyArrayReflect(A0, A1, A2, I);
13777 }
13778 llvm_unreachable("invalid enum value");
13779}
13780#endif
13781#ifdef GET_LINK_IMPL
13782bool ByteCodeEmitter::emitCopyArraySint8( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13783 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArraySint8, A0, A1, A2, L);
13784}
13785bool ByteCodeEmitter::emitCopyArrayUint8( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13786 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayUint8, A0, A1, A2, L);
13787}
13788bool ByteCodeEmitter::emitCopyArraySint16( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13789 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArraySint16, A0, A1, A2, L);
13790}
13791bool ByteCodeEmitter::emitCopyArrayUint16( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13792 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayUint16, A0, A1, A2, L);
13793}
13794bool ByteCodeEmitter::emitCopyArraySint32( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13795 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArraySint32, A0, A1, A2, L);
13796}
13797bool ByteCodeEmitter::emitCopyArrayUint32( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13798 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayUint32, A0, A1, A2, L);
13799}
13800bool ByteCodeEmitter::emitCopyArraySint64( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13801 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArraySint64, A0, A1, A2, L);
13802}
13803bool ByteCodeEmitter::emitCopyArrayUint64( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13804 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayUint64, A0, A1, A2, L);
13805}
13806bool ByteCodeEmitter::emitCopyArrayIntAP( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13807 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayIntAP, A0, A1, A2, L);
13808}
13809bool ByteCodeEmitter::emitCopyArrayIntAPS( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13810 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayIntAPS, A0, A1, A2, L);
13811}
13812bool ByteCodeEmitter::emitCopyArrayBool( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13813 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayBool, A0, A1, A2, L);
13814}
13815bool ByteCodeEmitter::emitCopyArrayFixedPoint( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13816 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayFixedPoint, A0, A1, A2, L);
13817}
13818bool ByteCodeEmitter::emitCopyArrayPtr( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13819 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayPtr, A0, A1, A2, L);
13820}
13821bool ByteCodeEmitter::emitCopyArrayMemberPtr( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13822 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayMemberPtr, A0, A1, A2, L);
13823}
13824bool ByteCodeEmitter::emitCopyArrayFloat( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13825 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayFloat, A0, A1, A2, L);
13826}
13827bool ByteCodeEmitter::emitCopyArrayReflect( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13828 return emitOp<uint32_t, uint32_t, uint32_t>(OP_CopyArrayReflect, A0, A1, A2, L);
13829}
13830#endif
13831#ifdef GET_EVAL_IMPL
13832bool EvalEmitter::emitCopyArraySint8( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13833 if (!isActive()) return true;
13834 CurrentSource = L;
13835 return CopyArray<PT_Sint8>(S, CodePtr(), A0, A1, A2);
13836}
13837bool EvalEmitter::emitCopyArrayUint8( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13838 if (!isActive()) return true;
13839 CurrentSource = L;
13840 return CopyArray<PT_Uint8>(S, CodePtr(), A0, A1, A2);
13841}
13842bool EvalEmitter::emitCopyArraySint16( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13843 if (!isActive()) return true;
13844 CurrentSource = L;
13845 return CopyArray<PT_Sint16>(S, CodePtr(), A0, A1, A2);
13846}
13847bool EvalEmitter::emitCopyArrayUint16( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13848 if (!isActive()) return true;
13849 CurrentSource = L;
13850 return CopyArray<PT_Uint16>(S, CodePtr(), A0, A1, A2);
13851}
13852bool EvalEmitter::emitCopyArraySint32( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13853 if (!isActive()) return true;
13854 CurrentSource = L;
13855 return CopyArray<PT_Sint32>(S, CodePtr(), A0, A1, A2);
13856}
13857bool EvalEmitter::emitCopyArrayUint32( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13858 if (!isActive()) return true;
13859 CurrentSource = L;
13860 return CopyArray<PT_Uint32>(S, CodePtr(), A0, A1, A2);
13861}
13862bool EvalEmitter::emitCopyArraySint64( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13863 if (!isActive()) return true;
13864 CurrentSource = L;
13865 return CopyArray<PT_Sint64>(S, CodePtr(), A0, A1, A2);
13866}
13867bool EvalEmitter::emitCopyArrayUint64( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13868 if (!isActive()) return true;
13869 CurrentSource = L;
13870 return CopyArray<PT_Uint64>(S, CodePtr(), A0, A1, A2);
13871}
13872bool EvalEmitter::emitCopyArrayIntAP( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13873 if (!isActive()) return true;
13874 CurrentSource = L;
13875 return CopyArray<PT_IntAP>(S, CodePtr(), A0, A1, A2);
13876}
13877bool EvalEmitter::emitCopyArrayIntAPS( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13878 if (!isActive()) return true;
13879 CurrentSource = L;
13880 return CopyArray<PT_IntAPS>(S, CodePtr(), A0, A1, A2);
13881}
13882bool EvalEmitter::emitCopyArrayBool( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13883 if (!isActive()) return true;
13884 CurrentSource = L;
13885 return CopyArray<PT_Bool>(S, CodePtr(), A0, A1, A2);
13886}
13887bool EvalEmitter::emitCopyArrayFixedPoint( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13888 if (!isActive()) return true;
13889 CurrentSource = L;
13890 return CopyArray<PT_FixedPoint>(S, CodePtr(), A0, A1, A2);
13891}
13892bool EvalEmitter::emitCopyArrayPtr( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13893 if (!isActive()) return true;
13894 CurrentSource = L;
13895 return CopyArray<PT_Ptr>(S, CodePtr(), A0, A1, A2);
13896}
13897bool EvalEmitter::emitCopyArrayMemberPtr( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13898 if (!isActive()) return true;
13899 CurrentSource = L;
13900 return CopyArray<PT_MemberPtr>(S, CodePtr(), A0, A1, A2);
13901}
13902bool EvalEmitter::emitCopyArrayFloat( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13903 if (!isActive()) return true;
13904 CurrentSource = L;
13905 return CopyArray<PT_Float>(S, CodePtr(), A0, A1, A2);
13906}
13907bool EvalEmitter::emitCopyArrayReflect( uint32_t A0, uint32_t A1, uint32_t A2, SourceInfo L) {
13908 if (!isActive()) return true;
13909 CurrentSource = L;
13910 return CopyArray<PT_Reflect>(S, CodePtr(), A0, A1, A2);
13911}
13912#endif
13913#ifdef GET_OPCODE_NAMES
13914OP_CopyMemberPtrPath,
13915#endif
13916#ifdef GET_INTERPFN_LIST
13917&Interp_CopyMemberPtrPath,
13918#endif
13919#ifdef GET_INTERPFN_DISPATCHERS
13920PRESERVE_NONE
13921static bool Interp_CopyMemberPtrPath(InterpState &S) {
13922 {
13923 const auto V0 = ReadArg<const RecordDecl *>(S, S.PC);
13924 const auto V1 = ReadArg<bool>(S, S.PC);
13925 CopyMemberPtrPath(S, V0, V1);
13926 }
13927#if USE_TAILCALLS
13928 MUSTTAIL return InterpNext(S);
13929#else
13930 return true;
13931#endif
13932}
13933#endif
13934#ifdef GET_DISASM
13935case OP_CopyMemberPtrPath:
13936 Text.Op = PrintName("CopyMemberPtrPath");
13937 Text.Args.push_back(printArg<const RecordDecl *>(PC));
13938 Text.Args.push_back(printArg<bool>(PC));
13939 break;
13940#endif
13941#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13942bool emitCopyMemberPtrPath( const RecordDecl * , bool , SourceInfo);
13943#endif
13944#ifdef GET_LINK_IMPL
13945bool ByteCodeEmitter::emitCopyMemberPtrPath( const RecordDecl * A0, bool A1, SourceInfo L) {
13946 return emitOp<const RecordDecl *, bool>(OP_CopyMemberPtrPath, A0, A1, L);
13947}
13948#endif
13949#ifdef GET_EVAL_IMPL
13950bool EvalEmitter::emitCopyMemberPtrPath( const RecordDecl * A0, bool A1, SourceInfo L) {
13951 if (!isActive()) return true;
13952 CurrentSource = L;
13953 return CopyMemberPtrPath(S, A0, A1);
13954}
13955#endif
13956#ifdef GET_OPCODE_NAMES
13957OP_CtorCheck,
13958#endif
13959#ifdef GET_INTERPFN_LIST
13960&Interp_CtorCheck,
13961#endif
13962#ifdef GET_INTERPFN_DISPATCHERS
13963PRESERVE_NONE
13964static bool Interp_CtorCheck(InterpState &S) {
13965 if (!CtorCheck(S)) return false;
13966#if USE_TAILCALLS
13967 MUSTTAIL return InterpNext(S);
13968#else
13969 return true;
13970#endif
13971}
13972#endif
13973#ifdef GET_DISASM
13974case OP_CtorCheck:
13975 Text.Op = PrintName("CtorCheck");
13976 break;
13977#endif
13978#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
13979bool emitCtorCheck(SourceInfo);
13980#endif
13981#ifdef GET_LINK_IMPL
13982bool ByteCodeEmitter::emitCtorCheck(SourceInfo L) {
13983 return emitOp<>(OP_CtorCheck, L);
13984}
13985#endif
13986#ifdef GET_EVAL_IMPL
13987bool EvalEmitter::emitCtorCheck(SourceInfo L) {
13988 if (!isActive()) return true;
13989 CurrentSource = L;
13990 return CtorCheck(S);
13991}
13992#endif
13993#ifdef GET_OPCODE_NAMES
13994OP_DecSint8,
13995OP_DecUint8,
13996OP_DecSint16,
13997OP_DecUint16,
13998OP_DecSint32,
13999OP_DecUint32,
14000OP_DecSint64,
14001OP_DecUint64,
14002OP_DecIntAP,
14003OP_DecIntAPS,
14004OP_DecBool,
14005OP_DecFixedPoint,
14006#endif
14007#ifdef GET_INTERPFN_LIST
14008&Interp_DecSint8,
14009&Interp_DecUint8,
14010&Interp_DecSint16,
14011&Interp_DecUint16,
14012&Interp_DecSint32,
14013&Interp_DecUint32,
14014&Interp_DecSint64,
14015&Interp_DecUint64,
14016&Interp_DecIntAP,
14017&Interp_DecIntAPS,
14018&Interp_DecBool,
14019&Interp_DecFixedPoint,
14020#endif
14021#ifdef GET_INTERPFN_DISPATCHERS
14022PRESERVE_NONE
14023static bool Interp_DecSint8(InterpState &S) {
14024 {
14025 CodePtr OpPC = S.PC;
14026 const auto V0 = ReadArg<bool>(S, S.PC);
14027 if (!Dec<PT_Sint8>(S, OpPC, V0)) return false;
14028 }
14029#if USE_TAILCALLS
14030 MUSTTAIL return InterpNext(S);
14031#else
14032 return true;
14033#endif
14034}
14035PRESERVE_NONE
14036static bool Interp_DecUint8(InterpState &S) {
14037 {
14038 CodePtr OpPC = S.PC;
14039 const auto V0 = ReadArg<bool>(S, S.PC);
14040 if (!Dec<PT_Uint8>(S, OpPC, V0)) return false;
14041 }
14042#if USE_TAILCALLS
14043 MUSTTAIL return InterpNext(S);
14044#else
14045 return true;
14046#endif
14047}
14048PRESERVE_NONE
14049static bool Interp_DecSint16(InterpState &S) {
14050 {
14051 CodePtr OpPC = S.PC;
14052 const auto V0 = ReadArg<bool>(S, S.PC);
14053 if (!Dec<PT_Sint16>(S, OpPC, V0)) return false;
14054 }
14055#if USE_TAILCALLS
14056 MUSTTAIL return InterpNext(S);
14057#else
14058 return true;
14059#endif
14060}
14061PRESERVE_NONE
14062static bool Interp_DecUint16(InterpState &S) {
14063 {
14064 CodePtr OpPC = S.PC;
14065 const auto V0 = ReadArg<bool>(S, S.PC);
14066 if (!Dec<PT_Uint16>(S, OpPC, V0)) return false;
14067 }
14068#if USE_TAILCALLS
14069 MUSTTAIL return InterpNext(S);
14070#else
14071 return true;
14072#endif
14073}
14074PRESERVE_NONE
14075static bool Interp_DecSint32(InterpState &S) {
14076 {
14077 CodePtr OpPC = S.PC;
14078 const auto V0 = ReadArg<bool>(S, S.PC);
14079 if (!Dec<PT_Sint32>(S, OpPC, V0)) return false;
14080 }
14081#if USE_TAILCALLS
14082 MUSTTAIL return InterpNext(S);
14083#else
14084 return true;
14085#endif
14086}
14087PRESERVE_NONE
14088static bool Interp_DecUint32(InterpState &S) {
14089 {
14090 CodePtr OpPC = S.PC;
14091 const auto V0 = ReadArg<bool>(S, S.PC);
14092 if (!Dec<PT_Uint32>(S, OpPC, V0)) return false;
14093 }
14094#if USE_TAILCALLS
14095 MUSTTAIL return InterpNext(S);
14096#else
14097 return true;
14098#endif
14099}
14100PRESERVE_NONE
14101static bool Interp_DecSint64(InterpState &S) {
14102 {
14103 CodePtr OpPC = S.PC;
14104 const auto V0 = ReadArg<bool>(S, S.PC);
14105 if (!Dec<PT_Sint64>(S, OpPC, V0)) return false;
14106 }
14107#if USE_TAILCALLS
14108 MUSTTAIL return InterpNext(S);
14109#else
14110 return true;
14111#endif
14112}
14113PRESERVE_NONE
14114static bool Interp_DecUint64(InterpState &S) {
14115 {
14116 CodePtr OpPC = S.PC;
14117 const auto V0 = ReadArg<bool>(S, S.PC);
14118 if (!Dec<PT_Uint64>(S, OpPC, V0)) return false;
14119 }
14120#if USE_TAILCALLS
14121 MUSTTAIL return InterpNext(S);
14122#else
14123 return true;
14124#endif
14125}
14126PRESERVE_NONE
14127static bool Interp_DecIntAP(InterpState &S) {
14128 {
14129 CodePtr OpPC = S.PC;
14130 const auto V0 = ReadArg<bool>(S, S.PC);
14131 if (!Dec<PT_IntAP>(S, OpPC, V0)) return false;
14132 }
14133#if USE_TAILCALLS
14134 MUSTTAIL return InterpNext(S);
14135#else
14136 return true;
14137#endif
14138}
14139PRESERVE_NONE
14140static bool Interp_DecIntAPS(InterpState &S) {
14141 {
14142 CodePtr OpPC = S.PC;
14143 const auto V0 = ReadArg<bool>(S, S.PC);
14144 if (!Dec<PT_IntAPS>(S, OpPC, V0)) return false;
14145 }
14146#if USE_TAILCALLS
14147 MUSTTAIL return InterpNext(S);
14148#else
14149 return true;
14150#endif
14151}
14152PRESERVE_NONE
14153static bool Interp_DecBool(InterpState &S) {
14154 {
14155 CodePtr OpPC = S.PC;
14156 const auto V0 = ReadArg<bool>(S, S.PC);
14157 if (!Dec<PT_Bool>(S, OpPC, V0)) return false;
14158 }
14159#if USE_TAILCALLS
14160 MUSTTAIL return InterpNext(S);
14161#else
14162 return true;
14163#endif
14164}
14165PRESERVE_NONE
14166static bool Interp_DecFixedPoint(InterpState &S) {
14167 {
14168 CodePtr OpPC = S.PC;
14169 const auto V0 = ReadArg<bool>(S, S.PC);
14170 if (!Dec<PT_FixedPoint>(S, OpPC, V0)) return false;
14171 }
14172#if USE_TAILCALLS
14173 MUSTTAIL return InterpNext(S);
14174#else
14175 return true;
14176#endif
14177}
14178#endif
14179#ifdef GET_DISASM
14180case OP_DecSint8:
14181 Text.Op = PrintName("DecSint8");
14182 Text.Args.push_back(printArg<bool>(PC));
14183 break;
14184case OP_DecUint8:
14185 Text.Op = PrintName("DecUint8");
14186 Text.Args.push_back(printArg<bool>(PC));
14187 break;
14188case OP_DecSint16:
14189 Text.Op = PrintName("DecSint16");
14190 Text.Args.push_back(printArg<bool>(PC));
14191 break;
14192case OP_DecUint16:
14193 Text.Op = PrintName("DecUint16");
14194 Text.Args.push_back(printArg<bool>(PC));
14195 break;
14196case OP_DecSint32:
14197 Text.Op = PrintName("DecSint32");
14198 Text.Args.push_back(printArg<bool>(PC));
14199 break;
14200case OP_DecUint32:
14201 Text.Op = PrintName("DecUint32");
14202 Text.Args.push_back(printArg<bool>(PC));
14203 break;
14204case OP_DecSint64:
14205 Text.Op = PrintName("DecSint64");
14206 Text.Args.push_back(printArg<bool>(PC));
14207 break;
14208case OP_DecUint64:
14209 Text.Op = PrintName("DecUint64");
14210 Text.Args.push_back(printArg<bool>(PC));
14211 break;
14212case OP_DecIntAP:
14213 Text.Op = PrintName("DecIntAP");
14214 Text.Args.push_back(printArg<bool>(PC));
14215 break;
14216case OP_DecIntAPS:
14217 Text.Op = PrintName("DecIntAPS");
14218 Text.Args.push_back(printArg<bool>(PC));
14219 break;
14220case OP_DecBool:
14221 Text.Op = PrintName("DecBool");
14222 Text.Args.push_back(printArg<bool>(PC));
14223 break;
14224case OP_DecFixedPoint:
14225 Text.Op = PrintName("DecFixedPoint");
14226 Text.Args.push_back(printArg<bool>(PC));
14227 break;
14228#endif
14229#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14230bool emitDecSint8( bool , SourceInfo);
14231bool emitDecUint8( bool , SourceInfo);
14232bool emitDecSint16( bool , SourceInfo);
14233bool emitDecUint16( bool , SourceInfo);
14234bool emitDecSint32( bool , SourceInfo);
14235bool emitDecUint32( bool , SourceInfo);
14236bool emitDecSint64( bool , SourceInfo);
14237bool emitDecUint64( bool , SourceInfo);
14238bool emitDecIntAP( bool , SourceInfo);
14239bool emitDecIntAPS( bool , SourceInfo);
14240bool emitDecBool( bool , SourceInfo);
14241bool emitDecFixedPoint( bool , SourceInfo);
14242#endif
14243#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14244[[nodiscard]] bool emitDec(PrimType, bool, SourceInfo I);
14245#endif
14246#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
14247bool
14248#if defined(GET_EVAL_IMPL)
14249EvalEmitter
14250#else
14251ByteCodeEmitter
14252#endif
14253::emitDec(PrimType T0, bool A0, SourceInfo I) {
14254 switch (T0) {
14255 case PT_Sint8:
14256 return emitDecSint8(A0, I);
14257 case PT_Uint8:
14258 return emitDecUint8(A0, I);
14259 case PT_Sint16:
14260 return emitDecSint16(A0, I);
14261 case PT_Uint16:
14262 return emitDecUint16(A0, I);
14263 case PT_Sint32:
14264 return emitDecSint32(A0, I);
14265 case PT_Uint32:
14266 return emitDecUint32(A0, I);
14267 case PT_Sint64:
14268 return emitDecSint64(A0, I);
14269 case PT_Uint64:
14270 return emitDecUint64(A0, I);
14271 case PT_IntAP:
14272 return emitDecIntAP(A0, I);
14273 case PT_IntAPS:
14274 return emitDecIntAPS(A0, I);
14275 case PT_Bool:
14276 return emitDecBool(A0, I);
14277 case PT_FixedPoint:
14278 return emitDecFixedPoint(A0, I);
14279 default: llvm_unreachable("invalid type: emitDec");
14280 }
14281 llvm_unreachable("invalid enum value");
14282}
14283#endif
14284#ifdef GET_LINK_IMPL
14285bool ByteCodeEmitter::emitDecSint8( bool A0, SourceInfo L) {
14286 return emitOp<bool>(OP_DecSint8, A0, L);
14287}
14288bool ByteCodeEmitter::emitDecUint8( bool A0, SourceInfo L) {
14289 return emitOp<bool>(OP_DecUint8, A0, L);
14290}
14291bool ByteCodeEmitter::emitDecSint16( bool A0, SourceInfo L) {
14292 return emitOp<bool>(OP_DecSint16, A0, L);
14293}
14294bool ByteCodeEmitter::emitDecUint16( bool A0, SourceInfo L) {
14295 return emitOp<bool>(OP_DecUint16, A0, L);
14296}
14297bool ByteCodeEmitter::emitDecSint32( bool A0, SourceInfo L) {
14298 return emitOp<bool>(OP_DecSint32, A0, L);
14299}
14300bool ByteCodeEmitter::emitDecUint32( bool A0, SourceInfo L) {
14301 return emitOp<bool>(OP_DecUint32, A0, L);
14302}
14303bool ByteCodeEmitter::emitDecSint64( bool A0, SourceInfo L) {
14304 return emitOp<bool>(OP_DecSint64, A0, L);
14305}
14306bool ByteCodeEmitter::emitDecUint64( bool A0, SourceInfo L) {
14307 return emitOp<bool>(OP_DecUint64, A0, L);
14308}
14309bool ByteCodeEmitter::emitDecIntAP( bool A0, SourceInfo L) {
14310 return emitOp<bool>(OP_DecIntAP, A0, L);
14311}
14312bool ByteCodeEmitter::emitDecIntAPS( bool A0, SourceInfo L) {
14313 return emitOp<bool>(OP_DecIntAPS, A0, L);
14314}
14315bool ByteCodeEmitter::emitDecBool( bool A0, SourceInfo L) {
14316 return emitOp<bool>(OP_DecBool, A0, L);
14317}
14318bool ByteCodeEmitter::emitDecFixedPoint( bool A0, SourceInfo L) {
14319 return emitOp<bool>(OP_DecFixedPoint, A0, L);
14320}
14321#endif
14322#ifdef GET_EVAL_IMPL
14323bool EvalEmitter::emitDecSint8( bool A0, SourceInfo L) {
14324 if (!isActive()) return true;
14325 CurrentSource = L;
14326 return Dec<PT_Sint8>(S, CodePtr(), A0);
14327}
14328bool EvalEmitter::emitDecUint8( bool A0, SourceInfo L) {
14329 if (!isActive()) return true;
14330 CurrentSource = L;
14331 return Dec<PT_Uint8>(S, CodePtr(), A0);
14332}
14333bool EvalEmitter::emitDecSint16( bool A0, SourceInfo L) {
14334 if (!isActive()) return true;
14335 CurrentSource = L;
14336 return Dec<PT_Sint16>(S, CodePtr(), A0);
14337}
14338bool EvalEmitter::emitDecUint16( bool A0, SourceInfo L) {
14339 if (!isActive()) return true;
14340 CurrentSource = L;
14341 return Dec<PT_Uint16>(S, CodePtr(), A0);
14342}
14343bool EvalEmitter::emitDecSint32( bool A0, SourceInfo L) {
14344 if (!isActive()) return true;
14345 CurrentSource = L;
14346 return Dec<PT_Sint32>(S, CodePtr(), A0);
14347}
14348bool EvalEmitter::emitDecUint32( bool A0, SourceInfo L) {
14349 if (!isActive()) return true;
14350 CurrentSource = L;
14351 return Dec<PT_Uint32>(S, CodePtr(), A0);
14352}
14353bool EvalEmitter::emitDecSint64( bool A0, SourceInfo L) {
14354 if (!isActive()) return true;
14355 CurrentSource = L;
14356 return Dec<PT_Sint64>(S, CodePtr(), A0);
14357}
14358bool EvalEmitter::emitDecUint64( bool A0, SourceInfo L) {
14359 if (!isActive()) return true;
14360 CurrentSource = L;
14361 return Dec<PT_Uint64>(S, CodePtr(), A0);
14362}
14363bool EvalEmitter::emitDecIntAP( bool A0, SourceInfo L) {
14364 if (!isActive()) return true;
14365 CurrentSource = L;
14366 return Dec<PT_IntAP>(S, CodePtr(), A0);
14367}
14368bool EvalEmitter::emitDecIntAPS( bool A0, SourceInfo L) {
14369 if (!isActive()) return true;
14370 CurrentSource = L;
14371 return Dec<PT_IntAPS>(S, CodePtr(), A0);
14372}
14373bool EvalEmitter::emitDecBool( bool A0, SourceInfo L) {
14374 if (!isActive()) return true;
14375 CurrentSource = L;
14376 return Dec<PT_Bool>(S, CodePtr(), A0);
14377}
14378bool EvalEmitter::emitDecFixedPoint( bool A0, SourceInfo L) {
14379 if (!isActive()) return true;
14380 CurrentSource = L;
14381 return Dec<PT_FixedPoint>(S, CodePtr(), A0);
14382}
14383#endif
14384#ifdef GET_OPCODE_NAMES
14385OP_DecBitfieldSint8,
14386OP_DecBitfieldUint8,
14387OP_DecBitfieldSint16,
14388OP_DecBitfieldUint16,
14389OP_DecBitfieldSint32,
14390OP_DecBitfieldUint32,
14391OP_DecBitfieldSint64,
14392OP_DecBitfieldUint64,
14393OP_DecBitfieldIntAP,
14394OP_DecBitfieldIntAPS,
14395OP_DecBitfieldBool,
14396OP_DecBitfieldFixedPoint,
14397#endif
14398#ifdef GET_INTERPFN_LIST
14399&Interp_DecBitfieldSint8,
14400&Interp_DecBitfieldUint8,
14401&Interp_DecBitfieldSint16,
14402&Interp_DecBitfieldUint16,
14403&Interp_DecBitfieldSint32,
14404&Interp_DecBitfieldUint32,
14405&Interp_DecBitfieldSint64,
14406&Interp_DecBitfieldUint64,
14407&Interp_DecBitfieldIntAP,
14408&Interp_DecBitfieldIntAPS,
14409&Interp_DecBitfieldBool,
14410&Interp_DecBitfieldFixedPoint,
14411#endif
14412#ifdef GET_INTERPFN_DISPATCHERS
14413PRESERVE_NONE
14414static bool Interp_DecBitfieldSint8(InterpState &S) {
14415 {
14416 CodePtr OpPC = S.PC;
14417 const auto V0 = ReadArg<bool>(S, S.PC);
14418 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14419 if (!DecBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
14420 }
14421#if USE_TAILCALLS
14422 MUSTTAIL return InterpNext(S);
14423#else
14424 return true;
14425#endif
14426}
14427PRESERVE_NONE
14428static bool Interp_DecBitfieldUint8(InterpState &S) {
14429 {
14430 CodePtr OpPC = S.PC;
14431 const auto V0 = ReadArg<bool>(S, S.PC);
14432 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14433 if (!DecBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
14434 }
14435#if USE_TAILCALLS
14436 MUSTTAIL return InterpNext(S);
14437#else
14438 return true;
14439#endif
14440}
14441PRESERVE_NONE
14442static bool Interp_DecBitfieldSint16(InterpState &S) {
14443 {
14444 CodePtr OpPC = S.PC;
14445 const auto V0 = ReadArg<bool>(S, S.PC);
14446 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14447 if (!DecBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
14448 }
14449#if USE_TAILCALLS
14450 MUSTTAIL return InterpNext(S);
14451#else
14452 return true;
14453#endif
14454}
14455PRESERVE_NONE
14456static bool Interp_DecBitfieldUint16(InterpState &S) {
14457 {
14458 CodePtr OpPC = S.PC;
14459 const auto V0 = ReadArg<bool>(S, S.PC);
14460 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14461 if (!DecBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
14462 }
14463#if USE_TAILCALLS
14464 MUSTTAIL return InterpNext(S);
14465#else
14466 return true;
14467#endif
14468}
14469PRESERVE_NONE
14470static bool Interp_DecBitfieldSint32(InterpState &S) {
14471 {
14472 CodePtr OpPC = S.PC;
14473 const auto V0 = ReadArg<bool>(S, S.PC);
14474 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14475 if (!DecBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
14476 }
14477#if USE_TAILCALLS
14478 MUSTTAIL return InterpNext(S);
14479#else
14480 return true;
14481#endif
14482}
14483PRESERVE_NONE
14484static bool Interp_DecBitfieldUint32(InterpState &S) {
14485 {
14486 CodePtr OpPC = S.PC;
14487 const auto V0 = ReadArg<bool>(S, S.PC);
14488 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14489 if (!DecBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
14490 }
14491#if USE_TAILCALLS
14492 MUSTTAIL return InterpNext(S);
14493#else
14494 return true;
14495#endif
14496}
14497PRESERVE_NONE
14498static bool Interp_DecBitfieldSint64(InterpState &S) {
14499 {
14500 CodePtr OpPC = S.PC;
14501 const auto V0 = ReadArg<bool>(S, S.PC);
14502 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14503 if (!DecBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
14504 }
14505#if USE_TAILCALLS
14506 MUSTTAIL return InterpNext(S);
14507#else
14508 return true;
14509#endif
14510}
14511PRESERVE_NONE
14512static bool Interp_DecBitfieldUint64(InterpState &S) {
14513 {
14514 CodePtr OpPC = S.PC;
14515 const auto V0 = ReadArg<bool>(S, S.PC);
14516 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14517 if (!DecBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
14518 }
14519#if USE_TAILCALLS
14520 MUSTTAIL return InterpNext(S);
14521#else
14522 return true;
14523#endif
14524}
14525PRESERVE_NONE
14526static bool Interp_DecBitfieldIntAP(InterpState &S) {
14527 {
14528 CodePtr OpPC = S.PC;
14529 const auto V0 = ReadArg<bool>(S, S.PC);
14530 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14531 if (!DecBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
14532 }
14533#if USE_TAILCALLS
14534 MUSTTAIL return InterpNext(S);
14535#else
14536 return true;
14537#endif
14538}
14539PRESERVE_NONE
14540static bool Interp_DecBitfieldIntAPS(InterpState &S) {
14541 {
14542 CodePtr OpPC = S.PC;
14543 const auto V0 = ReadArg<bool>(S, S.PC);
14544 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14545 if (!DecBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
14546 }
14547#if USE_TAILCALLS
14548 MUSTTAIL return InterpNext(S);
14549#else
14550 return true;
14551#endif
14552}
14553PRESERVE_NONE
14554static bool Interp_DecBitfieldBool(InterpState &S) {
14555 {
14556 CodePtr OpPC = S.PC;
14557 const auto V0 = ReadArg<bool>(S, S.PC);
14558 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14559 if (!DecBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
14560 }
14561#if USE_TAILCALLS
14562 MUSTTAIL return InterpNext(S);
14563#else
14564 return true;
14565#endif
14566}
14567PRESERVE_NONE
14568static bool Interp_DecBitfieldFixedPoint(InterpState &S) {
14569 {
14570 CodePtr OpPC = S.PC;
14571 const auto V0 = ReadArg<bool>(S, S.PC);
14572 const auto V1 = ReadArg<uint32_t>(S, S.PC);
14573 if (!DecBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
14574 }
14575#if USE_TAILCALLS
14576 MUSTTAIL return InterpNext(S);
14577#else
14578 return true;
14579#endif
14580}
14581#endif
14582#ifdef GET_DISASM
14583case OP_DecBitfieldSint8:
14584 Text.Op = PrintName("DecBitfieldSint8");
14585 Text.Args.push_back(printArg<bool>(PC));
14586 Text.Args.push_back(printArg<uint32_t>(PC));
14587 break;
14588case OP_DecBitfieldUint8:
14589 Text.Op = PrintName("DecBitfieldUint8");
14590 Text.Args.push_back(printArg<bool>(PC));
14591 Text.Args.push_back(printArg<uint32_t>(PC));
14592 break;
14593case OP_DecBitfieldSint16:
14594 Text.Op = PrintName("DecBitfieldSint16");
14595 Text.Args.push_back(printArg<bool>(PC));
14596 Text.Args.push_back(printArg<uint32_t>(PC));
14597 break;
14598case OP_DecBitfieldUint16:
14599 Text.Op = PrintName("DecBitfieldUint16");
14600 Text.Args.push_back(printArg<bool>(PC));
14601 Text.Args.push_back(printArg<uint32_t>(PC));
14602 break;
14603case OP_DecBitfieldSint32:
14604 Text.Op = PrintName("DecBitfieldSint32");
14605 Text.Args.push_back(printArg<bool>(PC));
14606 Text.Args.push_back(printArg<uint32_t>(PC));
14607 break;
14608case OP_DecBitfieldUint32:
14609 Text.Op = PrintName("DecBitfieldUint32");
14610 Text.Args.push_back(printArg<bool>(PC));
14611 Text.Args.push_back(printArg<uint32_t>(PC));
14612 break;
14613case OP_DecBitfieldSint64:
14614 Text.Op = PrintName("DecBitfieldSint64");
14615 Text.Args.push_back(printArg<bool>(PC));
14616 Text.Args.push_back(printArg<uint32_t>(PC));
14617 break;
14618case OP_DecBitfieldUint64:
14619 Text.Op = PrintName("DecBitfieldUint64");
14620 Text.Args.push_back(printArg<bool>(PC));
14621 Text.Args.push_back(printArg<uint32_t>(PC));
14622 break;
14623case OP_DecBitfieldIntAP:
14624 Text.Op = PrintName("DecBitfieldIntAP");
14625 Text.Args.push_back(printArg<bool>(PC));
14626 Text.Args.push_back(printArg<uint32_t>(PC));
14627 break;
14628case OP_DecBitfieldIntAPS:
14629 Text.Op = PrintName("DecBitfieldIntAPS");
14630 Text.Args.push_back(printArg<bool>(PC));
14631 Text.Args.push_back(printArg<uint32_t>(PC));
14632 break;
14633case OP_DecBitfieldBool:
14634 Text.Op = PrintName("DecBitfieldBool");
14635 Text.Args.push_back(printArg<bool>(PC));
14636 Text.Args.push_back(printArg<uint32_t>(PC));
14637 break;
14638case OP_DecBitfieldFixedPoint:
14639 Text.Op = PrintName("DecBitfieldFixedPoint");
14640 Text.Args.push_back(printArg<bool>(PC));
14641 Text.Args.push_back(printArg<uint32_t>(PC));
14642 break;
14643#endif
14644#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14645bool emitDecBitfieldSint8( bool , uint32_t , SourceInfo);
14646bool emitDecBitfieldUint8( bool , uint32_t , SourceInfo);
14647bool emitDecBitfieldSint16( bool , uint32_t , SourceInfo);
14648bool emitDecBitfieldUint16( bool , uint32_t , SourceInfo);
14649bool emitDecBitfieldSint32( bool , uint32_t , SourceInfo);
14650bool emitDecBitfieldUint32( bool , uint32_t , SourceInfo);
14651bool emitDecBitfieldSint64( bool , uint32_t , SourceInfo);
14652bool emitDecBitfieldUint64( bool , uint32_t , SourceInfo);
14653bool emitDecBitfieldIntAP( bool , uint32_t , SourceInfo);
14654bool emitDecBitfieldIntAPS( bool , uint32_t , SourceInfo);
14655bool emitDecBitfieldBool( bool , uint32_t , SourceInfo);
14656bool emitDecBitfieldFixedPoint( bool , uint32_t , SourceInfo);
14657#endif
14658#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
14659[[nodiscard]] bool emitDecBitfield(PrimType, bool, uint32_t, SourceInfo I);
14660#endif
14661#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
14662bool
14663#if defined(GET_EVAL_IMPL)
14664EvalEmitter
14665#else
14666ByteCodeEmitter
14667#endif
14668::emitDecBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
14669 switch (T0) {
14670 case PT_Sint8:
14671 return emitDecBitfieldSint8(A0, A1, I);
14672 case PT_Uint8:
14673 return emitDecBitfieldUint8(A0, A1, I);
14674 case PT_Sint16:
14675 return emitDecBitfieldSint16(A0, A1, I);
14676 case PT_Uint16:
14677 return emitDecBitfieldUint16(A0, A1, I);
14678 case PT_Sint32:
14679 return emitDecBitfieldSint32(A0, A1, I);
14680 case PT_Uint32:
14681 return emitDecBitfieldUint32(A0, A1, I);
14682 case PT_Sint64:
14683 return emitDecBitfieldSint64(A0, A1, I);
14684 case PT_Uint64:
14685 return emitDecBitfieldUint64(A0, A1, I);
14686 case PT_IntAP:
14687 return emitDecBitfieldIntAP(A0, A1, I);
14688 case PT_IntAPS:
14689 return emitDecBitfieldIntAPS(A0, A1, I);
14690 case PT_Bool:
14691 return emitDecBitfieldBool(A0, A1, I);
14692 case PT_FixedPoint:
14693 return emitDecBitfieldFixedPoint(A0, A1, I);
14694 default: llvm_unreachable("invalid type: emitDecBitfield");
14695 }
14696 llvm_unreachable("invalid enum value");
14697}
14698#endif
14699#ifdef GET_LINK_IMPL
14700bool ByteCodeEmitter::emitDecBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
14701 return emitOp<bool, uint32_t>(OP_DecBitfieldSint8, A0, A1, L);
14702}
14703bool ByteCodeEmitter::emitDecBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
14704 return emitOp<bool, uint32_t>(OP_DecBitfieldUint8, A0, A1, L);
14705}
14706bool ByteCodeEmitter::emitDecBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
14707 return emitOp<bool, uint32_t>(OP_DecBitfieldSint16, A0, A1, L);
14708}
14709bool ByteCodeEmitter::emitDecBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
14710 return emitOp<bool, uint32_t>(OP_DecBitfieldUint16, A0, A1, L);
14711}
14712bool ByteCodeEmitter::emitDecBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
14713 return emitOp<bool, uint32_t>(OP_DecBitfieldSint32, A0, A1, L);
14714}
14715bool ByteCodeEmitter::emitDecBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
14716 return emitOp<bool, uint32_t>(OP_DecBitfieldUint32, A0, A1, L);
14717}
14718bool ByteCodeEmitter::emitDecBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
14719 return emitOp<bool, uint32_t>(OP_DecBitfieldSint64, A0, A1, L);
14720}
14721bool ByteCodeEmitter::emitDecBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
14722 return emitOp<bool, uint32_t>(OP_DecBitfieldUint64, A0, A1, L);
14723}
14724bool ByteCodeEmitter::emitDecBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
14725 return emitOp<bool, uint32_t>(OP_DecBitfieldIntAP, A0, A1, L);
14726}
14727bool ByteCodeEmitter::emitDecBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
14728 return emitOp<bool, uint32_t>(OP_DecBitfieldIntAPS, A0, A1, L);
14729}
14730bool ByteCodeEmitter::emitDecBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
14731 return emitOp<bool, uint32_t>(OP_DecBitfieldBool, A0, A1, L);
14732}
14733bool ByteCodeEmitter::emitDecBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
14734 return emitOp<bool, uint32_t>(OP_DecBitfieldFixedPoint, A0, A1, L);
14735}
14736#endif
14737#ifdef GET_EVAL_IMPL
14738bool EvalEmitter::emitDecBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
14739 if (!isActive()) return true;
14740 CurrentSource = L;
14741 return DecBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
14742}
14743bool EvalEmitter::emitDecBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
14744 if (!isActive()) return true;
14745 CurrentSource = L;
14746 return DecBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
14747}
14748bool EvalEmitter::emitDecBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
14749 if (!isActive()) return true;
14750 CurrentSource = L;
14751 return DecBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
14752}
14753bool EvalEmitter::emitDecBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
14754 if (!isActive()) return true;
14755 CurrentSource = L;
14756 return DecBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
14757}
14758bool EvalEmitter::emitDecBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
14759 if (!isActive()) return true;
14760 CurrentSource = L;
14761 return DecBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
14762}
14763bool EvalEmitter::emitDecBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
14764 if (!isActive()) return true;
14765 CurrentSource = L;
14766 return DecBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
14767}
14768bool EvalEmitter::emitDecBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
14769 if (!isActive()) return true;
14770 CurrentSource = L;
14771 return DecBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
14772}
14773bool EvalEmitter::emitDecBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
14774 if (!isActive()) return true;
14775 CurrentSource = L;
14776 return DecBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
14777}
14778bool EvalEmitter::emitDecBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
14779 if (!isActive()) return true;
14780 CurrentSource = L;
14781 return DecBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
14782}
14783bool EvalEmitter::emitDecBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
14784 if (!isActive()) return true;
14785 CurrentSource = L;
14786 return DecBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
14787}
14788bool EvalEmitter::emitDecBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
14789 if (!isActive()) return true;
14790 CurrentSource = L;
14791 return DecBitfield<PT_Bool>(S, CodePtr(), A0, A1);
14792}
14793bool EvalEmitter::emitDecBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
14794 if (!isActive()) return true;
14795 CurrentSource = L;
14796 return DecBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
14797}
14798#endif
14799#ifdef GET_OPCODE_NAMES
14800OP_DecPopSint8,
14801OP_DecPopUint8,
14802OP_DecPopSint16,
14803OP_DecPopUint16,
14804OP_DecPopSint32,
14805OP_DecPopUint32,
14806OP_DecPopSint64,
14807OP_DecPopUint64,
14808OP_DecPopIntAP,
14809OP_DecPopIntAPS,
14810OP_DecPopBool,
14811OP_DecPopFixedPoint,
14812#endif
14813#ifdef GET_INTERPFN_LIST
14814&Interp_DecPopSint8,
14815&Interp_DecPopUint8,
14816&Interp_DecPopSint16,
14817&Interp_DecPopUint16,
14818&Interp_DecPopSint32,
14819&Interp_DecPopUint32,
14820&Interp_DecPopSint64,
14821&Interp_DecPopUint64,
14822&Interp_DecPopIntAP,
14823&Interp_DecPopIntAPS,
14824&Interp_DecPopBool,
14825&Interp_DecPopFixedPoint,
14826#endif
14827#ifdef GET_INTERPFN_DISPATCHERS
14828PRESERVE_NONE
14829static bool Interp_DecPopSint8(InterpState &S) {
14830 {
14831 CodePtr OpPC = S.PC;
14832 const auto V0 = ReadArg<bool>(S, S.PC);
14833 if (!DecPop<PT_Sint8>(S, OpPC, V0)) return false;
14834 }
14835#if USE_TAILCALLS
14836 MUSTTAIL return InterpNext(S);
14837#else
14838 return true;
14839#endif
14840}
14841PRESERVE_NONE
14842static bool Interp_DecPopUint8(InterpState &S) {
14843 {
14844 CodePtr OpPC = S.PC;
14845 const auto V0 = ReadArg<bool>(S, S.PC);
14846 if (!DecPop<PT_Uint8>(S, OpPC, V0)) return false;
14847 }
14848#if USE_TAILCALLS
14849 MUSTTAIL return InterpNext(S);
14850#else
14851 return true;
14852#endif
14853}
14854PRESERVE_NONE
14855static bool Interp_DecPopSint16(InterpState &S) {
14856 {
14857 CodePtr OpPC = S.PC;
14858 const auto V0 = ReadArg<bool>(S, S.PC);
14859 if (!DecPop<PT_Sint16>(S, OpPC, V0)) return false;
14860 }
14861#if USE_TAILCALLS
14862 MUSTTAIL return InterpNext(S);
14863#else
14864 return true;
14865#endif
14866}
14867PRESERVE_NONE
14868static bool Interp_DecPopUint16(InterpState &S) {
14869 {
14870 CodePtr OpPC = S.PC;
14871 const auto V0 = ReadArg<bool>(S, S.PC);
14872 if (!DecPop<PT_Uint16>(S, OpPC, V0)) return false;
14873 }
14874#if USE_TAILCALLS
14875 MUSTTAIL return InterpNext(S);
14876#else
14877 return true;
14878#endif
14879}
14880PRESERVE_NONE
14881static bool Interp_DecPopSint32(InterpState &S) {
14882 {
14883 CodePtr OpPC = S.PC;
14884 const auto V0 = ReadArg<bool>(S, S.PC);
14885 if (!DecPop<PT_Sint32>(S, OpPC, V0)) return false;
14886 }
14887#if USE_TAILCALLS
14888 MUSTTAIL return InterpNext(S);
14889#else
14890 return true;
14891#endif
14892}
14893PRESERVE_NONE
14894static bool Interp_DecPopUint32(InterpState &S) {
14895 {
14896 CodePtr OpPC = S.PC;
14897 const auto V0 = ReadArg<bool>(S, S.PC);
14898 if (!DecPop<PT_Uint32>(S, OpPC, V0)) return false;
14899 }
14900#if USE_TAILCALLS
14901 MUSTTAIL return InterpNext(S);
14902#else
14903 return true;
14904#endif
14905}
14906PRESERVE_NONE
14907static bool Interp_DecPopSint64(InterpState &S) {
14908 {
14909 CodePtr OpPC = S.PC;
14910 const auto V0 = ReadArg<bool>(S, S.PC);
14911 if (!DecPop<PT_Sint64>(S, OpPC, V0)) return false;
14912 }
14913#if USE_TAILCALLS
14914 MUSTTAIL return InterpNext(S);
14915#else
14916 return true;
14917#endif
14918}
14919PRESERVE_NONE
14920static bool Interp_DecPopUint64(InterpState &S) {
14921 {
14922 CodePtr OpPC = S.PC;
14923 const auto V0 = ReadArg<bool>(S, S.PC);
14924 if (!DecPop<PT_Uint64>(S, OpPC, V0)) return false;
14925 }
14926#if USE_TAILCALLS
14927 MUSTTAIL return InterpNext(S);
14928#else
14929 return true;
14930#endif
14931}
14932PRESERVE_NONE
14933static bool Interp_DecPopIntAP(InterpState &S) {
14934 {
14935 CodePtr OpPC = S.PC;
14936 const auto V0 = ReadArg<bool>(S, S.PC);
14937 if (!DecPop<PT_IntAP>(S, OpPC, V0)) return false;
14938 }
14939#if USE_TAILCALLS
14940 MUSTTAIL return InterpNext(S);
14941#else
14942 return true;
14943#endif
14944}
14945PRESERVE_NONE
14946static bool Interp_DecPopIntAPS(InterpState &S) {
14947 {
14948 CodePtr OpPC = S.PC;
14949 const auto V0 = ReadArg<bool>(S, S.PC);
14950 if (!DecPop<PT_IntAPS>(S, OpPC, V0)) return false;
14951 }
14952#if USE_TAILCALLS
14953 MUSTTAIL return InterpNext(S);
14954#else
14955 return true;
14956#endif
14957}
14958PRESERVE_NONE
14959static bool Interp_DecPopBool(InterpState &S) {
14960 {
14961 CodePtr OpPC = S.PC;
14962 const auto V0 = ReadArg<bool>(S, S.PC);
14963 if (!DecPop<PT_Bool>(S, OpPC, V0)) return false;
14964 }
14965#if USE_TAILCALLS
14966 MUSTTAIL return InterpNext(S);
14967#else
14968 return true;
14969#endif
14970}
14971PRESERVE_NONE
14972static bool Interp_DecPopFixedPoint(InterpState &S) {
14973 {
14974 CodePtr OpPC = S.PC;
14975 const auto V0 = ReadArg<bool>(S, S.PC);
14976 if (!DecPop<PT_FixedPoint>(S, OpPC, V0)) return false;
14977 }
14978#if USE_TAILCALLS
14979 MUSTTAIL return InterpNext(S);
14980#else
14981 return true;
14982#endif
14983}
14984#endif
14985#ifdef GET_DISASM
14986case OP_DecPopSint8:
14987 Text.Op = PrintName("DecPopSint8");
14988 Text.Args.push_back(printArg<bool>(PC));
14989 break;
14990case OP_DecPopUint8:
14991 Text.Op = PrintName("DecPopUint8");
14992 Text.Args.push_back(printArg<bool>(PC));
14993 break;
14994case OP_DecPopSint16:
14995 Text.Op = PrintName("DecPopSint16");
14996 Text.Args.push_back(printArg<bool>(PC));
14997 break;
14998case OP_DecPopUint16:
14999 Text.Op = PrintName("DecPopUint16");
15000 Text.Args.push_back(printArg<bool>(PC));
15001 break;
15002case OP_DecPopSint32:
15003 Text.Op = PrintName("DecPopSint32");
15004 Text.Args.push_back(printArg<bool>(PC));
15005 break;
15006case OP_DecPopUint32:
15007 Text.Op = PrintName("DecPopUint32");
15008 Text.Args.push_back(printArg<bool>(PC));
15009 break;
15010case OP_DecPopSint64:
15011 Text.Op = PrintName("DecPopSint64");
15012 Text.Args.push_back(printArg<bool>(PC));
15013 break;
15014case OP_DecPopUint64:
15015 Text.Op = PrintName("DecPopUint64");
15016 Text.Args.push_back(printArg<bool>(PC));
15017 break;
15018case OP_DecPopIntAP:
15019 Text.Op = PrintName("DecPopIntAP");
15020 Text.Args.push_back(printArg<bool>(PC));
15021 break;
15022case OP_DecPopIntAPS:
15023 Text.Op = PrintName("DecPopIntAPS");
15024 Text.Args.push_back(printArg<bool>(PC));
15025 break;
15026case OP_DecPopBool:
15027 Text.Op = PrintName("DecPopBool");
15028 Text.Args.push_back(printArg<bool>(PC));
15029 break;
15030case OP_DecPopFixedPoint:
15031 Text.Op = PrintName("DecPopFixedPoint");
15032 Text.Args.push_back(printArg<bool>(PC));
15033 break;
15034#endif
15035#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15036bool emitDecPopSint8( bool , SourceInfo);
15037bool emitDecPopUint8( bool , SourceInfo);
15038bool emitDecPopSint16( bool , SourceInfo);
15039bool emitDecPopUint16( bool , SourceInfo);
15040bool emitDecPopSint32( bool , SourceInfo);
15041bool emitDecPopUint32( bool , SourceInfo);
15042bool emitDecPopSint64( bool , SourceInfo);
15043bool emitDecPopUint64( bool , SourceInfo);
15044bool emitDecPopIntAP( bool , SourceInfo);
15045bool emitDecPopIntAPS( bool , SourceInfo);
15046bool emitDecPopBool( bool , SourceInfo);
15047bool emitDecPopFixedPoint( bool , SourceInfo);
15048#endif
15049#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15050[[nodiscard]] bool emitDecPop(PrimType, bool, SourceInfo I);
15051#endif
15052#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
15053bool
15054#if defined(GET_EVAL_IMPL)
15055EvalEmitter
15056#else
15057ByteCodeEmitter
15058#endif
15059::emitDecPop(PrimType T0, bool A0, SourceInfo I) {
15060 switch (T0) {
15061 case PT_Sint8:
15062 return emitDecPopSint8(A0, I);
15063 case PT_Uint8:
15064 return emitDecPopUint8(A0, I);
15065 case PT_Sint16:
15066 return emitDecPopSint16(A0, I);
15067 case PT_Uint16:
15068 return emitDecPopUint16(A0, I);
15069 case PT_Sint32:
15070 return emitDecPopSint32(A0, I);
15071 case PT_Uint32:
15072 return emitDecPopUint32(A0, I);
15073 case PT_Sint64:
15074 return emitDecPopSint64(A0, I);
15075 case PT_Uint64:
15076 return emitDecPopUint64(A0, I);
15077 case PT_IntAP:
15078 return emitDecPopIntAP(A0, I);
15079 case PT_IntAPS:
15080 return emitDecPopIntAPS(A0, I);
15081 case PT_Bool:
15082 return emitDecPopBool(A0, I);
15083 case PT_FixedPoint:
15084 return emitDecPopFixedPoint(A0, I);
15085 default: llvm_unreachable("invalid type: emitDecPop");
15086 }
15087 llvm_unreachable("invalid enum value");
15088}
15089#endif
15090#ifdef GET_LINK_IMPL
15091bool ByteCodeEmitter::emitDecPopSint8( bool A0, SourceInfo L) {
15092 return emitOp<bool>(OP_DecPopSint8, A0, L);
15093}
15094bool ByteCodeEmitter::emitDecPopUint8( bool A0, SourceInfo L) {
15095 return emitOp<bool>(OP_DecPopUint8, A0, L);
15096}
15097bool ByteCodeEmitter::emitDecPopSint16( bool A0, SourceInfo L) {
15098 return emitOp<bool>(OP_DecPopSint16, A0, L);
15099}
15100bool ByteCodeEmitter::emitDecPopUint16( bool A0, SourceInfo L) {
15101 return emitOp<bool>(OP_DecPopUint16, A0, L);
15102}
15103bool ByteCodeEmitter::emitDecPopSint32( bool A0, SourceInfo L) {
15104 return emitOp<bool>(OP_DecPopSint32, A0, L);
15105}
15106bool ByteCodeEmitter::emitDecPopUint32( bool A0, SourceInfo L) {
15107 return emitOp<bool>(OP_DecPopUint32, A0, L);
15108}
15109bool ByteCodeEmitter::emitDecPopSint64( bool A0, SourceInfo L) {
15110 return emitOp<bool>(OP_DecPopSint64, A0, L);
15111}
15112bool ByteCodeEmitter::emitDecPopUint64( bool A0, SourceInfo L) {
15113 return emitOp<bool>(OP_DecPopUint64, A0, L);
15114}
15115bool ByteCodeEmitter::emitDecPopIntAP( bool A0, SourceInfo L) {
15116 return emitOp<bool>(OP_DecPopIntAP, A0, L);
15117}
15118bool ByteCodeEmitter::emitDecPopIntAPS( bool A0, SourceInfo L) {
15119 return emitOp<bool>(OP_DecPopIntAPS, A0, L);
15120}
15121bool ByteCodeEmitter::emitDecPopBool( bool A0, SourceInfo L) {
15122 return emitOp<bool>(OP_DecPopBool, A0, L);
15123}
15124bool ByteCodeEmitter::emitDecPopFixedPoint( bool A0, SourceInfo L) {
15125 return emitOp<bool>(OP_DecPopFixedPoint, A0, L);
15126}
15127#endif
15128#ifdef GET_EVAL_IMPL
15129bool EvalEmitter::emitDecPopSint8( bool A0, SourceInfo L) {
15130 if (!isActive()) return true;
15131 CurrentSource = L;
15132 return DecPop<PT_Sint8>(S, CodePtr(), A0);
15133}
15134bool EvalEmitter::emitDecPopUint8( bool A0, SourceInfo L) {
15135 if (!isActive()) return true;
15136 CurrentSource = L;
15137 return DecPop<PT_Uint8>(S, CodePtr(), A0);
15138}
15139bool EvalEmitter::emitDecPopSint16( bool A0, SourceInfo L) {
15140 if (!isActive()) return true;
15141 CurrentSource = L;
15142 return DecPop<PT_Sint16>(S, CodePtr(), A0);
15143}
15144bool EvalEmitter::emitDecPopUint16( bool A0, SourceInfo L) {
15145 if (!isActive()) return true;
15146 CurrentSource = L;
15147 return DecPop<PT_Uint16>(S, CodePtr(), A0);
15148}
15149bool EvalEmitter::emitDecPopSint32( bool A0, SourceInfo L) {
15150 if (!isActive()) return true;
15151 CurrentSource = L;
15152 return DecPop<PT_Sint32>(S, CodePtr(), A0);
15153}
15154bool EvalEmitter::emitDecPopUint32( bool A0, SourceInfo L) {
15155 if (!isActive()) return true;
15156 CurrentSource = L;
15157 return DecPop<PT_Uint32>(S, CodePtr(), A0);
15158}
15159bool EvalEmitter::emitDecPopSint64( bool A0, SourceInfo L) {
15160 if (!isActive()) return true;
15161 CurrentSource = L;
15162 return DecPop<PT_Sint64>(S, CodePtr(), A0);
15163}
15164bool EvalEmitter::emitDecPopUint64( bool A0, SourceInfo L) {
15165 if (!isActive()) return true;
15166 CurrentSource = L;
15167 return DecPop<PT_Uint64>(S, CodePtr(), A0);
15168}
15169bool EvalEmitter::emitDecPopIntAP( bool A0, SourceInfo L) {
15170 if (!isActive()) return true;
15171 CurrentSource = L;
15172 return DecPop<PT_IntAP>(S, CodePtr(), A0);
15173}
15174bool EvalEmitter::emitDecPopIntAPS( bool A0, SourceInfo L) {
15175 if (!isActive()) return true;
15176 CurrentSource = L;
15177 return DecPop<PT_IntAPS>(S, CodePtr(), A0);
15178}
15179bool EvalEmitter::emitDecPopBool( bool A0, SourceInfo L) {
15180 if (!isActive()) return true;
15181 CurrentSource = L;
15182 return DecPop<PT_Bool>(S, CodePtr(), A0);
15183}
15184bool EvalEmitter::emitDecPopFixedPoint( bool A0, SourceInfo L) {
15185 if (!isActive()) return true;
15186 CurrentSource = L;
15187 return DecPop<PT_FixedPoint>(S, CodePtr(), A0);
15188}
15189#endif
15190#ifdef GET_OPCODE_NAMES
15191OP_DecPopBitfieldSint8,
15192OP_DecPopBitfieldUint8,
15193OP_DecPopBitfieldSint16,
15194OP_DecPopBitfieldUint16,
15195OP_DecPopBitfieldSint32,
15196OP_DecPopBitfieldUint32,
15197OP_DecPopBitfieldSint64,
15198OP_DecPopBitfieldUint64,
15199OP_DecPopBitfieldIntAP,
15200OP_DecPopBitfieldIntAPS,
15201OP_DecPopBitfieldBool,
15202OP_DecPopBitfieldFixedPoint,
15203#endif
15204#ifdef GET_INTERPFN_LIST
15205&Interp_DecPopBitfieldSint8,
15206&Interp_DecPopBitfieldUint8,
15207&Interp_DecPopBitfieldSint16,
15208&Interp_DecPopBitfieldUint16,
15209&Interp_DecPopBitfieldSint32,
15210&Interp_DecPopBitfieldUint32,
15211&Interp_DecPopBitfieldSint64,
15212&Interp_DecPopBitfieldUint64,
15213&Interp_DecPopBitfieldIntAP,
15214&Interp_DecPopBitfieldIntAPS,
15215&Interp_DecPopBitfieldBool,
15216&Interp_DecPopBitfieldFixedPoint,
15217#endif
15218#ifdef GET_INTERPFN_DISPATCHERS
15219PRESERVE_NONE
15220static bool Interp_DecPopBitfieldSint8(InterpState &S) {
15221 {
15222 CodePtr OpPC = S.PC;
15223 const auto V0 = ReadArg<bool>(S, S.PC);
15224 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15225 if (!DecPopBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
15226 }
15227#if USE_TAILCALLS
15228 MUSTTAIL return InterpNext(S);
15229#else
15230 return true;
15231#endif
15232}
15233PRESERVE_NONE
15234static bool Interp_DecPopBitfieldUint8(InterpState &S) {
15235 {
15236 CodePtr OpPC = S.PC;
15237 const auto V0 = ReadArg<bool>(S, S.PC);
15238 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15239 if (!DecPopBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
15240 }
15241#if USE_TAILCALLS
15242 MUSTTAIL return InterpNext(S);
15243#else
15244 return true;
15245#endif
15246}
15247PRESERVE_NONE
15248static bool Interp_DecPopBitfieldSint16(InterpState &S) {
15249 {
15250 CodePtr OpPC = S.PC;
15251 const auto V0 = ReadArg<bool>(S, S.PC);
15252 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15253 if (!DecPopBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
15254 }
15255#if USE_TAILCALLS
15256 MUSTTAIL return InterpNext(S);
15257#else
15258 return true;
15259#endif
15260}
15261PRESERVE_NONE
15262static bool Interp_DecPopBitfieldUint16(InterpState &S) {
15263 {
15264 CodePtr OpPC = S.PC;
15265 const auto V0 = ReadArg<bool>(S, S.PC);
15266 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15267 if (!DecPopBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
15268 }
15269#if USE_TAILCALLS
15270 MUSTTAIL return InterpNext(S);
15271#else
15272 return true;
15273#endif
15274}
15275PRESERVE_NONE
15276static bool Interp_DecPopBitfieldSint32(InterpState &S) {
15277 {
15278 CodePtr OpPC = S.PC;
15279 const auto V0 = ReadArg<bool>(S, S.PC);
15280 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15281 if (!DecPopBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
15282 }
15283#if USE_TAILCALLS
15284 MUSTTAIL return InterpNext(S);
15285#else
15286 return true;
15287#endif
15288}
15289PRESERVE_NONE
15290static bool Interp_DecPopBitfieldUint32(InterpState &S) {
15291 {
15292 CodePtr OpPC = S.PC;
15293 const auto V0 = ReadArg<bool>(S, S.PC);
15294 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15295 if (!DecPopBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
15296 }
15297#if USE_TAILCALLS
15298 MUSTTAIL return InterpNext(S);
15299#else
15300 return true;
15301#endif
15302}
15303PRESERVE_NONE
15304static bool Interp_DecPopBitfieldSint64(InterpState &S) {
15305 {
15306 CodePtr OpPC = S.PC;
15307 const auto V0 = ReadArg<bool>(S, S.PC);
15308 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15309 if (!DecPopBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
15310 }
15311#if USE_TAILCALLS
15312 MUSTTAIL return InterpNext(S);
15313#else
15314 return true;
15315#endif
15316}
15317PRESERVE_NONE
15318static bool Interp_DecPopBitfieldUint64(InterpState &S) {
15319 {
15320 CodePtr OpPC = S.PC;
15321 const auto V0 = ReadArg<bool>(S, S.PC);
15322 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15323 if (!DecPopBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
15324 }
15325#if USE_TAILCALLS
15326 MUSTTAIL return InterpNext(S);
15327#else
15328 return true;
15329#endif
15330}
15331PRESERVE_NONE
15332static bool Interp_DecPopBitfieldIntAP(InterpState &S) {
15333 {
15334 CodePtr OpPC = S.PC;
15335 const auto V0 = ReadArg<bool>(S, S.PC);
15336 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15337 if (!DecPopBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
15338 }
15339#if USE_TAILCALLS
15340 MUSTTAIL return InterpNext(S);
15341#else
15342 return true;
15343#endif
15344}
15345PRESERVE_NONE
15346static bool Interp_DecPopBitfieldIntAPS(InterpState &S) {
15347 {
15348 CodePtr OpPC = S.PC;
15349 const auto V0 = ReadArg<bool>(S, S.PC);
15350 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15351 if (!DecPopBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
15352 }
15353#if USE_TAILCALLS
15354 MUSTTAIL return InterpNext(S);
15355#else
15356 return true;
15357#endif
15358}
15359PRESERVE_NONE
15360static bool Interp_DecPopBitfieldBool(InterpState &S) {
15361 {
15362 CodePtr OpPC = S.PC;
15363 const auto V0 = ReadArg<bool>(S, S.PC);
15364 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15365 if (!DecPopBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
15366 }
15367#if USE_TAILCALLS
15368 MUSTTAIL return InterpNext(S);
15369#else
15370 return true;
15371#endif
15372}
15373PRESERVE_NONE
15374static bool Interp_DecPopBitfieldFixedPoint(InterpState &S) {
15375 {
15376 CodePtr OpPC = S.PC;
15377 const auto V0 = ReadArg<bool>(S, S.PC);
15378 const auto V1 = ReadArg<uint32_t>(S, S.PC);
15379 if (!DecPopBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
15380 }
15381#if USE_TAILCALLS
15382 MUSTTAIL return InterpNext(S);
15383#else
15384 return true;
15385#endif
15386}
15387#endif
15388#ifdef GET_DISASM
15389case OP_DecPopBitfieldSint8:
15390 Text.Op = PrintName("DecPopBitfieldSint8");
15391 Text.Args.push_back(printArg<bool>(PC));
15392 Text.Args.push_back(printArg<uint32_t>(PC));
15393 break;
15394case OP_DecPopBitfieldUint8:
15395 Text.Op = PrintName("DecPopBitfieldUint8");
15396 Text.Args.push_back(printArg<bool>(PC));
15397 Text.Args.push_back(printArg<uint32_t>(PC));
15398 break;
15399case OP_DecPopBitfieldSint16:
15400 Text.Op = PrintName("DecPopBitfieldSint16");
15401 Text.Args.push_back(printArg<bool>(PC));
15402 Text.Args.push_back(printArg<uint32_t>(PC));
15403 break;
15404case OP_DecPopBitfieldUint16:
15405 Text.Op = PrintName("DecPopBitfieldUint16");
15406 Text.Args.push_back(printArg<bool>(PC));
15407 Text.Args.push_back(printArg<uint32_t>(PC));
15408 break;
15409case OP_DecPopBitfieldSint32:
15410 Text.Op = PrintName("DecPopBitfieldSint32");
15411 Text.Args.push_back(printArg<bool>(PC));
15412 Text.Args.push_back(printArg<uint32_t>(PC));
15413 break;
15414case OP_DecPopBitfieldUint32:
15415 Text.Op = PrintName("DecPopBitfieldUint32");
15416 Text.Args.push_back(printArg<bool>(PC));
15417 Text.Args.push_back(printArg<uint32_t>(PC));
15418 break;
15419case OP_DecPopBitfieldSint64:
15420 Text.Op = PrintName("DecPopBitfieldSint64");
15421 Text.Args.push_back(printArg<bool>(PC));
15422 Text.Args.push_back(printArg<uint32_t>(PC));
15423 break;
15424case OP_DecPopBitfieldUint64:
15425 Text.Op = PrintName("DecPopBitfieldUint64");
15426 Text.Args.push_back(printArg<bool>(PC));
15427 Text.Args.push_back(printArg<uint32_t>(PC));
15428 break;
15429case OP_DecPopBitfieldIntAP:
15430 Text.Op = PrintName("DecPopBitfieldIntAP");
15431 Text.Args.push_back(printArg<bool>(PC));
15432 Text.Args.push_back(printArg<uint32_t>(PC));
15433 break;
15434case OP_DecPopBitfieldIntAPS:
15435 Text.Op = PrintName("DecPopBitfieldIntAPS");
15436 Text.Args.push_back(printArg<bool>(PC));
15437 Text.Args.push_back(printArg<uint32_t>(PC));
15438 break;
15439case OP_DecPopBitfieldBool:
15440 Text.Op = PrintName("DecPopBitfieldBool");
15441 Text.Args.push_back(printArg<bool>(PC));
15442 Text.Args.push_back(printArg<uint32_t>(PC));
15443 break;
15444case OP_DecPopBitfieldFixedPoint:
15445 Text.Op = PrintName("DecPopBitfieldFixedPoint");
15446 Text.Args.push_back(printArg<bool>(PC));
15447 Text.Args.push_back(printArg<uint32_t>(PC));
15448 break;
15449#endif
15450#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15451bool emitDecPopBitfieldSint8( bool , uint32_t , SourceInfo);
15452bool emitDecPopBitfieldUint8( bool , uint32_t , SourceInfo);
15453bool emitDecPopBitfieldSint16( bool , uint32_t , SourceInfo);
15454bool emitDecPopBitfieldUint16( bool , uint32_t , SourceInfo);
15455bool emitDecPopBitfieldSint32( bool , uint32_t , SourceInfo);
15456bool emitDecPopBitfieldUint32( bool , uint32_t , SourceInfo);
15457bool emitDecPopBitfieldSint64( bool , uint32_t , SourceInfo);
15458bool emitDecPopBitfieldUint64( bool , uint32_t , SourceInfo);
15459bool emitDecPopBitfieldIntAP( bool , uint32_t , SourceInfo);
15460bool emitDecPopBitfieldIntAPS( bool , uint32_t , SourceInfo);
15461bool emitDecPopBitfieldBool( bool , uint32_t , SourceInfo);
15462bool emitDecPopBitfieldFixedPoint( bool , uint32_t , SourceInfo);
15463#endif
15464#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15465[[nodiscard]] bool emitDecPopBitfield(PrimType, bool, uint32_t, SourceInfo I);
15466#endif
15467#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
15468bool
15469#if defined(GET_EVAL_IMPL)
15470EvalEmitter
15471#else
15472ByteCodeEmitter
15473#endif
15474::emitDecPopBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
15475 switch (T0) {
15476 case PT_Sint8:
15477 return emitDecPopBitfieldSint8(A0, A1, I);
15478 case PT_Uint8:
15479 return emitDecPopBitfieldUint8(A0, A1, I);
15480 case PT_Sint16:
15481 return emitDecPopBitfieldSint16(A0, A1, I);
15482 case PT_Uint16:
15483 return emitDecPopBitfieldUint16(A0, A1, I);
15484 case PT_Sint32:
15485 return emitDecPopBitfieldSint32(A0, A1, I);
15486 case PT_Uint32:
15487 return emitDecPopBitfieldUint32(A0, A1, I);
15488 case PT_Sint64:
15489 return emitDecPopBitfieldSint64(A0, A1, I);
15490 case PT_Uint64:
15491 return emitDecPopBitfieldUint64(A0, A1, I);
15492 case PT_IntAP:
15493 return emitDecPopBitfieldIntAP(A0, A1, I);
15494 case PT_IntAPS:
15495 return emitDecPopBitfieldIntAPS(A0, A1, I);
15496 case PT_Bool:
15497 return emitDecPopBitfieldBool(A0, A1, I);
15498 case PT_FixedPoint:
15499 return emitDecPopBitfieldFixedPoint(A0, A1, I);
15500 default: llvm_unreachable("invalid type: emitDecPopBitfield");
15501 }
15502 llvm_unreachable("invalid enum value");
15503}
15504#endif
15505#ifdef GET_LINK_IMPL
15506bool ByteCodeEmitter::emitDecPopBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
15507 return emitOp<bool, uint32_t>(OP_DecPopBitfieldSint8, A0, A1, L);
15508}
15509bool ByteCodeEmitter::emitDecPopBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
15510 return emitOp<bool, uint32_t>(OP_DecPopBitfieldUint8, A0, A1, L);
15511}
15512bool ByteCodeEmitter::emitDecPopBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
15513 return emitOp<bool, uint32_t>(OP_DecPopBitfieldSint16, A0, A1, L);
15514}
15515bool ByteCodeEmitter::emitDecPopBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
15516 return emitOp<bool, uint32_t>(OP_DecPopBitfieldUint16, A0, A1, L);
15517}
15518bool ByteCodeEmitter::emitDecPopBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
15519 return emitOp<bool, uint32_t>(OP_DecPopBitfieldSint32, A0, A1, L);
15520}
15521bool ByteCodeEmitter::emitDecPopBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
15522 return emitOp<bool, uint32_t>(OP_DecPopBitfieldUint32, A0, A1, L);
15523}
15524bool ByteCodeEmitter::emitDecPopBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
15525 return emitOp<bool, uint32_t>(OP_DecPopBitfieldSint64, A0, A1, L);
15526}
15527bool ByteCodeEmitter::emitDecPopBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
15528 return emitOp<bool, uint32_t>(OP_DecPopBitfieldUint64, A0, A1, L);
15529}
15530bool ByteCodeEmitter::emitDecPopBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
15531 return emitOp<bool, uint32_t>(OP_DecPopBitfieldIntAP, A0, A1, L);
15532}
15533bool ByteCodeEmitter::emitDecPopBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
15534 return emitOp<bool, uint32_t>(OP_DecPopBitfieldIntAPS, A0, A1, L);
15535}
15536bool ByteCodeEmitter::emitDecPopBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
15537 return emitOp<bool, uint32_t>(OP_DecPopBitfieldBool, A0, A1, L);
15538}
15539bool ByteCodeEmitter::emitDecPopBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
15540 return emitOp<bool, uint32_t>(OP_DecPopBitfieldFixedPoint, A0, A1, L);
15541}
15542#endif
15543#ifdef GET_EVAL_IMPL
15544bool EvalEmitter::emitDecPopBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
15545 if (!isActive()) return true;
15546 CurrentSource = L;
15547 return DecPopBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
15548}
15549bool EvalEmitter::emitDecPopBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
15550 if (!isActive()) return true;
15551 CurrentSource = L;
15552 return DecPopBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
15553}
15554bool EvalEmitter::emitDecPopBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
15555 if (!isActive()) return true;
15556 CurrentSource = L;
15557 return DecPopBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
15558}
15559bool EvalEmitter::emitDecPopBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
15560 if (!isActive()) return true;
15561 CurrentSource = L;
15562 return DecPopBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
15563}
15564bool EvalEmitter::emitDecPopBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
15565 if (!isActive()) return true;
15566 CurrentSource = L;
15567 return DecPopBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
15568}
15569bool EvalEmitter::emitDecPopBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
15570 if (!isActive()) return true;
15571 CurrentSource = L;
15572 return DecPopBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
15573}
15574bool EvalEmitter::emitDecPopBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
15575 if (!isActive()) return true;
15576 CurrentSource = L;
15577 return DecPopBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
15578}
15579bool EvalEmitter::emitDecPopBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
15580 if (!isActive()) return true;
15581 CurrentSource = L;
15582 return DecPopBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
15583}
15584bool EvalEmitter::emitDecPopBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
15585 if (!isActive()) return true;
15586 CurrentSource = L;
15587 return DecPopBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
15588}
15589bool EvalEmitter::emitDecPopBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
15590 if (!isActive()) return true;
15591 CurrentSource = L;
15592 return DecPopBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
15593}
15594bool EvalEmitter::emitDecPopBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
15595 if (!isActive()) return true;
15596 CurrentSource = L;
15597 return DecPopBitfield<PT_Bool>(S, CodePtr(), A0, A1);
15598}
15599bool EvalEmitter::emitDecPopBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
15600 if (!isActive()) return true;
15601 CurrentSource = L;
15602 return DecPopBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
15603}
15604#endif
15605#ifdef GET_OPCODE_NAMES
15606OP_DecPtr,
15607#endif
15608#ifdef GET_INTERPFN_LIST
15609&Interp_DecPtr,
15610#endif
15611#ifdef GET_INTERPFN_DISPATCHERS
15612PRESERVE_NONE
15613static bool Interp_DecPtr(InterpState &S) {
15614 if (!DecPtr(S, S.PC)) return false;
15615#if USE_TAILCALLS
15616 MUSTTAIL return InterpNext(S);
15617#else
15618 return true;
15619#endif
15620}
15621#endif
15622#ifdef GET_DISASM
15623case OP_DecPtr:
15624 Text.Op = PrintName("DecPtr");
15625 break;
15626#endif
15627#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15628bool emitDecPtr(SourceInfo);
15629#endif
15630#ifdef GET_LINK_IMPL
15631bool ByteCodeEmitter::emitDecPtr(SourceInfo L) {
15632 return emitOp<>(OP_DecPtr, L);
15633}
15634#endif
15635#ifdef GET_EVAL_IMPL
15636bool EvalEmitter::emitDecPtr(SourceInfo L) {
15637 if (!isActive()) return true;
15638 CurrentSource = L;
15639 return DecPtr(S, CodePtr());
15640}
15641#endif
15642#ifdef GET_OPCODE_NAMES
15643OP_DecayPtrPtrPtr,
15644OP_DecayPtrPtrMemberPtr,
15645OP_DecayPtrMemberPtrPtr,
15646OP_DecayPtrMemberPtrMemberPtr,
15647#endif
15648#ifdef GET_INTERPFN_LIST
15649&Interp_DecayPtrPtrPtr,
15650&Interp_DecayPtrPtrMemberPtr,
15651&Interp_DecayPtrMemberPtrPtr,
15652&Interp_DecayPtrMemberPtrMemberPtr,
15653#endif
15654#ifdef GET_INTERPFN_DISPATCHERS
15655PRESERVE_NONE
15656static bool Interp_DecayPtrPtrPtr(InterpState &S) {
15657 if (!DecayPtr<PT_Ptr, PT_Ptr>(S)) return false;
15658#if USE_TAILCALLS
15659 MUSTTAIL return InterpNext(S);
15660#else
15661 return true;
15662#endif
15663}
15664PRESERVE_NONE
15665static bool Interp_DecayPtrPtrMemberPtr(InterpState &S) {
15666 if (!DecayPtr<PT_Ptr, PT_MemberPtr>(S)) return false;
15667#if USE_TAILCALLS
15668 MUSTTAIL return InterpNext(S);
15669#else
15670 return true;
15671#endif
15672}
15673PRESERVE_NONE
15674static bool Interp_DecayPtrMemberPtrPtr(InterpState &S) {
15675 if (!DecayPtr<PT_MemberPtr, PT_Ptr>(S)) return false;
15676#if USE_TAILCALLS
15677 MUSTTAIL return InterpNext(S);
15678#else
15679 return true;
15680#endif
15681}
15682PRESERVE_NONE
15683static bool Interp_DecayPtrMemberPtrMemberPtr(InterpState &S) {
15684 if (!DecayPtr<PT_MemberPtr, PT_MemberPtr>(S)) return false;
15685#if USE_TAILCALLS
15686 MUSTTAIL return InterpNext(S);
15687#else
15688 return true;
15689#endif
15690}
15691#endif
15692#ifdef GET_DISASM
15693case OP_DecayPtrPtrPtr:
15694 Text.Op = PrintName("DecayPtrPtrPtr");
15695 break;
15696case OP_DecayPtrPtrMemberPtr:
15697 Text.Op = PrintName("DecayPtrPtrMemberPtr");
15698 break;
15699case OP_DecayPtrMemberPtrPtr:
15700 Text.Op = PrintName("DecayPtrMemberPtrPtr");
15701 break;
15702case OP_DecayPtrMemberPtrMemberPtr:
15703 Text.Op = PrintName("DecayPtrMemberPtrMemberPtr");
15704 break;
15705#endif
15706#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15707bool emitDecayPtrPtrPtr(SourceInfo);
15708bool emitDecayPtrPtrMemberPtr(SourceInfo);
15709bool emitDecayPtrMemberPtrPtr(SourceInfo);
15710bool emitDecayPtrMemberPtrMemberPtr(SourceInfo);
15711#endif
15712#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15713[[nodiscard]] bool emitDecayPtr(PrimType, PrimType, SourceInfo I);
15714#endif
15715#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
15716bool
15717#if defined(GET_EVAL_IMPL)
15718EvalEmitter
15719#else
15720ByteCodeEmitter
15721#endif
15722::emitDecayPtr(PrimType T0, PrimType T1, SourceInfo I) {
15723 switch (T0) {
15724 case PT_Ptr:
15725 switch (T1) {
15726 case PT_Ptr:
15727 return emitDecayPtrPtrPtr(I);
15728 case PT_MemberPtr:
15729 return emitDecayPtrPtrMemberPtr(I);
15730 default: llvm_unreachable("invalid type: emitDecayPtr");
15731 }
15732 llvm_unreachable("invalid enum value");
15733 case PT_MemberPtr:
15734 switch (T1) {
15735 case PT_Ptr:
15736 return emitDecayPtrMemberPtrPtr(I);
15737 case PT_MemberPtr:
15738 return emitDecayPtrMemberPtrMemberPtr(I);
15739 default: llvm_unreachable("invalid type: emitDecayPtr");
15740 }
15741 llvm_unreachable("invalid enum value");
15742 default: llvm_unreachable("invalid type: emitDecayPtr");
15743 }
15744 llvm_unreachable("invalid enum value");
15745}
15746#endif
15747#ifdef GET_LINK_IMPL
15748bool ByteCodeEmitter::emitDecayPtrPtrPtr(SourceInfo L) {
15749 return emitOp<>(OP_DecayPtrPtrPtr, L);
15750}
15751bool ByteCodeEmitter::emitDecayPtrPtrMemberPtr(SourceInfo L) {
15752 return emitOp<>(OP_DecayPtrPtrMemberPtr, L);
15753}
15754bool ByteCodeEmitter::emitDecayPtrMemberPtrPtr(SourceInfo L) {
15755 return emitOp<>(OP_DecayPtrMemberPtrPtr, L);
15756}
15757bool ByteCodeEmitter::emitDecayPtrMemberPtrMemberPtr(SourceInfo L) {
15758 return emitOp<>(OP_DecayPtrMemberPtrMemberPtr, L);
15759}
15760#endif
15761#ifdef GET_EVAL_IMPL
15762bool EvalEmitter::emitDecayPtrPtrPtr(SourceInfo L) {
15763 if (!isActive()) return true;
15764 CurrentSource = L;
15765 return DecayPtr<PT_Ptr, PT_Ptr>(S);
15766}
15767bool EvalEmitter::emitDecayPtrPtrMemberPtr(SourceInfo L) {
15768 if (!isActive()) return true;
15769 CurrentSource = L;
15770 return DecayPtr<PT_Ptr, PT_MemberPtr>(S);
15771}
15772bool EvalEmitter::emitDecayPtrMemberPtrPtr(SourceInfo L) {
15773 if (!isActive()) return true;
15774 CurrentSource = L;
15775 return DecayPtr<PT_MemberPtr, PT_Ptr>(S);
15776}
15777bool EvalEmitter::emitDecayPtrMemberPtrMemberPtr(SourceInfo L) {
15778 if (!isActive()) return true;
15779 CurrentSource = L;
15780 return DecayPtr<PT_MemberPtr, PT_MemberPtr>(S);
15781}
15782#endif
15783#ifdef GET_OPCODE_NAMES
15784OP_Decf,
15785#endif
15786#ifdef GET_INTERPFN_LIST
15787&Interp_Decf,
15788#endif
15789#ifdef GET_INTERPFN_DISPATCHERS
15790PRESERVE_NONE
15791static bool Interp_Decf(InterpState &S) {
15792 {
15793 CodePtr OpPC = S.PC;
15794 const auto V0 = ReadArg<uint32_t>(S, S.PC);
15795 if (!Decf(S, OpPC, V0)) return false;
15796 }
15797#if USE_TAILCALLS
15798 MUSTTAIL return InterpNext(S);
15799#else
15800 return true;
15801#endif
15802}
15803#endif
15804#ifdef GET_DISASM
15805case OP_Decf:
15806 Text.Op = PrintName("Decf");
15807 Text.Args.push_back(printArg<uint32_t>(PC));
15808 break;
15809#endif
15810#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15811bool emitDecf( uint32_t , SourceInfo);
15812#endif
15813#ifdef GET_LINK_IMPL
15814bool ByteCodeEmitter::emitDecf( uint32_t A0, SourceInfo L) {
15815 return emitOp<uint32_t>(OP_Decf, A0, L);
15816}
15817#endif
15818#ifdef GET_EVAL_IMPL
15819bool EvalEmitter::emitDecf( uint32_t A0, SourceInfo L) {
15820 if (!isActive()) return true;
15821 CurrentSource = L;
15822 return Decf(S, CodePtr(), A0);
15823}
15824#endif
15825#ifdef GET_OPCODE_NAMES
15826OP_DecfPop,
15827#endif
15828#ifdef GET_INTERPFN_LIST
15829&Interp_DecfPop,
15830#endif
15831#ifdef GET_INTERPFN_DISPATCHERS
15832PRESERVE_NONE
15833static bool Interp_DecfPop(InterpState &S) {
15834 {
15835 CodePtr OpPC = S.PC;
15836 const auto V0 = ReadArg<uint32_t>(S, S.PC);
15837 if (!DecfPop(S, OpPC, V0)) return false;
15838 }
15839#if USE_TAILCALLS
15840 MUSTTAIL return InterpNext(S);
15841#else
15842 return true;
15843#endif
15844}
15845#endif
15846#ifdef GET_DISASM
15847case OP_DecfPop:
15848 Text.Op = PrintName("DecfPop");
15849 Text.Args.push_back(printArg<uint32_t>(PC));
15850 break;
15851#endif
15852#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15853bool emitDecfPop( uint32_t , SourceInfo);
15854#endif
15855#ifdef GET_LINK_IMPL
15856bool ByteCodeEmitter::emitDecfPop( uint32_t A0, SourceInfo L) {
15857 return emitOp<uint32_t>(OP_DecfPop, A0, L);
15858}
15859#endif
15860#ifdef GET_EVAL_IMPL
15861bool EvalEmitter::emitDecfPop( uint32_t A0, SourceInfo L) {
15862 if (!isActive()) return true;
15863 CurrentSource = L;
15864 return DecfPop(S, CodePtr(), A0);
15865}
15866#endif
15867#ifdef GET_OPCODE_NAMES
15868OP_DefaultInit,
15869#endif
15870#ifdef GET_INTERPFN_LIST
15871&Interp_DefaultInit,
15872#endif
15873#ifdef GET_INTERPFN_DISPATCHERS
15874PRESERVE_NONE
15875static bool Interp_DefaultInit(InterpState &S) {
15876 {
15877 CodePtr OpPC = S.PC;
15878 const auto V0 = ReadArg<const CXXConstructorDecl *>(S, S.PC);
15879 if (!DefaultInit(S, OpPC, V0)) return false;
15880 }
15881#if USE_TAILCALLS
15882 MUSTTAIL return InterpNext(S);
15883#else
15884 return true;
15885#endif
15886}
15887#endif
15888#ifdef GET_DISASM
15889case OP_DefaultInit:
15890 Text.Op = PrintName("DefaultInit");
15891 Text.Args.push_back(printArg<const CXXConstructorDecl *>(PC));
15892 break;
15893#endif
15894#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15895bool emitDefaultInit( const CXXConstructorDecl * , SourceInfo);
15896#endif
15897#ifdef GET_LINK_IMPL
15898bool ByteCodeEmitter::emitDefaultInit( const CXXConstructorDecl * A0, SourceInfo L) {
15899 return emitOp<const CXXConstructorDecl *>(OP_DefaultInit, A0, L);
15900}
15901#endif
15902#ifdef GET_EVAL_IMPL
15903bool EvalEmitter::emitDefaultInit( const CXXConstructorDecl * A0, SourceInfo L) {
15904 if (!isActive()) return true;
15905 CurrentSource = L;
15906 return DefaultInit(S, CodePtr(), A0);
15907}
15908#endif
15909#ifdef GET_OPCODE_NAMES
15910OP_Destroy,
15911#endif
15912#ifdef GET_INTERPFN_LIST
15913&Interp_Destroy,
15914#endif
15915#ifdef GET_INTERPFN_DISPATCHERS
15916PRESERVE_NONE
15917static bool Interp_Destroy(InterpState &S) {
15918 {
15919 CodePtr OpPC = S.PC;
15920 const auto V0 = ReadArg<uint32_t>(S, S.PC);
15921 if (!Destroy(S, OpPC, V0)) return false;
15922 }
15923#if USE_TAILCALLS
15924 MUSTTAIL return InterpNext(S);
15925#else
15926 return true;
15927#endif
15928}
15929#endif
15930#ifdef GET_DISASM
15931case OP_Destroy:
15932 Text.Op = PrintName("Destroy");
15933 Text.Args.push_back(printArg<uint32_t>(PC));
15934 break;
15935#endif
15936#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15937bool emitDestroy( uint32_t , SourceInfo);
15938#endif
15939#ifdef GET_LINK_IMPL
15940bool ByteCodeEmitter::emitDestroy( uint32_t A0, SourceInfo L) {
15941 return emitOp<uint32_t>(OP_Destroy, A0, L);
15942}
15943#endif
15944#ifdef GET_OPCODE_NAMES
15945OP_DiagTypeid,
15946#endif
15947#ifdef GET_INTERPFN_LIST
15948&Interp_DiagTypeid,
15949#endif
15950#ifdef GET_INTERPFN_DISPATCHERS
15951PRESERVE_NONE
15952static bool Interp_DiagTypeid(InterpState &S) {
15953 if (!DiagTypeid(S, S.PC)) return false;
15954#if USE_TAILCALLS
15955 MUSTTAIL return InterpNext(S);
15956#else
15957 return true;
15958#endif
15959}
15960#endif
15961#ifdef GET_DISASM
15962case OP_DiagTypeid:
15963 Text.Op = PrintName("DiagTypeid");
15964 break;
15965#endif
15966#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
15967bool emitDiagTypeid(SourceInfo);
15968#endif
15969#ifdef GET_LINK_IMPL
15970bool ByteCodeEmitter::emitDiagTypeid(SourceInfo L) {
15971 return emitOp<>(OP_DiagTypeid, L);
15972}
15973#endif
15974#ifdef GET_EVAL_IMPL
15975bool EvalEmitter::emitDiagTypeid(SourceInfo L) {
15976 if (!isActive()) return true;
15977 CurrentSource = L;
15978 return DiagTypeid(S, CodePtr());
15979}
15980#endif
15981#ifdef GET_OPCODE_NAMES
15982OP_DivSint8,
15983OP_DivUint8,
15984OP_DivSint16,
15985OP_DivUint16,
15986OP_DivSint32,
15987OP_DivUint32,
15988OP_DivSint64,
15989OP_DivUint64,
15990OP_DivIntAP,
15991OP_DivIntAPS,
15992OP_DivFixedPoint,
15993#endif
15994#ifdef GET_INTERPFN_LIST
15995&Interp_DivSint8,
15996&Interp_DivUint8,
15997&Interp_DivSint16,
15998&Interp_DivUint16,
15999&Interp_DivSint32,
16000&Interp_DivUint32,
16001&Interp_DivSint64,
16002&Interp_DivUint64,
16003&Interp_DivIntAP,
16004&Interp_DivIntAPS,
16005&Interp_DivFixedPoint,
16006#endif
16007#ifdef GET_INTERPFN_DISPATCHERS
16008PRESERVE_NONE
16009static bool Interp_DivSint8(InterpState &S) {
16010 if (!Div<PT_Sint8>(S, S.PC)) return false;
16011#if USE_TAILCALLS
16012 MUSTTAIL return InterpNext(S);
16013#else
16014 return true;
16015#endif
16016}
16017PRESERVE_NONE
16018static bool Interp_DivUint8(InterpState &S) {
16019 if (!Div<PT_Uint8>(S, S.PC)) return false;
16020#if USE_TAILCALLS
16021 MUSTTAIL return InterpNext(S);
16022#else
16023 return true;
16024#endif
16025}
16026PRESERVE_NONE
16027static bool Interp_DivSint16(InterpState &S) {
16028 if (!Div<PT_Sint16>(S, S.PC)) return false;
16029#if USE_TAILCALLS
16030 MUSTTAIL return InterpNext(S);
16031#else
16032 return true;
16033#endif
16034}
16035PRESERVE_NONE
16036static bool Interp_DivUint16(InterpState &S) {
16037 if (!Div<PT_Uint16>(S, S.PC)) return false;
16038#if USE_TAILCALLS
16039 MUSTTAIL return InterpNext(S);
16040#else
16041 return true;
16042#endif
16043}
16044PRESERVE_NONE
16045static bool Interp_DivSint32(InterpState &S) {
16046 if (!Div<PT_Sint32>(S, S.PC)) return false;
16047#if USE_TAILCALLS
16048 MUSTTAIL return InterpNext(S);
16049#else
16050 return true;
16051#endif
16052}
16053PRESERVE_NONE
16054static bool Interp_DivUint32(InterpState &S) {
16055 if (!Div<PT_Uint32>(S, S.PC)) return false;
16056#if USE_TAILCALLS
16057 MUSTTAIL return InterpNext(S);
16058#else
16059 return true;
16060#endif
16061}
16062PRESERVE_NONE
16063static bool Interp_DivSint64(InterpState &S) {
16064 if (!Div<PT_Sint64>(S, S.PC)) return false;
16065#if USE_TAILCALLS
16066 MUSTTAIL return InterpNext(S);
16067#else
16068 return true;
16069#endif
16070}
16071PRESERVE_NONE
16072static bool Interp_DivUint64(InterpState &S) {
16073 if (!Div<PT_Uint64>(S, S.PC)) return false;
16074#if USE_TAILCALLS
16075 MUSTTAIL return InterpNext(S);
16076#else
16077 return true;
16078#endif
16079}
16080PRESERVE_NONE
16081static bool Interp_DivIntAP(InterpState &S) {
16082 if (!Div<PT_IntAP>(S, S.PC)) return false;
16083#if USE_TAILCALLS
16084 MUSTTAIL return InterpNext(S);
16085#else
16086 return true;
16087#endif
16088}
16089PRESERVE_NONE
16090static bool Interp_DivIntAPS(InterpState &S) {
16091 if (!Div<PT_IntAPS>(S, S.PC)) return false;
16092#if USE_TAILCALLS
16093 MUSTTAIL return InterpNext(S);
16094#else
16095 return true;
16096#endif
16097}
16098PRESERVE_NONE
16099static bool Interp_DivFixedPoint(InterpState &S) {
16100 if (!Div<PT_FixedPoint>(S, S.PC)) return false;
16101#if USE_TAILCALLS
16102 MUSTTAIL return InterpNext(S);
16103#else
16104 return true;
16105#endif
16106}
16107#endif
16108#ifdef GET_DISASM
16109case OP_DivSint8:
16110 Text.Op = PrintName("DivSint8");
16111 break;
16112case OP_DivUint8:
16113 Text.Op = PrintName("DivUint8");
16114 break;
16115case OP_DivSint16:
16116 Text.Op = PrintName("DivSint16");
16117 break;
16118case OP_DivUint16:
16119 Text.Op = PrintName("DivUint16");
16120 break;
16121case OP_DivSint32:
16122 Text.Op = PrintName("DivSint32");
16123 break;
16124case OP_DivUint32:
16125 Text.Op = PrintName("DivUint32");
16126 break;
16127case OP_DivSint64:
16128 Text.Op = PrintName("DivSint64");
16129 break;
16130case OP_DivUint64:
16131 Text.Op = PrintName("DivUint64");
16132 break;
16133case OP_DivIntAP:
16134 Text.Op = PrintName("DivIntAP");
16135 break;
16136case OP_DivIntAPS:
16137 Text.Op = PrintName("DivIntAPS");
16138 break;
16139case OP_DivFixedPoint:
16140 Text.Op = PrintName("DivFixedPoint");
16141 break;
16142#endif
16143#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16144bool emitDivSint8(SourceInfo);
16145bool emitDivUint8(SourceInfo);
16146bool emitDivSint16(SourceInfo);
16147bool emitDivUint16(SourceInfo);
16148bool emitDivSint32(SourceInfo);
16149bool emitDivUint32(SourceInfo);
16150bool emitDivSint64(SourceInfo);
16151bool emitDivUint64(SourceInfo);
16152bool emitDivIntAP(SourceInfo);
16153bool emitDivIntAPS(SourceInfo);
16154bool emitDivFixedPoint(SourceInfo);
16155#endif
16156#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16157[[nodiscard]] bool emitDiv(PrimType, SourceInfo I);
16158#endif
16159#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
16160bool
16161#if defined(GET_EVAL_IMPL)
16162EvalEmitter
16163#else
16164ByteCodeEmitter
16165#endif
16166::emitDiv(PrimType T0, SourceInfo I) {
16167 switch (T0) {
16168 case PT_Sint8:
16169 return emitDivSint8(I);
16170 case PT_Uint8:
16171 return emitDivUint8(I);
16172 case PT_Sint16:
16173 return emitDivSint16(I);
16174 case PT_Uint16:
16175 return emitDivUint16(I);
16176 case PT_Sint32:
16177 return emitDivSint32(I);
16178 case PT_Uint32:
16179 return emitDivUint32(I);
16180 case PT_Sint64:
16181 return emitDivSint64(I);
16182 case PT_Uint64:
16183 return emitDivUint64(I);
16184 case PT_IntAP:
16185 return emitDivIntAP(I);
16186 case PT_IntAPS:
16187 return emitDivIntAPS(I);
16188 case PT_FixedPoint:
16189 return emitDivFixedPoint(I);
16190 default: llvm_unreachable("invalid type: emitDiv");
16191 }
16192 llvm_unreachable("invalid enum value");
16193}
16194#endif
16195#ifdef GET_LINK_IMPL
16196bool ByteCodeEmitter::emitDivSint8(SourceInfo L) {
16197 return emitOp<>(OP_DivSint8, L);
16198}
16199bool ByteCodeEmitter::emitDivUint8(SourceInfo L) {
16200 return emitOp<>(OP_DivUint8, L);
16201}
16202bool ByteCodeEmitter::emitDivSint16(SourceInfo L) {
16203 return emitOp<>(OP_DivSint16, L);
16204}
16205bool ByteCodeEmitter::emitDivUint16(SourceInfo L) {
16206 return emitOp<>(OP_DivUint16, L);
16207}
16208bool ByteCodeEmitter::emitDivSint32(SourceInfo L) {
16209 return emitOp<>(OP_DivSint32, L);
16210}
16211bool ByteCodeEmitter::emitDivUint32(SourceInfo L) {
16212 return emitOp<>(OP_DivUint32, L);
16213}
16214bool ByteCodeEmitter::emitDivSint64(SourceInfo L) {
16215 return emitOp<>(OP_DivSint64, L);
16216}
16217bool ByteCodeEmitter::emitDivUint64(SourceInfo L) {
16218 return emitOp<>(OP_DivUint64, L);
16219}
16220bool ByteCodeEmitter::emitDivIntAP(SourceInfo L) {
16221 return emitOp<>(OP_DivIntAP, L);
16222}
16223bool ByteCodeEmitter::emitDivIntAPS(SourceInfo L) {
16224 return emitOp<>(OP_DivIntAPS, L);
16225}
16226bool ByteCodeEmitter::emitDivFixedPoint(SourceInfo L) {
16227 return emitOp<>(OP_DivFixedPoint, L);
16228}
16229#endif
16230#ifdef GET_EVAL_IMPL
16231bool EvalEmitter::emitDivSint8(SourceInfo L) {
16232 if (!isActive()) return true;
16233 CurrentSource = L;
16234 return Div<PT_Sint8>(S, CodePtr());
16235}
16236bool EvalEmitter::emitDivUint8(SourceInfo L) {
16237 if (!isActive()) return true;
16238 CurrentSource = L;
16239 return Div<PT_Uint8>(S, CodePtr());
16240}
16241bool EvalEmitter::emitDivSint16(SourceInfo L) {
16242 if (!isActive()) return true;
16243 CurrentSource = L;
16244 return Div<PT_Sint16>(S, CodePtr());
16245}
16246bool EvalEmitter::emitDivUint16(SourceInfo L) {
16247 if (!isActive()) return true;
16248 CurrentSource = L;
16249 return Div<PT_Uint16>(S, CodePtr());
16250}
16251bool EvalEmitter::emitDivSint32(SourceInfo L) {
16252 if (!isActive()) return true;
16253 CurrentSource = L;
16254 return Div<PT_Sint32>(S, CodePtr());
16255}
16256bool EvalEmitter::emitDivUint32(SourceInfo L) {
16257 if (!isActive()) return true;
16258 CurrentSource = L;
16259 return Div<PT_Uint32>(S, CodePtr());
16260}
16261bool EvalEmitter::emitDivSint64(SourceInfo L) {
16262 if (!isActive()) return true;
16263 CurrentSource = L;
16264 return Div<PT_Sint64>(S, CodePtr());
16265}
16266bool EvalEmitter::emitDivUint64(SourceInfo L) {
16267 if (!isActive()) return true;
16268 CurrentSource = L;
16269 return Div<PT_Uint64>(S, CodePtr());
16270}
16271bool EvalEmitter::emitDivIntAP(SourceInfo L) {
16272 if (!isActive()) return true;
16273 CurrentSource = L;
16274 return Div<PT_IntAP>(S, CodePtr());
16275}
16276bool EvalEmitter::emitDivIntAPS(SourceInfo L) {
16277 if (!isActive()) return true;
16278 CurrentSource = L;
16279 return Div<PT_IntAPS>(S, CodePtr());
16280}
16281bool EvalEmitter::emitDivFixedPoint(SourceInfo L) {
16282 if (!isActive()) return true;
16283 CurrentSource = L;
16284 return Div<PT_FixedPoint>(S, CodePtr());
16285}
16286#endif
16287#ifdef GET_OPCODE_NAMES
16288OP_DivcSint8,
16289OP_DivcUint8,
16290OP_DivcSint16,
16291OP_DivcUint16,
16292OP_DivcSint32,
16293OP_DivcUint32,
16294OP_DivcSint64,
16295OP_DivcUint64,
16296OP_DivcIntAP,
16297OP_DivcIntAPS,
16298OP_DivcFloat,
16299#endif
16300#ifdef GET_INTERPFN_LIST
16301&Interp_DivcSint8,
16302&Interp_DivcUint8,
16303&Interp_DivcSint16,
16304&Interp_DivcUint16,
16305&Interp_DivcSint32,
16306&Interp_DivcUint32,
16307&Interp_DivcSint64,
16308&Interp_DivcUint64,
16309&Interp_DivcIntAP,
16310&Interp_DivcIntAPS,
16311&Interp_DivcFloat,
16312#endif
16313#ifdef GET_INTERPFN_DISPATCHERS
16314PRESERVE_NONE
16315static bool Interp_DivcSint8(InterpState &S) {
16316 if (!Divc<PT_Sint8>(S, S.PC)) return false;
16317#if USE_TAILCALLS
16318 MUSTTAIL return InterpNext(S);
16319#else
16320 return true;
16321#endif
16322}
16323PRESERVE_NONE
16324static bool Interp_DivcUint8(InterpState &S) {
16325 if (!Divc<PT_Uint8>(S, S.PC)) return false;
16326#if USE_TAILCALLS
16327 MUSTTAIL return InterpNext(S);
16328#else
16329 return true;
16330#endif
16331}
16332PRESERVE_NONE
16333static bool Interp_DivcSint16(InterpState &S) {
16334 if (!Divc<PT_Sint16>(S, S.PC)) return false;
16335#if USE_TAILCALLS
16336 MUSTTAIL return InterpNext(S);
16337#else
16338 return true;
16339#endif
16340}
16341PRESERVE_NONE
16342static bool Interp_DivcUint16(InterpState &S) {
16343 if (!Divc<PT_Uint16>(S, S.PC)) return false;
16344#if USE_TAILCALLS
16345 MUSTTAIL return InterpNext(S);
16346#else
16347 return true;
16348#endif
16349}
16350PRESERVE_NONE
16351static bool Interp_DivcSint32(InterpState &S) {
16352 if (!Divc<PT_Sint32>(S, S.PC)) return false;
16353#if USE_TAILCALLS
16354 MUSTTAIL return InterpNext(S);
16355#else
16356 return true;
16357#endif
16358}
16359PRESERVE_NONE
16360static bool Interp_DivcUint32(InterpState &S) {
16361 if (!Divc<PT_Uint32>(S, S.PC)) return false;
16362#if USE_TAILCALLS
16363 MUSTTAIL return InterpNext(S);
16364#else
16365 return true;
16366#endif
16367}
16368PRESERVE_NONE
16369static bool Interp_DivcSint64(InterpState &S) {
16370 if (!Divc<PT_Sint64>(S, S.PC)) return false;
16371#if USE_TAILCALLS
16372 MUSTTAIL return InterpNext(S);
16373#else
16374 return true;
16375#endif
16376}
16377PRESERVE_NONE
16378static bool Interp_DivcUint64(InterpState &S) {
16379 if (!Divc<PT_Uint64>(S, S.PC)) return false;
16380#if USE_TAILCALLS
16381 MUSTTAIL return InterpNext(S);
16382#else
16383 return true;
16384#endif
16385}
16386PRESERVE_NONE
16387static bool Interp_DivcIntAP(InterpState &S) {
16388 if (!Divc<PT_IntAP>(S, S.PC)) return false;
16389#if USE_TAILCALLS
16390 MUSTTAIL return InterpNext(S);
16391#else
16392 return true;
16393#endif
16394}
16395PRESERVE_NONE
16396static bool Interp_DivcIntAPS(InterpState &S) {
16397 if (!Divc<PT_IntAPS>(S, S.PC)) return false;
16398#if USE_TAILCALLS
16399 MUSTTAIL return InterpNext(S);
16400#else
16401 return true;
16402#endif
16403}
16404PRESERVE_NONE
16405static bool Interp_DivcFloat(InterpState &S) {
16406 if (!Divc<PT_Float>(S, S.PC)) return false;
16407#if USE_TAILCALLS
16408 MUSTTAIL return InterpNext(S);
16409#else
16410 return true;
16411#endif
16412}
16413#endif
16414#ifdef GET_DISASM
16415case OP_DivcSint8:
16416 Text.Op = PrintName("DivcSint8");
16417 break;
16418case OP_DivcUint8:
16419 Text.Op = PrintName("DivcUint8");
16420 break;
16421case OP_DivcSint16:
16422 Text.Op = PrintName("DivcSint16");
16423 break;
16424case OP_DivcUint16:
16425 Text.Op = PrintName("DivcUint16");
16426 break;
16427case OP_DivcSint32:
16428 Text.Op = PrintName("DivcSint32");
16429 break;
16430case OP_DivcUint32:
16431 Text.Op = PrintName("DivcUint32");
16432 break;
16433case OP_DivcSint64:
16434 Text.Op = PrintName("DivcSint64");
16435 break;
16436case OP_DivcUint64:
16437 Text.Op = PrintName("DivcUint64");
16438 break;
16439case OP_DivcIntAP:
16440 Text.Op = PrintName("DivcIntAP");
16441 break;
16442case OP_DivcIntAPS:
16443 Text.Op = PrintName("DivcIntAPS");
16444 break;
16445case OP_DivcFloat:
16446 Text.Op = PrintName("DivcFloat");
16447 break;
16448#endif
16449#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16450bool emitDivcSint8(SourceInfo);
16451bool emitDivcUint8(SourceInfo);
16452bool emitDivcSint16(SourceInfo);
16453bool emitDivcUint16(SourceInfo);
16454bool emitDivcSint32(SourceInfo);
16455bool emitDivcUint32(SourceInfo);
16456bool emitDivcSint64(SourceInfo);
16457bool emitDivcUint64(SourceInfo);
16458bool emitDivcIntAP(SourceInfo);
16459bool emitDivcIntAPS(SourceInfo);
16460bool emitDivcFloat(SourceInfo);
16461#endif
16462#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16463[[nodiscard]] bool emitDivc(PrimType, SourceInfo I);
16464#endif
16465#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
16466bool
16467#if defined(GET_EVAL_IMPL)
16468EvalEmitter
16469#else
16470ByteCodeEmitter
16471#endif
16472::emitDivc(PrimType T0, SourceInfo I) {
16473 switch (T0) {
16474 case PT_Sint8:
16475 return emitDivcSint8(I);
16476 case PT_Uint8:
16477 return emitDivcUint8(I);
16478 case PT_Sint16:
16479 return emitDivcSint16(I);
16480 case PT_Uint16:
16481 return emitDivcUint16(I);
16482 case PT_Sint32:
16483 return emitDivcSint32(I);
16484 case PT_Uint32:
16485 return emitDivcUint32(I);
16486 case PT_Sint64:
16487 return emitDivcSint64(I);
16488 case PT_Uint64:
16489 return emitDivcUint64(I);
16490 case PT_IntAP:
16491 return emitDivcIntAP(I);
16492 case PT_IntAPS:
16493 return emitDivcIntAPS(I);
16494 case PT_Float:
16495 return emitDivcFloat(I);
16496 default: llvm_unreachable("invalid type: emitDivc");
16497 }
16498 llvm_unreachable("invalid enum value");
16499}
16500#endif
16501#ifdef GET_LINK_IMPL
16502bool ByteCodeEmitter::emitDivcSint8(SourceInfo L) {
16503 return emitOp<>(OP_DivcSint8, L);
16504}
16505bool ByteCodeEmitter::emitDivcUint8(SourceInfo L) {
16506 return emitOp<>(OP_DivcUint8, L);
16507}
16508bool ByteCodeEmitter::emitDivcSint16(SourceInfo L) {
16509 return emitOp<>(OP_DivcSint16, L);
16510}
16511bool ByteCodeEmitter::emitDivcUint16(SourceInfo L) {
16512 return emitOp<>(OP_DivcUint16, L);
16513}
16514bool ByteCodeEmitter::emitDivcSint32(SourceInfo L) {
16515 return emitOp<>(OP_DivcSint32, L);
16516}
16517bool ByteCodeEmitter::emitDivcUint32(SourceInfo L) {
16518 return emitOp<>(OP_DivcUint32, L);
16519}
16520bool ByteCodeEmitter::emitDivcSint64(SourceInfo L) {
16521 return emitOp<>(OP_DivcSint64, L);
16522}
16523bool ByteCodeEmitter::emitDivcUint64(SourceInfo L) {
16524 return emitOp<>(OP_DivcUint64, L);
16525}
16526bool ByteCodeEmitter::emitDivcIntAP(SourceInfo L) {
16527 return emitOp<>(OP_DivcIntAP, L);
16528}
16529bool ByteCodeEmitter::emitDivcIntAPS(SourceInfo L) {
16530 return emitOp<>(OP_DivcIntAPS, L);
16531}
16532bool ByteCodeEmitter::emitDivcFloat(SourceInfo L) {
16533 return emitOp<>(OP_DivcFloat, L);
16534}
16535#endif
16536#ifdef GET_EVAL_IMPL
16537bool EvalEmitter::emitDivcSint8(SourceInfo L) {
16538 if (!isActive()) return true;
16539 CurrentSource = L;
16540 return Divc<PT_Sint8>(S, CodePtr());
16541}
16542bool EvalEmitter::emitDivcUint8(SourceInfo L) {
16543 if (!isActive()) return true;
16544 CurrentSource = L;
16545 return Divc<PT_Uint8>(S, CodePtr());
16546}
16547bool EvalEmitter::emitDivcSint16(SourceInfo L) {
16548 if (!isActive()) return true;
16549 CurrentSource = L;
16550 return Divc<PT_Sint16>(S, CodePtr());
16551}
16552bool EvalEmitter::emitDivcUint16(SourceInfo L) {
16553 if (!isActive()) return true;
16554 CurrentSource = L;
16555 return Divc<PT_Uint16>(S, CodePtr());
16556}
16557bool EvalEmitter::emitDivcSint32(SourceInfo L) {
16558 if (!isActive()) return true;
16559 CurrentSource = L;
16560 return Divc<PT_Sint32>(S, CodePtr());
16561}
16562bool EvalEmitter::emitDivcUint32(SourceInfo L) {
16563 if (!isActive()) return true;
16564 CurrentSource = L;
16565 return Divc<PT_Uint32>(S, CodePtr());
16566}
16567bool EvalEmitter::emitDivcSint64(SourceInfo L) {
16568 if (!isActive()) return true;
16569 CurrentSource = L;
16570 return Divc<PT_Sint64>(S, CodePtr());
16571}
16572bool EvalEmitter::emitDivcUint64(SourceInfo L) {
16573 if (!isActive()) return true;
16574 CurrentSource = L;
16575 return Divc<PT_Uint64>(S, CodePtr());
16576}
16577bool EvalEmitter::emitDivcIntAP(SourceInfo L) {
16578 if (!isActive()) return true;
16579 CurrentSource = L;
16580 return Divc<PT_IntAP>(S, CodePtr());
16581}
16582bool EvalEmitter::emitDivcIntAPS(SourceInfo L) {
16583 if (!isActive()) return true;
16584 CurrentSource = L;
16585 return Divc<PT_IntAPS>(S, CodePtr());
16586}
16587bool EvalEmitter::emitDivcFloat(SourceInfo L) {
16588 if (!isActive()) return true;
16589 CurrentSource = L;
16590 return Divc<PT_Float>(S, CodePtr());
16591}
16592#endif
16593#ifdef GET_OPCODE_NAMES
16594OP_Divf,
16595#endif
16596#ifdef GET_INTERPFN_LIST
16597&Interp_Divf,
16598#endif
16599#ifdef GET_INTERPFN_DISPATCHERS
16600PRESERVE_NONE
16601static bool Interp_Divf(InterpState &S) {
16602 {
16603 CodePtr OpPC = S.PC;
16604 const auto V0 = ReadArg<uint32_t>(S, S.PC);
16605 if (!Divf(S, OpPC, V0)) return false;
16606 }
16607#if USE_TAILCALLS
16608 MUSTTAIL return InterpNext(S);
16609#else
16610 return true;
16611#endif
16612}
16613#endif
16614#ifdef GET_DISASM
16615case OP_Divf:
16616 Text.Op = PrintName("Divf");
16617 Text.Args.push_back(printArg<uint32_t>(PC));
16618 break;
16619#endif
16620#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16621bool emitDivf( uint32_t , SourceInfo);
16622#endif
16623#ifdef GET_LINK_IMPL
16624bool ByteCodeEmitter::emitDivf( uint32_t A0, SourceInfo L) {
16625 return emitOp<uint32_t>(OP_Divf, A0, L);
16626}
16627#endif
16628#ifdef GET_EVAL_IMPL
16629bool EvalEmitter::emitDivf( uint32_t A0, SourceInfo L) {
16630 if (!isActive()) return true;
16631 CurrentSource = L;
16632 return Divf(S, CodePtr(), A0);
16633}
16634#endif
16635#ifdef GET_OPCODE_NAMES
16636OP_Dump,
16637#endif
16638#ifdef GET_INTERPFN_LIST
16639&Interp_Dump,
16640#endif
16641#ifdef GET_INTERPFN_DISPATCHERS
16642PRESERVE_NONE
16643static bool Interp_Dump(InterpState &S) {
16644 if (!Dump(S)) return false;
16645#if USE_TAILCALLS
16646 MUSTTAIL return InterpNext(S);
16647#else
16648 return true;
16649#endif
16650}
16651#endif
16652#ifdef GET_DISASM
16653case OP_Dump:
16654 Text.Op = PrintName("Dump");
16655 break;
16656#endif
16657#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16658bool emitDump(SourceInfo);
16659#endif
16660#ifdef GET_LINK_IMPL
16661bool ByteCodeEmitter::emitDump(SourceInfo L) {
16662 return emitOp<>(OP_Dump, L);
16663}
16664#endif
16665#ifdef GET_EVAL_IMPL
16666bool EvalEmitter::emitDump(SourceInfo L) {
16667 if (!isActive()) return true;
16668 CurrentSource = L;
16669 return Dump(S);
16670}
16671#endif
16672#ifdef GET_OPCODE_NAMES
16673OP_DupSint8,
16674OP_DupUint8,
16675OP_DupSint16,
16676OP_DupUint16,
16677OP_DupSint32,
16678OP_DupUint32,
16679OP_DupSint64,
16680OP_DupUint64,
16681OP_DupIntAP,
16682OP_DupIntAPS,
16683OP_DupBool,
16684OP_DupFixedPoint,
16685OP_DupPtr,
16686OP_DupMemberPtr,
16687OP_DupFloat,
16688OP_DupReflect,
16689#endif
16690#ifdef GET_INTERPFN_LIST
16691&Interp_DupSint8,
16692&Interp_DupUint8,
16693&Interp_DupSint16,
16694&Interp_DupUint16,
16695&Interp_DupSint32,
16696&Interp_DupUint32,
16697&Interp_DupSint64,
16698&Interp_DupUint64,
16699&Interp_DupIntAP,
16700&Interp_DupIntAPS,
16701&Interp_DupBool,
16702&Interp_DupFixedPoint,
16703&Interp_DupPtr,
16704&Interp_DupMemberPtr,
16705&Interp_DupFloat,
16706&Interp_DupReflect,
16707#endif
16708#ifdef GET_INTERPFN_DISPATCHERS
16709PRESERVE_NONE
16710static bool Interp_DupSint8(InterpState &S) {
16711 Dup<PT_Sint8>(S);
16712#if USE_TAILCALLS
16713 MUSTTAIL return InterpNext(S);
16714#else
16715 return true;
16716#endif
16717}
16718PRESERVE_NONE
16719static bool Interp_DupUint8(InterpState &S) {
16720 Dup<PT_Uint8>(S);
16721#if USE_TAILCALLS
16722 MUSTTAIL return InterpNext(S);
16723#else
16724 return true;
16725#endif
16726}
16727PRESERVE_NONE
16728static bool Interp_DupSint16(InterpState &S) {
16729 Dup<PT_Sint16>(S);
16730#if USE_TAILCALLS
16731 MUSTTAIL return InterpNext(S);
16732#else
16733 return true;
16734#endif
16735}
16736PRESERVE_NONE
16737static bool Interp_DupUint16(InterpState &S) {
16738 Dup<PT_Uint16>(S);
16739#if USE_TAILCALLS
16740 MUSTTAIL return InterpNext(S);
16741#else
16742 return true;
16743#endif
16744}
16745PRESERVE_NONE
16746static bool Interp_DupSint32(InterpState &S) {
16747 Dup<PT_Sint32>(S);
16748#if USE_TAILCALLS
16749 MUSTTAIL return InterpNext(S);
16750#else
16751 return true;
16752#endif
16753}
16754PRESERVE_NONE
16755static bool Interp_DupUint32(InterpState &S) {
16756 Dup<PT_Uint32>(S);
16757#if USE_TAILCALLS
16758 MUSTTAIL return InterpNext(S);
16759#else
16760 return true;
16761#endif
16762}
16763PRESERVE_NONE
16764static bool Interp_DupSint64(InterpState &S) {
16765 Dup<PT_Sint64>(S);
16766#if USE_TAILCALLS
16767 MUSTTAIL return InterpNext(S);
16768#else
16769 return true;
16770#endif
16771}
16772PRESERVE_NONE
16773static bool Interp_DupUint64(InterpState &S) {
16774 Dup<PT_Uint64>(S);
16775#if USE_TAILCALLS
16776 MUSTTAIL return InterpNext(S);
16777#else
16778 return true;
16779#endif
16780}
16781PRESERVE_NONE
16782static bool Interp_DupIntAP(InterpState &S) {
16783 Dup<PT_IntAP>(S);
16784#if USE_TAILCALLS
16785 MUSTTAIL return InterpNext(S);
16786#else
16787 return true;
16788#endif
16789}
16790PRESERVE_NONE
16791static bool Interp_DupIntAPS(InterpState &S) {
16792 Dup<PT_IntAPS>(S);
16793#if USE_TAILCALLS
16794 MUSTTAIL return InterpNext(S);
16795#else
16796 return true;
16797#endif
16798}
16799PRESERVE_NONE
16800static bool Interp_DupBool(InterpState &S) {
16801 Dup<PT_Bool>(S);
16802#if USE_TAILCALLS
16803 MUSTTAIL return InterpNext(S);
16804#else
16805 return true;
16806#endif
16807}
16808PRESERVE_NONE
16809static bool Interp_DupFixedPoint(InterpState &S) {
16810 Dup<PT_FixedPoint>(S);
16811#if USE_TAILCALLS
16812 MUSTTAIL return InterpNext(S);
16813#else
16814 return true;
16815#endif
16816}
16817PRESERVE_NONE
16818static bool Interp_DupPtr(InterpState &S) {
16819 Dup<PT_Ptr>(S);
16820#if USE_TAILCALLS
16821 MUSTTAIL return InterpNext(S);
16822#else
16823 return true;
16824#endif
16825}
16826PRESERVE_NONE
16827static bool Interp_DupMemberPtr(InterpState &S) {
16828 Dup<PT_MemberPtr>(S);
16829#if USE_TAILCALLS
16830 MUSTTAIL return InterpNext(S);
16831#else
16832 return true;
16833#endif
16834}
16835PRESERVE_NONE
16836static bool Interp_DupFloat(InterpState &S) {
16837 Dup<PT_Float>(S);
16838#if USE_TAILCALLS
16839 MUSTTAIL return InterpNext(S);
16840#else
16841 return true;
16842#endif
16843}
16844PRESERVE_NONE
16845static bool Interp_DupReflect(InterpState &S) {
16846 Dup<PT_Reflect>(S);
16847#if USE_TAILCALLS
16848 MUSTTAIL return InterpNext(S);
16849#else
16850 return true;
16851#endif
16852}
16853#endif
16854#ifdef GET_DISASM
16855case OP_DupSint8:
16856 Text.Op = PrintName("DupSint8");
16857 break;
16858case OP_DupUint8:
16859 Text.Op = PrintName("DupUint8");
16860 break;
16861case OP_DupSint16:
16862 Text.Op = PrintName("DupSint16");
16863 break;
16864case OP_DupUint16:
16865 Text.Op = PrintName("DupUint16");
16866 break;
16867case OP_DupSint32:
16868 Text.Op = PrintName("DupSint32");
16869 break;
16870case OP_DupUint32:
16871 Text.Op = PrintName("DupUint32");
16872 break;
16873case OP_DupSint64:
16874 Text.Op = PrintName("DupSint64");
16875 break;
16876case OP_DupUint64:
16877 Text.Op = PrintName("DupUint64");
16878 break;
16879case OP_DupIntAP:
16880 Text.Op = PrintName("DupIntAP");
16881 break;
16882case OP_DupIntAPS:
16883 Text.Op = PrintName("DupIntAPS");
16884 break;
16885case OP_DupBool:
16886 Text.Op = PrintName("DupBool");
16887 break;
16888case OP_DupFixedPoint:
16889 Text.Op = PrintName("DupFixedPoint");
16890 break;
16891case OP_DupPtr:
16892 Text.Op = PrintName("DupPtr");
16893 break;
16894case OP_DupMemberPtr:
16895 Text.Op = PrintName("DupMemberPtr");
16896 break;
16897case OP_DupFloat:
16898 Text.Op = PrintName("DupFloat");
16899 break;
16900case OP_DupReflect:
16901 Text.Op = PrintName("DupReflect");
16902 break;
16903#endif
16904#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16905bool emitDupSint8(SourceInfo);
16906bool emitDupUint8(SourceInfo);
16907bool emitDupSint16(SourceInfo);
16908bool emitDupUint16(SourceInfo);
16909bool emitDupSint32(SourceInfo);
16910bool emitDupUint32(SourceInfo);
16911bool emitDupSint64(SourceInfo);
16912bool emitDupUint64(SourceInfo);
16913bool emitDupIntAP(SourceInfo);
16914bool emitDupIntAPS(SourceInfo);
16915bool emitDupBool(SourceInfo);
16916bool emitDupFixedPoint(SourceInfo);
16917bool emitDupPtr(SourceInfo);
16918bool emitDupMemberPtr(SourceInfo);
16919bool emitDupFloat(SourceInfo);
16920bool emitDupReflect(SourceInfo);
16921#endif
16922#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
16923[[nodiscard]] bool emitDup(PrimType, SourceInfo I);
16924#endif
16925#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
16926bool
16927#if defined(GET_EVAL_IMPL)
16928EvalEmitter
16929#else
16930ByteCodeEmitter
16931#endif
16932::emitDup(PrimType T0, SourceInfo I) {
16933 switch (T0) {
16934 case PT_Sint8:
16935 return emitDupSint8(I);
16936 case PT_Uint8:
16937 return emitDupUint8(I);
16938 case PT_Sint16:
16939 return emitDupSint16(I);
16940 case PT_Uint16:
16941 return emitDupUint16(I);
16942 case PT_Sint32:
16943 return emitDupSint32(I);
16944 case PT_Uint32:
16945 return emitDupUint32(I);
16946 case PT_Sint64:
16947 return emitDupSint64(I);
16948 case PT_Uint64:
16949 return emitDupUint64(I);
16950 case PT_IntAP:
16951 return emitDupIntAP(I);
16952 case PT_IntAPS:
16953 return emitDupIntAPS(I);
16954 case PT_Bool:
16955 return emitDupBool(I);
16956 case PT_FixedPoint:
16957 return emitDupFixedPoint(I);
16958 case PT_Ptr:
16959 return emitDupPtr(I);
16960 case PT_MemberPtr:
16961 return emitDupMemberPtr(I);
16962 case PT_Float:
16963 return emitDupFloat(I);
16964 case PT_Reflect:
16965 return emitDupReflect(I);
16966 }
16967 llvm_unreachable("invalid enum value");
16968}
16969#endif
16970#ifdef GET_LINK_IMPL
16971bool ByteCodeEmitter::emitDupSint8(SourceInfo L) {
16972 return emitOp<>(OP_DupSint8, L);
16973}
16974bool ByteCodeEmitter::emitDupUint8(SourceInfo L) {
16975 return emitOp<>(OP_DupUint8, L);
16976}
16977bool ByteCodeEmitter::emitDupSint16(SourceInfo L) {
16978 return emitOp<>(OP_DupSint16, L);
16979}
16980bool ByteCodeEmitter::emitDupUint16(SourceInfo L) {
16981 return emitOp<>(OP_DupUint16, L);
16982}
16983bool ByteCodeEmitter::emitDupSint32(SourceInfo L) {
16984 return emitOp<>(OP_DupSint32, L);
16985}
16986bool ByteCodeEmitter::emitDupUint32(SourceInfo L) {
16987 return emitOp<>(OP_DupUint32, L);
16988}
16989bool ByteCodeEmitter::emitDupSint64(SourceInfo L) {
16990 return emitOp<>(OP_DupSint64, L);
16991}
16992bool ByteCodeEmitter::emitDupUint64(SourceInfo L) {
16993 return emitOp<>(OP_DupUint64, L);
16994}
16995bool ByteCodeEmitter::emitDupIntAP(SourceInfo L) {
16996 return emitOp<>(OP_DupIntAP, L);
16997}
16998bool ByteCodeEmitter::emitDupIntAPS(SourceInfo L) {
16999 return emitOp<>(OP_DupIntAPS, L);
17000}
17001bool ByteCodeEmitter::emitDupBool(SourceInfo L) {
17002 return emitOp<>(OP_DupBool, L);
17003}
17004bool ByteCodeEmitter::emitDupFixedPoint(SourceInfo L) {
17005 return emitOp<>(OP_DupFixedPoint, L);
17006}
17007bool ByteCodeEmitter::emitDupPtr(SourceInfo L) {
17008 return emitOp<>(OP_DupPtr, L);
17009}
17010bool ByteCodeEmitter::emitDupMemberPtr(SourceInfo L) {
17011 return emitOp<>(OP_DupMemberPtr, L);
17012}
17013bool ByteCodeEmitter::emitDupFloat(SourceInfo L) {
17014 return emitOp<>(OP_DupFloat, L);
17015}
17016bool ByteCodeEmitter::emitDupReflect(SourceInfo L) {
17017 return emitOp<>(OP_DupReflect, L);
17018}
17019#endif
17020#ifdef GET_EVAL_IMPL
17021bool EvalEmitter::emitDupSint8(SourceInfo L) {
17022 if (!isActive()) return true;
17023 CurrentSource = L;
17024 return Dup<PT_Sint8>(S);
17025}
17026bool EvalEmitter::emitDupUint8(SourceInfo L) {
17027 if (!isActive()) return true;
17028 CurrentSource = L;
17029 return Dup<PT_Uint8>(S);
17030}
17031bool EvalEmitter::emitDupSint16(SourceInfo L) {
17032 if (!isActive()) return true;
17033 CurrentSource = L;
17034 return Dup<PT_Sint16>(S);
17035}
17036bool EvalEmitter::emitDupUint16(SourceInfo L) {
17037 if (!isActive()) return true;
17038 CurrentSource = L;
17039 return Dup<PT_Uint16>(S);
17040}
17041bool EvalEmitter::emitDupSint32(SourceInfo L) {
17042 if (!isActive()) return true;
17043 CurrentSource = L;
17044 return Dup<PT_Sint32>(S);
17045}
17046bool EvalEmitter::emitDupUint32(SourceInfo L) {
17047 if (!isActive()) return true;
17048 CurrentSource = L;
17049 return Dup<PT_Uint32>(S);
17050}
17051bool EvalEmitter::emitDupSint64(SourceInfo L) {
17052 if (!isActive()) return true;
17053 CurrentSource = L;
17054 return Dup<PT_Sint64>(S);
17055}
17056bool EvalEmitter::emitDupUint64(SourceInfo L) {
17057 if (!isActive()) return true;
17058 CurrentSource = L;
17059 return Dup<PT_Uint64>(S);
17060}
17061bool EvalEmitter::emitDupIntAP(SourceInfo L) {
17062 if (!isActive()) return true;
17063 CurrentSource = L;
17064 return Dup<PT_IntAP>(S);
17065}
17066bool EvalEmitter::emitDupIntAPS(SourceInfo L) {
17067 if (!isActive()) return true;
17068 CurrentSource = L;
17069 return Dup<PT_IntAPS>(S);
17070}
17071bool EvalEmitter::emitDupBool(SourceInfo L) {
17072 if (!isActive()) return true;
17073 CurrentSource = L;
17074 return Dup<PT_Bool>(S);
17075}
17076bool EvalEmitter::emitDupFixedPoint(SourceInfo L) {
17077 if (!isActive()) return true;
17078 CurrentSource = L;
17079 return Dup<PT_FixedPoint>(S);
17080}
17081bool EvalEmitter::emitDupPtr(SourceInfo L) {
17082 if (!isActive()) return true;
17083 CurrentSource = L;
17084 return Dup<PT_Ptr>(S);
17085}
17086bool EvalEmitter::emitDupMemberPtr(SourceInfo L) {
17087 if (!isActive()) return true;
17088 CurrentSource = L;
17089 return Dup<PT_MemberPtr>(S);
17090}
17091bool EvalEmitter::emitDupFloat(SourceInfo L) {
17092 if (!isActive()) return true;
17093 CurrentSource = L;
17094 return Dup<PT_Float>(S);
17095}
17096bool EvalEmitter::emitDupReflect(SourceInfo L) {
17097 if (!isActive()) return true;
17098 CurrentSource = L;
17099 return Dup<PT_Reflect>(S);
17100}
17101#endif
17102#ifdef GET_OPCODE_NAMES
17103OP_DynamicCast,
17104#endif
17105#ifdef GET_INTERPFN_LIST
17106&Interp_DynamicCast,
17107#endif
17108#ifdef GET_INTERPFN_DISPATCHERS
17109PRESERVE_NONE
17110static bool Interp_DynamicCast(InterpState &S) {
17111 {
17112 CodePtr OpPC = S.PC;
17113 const auto V0 = ReadArg<const Type *>(S, S.PC);
17114 const auto V1 = ReadArg<bool>(S, S.PC);
17115 if (!DynamicCast(S, OpPC, V0, V1)) return false;
17116 }
17117#if USE_TAILCALLS
17118 MUSTTAIL return InterpNext(S);
17119#else
17120 return true;
17121#endif
17122}
17123#endif
17124#ifdef GET_DISASM
17125case OP_DynamicCast:
17126 Text.Op = PrintName("DynamicCast");
17127 Text.Args.push_back(printArg<const Type *>(PC));
17128 Text.Args.push_back(printArg<bool>(PC));
17129 break;
17130#endif
17131#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17132bool emitDynamicCast( const Type * , bool , SourceInfo);
17133#endif
17134#ifdef GET_LINK_IMPL
17135bool ByteCodeEmitter::emitDynamicCast( const Type * A0, bool A1, SourceInfo L) {
17136 return emitOp<const Type *, bool>(OP_DynamicCast, A0, A1, L);
17137}
17138#endif
17139#ifdef GET_EVAL_IMPL
17140bool EvalEmitter::emitDynamicCast( const Type * A0, bool A1, SourceInfo L) {
17141 if (!isActive()) return true;
17142 CurrentSource = L;
17143 return DynamicCast(S, CodePtr(), A0, A1);
17144}
17145#endif
17146#ifdef GET_OPCODE_NAMES
17147OP_EQSint8,
17148OP_EQUint8,
17149OP_EQSint16,
17150OP_EQUint16,
17151OP_EQSint32,
17152OP_EQUint32,
17153OP_EQSint64,
17154OP_EQUint64,
17155OP_EQIntAP,
17156OP_EQIntAPS,
17157OP_EQBool,
17158OP_EQFixedPoint,
17159OP_EQPtr,
17160OP_EQMemberPtr,
17161OP_EQFloat,
17162OP_EQReflect,
17163#endif
17164#ifdef GET_INTERPFN_LIST
17165&Interp_EQSint8,
17166&Interp_EQUint8,
17167&Interp_EQSint16,
17168&Interp_EQUint16,
17169&Interp_EQSint32,
17170&Interp_EQUint32,
17171&Interp_EQSint64,
17172&Interp_EQUint64,
17173&Interp_EQIntAP,
17174&Interp_EQIntAPS,
17175&Interp_EQBool,
17176&Interp_EQFixedPoint,
17177&Interp_EQPtr,
17178&Interp_EQMemberPtr,
17179&Interp_EQFloat,
17180&Interp_EQReflect,
17181#endif
17182#ifdef GET_INTERPFN_DISPATCHERS
17183PRESERVE_NONE
17184static bool Interp_EQSint8(InterpState &S) {
17185 if (!EQ<PT_Sint8>(S, S.PC)) return false;
17186#if USE_TAILCALLS
17187 MUSTTAIL return InterpNext(S);
17188#else
17189 return true;
17190#endif
17191}
17192PRESERVE_NONE
17193static bool Interp_EQUint8(InterpState &S) {
17194 if (!EQ<PT_Uint8>(S, S.PC)) return false;
17195#if USE_TAILCALLS
17196 MUSTTAIL return InterpNext(S);
17197#else
17198 return true;
17199#endif
17200}
17201PRESERVE_NONE
17202static bool Interp_EQSint16(InterpState &S) {
17203 if (!EQ<PT_Sint16>(S, S.PC)) return false;
17204#if USE_TAILCALLS
17205 MUSTTAIL return InterpNext(S);
17206#else
17207 return true;
17208#endif
17209}
17210PRESERVE_NONE
17211static bool Interp_EQUint16(InterpState &S) {
17212 if (!EQ<PT_Uint16>(S, S.PC)) return false;
17213#if USE_TAILCALLS
17214 MUSTTAIL return InterpNext(S);
17215#else
17216 return true;
17217#endif
17218}
17219PRESERVE_NONE
17220static bool Interp_EQSint32(InterpState &S) {
17221 if (!EQ<PT_Sint32>(S, S.PC)) return false;
17222#if USE_TAILCALLS
17223 MUSTTAIL return InterpNext(S);
17224#else
17225 return true;
17226#endif
17227}
17228PRESERVE_NONE
17229static bool Interp_EQUint32(InterpState &S) {
17230 if (!EQ<PT_Uint32>(S, S.PC)) return false;
17231#if USE_TAILCALLS
17232 MUSTTAIL return InterpNext(S);
17233#else
17234 return true;
17235#endif
17236}
17237PRESERVE_NONE
17238static bool Interp_EQSint64(InterpState &S) {
17239 if (!EQ<PT_Sint64>(S, S.PC)) return false;
17240#if USE_TAILCALLS
17241 MUSTTAIL return InterpNext(S);
17242#else
17243 return true;
17244#endif
17245}
17246PRESERVE_NONE
17247static bool Interp_EQUint64(InterpState &S) {
17248 if (!EQ<PT_Uint64>(S, S.PC)) return false;
17249#if USE_TAILCALLS
17250 MUSTTAIL return InterpNext(S);
17251#else
17252 return true;
17253#endif
17254}
17255PRESERVE_NONE
17256static bool Interp_EQIntAP(InterpState &S) {
17257 if (!EQ<PT_IntAP>(S, S.PC)) return false;
17258#if USE_TAILCALLS
17259 MUSTTAIL return InterpNext(S);
17260#else
17261 return true;
17262#endif
17263}
17264PRESERVE_NONE
17265static bool Interp_EQIntAPS(InterpState &S) {
17266 if (!EQ<PT_IntAPS>(S, S.PC)) return false;
17267#if USE_TAILCALLS
17268 MUSTTAIL return InterpNext(S);
17269#else
17270 return true;
17271#endif
17272}
17273PRESERVE_NONE
17274static bool Interp_EQBool(InterpState &S) {
17275 if (!EQ<PT_Bool>(S, S.PC)) return false;
17276#if USE_TAILCALLS
17277 MUSTTAIL return InterpNext(S);
17278#else
17279 return true;
17280#endif
17281}
17282PRESERVE_NONE
17283static bool Interp_EQFixedPoint(InterpState &S) {
17284 if (!EQ<PT_FixedPoint>(S, S.PC)) return false;
17285#if USE_TAILCALLS
17286 MUSTTAIL return InterpNext(S);
17287#else
17288 return true;
17289#endif
17290}
17291PRESERVE_NONE
17292static bool Interp_EQPtr(InterpState &S) {
17293 if (!EQ<PT_Ptr>(S, S.PC)) return false;
17294#if USE_TAILCALLS
17295 MUSTTAIL return InterpNext(S);
17296#else
17297 return true;
17298#endif
17299}
17300PRESERVE_NONE
17301static bool Interp_EQMemberPtr(InterpState &S) {
17302 if (!EQ<PT_MemberPtr>(S, S.PC)) return false;
17303#if USE_TAILCALLS
17304 MUSTTAIL return InterpNext(S);
17305#else
17306 return true;
17307#endif
17308}
17309PRESERVE_NONE
17310static bool Interp_EQFloat(InterpState &S) {
17311 if (!EQ<PT_Float>(S, S.PC)) return false;
17312#if USE_TAILCALLS
17313 MUSTTAIL return InterpNext(S);
17314#else
17315 return true;
17316#endif
17317}
17318PRESERVE_NONE
17319static bool Interp_EQReflect(InterpState &S) {
17320 if (!EQ<PT_Reflect>(S, S.PC)) return false;
17321#if USE_TAILCALLS
17322 MUSTTAIL return InterpNext(S);
17323#else
17324 return true;
17325#endif
17326}
17327#endif
17328#ifdef GET_DISASM
17329case OP_EQSint8:
17330 Text.Op = PrintName("EQSint8");
17331 break;
17332case OP_EQUint8:
17333 Text.Op = PrintName("EQUint8");
17334 break;
17335case OP_EQSint16:
17336 Text.Op = PrintName("EQSint16");
17337 break;
17338case OP_EQUint16:
17339 Text.Op = PrintName("EQUint16");
17340 break;
17341case OP_EQSint32:
17342 Text.Op = PrintName("EQSint32");
17343 break;
17344case OP_EQUint32:
17345 Text.Op = PrintName("EQUint32");
17346 break;
17347case OP_EQSint64:
17348 Text.Op = PrintName("EQSint64");
17349 break;
17350case OP_EQUint64:
17351 Text.Op = PrintName("EQUint64");
17352 break;
17353case OP_EQIntAP:
17354 Text.Op = PrintName("EQIntAP");
17355 break;
17356case OP_EQIntAPS:
17357 Text.Op = PrintName("EQIntAPS");
17358 break;
17359case OP_EQBool:
17360 Text.Op = PrintName("EQBool");
17361 break;
17362case OP_EQFixedPoint:
17363 Text.Op = PrintName("EQFixedPoint");
17364 break;
17365case OP_EQPtr:
17366 Text.Op = PrintName("EQPtr");
17367 break;
17368case OP_EQMemberPtr:
17369 Text.Op = PrintName("EQMemberPtr");
17370 break;
17371case OP_EQFloat:
17372 Text.Op = PrintName("EQFloat");
17373 break;
17374case OP_EQReflect:
17375 Text.Op = PrintName("EQReflect");
17376 break;
17377#endif
17378#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17379bool emitEQSint8(SourceInfo);
17380bool emitEQUint8(SourceInfo);
17381bool emitEQSint16(SourceInfo);
17382bool emitEQUint16(SourceInfo);
17383bool emitEQSint32(SourceInfo);
17384bool emitEQUint32(SourceInfo);
17385bool emitEQSint64(SourceInfo);
17386bool emitEQUint64(SourceInfo);
17387bool emitEQIntAP(SourceInfo);
17388bool emitEQIntAPS(SourceInfo);
17389bool emitEQBool(SourceInfo);
17390bool emitEQFixedPoint(SourceInfo);
17391bool emitEQPtr(SourceInfo);
17392bool emitEQMemberPtr(SourceInfo);
17393bool emitEQFloat(SourceInfo);
17394bool emitEQReflect(SourceInfo);
17395#endif
17396#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17397[[nodiscard]] bool emitEQ(PrimType, SourceInfo I);
17398#endif
17399#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
17400bool
17401#if defined(GET_EVAL_IMPL)
17402EvalEmitter
17403#else
17404ByteCodeEmitter
17405#endif
17406::emitEQ(PrimType T0, SourceInfo I) {
17407 switch (T0) {
17408 case PT_Sint8:
17409 return emitEQSint8(I);
17410 case PT_Uint8:
17411 return emitEQUint8(I);
17412 case PT_Sint16:
17413 return emitEQSint16(I);
17414 case PT_Uint16:
17415 return emitEQUint16(I);
17416 case PT_Sint32:
17417 return emitEQSint32(I);
17418 case PT_Uint32:
17419 return emitEQUint32(I);
17420 case PT_Sint64:
17421 return emitEQSint64(I);
17422 case PT_Uint64:
17423 return emitEQUint64(I);
17424 case PT_IntAP:
17425 return emitEQIntAP(I);
17426 case PT_IntAPS:
17427 return emitEQIntAPS(I);
17428 case PT_Bool:
17429 return emitEQBool(I);
17430 case PT_FixedPoint:
17431 return emitEQFixedPoint(I);
17432 case PT_Ptr:
17433 return emitEQPtr(I);
17434 case PT_MemberPtr:
17435 return emitEQMemberPtr(I);
17436 case PT_Float:
17437 return emitEQFloat(I);
17438 case PT_Reflect:
17439 return emitEQReflect(I);
17440 }
17441 llvm_unreachable("invalid enum value");
17442}
17443#endif
17444#ifdef GET_LINK_IMPL
17445bool ByteCodeEmitter::emitEQSint8(SourceInfo L) {
17446 return emitOp<>(OP_EQSint8, L);
17447}
17448bool ByteCodeEmitter::emitEQUint8(SourceInfo L) {
17449 return emitOp<>(OP_EQUint8, L);
17450}
17451bool ByteCodeEmitter::emitEQSint16(SourceInfo L) {
17452 return emitOp<>(OP_EQSint16, L);
17453}
17454bool ByteCodeEmitter::emitEQUint16(SourceInfo L) {
17455 return emitOp<>(OP_EQUint16, L);
17456}
17457bool ByteCodeEmitter::emitEQSint32(SourceInfo L) {
17458 return emitOp<>(OP_EQSint32, L);
17459}
17460bool ByteCodeEmitter::emitEQUint32(SourceInfo L) {
17461 return emitOp<>(OP_EQUint32, L);
17462}
17463bool ByteCodeEmitter::emitEQSint64(SourceInfo L) {
17464 return emitOp<>(OP_EQSint64, L);
17465}
17466bool ByteCodeEmitter::emitEQUint64(SourceInfo L) {
17467 return emitOp<>(OP_EQUint64, L);
17468}
17469bool ByteCodeEmitter::emitEQIntAP(SourceInfo L) {
17470 return emitOp<>(OP_EQIntAP, L);
17471}
17472bool ByteCodeEmitter::emitEQIntAPS(SourceInfo L) {
17473 return emitOp<>(OP_EQIntAPS, L);
17474}
17475bool ByteCodeEmitter::emitEQBool(SourceInfo L) {
17476 return emitOp<>(OP_EQBool, L);
17477}
17478bool ByteCodeEmitter::emitEQFixedPoint(SourceInfo L) {
17479 return emitOp<>(OP_EQFixedPoint, L);
17480}
17481bool ByteCodeEmitter::emitEQPtr(SourceInfo L) {
17482 return emitOp<>(OP_EQPtr, L);
17483}
17484bool ByteCodeEmitter::emitEQMemberPtr(SourceInfo L) {
17485 return emitOp<>(OP_EQMemberPtr, L);
17486}
17487bool ByteCodeEmitter::emitEQFloat(SourceInfo L) {
17488 return emitOp<>(OP_EQFloat, L);
17489}
17490bool ByteCodeEmitter::emitEQReflect(SourceInfo L) {
17491 return emitOp<>(OP_EQReflect, L);
17492}
17493#endif
17494#ifdef GET_EVAL_IMPL
17495bool EvalEmitter::emitEQSint8(SourceInfo L) {
17496 if (!isActive()) return true;
17497 CurrentSource = L;
17498 return EQ<PT_Sint8>(S, CodePtr());
17499}
17500bool EvalEmitter::emitEQUint8(SourceInfo L) {
17501 if (!isActive()) return true;
17502 CurrentSource = L;
17503 return EQ<PT_Uint8>(S, CodePtr());
17504}
17505bool EvalEmitter::emitEQSint16(SourceInfo L) {
17506 if (!isActive()) return true;
17507 CurrentSource = L;
17508 return EQ<PT_Sint16>(S, CodePtr());
17509}
17510bool EvalEmitter::emitEQUint16(SourceInfo L) {
17511 if (!isActive()) return true;
17512 CurrentSource = L;
17513 return EQ<PT_Uint16>(S, CodePtr());
17514}
17515bool EvalEmitter::emitEQSint32(SourceInfo L) {
17516 if (!isActive()) return true;
17517 CurrentSource = L;
17518 return EQ<PT_Sint32>(S, CodePtr());
17519}
17520bool EvalEmitter::emitEQUint32(SourceInfo L) {
17521 if (!isActive()) return true;
17522 CurrentSource = L;
17523 return EQ<PT_Uint32>(S, CodePtr());
17524}
17525bool EvalEmitter::emitEQSint64(SourceInfo L) {
17526 if (!isActive()) return true;
17527 CurrentSource = L;
17528 return EQ<PT_Sint64>(S, CodePtr());
17529}
17530bool EvalEmitter::emitEQUint64(SourceInfo L) {
17531 if (!isActive()) return true;
17532 CurrentSource = L;
17533 return EQ<PT_Uint64>(S, CodePtr());
17534}
17535bool EvalEmitter::emitEQIntAP(SourceInfo L) {
17536 if (!isActive()) return true;
17537 CurrentSource = L;
17538 return EQ<PT_IntAP>(S, CodePtr());
17539}
17540bool EvalEmitter::emitEQIntAPS(SourceInfo L) {
17541 if (!isActive()) return true;
17542 CurrentSource = L;
17543 return EQ<PT_IntAPS>(S, CodePtr());
17544}
17545bool EvalEmitter::emitEQBool(SourceInfo L) {
17546 if (!isActive()) return true;
17547 CurrentSource = L;
17548 return EQ<PT_Bool>(S, CodePtr());
17549}
17550bool EvalEmitter::emitEQFixedPoint(SourceInfo L) {
17551 if (!isActive()) return true;
17552 CurrentSource = L;
17553 return EQ<PT_FixedPoint>(S, CodePtr());
17554}
17555bool EvalEmitter::emitEQPtr(SourceInfo L) {
17556 if (!isActive()) return true;
17557 CurrentSource = L;
17558 return EQ<PT_Ptr>(S, CodePtr());
17559}
17560bool EvalEmitter::emitEQMemberPtr(SourceInfo L) {
17561 if (!isActive()) return true;
17562 CurrentSource = L;
17563 return EQ<PT_MemberPtr>(S, CodePtr());
17564}
17565bool EvalEmitter::emitEQFloat(SourceInfo L) {
17566 if (!isActive()) return true;
17567 CurrentSource = L;
17568 return EQ<PT_Float>(S, CodePtr());
17569}
17570bool EvalEmitter::emitEQReflect(SourceInfo L) {
17571 if (!isActive()) return true;
17572 CurrentSource = L;
17573 return EQ<PT_Reflect>(S, CodePtr());
17574}
17575#endif
17576#ifdef GET_OPCODE_NAMES
17577OP_EnableLocal,
17578#endif
17579#ifdef GET_INTERPFN_LIST
17580&Interp_EnableLocal,
17581#endif
17582#ifdef GET_INTERPFN_DISPATCHERS
17583PRESERVE_NONE
17584static bool Interp_EnableLocal(InterpState &S) {
17585 {
17586 const auto V0 = ReadArg<uint32_t>(S, S.PC);
17587 EnableLocal(S, V0);
17588 }
17589#if USE_TAILCALLS
17590 MUSTTAIL return InterpNext(S);
17591#else
17592 return true;
17593#endif
17594}
17595#endif
17596#ifdef GET_DISASM
17597case OP_EnableLocal:
17598 Text.Op = PrintName("EnableLocal");
17599 Text.Args.push_back(printArg<uint32_t>(PC));
17600 break;
17601#endif
17602#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17603bool emitEnableLocal( uint32_t , SourceInfo);
17604#endif
17605#ifdef GET_LINK_IMPL
17606bool ByteCodeEmitter::emitEnableLocal( uint32_t A0, SourceInfo L) {
17607 return emitOp<uint32_t>(OP_EnableLocal, A0, L);
17608}
17609#endif
17610#ifdef GET_OPCODE_NAMES
17611OP_EndInit,
17612#endif
17613#ifdef GET_INTERPFN_LIST
17614&Interp_EndInit,
17615#endif
17616#ifdef GET_INTERPFN_DISPATCHERS
17617PRESERVE_NONE
17618static bool Interp_EndInit(InterpState &S) {
17619 EndInit(S);
17620#if USE_TAILCALLS
17621 MUSTTAIL return InterpNext(S);
17622#else
17623 return true;
17624#endif
17625}
17626#endif
17627#ifdef GET_DISASM
17628case OP_EndInit:
17629 Text.Op = PrintName("EndInit");
17630 break;
17631#endif
17632#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17633bool emitEndInit(SourceInfo);
17634#endif
17635#ifdef GET_LINK_IMPL
17636bool ByteCodeEmitter::emitEndInit(SourceInfo L) {
17637 return emitOp<>(OP_EndInit, L);
17638}
17639#endif
17640#ifdef GET_EVAL_IMPL
17641bool EvalEmitter::emitEndInit(SourceInfo L) {
17642 if (!isActive()) return true;
17643 CurrentSource = L;
17644 return EndInit(S);
17645}
17646#endif
17647#ifdef GET_OPCODE_NAMES
17648OP_EndLifetime,
17649#endif
17650#ifdef GET_INTERPFN_LIST
17651&Interp_EndLifetime,
17652#endif
17653#ifdef GET_INTERPFN_DISPATCHERS
17654PRESERVE_NONE
17655static bool Interp_EndLifetime(InterpState &S) {
17656 if (!EndLifetime(S, S.PC)) return false;
17657#if USE_TAILCALLS
17658 MUSTTAIL return InterpNext(S);
17659#else
17660 return true;
17661#endif
17662}
17663#endif
17664#ifdef GET_DISASM
17665case OP_EndLifetime:
17666 Text.Op = PrintName("EndLifetime");
17667 break;
17668#endif
17669#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17670bool emitEndLifetime(SourceInfo);
17671#endif
17672#ifdef GET_LINK_IMPL
17673bool ByteCodeEmitter::emitEndLifetime(SourceInfo L) {
17674 return emitOp<>(OP_EndLifetime, L);
17675}
17676#endif
17677#ifdef GET_EVAL_IMPL
17678bool EvalEmitter::emitEndLifetime(SourceInfo L) {
17679 if (!isActive()) return true;
17680 CurrentSource = L;
17681 return EndLifetime(S, CodePtr());
17682}
17683#endif
17684#ifdef GET_OPCODE_NAMES
17685OP_EndSpeculation,
17686#endif
17687#ifdef GET_INTERPFN_LIST
17688&Interp_EndSpeculation,
17689#endif
17690#ifdef GET_INTERPFN_DISPATCHERS
17691PRESERVE_NONE
17692static bool Interp_EndSpeculation(InterpState &S) {
17693 MUSTTAIL return EndSpeculation(S);
17694}
17695#endif
17696#ifdef GET_DISASM
17697case OP_EndSpeculation:
17698 Text.Op = PrintName("EndSpeculation");
17699 break;
17700#endif
17701#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17702bool emitEndSpeculation(SourceInfo);
17703#endif
17704#ifdef GET_LINK_IMPL
17705bool ByteCodeEmitter::emitEndSpeculation(SourceInfo L) {
17706 return emitOp<>(OP_EndSpeculation, L);
17707}
17708#endif
17709#ifdef GET_EVAL_IMPL
17710bool EvalEmitter::emitEndSpeculation(SourceInfo L) {
17711 if (!isActive()) return true;
17712 CurrentSource = L;
17713return EndSpeculation(S);
17714}
17715#endif
17716#ifdef GET_OPCODE_NAMES
17717OP_Error,
17718#endif
17719#ifdef GET_INTERPFN_LIST
17720&Interp_Error,
17721#endif
17722#ifdef GET_INTERPFN_DISPATCHERS
17723PRESERVE_NONE
17724static bool Interp_Error(InterpState &S) {
17725 if (!Error(S)) return false;
17726#if USE_TAILCALLS
17727 MUSTTAIL return InterpNext(S);
17728#else
17729 return true;
17730#endif
17731}
17732#endif
17733#ifdef GET_DISASM
17734case OP_Error:
17735 Text.Op = PrintName("Error");
17736 break;
17737#endif
17738#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17739bool emitError(SourceInfo);
17740#endif
17741#ifdef GET_LINK_IMPL
17742bool ByteCodeEmitter::emitError(SourceInfo L) {
17743 return emitOp<>(OP_Error, L);
17744}
17745#endif
17746#ifdef GET_EVAL_IMPL
17747bool EvalEmitter::emitError(SourceInfo L) {
17748 if (!isActive()) return true;
17749 CurrentSource = L;
17750 return Error(S);
17751}
17752#endif
17753#ifdef GET_OPCODE_NAMES
17754OP_ExpandPtr,
17755#endif
17756#ifdef GET_INTERPFN_LIST
17757&Interp_ExpandPtr,
17758#endif
17759#ifdef GET_INTERPFN_DISPATCHERS
17760PRESERVE_NONE
17761static bool Interp_ExpandPtr(InterpState &S) {
17762 ExpandPtr(S);
17763#if USE_TAILCALLS
17764 MUSTTAIL return InterpNext(S);
17765#else
17766 return true;
17767#endif
17768}
17769#endif
17770#ifdef GET_DISASM
17771case OP_ExpandPtr:
17772 Text.Op = PrintName("ExpandPtr");
17773 break;
17774#endif
17775#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17776bool emitExpandPtr(SourceInfo);
17777#endif
17778#ifdef GET_LINK_IMPL
17779bool ByteCodeEmitter::emitExpandPtr(SourceInfo L) {
17780 return emitOp<>(OP_ExpandPtr, L);
17781}
17782#endif
17783#ifdef GET_EVAL_IMPL
17784bool EvalEmitter::emitExpandPtr(SourceInfo L) {
17785 if (!isActive()) return true;
17786 CurrentSource = L;
17787 return ExpandPtr(S);
17788}
17789#endif
17790#ifdef GET_OPCODE_NAMES
17791OP_FinishInit,
17792#endif
17793#ifdef GET_INTERPFN_LIST
17794&Interp_FinishInit,
17795#endif
17796#ifdef GET_INTERPFN_DISPATCHERS
17797PRESERVE_NONE
17798static bool Interp_FinishInit(InterpState &S) {
17799 FinishInit(S);
17800#if USE_TAILCALLS
17801 MUSTTAIL return InterpNext(S);
17802#else
17803 return true;
17804#endif
17805}
17806#endif
17807#ifdef GET_DISASM
17808case OP_FinishInit:
17809 Text.Op = PrintName("FinishInit");
17810 break;
17811#endif
17812#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17813bool emitFinishInit(SourceInfo);
17814#endif
17815#ifdef GET_LINK_IMPL
17816bool ByteCodeEmitter::emitFinishInit(SourceInfo L) {
17817 return emitOp<>(OP_FinishInit, L);
17818}
17819#endif
17820#ifdef GET_EVAL_IMPL
17821bool EvalEmitter::emitFinishInit(SourceInfo L) {
17822 if (!isActive()) return true;
17823 CurrentSource = L;
17824 return FinishInit(S);
17825}
17826#endif
17827#ifdef GET_OPCODE_NAMES
17828OP_FinishInitActivate,
17829#endif
17830#ifdef GET_INTERPFN_LIST
17831&Interp_FinishInitActivate,
17832#endif
17833#ifdef GET_INTERPFN_DISPATCHERS
17834PRESERVE_NONE
17835static bool Interp_FinishInitActivate(InterpState &S) {
17836 FinishInitActivate(S);
17837#if USE_TAILCALLS
17838 MUSTTAIL return InterpNext(S);
17839#else
17840 return true;
17841#endif
17842}
17843#endif
17844#ifdef GET_DISASM
17845case OP_FinishInitActivate:
17846 Text.Op = PrintName("FinishInitActivate");
17847 break;
17848#endif
17849#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17850bool emitFinishInitActivate(SourceInfo);
17851#endif
17852#ifdef GET_LINK_IMPL
17853bool ByteCodeEmitter::emitFinishInitActivate(SourceInfo L) {
17854 return emitOp<>(OP_FinishInitActivate, L);
17855}
17856#endif
17857#ifdef GET_EVAL_IMPL
17858bool EvalEmitter::emitFinishInitActivate(SourceInfo L) {
17859 if (!isActive()) return true;
17860 CurrentSource = L;
17861 return FinishInitActivate(S);
17862}
17863#endif
17864#ifdef GET_OPCODE_NAMES
17865OP_FinishInitActivatePop,
17866#endif
17867#ifdef GET_INTERPFN_LIST
17868&Interp_FinishInitActivatePop,
17869#endif
17870#ifdef GET_INTERPFN_DISPATCHERS
17871PRESERVE_NONE
17872static bool Interp_FinishInitActivatePop(InterpState &S) {
17873 FinishInitActivatePop(S);
17874#if USE_TAILCALLS
17875 MUSTTAIL return InterpNext(S);
17876#else
17877 return true;
17878#endif
17879}
17880#endif
17881#ifdef GET_DISASM
17882case OP_FinishInitActivatePop:
17883 Text.Op = PrintName("FinishInitActivatePop");
17884 break;
17885#endif
17886#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17887bool emitFinishInitActivatePop(SourceInfo);
17888#endif
17889#ifdef GET_LINK_IMPL
17890bool ByteCodeEmitter::emitFinishInitActivatePop(SourceInfo L) {
17891 return emitOp<>(OP_FinishInitActivatePop, L);
17892}
17893#endif
17894#ifdef GET_EVAL_IMPL
17895bool EvalEmitter::emitFinishInitActivatePop(SourceInfo L) {
17896 if (!isActive()) return true;
17897 CurrentSource = L;
17898 return FinishInitActivatePop(S);
17899}
17900#endif
17901#ifdef GET_OPCODE_NAMES
17902OP_FinishInitGlobal,
17903#endif
17904#ifdef GET_INTERPFN_LIST
17905&Interp_FinishInitGlobal,
17906#endif
17907#ifdef GET_INTERPFN_DISPATCHERS
17908PRESERVE_NONE
17909static bool Interp_FinishInitGlobal(InterpState &S) {
17910 FinishInitGlobal(S);
17911#if USE_TAILCALLS
17912 MUSTTAIL return InterpNext(S);
17913#else
17914 return true;
17915#endif
17916}
17917#endif
17918#ifdef GET_DISASM
17919case OP_FinishInitGlobal:
17920 Text.Op = PrintName("FinishInitGlobal");
17921 break;
17922#endif
17923#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17924bool emitFinishInitGlobal(SourceInfo);
17925#endif
17926#ifdef GET_LINK_IMPL
17927bool ByteCodeEmitter::emitFinishInitGlobal(SourceInfo L) {
17928 return emitOp<>(OP_FinishInitGlobal, L);
17929}
17930#endif
17931#ifdef GET_EVAL_IMPL
17932bool EvalEmitter::emitFinishInitGlobal(SourceInfo L) {
17933 if (!isActive()) return true;
17934 CurrentSource = L;
17935 return FinishInitGlobal(S);
17936}
17937#endif
17938#ifdef GET_OPCODE_NAMES
17939OP_FinishInitPop,
17940#endif
17941#ifdef GET_INTERPFN_LIST
17942&Interp_FinishInitPop,
17943#endif
17944#ifdef GET_INTERPFN_DISPATCHERS
17945PRESERVE_NONE
17946static bool Interp_FinishInitPop(InterpState &S) {
17947 FinishInitPop(S);
17948#if USE_TAILCALLS
17949 MUSTTAIL return InterpNext(S);
17950#else
17951 return true;
17952#endif
17953}
17954#endif
17955#ifdef GET_DISASM
17956case OP_FinishInitPop:
17957 Text.Op = PrintName("FinishInitPop");
17958 break;
17959#endif
17960#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
17961bool emitFinishInitPop(SourceInfo);
17962#endif
17963#ifdef GET_LINK_IMPL
17964bool ByteCodeEmitter::emitFinishInitPop(SourceInfo L) {
17965 return emitOp<>(OP_FinishInitPop, L);
17966}
17967#endif
17968#ifdef GET_EVAL_IMPL
17969bool EvalEmitter::emitFinishInitPop(SourceInfo L) {
17970 if (!isActive()) return true;
17971 CurrentSource = L;
17972 return FinishInitPop(S);
17973}
17974#endif
17975#ifdef GET_OPCODE_NAMES
17976OP_FlipSint8Sint8,
17977OP_FlipSint8Uint8,
17978OP_FlipSint8Sint16,
17979OP_FlipSint8Uint16,
17980OP_FlipSint8Sint32,
17981OP_FlipSint8Uint32,
17982OP_FlipSint8Sint64,
17983OP_FlipSint8Uint64,
17984OP_FlipSint8IntAP,
17985OP_FlipSint8IntAPS,
17986OP_FlipSint8Bool,
17987OP_FlipSint8FixedPoint,
17988OP_FlipSint8Ptr,
17989OP_FlipSint8MemberPtr,
17990OP_FlipSint8Float,
17991OP_FlipSint8Reflect,
17992OP_FlipUint8Sint8,
17993OP_FlipUint8Uint8,
17994OP_FlipUint8Sint16,
17995OP_FlipUint8Uint16,
17996OP_FlipUint8Sint32,
17997OP_FlipUint8Uint32,
17998OP_FlipUint8Sint64,
17999OP_FlipUint8Uint64,
18000OP_FlipUint8IntAP,
18001OP_FlipUint8IntAPS,
18002OP_FlipUint8Bool,
18003OP_FlipUint8FixedPoint,
18004OP_FlipUint8Ptr,
18005OP_FlipUint8MemberPtr,
18006OP_FlipUint8Float,
18007OP_FlipUint8Reflect,
18008OP_FlipSint16Sint8,
18009OP_FlipSint16Uint8,
18010OP_FlipSint16Sint16,
18011OP_FlipSint16Uint16,
18012OP_FlipSint16Sint32,
18013OP_FlipSint16Uint32,
18014OP_FlipSint16Sint64,
18015OP_FlipSint16Uint64,
18016OP_FlipSint16IntAP,
18017OP_FlipSint16IntAPS,
18018OP_FlipSint16Bool,
18019OP_FlipSint16FixedPoint,
18020OP_FlipSint16Ptr,
18021OP_FlipSint16MemberPtr,
18022OP_FlipSint16Float,
18023OP_FlipSint16Reflect,
18024OP_FlipUint16Sint8,
18025OP_FlipUint16Uint8,
18026OP_FlipUint16Sint16,
18027OP_FlipUint16Uint16,
18028OP_FlipUint16Sint32,
18029OP_FlipUint16Uint32,
18030OP_FlipUint16Sint64,
18031OP_FlipUint16Uint64,
18032OP_FlipUint16IntAP,
18033OP_FlipUint16IntAPS,
18034OP_FlipUint16Bool,
18035OP_FlipUint16FixedPoint,
18036OP_FlipUint16Ptr,
18037OP_FlipUint16MemberPtr,
18038OP_FlipUint16Float,
18039OP_FlipUint16Reflect,
18040OP_FlipSint32Sint8,
18041OP_FlipSint32Uint8,
18042OP_FlipSint32Sint16,
18043OP_FlipSint32Uint16,
18044OP_FlipSint32Sint32,
18045OP_FlipSint32Uint32,
18046OP_FlipSint32Sint64,
18047OP_FlipSint32Uint64,
18048OP_FlipSint32IntAP,
18049OP_FlipSint32IntAPS,
18050OP_FlipSint32Bool,
18051OP_FlipSint32FixedPoint,
18052OP_FlipSint32Ptr,
18053OP_FlipSint32MemberPtr,
18054OP_FlipSint32Float,
18055OP_FlipSint32Reflect,
18056OP_FlipUint32Sint8,
18057OP_FlipUint32Uint8,
18058OP_FlipUint32Sint16,
18059OP_FlipUint32Uint16,
18060OP_FlipUint32Sint32,
18061OP_FlipUint32Uint32,
18062OP_FlipUint32Sint64,
18063OP_FlipUint32Uint64,
18064OP_FlipUint32IntAP,
18065OP_FlipUint32IntAPS,
18066OP_FlipUint32Bool,
18067OP_FlipUint32FixedPoint,
18068OP_FlipUint32Ptr,
18069OP_FlipUint32MemberPtr,
18070OP_FlipUint32Float,
18071OP_FlipUint32Reflect,
18072OP_FlipSint64Sint8,
18073OP_FlipSint64Uint8,
18074OP_FlipSint64Sint16,
18075OP_FlipSint64Uint16,
18076OP_FlipSint64Sint32,
18077OP_FlipSint64Uint32,
18078OP_FlipSint64Sint64,
18079OP_FlipSint64Uint64,
18080OP_FlipSint64IntAP,
18081OP_FlipSint64IntAPS,
18082OP_FlipSint64Bool,
18083OP_FlipSint64FixedPoint,
18084OP_FlipSint64Ptr,
18085OP_FlipSint64MemberPtr,
18086OP_FlipSint64Float,
18087OP_FlipSint64Reflect,
18088OP_FlipUint64Sint8,
18089OP_FlipUint64Uint8,
18090OP_FlipUint64Sint16,
18091OP_FlipUint64Uint16,
18092OP_FlipUint64Sint32,
18093OP_FlipUint64Uint32,
18094OP_FlipUint64Sint64,
18095OP_FlipUint64Uint64,
18096OP_FlipUint64IntAP,
18097OP_FlipUint64IntAPS,
18098OP_FlipUint64Bool,
18099OP_FlipUint64FixedPoint,
18100OP_FlipUint64Ptr,
18101OP_FlipUint64MemberPtr,
18102OP_FlipUint64Float,
18103OP_FlipUint64Reflect,
18104OP_FlipIntAPSint8,
18105OP_FlipIntAPUint8,
18106OP_FlipIntAPSint16,
18107OP_FlipIntAPUint16,
18108OP_FlipIntAPSint32,
18109OP_FlipIntAPUint32,
18110OP_FlipIntAPSint64,
18111OP_FlipIntAPUint64,
18112OP_FlipIntAPIntAP,
18113OP_FlipIntAPIntAPS,
18114OP_FlipIntAPBool,
18115OP_FlipIntAPFixedPoint,
18116OP_FlipIntAPPtr,
18117OP_FlipIntAPMemberPtr,
18118OP_FlipIntAPFloat,
18119OP_FlipIntAPReflect,
18120OP_FlipIntAPSSint8,
18121OP_FlipIntAPSUint8,
18122OP_FlipIntAPSSint16,
18123OP_FlipIntAPSUint16,
18124OP_FlipIntAPSSint32,
18125OP_FlipIntAPSUint32,
18126OP_FlipIntAPSSint64,
18127OP_FlipIntAPSUint64,
18128OP_FlipIntAPSIntAP,
18129OP_FlipIntAPSIntAPS,
18130OP_FlipIntAPSBool,
18131OP_FlipIntAPSFixedPoint,
18132OP_FlipIntAPSPtr,
18133OP_FlipIntAPSMemberPtr,
18134OP_FlipIntAPSFloat,
18135OP_FlipIntAPSReflect,
18136OP_FlipBoolSint8,
18137OP_FlipBoolUint8,
18138OP_FlipBoolSint16,
18139OP_FlipBoolUint16,
18140OP_FlipBoolSint32,
18141OP_FlipBoolUint32,
18142OP_FlipBoolSint64,
18143OP_FlipBoolUint64,
18144OP_FlipBoolIntAP,
18145OP_FlipBoolIntAPS,
18146OP_FlipBoolBool,
18147OP_FlipBoolFixedPoint,
18148OP_FlipBoolPtr,
18149OP_FlipBoolMemberPtr,
18150OP_FlipBoolFloat,
18151OP_FlipBoolReflect,
18152OP_FlipFixedPointSint8,
18153OP_FlipFixedPointUint8,
18154OP_FlipFixedPointSint16,
18155OP_FlipFixedPointUint16,
18156OP_FlipFixedPointSint32,
18157OP_FlipFixedPointUint32,
18158OP_FlipFixedPointSint64,
18159OP_FlipFixedPointUint64,
18160OP_FlipFixedPointIntAP,
18161OP_FlipFixedPointIntAPS,
18162OP_FlipFixedPointBool,
18163OP_FlipFixedPointFixedPoint,
18164OP_FlipFixedPointPtr,
18165OP_FlipFixedPointMemberPtr,
18166OP_FlipFixedPointFloat,
18167OP_FlipFixedPointReflect,
18168OP_FlipPtrSint8,
18169OP_FlipPtrUint8,
18170OP_FlipPtrSint16,
18171OP_FlipPtrUint16,
18172OP_FlipPtrSint32,
18173OP_FlipPtrUint32,
18174OP_FlipPtrSint64,
18175OP_FlipPtrUint64,
18176OP_FlipPtrIntAP,
18177OP_FlipPtrIntAPS,
18178OP_FlipPtrBool,
18179OP_FlipPtrFixedPoint,
18180OP_FlipPtrPtr,
18181OP_FlipPtrMemberPtr,
18182OP_FlipPtrFloat,
18183OP_FlipPtrReflect,
18184OP_FlipMemberPtrSint8,
18185OP_FlipMemberPtrUint8,
18186OP_FlipMemberPtrSint16,
18187OP_FlipMemberPtrUint16,
18188OP_FlipMemberPtrSint32,
18189OP_FlipMemberPtrUint32,
18190OP_FlipMemberPtrSint64,
18191OP_FlipMemberPtrUint64,
18192OP_FlipMemberPtrIntAP,
18193OP_FlipMemberPtrIntAPS,
18194OP_FlipMemberPtrBool,
18195OP_FlipMemberPtrFixedPoint,
18196OP_FlipMemberPtrPtr,
18197OP_FlipMemberPtrMemberPtr,
18198OP_FlipMemberPtrFloat,
18199OP_FlipMemberPtrReflect,
18200OP_FlipFloatSint8,
18201OP_FlipFloatUint8,
18202OP_FlipFloatSint16,
18203OP_FlipFloatUint16,
18204OP_FlipFloatSint32,
18205OP_FlipFloatUint32,
18206OP_FlipFloatSint64,
18207OP_FlipFloatUint64,
18208OP_FlipFloatIntAP,
18209OP_FlipFloatIntAPS,
18210OP_FlipFloatBool,
18211OP_FlipFloatFixedPoint,
18212OP_FlipFloatPtr,
18213OP_FlipFloatMemberPtr,
18214OP_FlipFloatFloat,
18215OP_FlipFloatReflect,
18216OP_FlipReflectSint8,
18217OP_FlipReflectUint8,
18218OP_FlipReflectSint16,
18219OP_FlipReflectUint16,
18220OP_FlipReflectSint32,
18221OP_FlipReflectUint32,
18222OP_FlipReflectSint64,
18223OP_FlipReflectUint64,
18224OP_FlipReflectIntAP,
18225OP_FlipReflectIntAPS,
18226OP_FlipReflectBool,
18227OP_FlipReflectFixedPoint,
18228OP_FlipReflectPtr,
18229OP_FlipReflectMemberPtr,
18230OP_FlipReflectFloat,
18231OP_FlipReflectReflect,
18232#endif
18233#ifdef GET_INTERPFN_LIST
18234&Interp_FlipSint8Sint8,
18235&Interp_FlipSint8Uint8,
18236&Interp_FlipSint8Sint16,
18237&Interp_FlipSint8Uint16,
18238&Interp_FlipSint8Sint32,
18239&Interp_FlipSint8Uint32,
18240&Interp_FlipSint8Sint64,
18241&Interp_FlipSint8Uint64,
18242&Interp_FlipSint8IntAP,
18243&Interp_FlipSint8IntAPS,
18244&Interp_FlipSint8Bool,
18245&Interp_FlipSint8FixedPoint,
18246&Interp_FlipSint8Ptr,
18247&Interp_FlipSint8MemberPtr,
18248&Interp_FlipSint8Float,
18249&Interp_FlipSint8Reflect,
18250&Interp_FlipUint8Sint8,
18251&Interp_FlipUint8Uint8,
18252&Interp_FlipUint8Sint16,
18253&Interp_FlipUint8Uint16,
18254&Interp_FlipUint8Sint32,
18255&Interp_FlipUint8Uint32,
18256&Interp_FlipUint8Sint64,
18257&Interp_FlipUint8Uint64,
18258&Interp_FlipUint8IntAP,
18259&Interp_FlipUint8IntAPS,
18260&Interp_FlipUint8Bool,
18261&Interp_FlipUint8FixedPoint,
18262&Interp_FlipUint8Ptr,
18263&Interp_FlipUint8MemberPtr,
18264&Interp_FlipUint8Float,
18265&Interp_FlipUint8Reflect,
18266&Interp_FlipSint16Sint8,
18267&Interp_FlipSint16Uint8,
18268&Interp_FlipSint16Sint16,
18269&Interp_FlipSint16Uint16,
18270&Interp_FlipSint16Sint32,
18271&Interp_FlipSint16Uint32,
18272&Interp_FlipSint16Sint64,
18273&Interp_FlipSint16Uint64,
18274&Interp_FlipSint16IntAP,
18275&Interp_FlipSint16IntAPS,
18276&Interp_FlipSint16Bool,
18277&Interp_FlipSint16FixedPoint,
18278&Interp_FlipSint16Ptr,
18279&Interp_FlipSint16MemberPtr,
18280&Interp_FlipSint16Float,
18281&Interp_FlipSint16Reflect,
18282&Interp_FlipUint16Sint8,
18283&Interp_FlipUint16Uint8,
18284&Interp_FlipUint16Sint16,
18285&Interp_FlipUint16Uint16,
18286&Interp_FlipUint16Sint32,
18287&Interp_FlipUint16Uint32,
18288&Interp_FlipUint16Sint64,
18289&Interp_FlipUint16Uint64,
18290&Interp_FlipUint16IntAP,
18291&Interp_FlipUint16IntAPS,
18292&Interp_FlipUint16Bool,
18293&Interp_FlipUint16FixedPoint,
18294&Interp_FlipUint16Ptr,
18295&Interp_FlipUint16MemberPtr,
18296&Interp_FlipUint16Float,
18297&Interp_FlipUint16Reflect,
18298&Interp_FlipSint32Sint8,
18299&Interp_FlipSint32Uint8,
18300&Interp_FlipSint32Sint16,
18301&Interp_FlipSint32Uint16,
18302&Interp_FlipSint32Sint32,
18303&Interp_FlipSint32Uint32,
18304&Interp_FlipSint32Sint64,
18305&Interp_FlipSint32Uint64,
18306&Interp_FlipSint32IntAP,
18307&Interp_FlipSint32IntAPS,
18308&Interp_FlipSint32Bool,
18309&Interp_FlipSint32FixedPoint,
18310&Interp_FlipSint32Ptr,
18311&Interp_FlipSint32MemberPtr,
18312&Interp_FlipSint32Float,
18313&Interp_FlipSint32Reflect,
18314&Interp_FlipUint32Sint8,
18315&Interp_FlipUint32Uint8,
18316&Interp_FlipUint32Sint16,
18317&Interp_FlipUint32Uint16,
18318&Interp_FlipUint32Sint32,
18319&Interp_FlipUint32Uint32,
18320&Interp_FlipUint32Sint64,
18321&Interp_FlipUint32Uint64,
18322&Interp_FlipUint32IntAP,
18323&Interp_FlipUint32IntAPS,
18324&Interp_FlipUint32Bool,
18325&Interp_FlipUint32FixedPoint,
18326&Interp_FlipUint32Ptr,
18327&Interp_FlipUint32MemberPtr,
18328&Interp_FlipUint32Float,
18329&Interp_FlipUint32Reflect,
18330&Interp_FlipSint64Sint8,
18331&Interp_FlipSint64Uint8,
18332&Interp_FlipSint64Sint16,
18333&Interp_FlipSint64Uint16,
18334&Interp_FlipSint64Sint32,
18335&Interp_FlipSint64Uint32,
18336&Interp_FlipSint64Sint64,
18337&Interp_FlipSint64Uint64,
18338&Interp_FlipSint64IntAP,
18339&Interp_FlipSint64IntAPS,
18340&Interp_FlipSint64Bool,
18341&Interp_FlipSint64FixedPoint,
18342&Interp_FlipSint64Ptr,
18343&Interp_FlipSint64MemberPtr,
18344&Interp_FlipSint64Float,
18345&Interp_FlipSint64Reflect,
18346&Interp_FlipUint64Sint8,
18347&Interp_FlipUint64Uint8,
18348&Interp_FlipUint64Sint16,
18349&Interp_FlipUint64Uint16,
18350&Interp_FlipUint64Sint32,
18351&Interp_FlipUint64Uint32,
18352&Interp_FlipUint64Sint64,
18353&Interp_FlipUint64Uint64,
18354&Interp_FlipUint64IntAP,
18355&Interp_FlipUint64IntAPS,
18356&Interp_FlipUint64Bool,
18357&Interp_FlipUint64FixedPoint,
18358&Interp_FlipUint64Ptr,
18359&Interp_FlipUint64MemberPtr,
18360&Interp_FlipUint64Float,
18361&Interp_FlipUint64Reflect,
18362&Interp_FlipIntAPSint8,
18363&Interp_FlipIntAPUint8,
18364&Interp_FlipIntAPSint16,
18365&Interp_FlipIntAPUint16,
18366&Interp_FlipIntAPSint32,
18367&Interp_FlipIntAPUint32,
18368&Interp_FlipIntAPSint64,
18369&Interp_FlipIntAPUint64,
18370&Interp_FlipIntAPIntAP,
18371&Interp_FlipIntAPIntAPS,
18372&Interp_FlipIntAPBool,
18373&Interp_FlipIntAPFixedPoint,
18374&Interp_FlipIntAPPtr,
18375&Interp_FlipIntAPMemberPtr,
18376&Interp_FlipIntAPFloat,
18377&Interp_FlipIntAPReflect,
18378&Interp_FlipIntAPSSint8,
18379&Interp_FlipIntAPSUint8,
18380&Interp_FlipIntAPSSint16,
18381&Interp_FlipIntAPSUint16,
18382&Interp_FlipIntAPSSint32,
18383&Interp_FlipIntAPSUint32,
18384&Interp_FlipIntAPSSint64,
18385&Interp_FlipIntAPSUint64,
18386&Interp_FlipIntAPSIntAP,
18387&Interp_FlipIntAPSIntAPS,
18388&Interp_FlipIntAPSBool,
18389&Interp_FlipIntAPSFixedPoint,
18390&Interp_FlipIntAPSPtr,
18391&Interp_FlipIntAPSMemberPtr,
18392&Interp_FlipIntAPSFloat,
18393&Interp_FlipIntAPSReflect,
18394&Interp_FlipBoolSint8,
18395&Interp_FlipBoolUint8,
18396&Interp_FlipBoolSint16,
18397&Interp_FlipBoolUint16,
18398&Interp_FlipBoolSint32,
18399&Interp_FlipBoolUint32,
18400&Interp_FlipBoolSint64,
18401&Interp_FlipBoolUint64,
18402&Interp_FlipBoolIntAP,
18403&Interp_FlipBoolIntAPS,
18404&Interp_FlipBoolBool,
18405&Interp_FlipBoolFixedPoint,
18406&Interp_FlipBoolPtr,
18407&Interp_FlipBoolMemberPtr,
18408&Interp_FlipBoolFloat,
18409&Interp_FlipBoolReflect,
18410&Interp_FlipFixedPointSint8,
18411&Interp_FlipFixedPointUint8,
18412&Interp_FlipFixedPointSint16,
18413&Interp_FlipFixedPointUint16,
18414&Interp_FlipFixedPointSint32,
18415&Interp_FlipFixedPointUint32,
18416&Interp_FlipFixedPointSint64,
18417&Interp_FlipFixedPointUint64,
18418&Interp_FlipFixedPointIntAP,
18419&Interp_FlipFixedPointIntAPS,
18420&Interp_FlipFixedPointBool,
18421&Interp_FlipFixedPointFixedPoint,
18422&Interp_FlipFixedPointPtr,
18423&Interp_FlipFixedPointMemberPtr,
18424&Interp_FlipFixedPointFloat,
18425&Interp_FlipFixedPointReflect,
18426&Interp_FlipPtrSint8,
18427&Interp_FlipPtrUint8,
18428&Interp_FlipPtrSint16,
18429&Interp_FlipPtrUint16,
18430&Interp_FlipPtrSint32,
18431&Interp_FlipPtrUint32,
18432&Interp_FlipPtrSint64,
18433&Interp_FlipPtrUint64,
18434&Interp_FlipPtrIntAP,
18435&Interp_FlipPtrIntAPS,
18436&Interp_FlipPtrBool,
18437&Interp_FlipPtrFixedPoint,
18438&Interp_FlipPtrPtr,
18439&Interp_FlipPtrMemberPtr,
18440&Interp_FlipPtrFloat,
18441&Interp_FlipPtrReflect,
18442&Interp_FlipMemberPtrSint8,
18443&Interp_FlipMemberPtrUint8,
18444&Interp_FlipMemberPtrSint16,
18445&Interp_FlipMemberPtrUint16,
18446&Interp_FlipMemberPtrSint32,
18447&Interp_FlipMemberPtrUint32,
18448&Interp_FlipMemberPtrSint64,
18449&Interp_FlipMemberPtrUint64,
18450&Interp_FlipMemberPtrIntAP,
18451&Interp_FlipMemberPtrIntAPS,
18452&Interp_FlipMemberPtrBool,
18453&Interp_FlipMemberPtrFixedPoint,
18454&Interp_FlipMemberPtrPtr,
18455&Interp_FlipMemberPtrMemberPtr,
18456&Interp_FlipMemberPtrFloat,
18457&Interp_FlipMemberPtrReflect,
18458&Interp_FlipFloatSint8,
18459&Interp_FlipFloatUint8,
18460&Interp_FlipFloatSint16,
18461&Interp_FlipFloatUint16,
18462&Interp_FlipFloatSint32,
18463&Interp_FlipFloatUint32,
18464&Interp_FlipFloatSint64,
18465&Interp_FlipFloatUint64,
18466&Interp_FlipFloatIntAP,
18467&Interp_FlipFloatIntAPS,
18468&Interp_FlipFloatBool,
18469&Interp_FlipFloatFixedPoint,
18470&Interp_FlipFloatPtr,
18471&Interp_FlipFloatMemberPtr,
18472&Interp_FlipFloatFloat,
18473&Interp_FlipFloatReflect,
18474&Interp_FlipReflectSint8,
18475&Interp_FlipReflectUint8,
18476&Interp_FlipReflectSint16,
18477&Interp_FlipReflectUint16,
18478&Interp_FlipReflectSint32,
18479&Interp_FlipReflectUint32,
18480&Interp_FlipReflectSint64,
18481&Interp_FlipReflectUint64,
18482&Interp_FlipReflectIntAP,
18483&Interp_FlipReflectIntAPS,
18484&Interp_FlipReflectBool,
18485&Interp_FlipReflectFixedPoint,
18486&Interp_FlipReflectPtr,
18487&Interp_FlipReflectMemberPtr,
18488&Interp_FlipReflectFloat,
18489&Interp_FlipReflectReflect,
18490#endif
18491#ifdef GET_INTERPFN_DISPATCHERS
18492PRESERVE_NONE
18493static bool Interp_FlipSint8Sint8(InterpState &S) {
18494 Flip<PT_Sint8, PT_Sint8>(S);
18495#if USE_TAILCALLS
18496 MUSTTAIL return InterpNext(S);
18497#else
18498 return true;
18499#endif
18500}
18501PRESERVE_NONE
18502static bool Interp_FlipSint8Uint8(InterpState &S) {
18503 Flip<PT_Sint8, PT_Uint8>(S);
18504#if USE_TAILCALLS
18505 MUSTTAIL return InterpNext(S);
18506#else
18507 return true;
18508#endif
18509}
18510PRESERVE_NONE
18511static bool Interp_FlipSint8Sint16(InterpState &S) {
18512 Flip<PT_Sint8, PT_Sint16>(S);
18513#if USE_TAILCALLS
18514 MUSTTAIL return InterpNext(S);
18515#else
18516 return true;
18517#endif
18518}
18519PRESERVE_NONE
18520static bool Interp_FlipSint8Uint16(InterpState &S) {
18521 Flip<PT_Sint8, PT_Uint16>(S);
18522#if USE_TAILCALLS
18523 MUSTTAIL return InterpNext(S);
18524#else
18525 return true;
18526#endif
18527}
18528PRESERVE_NONE
18529static bool Interp_FlipSint8Sint32(InterpState &S) {
18530 Flip<PT_Sint8, PT_Sint32>(S);
18531#if USE_TAILCALLS
18532 MUSTTAIL return InterpNext(S);
18533#else
18534 return true;
18535#endif
18536}
18537PRESERVE_NONE
18538static bool Interp_FlipSint8Uint32(InterpState &S) {
18539 Flip<PT_Sint8, PT_Uint32>(S);
18540#if USE_TAILCALLS
18541 MUSTTAIL return InterpNext(S);
18542#else
18543 return true;
18544#endif
18545}
18546PRESERVE_NONE
18547static bool Interp_FlipSint8Sint64(InterpState &S) {
18548 Flip<PT_Sint8, PT_Sint64>(S);
18549#if USE_TAILCALLS
18550 MUSTTAIL return InterpNext(S);
18551#else
18552 return true;
18553#endif
18554}
18555PRESERVE_NONE
18556static bool Interp_FlipSint8Uint64(InterpState &S) {
18557 Flip<PT_Sint8, PT_Uint64>(S);
18558#if USE_TAILCALLS
18559 MUSTTAIL return InterpNext(S);
18560#else
18561 return true;
18562#endif
18563}
18564PRESERVE_NONE
18565static bool Interp_FlipSint8IntAP(InterpState &S) {
18566 Flip<PT_Sint8, PT_IntAP>(S);
18567#if USE_TAILCALLS
18568 MUSTTAIL return InterpNext(S);
18569#else
18570 return true;
18571#endif
18572}
18573PRESERVE_NONE
18574static bool Interp_FlipSint8IntAPS(InterpState &S) {
18575 Flip<PT_Sint8, PT_IntAPS>(S);
18576#if USE_TAILCALLS
18577 MUSTTAIL return InterpNext(S);
18578#else
18579 return true;
18580#endif
18581}
18582PRESERVE_NONE
18583static bool Interp_FlipSint8Bool(InterpState &S) {
18584 Flip<PT_Sint8, PT_Bool>(S);
18585#if USE_TAILCALLS
18586 MUSTTAIL return InterpNext(S);
18587#else
18588 return true;
18589#endif
18590}
18591PRESERVE_NONE
18592static bool Interp_FlipSint8FixedPoint(InterpState &S) {
18593 Flip<PT_Sint8, PT_FixedPoint>(S);
18594#if USE_TAILCALLS
18595 MUSTTAIL return InterpNext(S);
18596#else
18597 return true;
18598#endif
18599}
18600PRESERVE_NONE
18601static bool Interp_FlipSint8Ptr(InterpState &S) {
18602 Flip<PT_Sint8, PT_Ptr>(S);
18603#if USE_TAILCALLS
18604 MUSTTAIL return InterpNext(S);
18605#else
18606 return true;
18607#endif
18608}
18609PRESERVE_NONE
18610static bool Interp_FlipSint8MemberPtr(InterpState &S) {
18611 Flip<PT_Sint8, PT_MemberPtr>(S);
18612#if USE_TAILCALLS
18613 MUSTTAIL return InterpNext(S);
18614#else
18615 return true;
18616#endif
18617}
18618PRESERVE_NONE
18619static bool Interp_FlipSint8Float(InterpState &S) {
18620 Flip<PT_Sint8, PT_Float>(S);
18621#if USE_TAILCALLS
18622 MUSTTAIL return InterpNext(S);
18623#else
18624 return true;
18625#endif
18626}
18627PRESERVE_NONE
18628static bool Interp_FlipSint8Reflect(InterpState &S) {
18629 Flip<PT_Sint8, PT_Reflect>(S);
18630#if USE_TAILCALLS
18631 MUSTTAIL return InterpNext(S);
18632#else
18633 return true;
18634#endif
18635}
18636PRESERVE_NONE
18637static bool Interp_FlipUint8Sint8(InterpState &S) {
18638 Flip<PT_Uint8, PT_Sint8>(S);
18639#if USE_TAILCALLS
18640 MUSTTAIL return InterpNext(S);
18641#else
18642 return true;
18643#endif
18644}
18645PRESERVE_NONE
18646static bool Interp_FlipUint8Uint8(InterpState &S) {
18647 Flip<PT_Uint8, PT_Uint8>(S);
18648#if USE_TAILCALLS
18649 MUSTTAIL return InterpNext(S);
18650#else
18651 return true;
18652#endif
18653}
18654PRESERVE_NONE
18655static bool Interp_FlipUint8Sint16(InterpState &S) {
18656 Flip<PT_Uint8, PT_Sint16>(S);
18657#if USE_TAILCALLS
18658 MUSTTAIL return InterpNext(S);
18659#else
18660 return true;
18661#endif
18662}
18663PRESERVE_NONE
18664static bool Interp_FlipUint8Uint16(InterpState &S) {
18665 Flip<PT_Uint8, PT_Uint16>(S);
18666#if USE_TAILCALLS
18667 MUSTTAIL return InterpNext(S);
18668#else
18669 return true;
18670#endif
18671}
18672PRESERVE_NONE
18673static bool Interp_FlipUint8Sint32(InterpState &S) {
18674 Flip<PT_Uint8, PT_Sint32>(S);
18675#if USE_TAILCALLS
18676 MUSTTAIL return InterpNext(S);
18677#else
18678 return true;
18679#endif
18680}
18681PRESERVE_NONE
18682static bool Interp_FlipUint8Uint32(InterpState &S) {
18683 Flip<PT_Uint8, PT_Uint32>(S);
18684#if USE_TAILCALLS
18685 MUSTTAIL return InterpNext(S);
18686#else
18687 return true;
18688#endif
18689}
18690PRESERVE_NONE
18691static bool Interp_FlipUint8Sint64(InterpState &S) {
18692 Flip<PT_Uint8, PT_Sint64>(S);
18693#if USE_TAILCALLS
18694 MUSTTAIL return InterpNext(S);
18695#else
18696 return true;
18697#endif
18698}
18699PRESERVE_NONE
18700static bool Interp_FlipUint8Uint64(InterpState &S) {
18701 Flip<PT_Uint8, PT_Uint64>(S);
18702#if USE_TAILCALLS
18703 MUSTTAIL return InterpNext(S);
18704#else
18705 return true;
18706#endif
18707}
18708PRESERVE_NONE
18709static bool Interp_FlipUint8IntAP(InterpState &S) {
18710 Flip<PT_Uint8, PT_IntAP>(S);
18711#if USE_TAILCALLS
18712 MUSTTAIL return InterpNext(S);
18713#else
18714 return true;
18715#endif
18716}
18717PRESERVE_NONE
18718static bool Interp_FlipUint8IntAPS(InterpState &S) {
18719 Flip<PT_Uint8, PT_IntAPS>(S);
18720#if USE_TAILCALLS
18721 MUSTTAIL return InterpNext(S);
18722#else
18723 return true;
18724#endif
18725}
18726PRESERVE_NONE
18727static bool Interp_FlipUint8Bool(InterpState &S) {
18728 Flip<PT_Uint8, PT_Bool>(S);
18729#if USE_TAILCALLS
18730 MUSTTAIL return InterpNext(S);
18731#else
18732 return true;
18733#endif
18734}
18735PRESERVE_NONE
18736static bool Interp_FlipUint8FixedPoint(InterpState &S) {
18737 Flip<PT_Uint8, PT_FixedPoint>(S);
18738#if USE_TAILCALLS
18739 MUSTTAIL return InterpNext(S);
18740#else
18741 return true;
18742#endif
18743}
18744PRESERVE_NONE
18745static bool Interp_FlipUint8Ptr(InterpState &S) {
18746 Flip<PT_Uint8, PT_Ptr>(S);
18747#if USE_TAILCALLS
18748 MUSTTAIL return InterpNext(S);
18749#else
18750 return true;
18751#endif
18752}
18753PRESERVE_NONE
18754static bool Interp_FlipUint8MemberPtr(InterpState &S) {
18755 Flip<PT_Uint8, PT_MemberPtr>(S);
18756#if USE_TAILCALLS
18757 MUSTTAIL return InterpNext(S);
18758#else
18759 return true;
18760#endif
18761}
18762PRESERVE_NONE
18763static bool Interp_FlipUint8Float(InterpState &S) {
18764 Flip<PT_Uint8, PT_Float>(S);
18765#if USE_TAILCALLS
18766 MUSTTAIL return InterpNext(S);
18767#else
18768 return true;
18769#endif
18770}
18771PRESERVE_NONE
18772static bool Interp_FlipUint8Reflect(InterpState &S) {
18773 Flip<PT_Uint8, PT_Reflect>(S);
18774#if USE_TAILCALLS
18775 MUSTTAIL return InterpNext(S);
18776#else
18777 return true;
18778#endif
18779}
18780PRESERVE_NONE
18781static bool Interp_FlipSint16Sint8(InterpState &S) {
18782 Flip<PT_Sint16, PT_Sint8>(S);
18783#if USE_TAILCALLS
18784 MUSTTAIL return InterpNext(S);
18785#else
18786 return true;
18787#endif
18788}
18789PRESERVE_NONE
18790static bool Interp_FlipSint16Uint8(InterpState &S) {
18791 Flip<PT_Sint16, PT_Uint8>(S);
18792#if USE_TAILCALLS
18793 MUSTTAIL return InterpNext(S);
18794#else
18795 return true;
18796#endif
18797}
18798PRESERVE_NONE
18799static bool Interp_FlipSint16Sint16(InterpState &S) {
18800 Flip<PT_Sint16, PT_Sint16>(S);
18801#if USE_TAILCALLS
18802 MUSTTAIL return InterpNext(S);
18803#else
18804 return true;
18805#endif
18806}
18807PRESERVE_NONE
18808static bool Interp_FlipSint16Uint16(InterpState &S) {
18809 Flip<PT_Sint16, PT_Uint16>(S);
18810#if USE_TAILCALLS
18811 MUSTTAIL return InterpNext(S);
18812#else
18813 return true;
18814#endif
18815}
18816PRESERVE_NONE
18817static bool Interp_FlipSint16Sint32(InterpState &S) {
18818 Flip<PT_Sint16, PT_Sint32>(S);
18819#if USE_TAILCALLS
18820 MUSTTAIL return InterpNext(S);
18821#else
18822 return true;
18823#endif
18824}
18825PRESERVE_NONE
18826static bool Interp_FlipSint16Uint32(InterpState &S) {
18827 Flip<PT_Sint16, PT_Uint32>(S);
18828#if USE_TAILCALLS
18829 MUSTTAIL return InterpNext(S);
18830#else
18831 return true;
18832#endif
18833}
18834PRESERVE_NONE
18835static bool Interp_FlipSint16Sint64(InterpState &S) {
18836 Flip<PT_Sint16, PT_Sint64>(S);
18837#if USE_TAILCALLS
18838 MUSTTAIL return InterpNext(S);
18839#else
18840 return true;
18841#endif
18842}
18843PRESERVE_NONE
18844static bool Interp_FlipSint16Uint64(InterpState &S) {
18845 Flip<PT_Sint16, PT_Uint64>(S);
18846#if USE_TAILCALLS
18847 MUSTTAIL return InterpNext(S);
18848#else
18849 return true;
18850#endif
18851}
18852PRESERVE_NONE
18853static bool Interp_FlipSint16IntAP(InterpState &S) {
18854 Flip<PT_Sint16, PT_IntAP>(S);
18855#if USE_TAILCALLS
18856 MUSTTAIL return InterpNext(S);
18857#else
18858 return true;
18859#endif
18860}
18861PRESERVE_NONE
18862static bool Interp_FlipSint16IntAPS(InterpState &S) {
18863 Flip<PT_Sint16, PT_IntAPS>(S);
18864#if USE_TAILCALLS
18865 MUSTTAIL return InterpNext(S);
18866#else
18867 return true;
18868#endif
18869}
18870PRESERVE_NONE
18871static bool Interp_FlipSint16Bool(InterpState &S) {
18872 Flip<PT_Sint16, PT_Bool>(S);
18873#if USE_TAILCALLS
18874 MUSTTAIL return InterpNext(S);
18875#else
18876 return true;
18877#endif
18878}
18879PRESERVE_NONE
18880static bool Interp_FlipSint16FixedPoint(InterpState &S) {
18881 Flip<PT_Sint16, PT_FixedPoint>(S);
18882#if USE_TAILCALLS
18883 MUSTTAIL return InterpNext(S);
18884#else
18885 return true;
18886#endif
18887}
18888PRESERVE_NONE
18889static bool Interp_FlipSint16Ptr(InterpState &S) {
18890 Flip<PT_Sint16, PT_Ptr>(S);
18891#if USE_TAILCALLS
18892 MUSTTAIL return InterpNext(S);
18893#else
18894 return true;
18895#endif
18896}
18897PRESERVE_NONE
18898static bool Interp_FlipSint16MemberPtr(InterpState &S) {
18899 Flip<PT_Sint16, PT_MemberPtr>(S);
18900#if USE_TAILCALLS
18901 MUSTTAIL return InterpNext(S);
18902#else
18903 return true;
18904#endif
18905}
18906PRESERVE_NONE
18907static bool Interp_FlipSint16Float(InterpState &S) {
18908 Flip<PT_Sint16, PT_Float>(S);
18909#if USE_TAILCALLS
18910 MUSTTAIL return InterpNext(S);
18911#else
18912 return true;
18913#endif
18914}
18915PRESERVE_NONE
18916static bool Interp_FlipSint16Reflect(InterpState &S) {
18917 Flip<PT_Sint16, PT_Reflect>(S);
18918#if USE_TAILCALLS
18919 MUSTTAIL return InterpNext(S);
18920#else
18921 return true;
18922#endif
18923}
18924PRESERVE_NONE
18925static bool Interp_FlipUint16Sint8(InterpState &S) {
18926 Flip<PT_Uint16, PT_Sint8>(S);
18927#if USE_TAILCALLS
18928 MUSTTAIL return InterpNext(S);
18929#else
18930 return true;
18931#endif
18932}
18933PRESERVE_NONE
18934static bool Interp_FlipUint16Uint8(InterpState &S) {
18935 Flip<PT_Uint16, PT_Uint8>(S);
18936#if USE_TAILCALLS
18937 MUSTTAIL return InterpNext(S);
18938#else
18939 return true;
18940#endif
18941}
18942PRESERVE_NONE
18943static bool Interp_FlipUint16Sint16(InterpState &S) {
18944 Flip<PT_Uint16, PT_Sint16>(S);
18945#if USE_TAILCALLS
18946 MUSTTAIL return InterpNext(S);
18947#else
18948 return true;
18949#endif
18950}
18951PRESERVE_NONE
18952static bool Interp_FlipUint16Uint16(InterpState &S) {
18953 Flip<PT_Uint16, PT_Uint16>(S);
18954#if USE_TAILCALLS
18955 MUSTTAIL return InterpNext(S);
18956#else
18957 return true;
18958#endif
18959}
18960PRESERVE_NONE
18961static bool Interp_FlipUint16Sint32(InterpState &S) {
18962 Flip<PT_Uint16, PT_Sint32>(S);
18963#if USE_TAILCALLS
18964 MUSTTAIL return InterpNext(S);
18965#else
18966 return true;
18967#endif
18968}
18969PRESERVE_NONE
18970static bool Interp_FlipUint16Uint32(InterpState &S) {
18971 Flip<PT_Uint16, PT_Uint32>(S);
18972#if USE_TAILCALLS
18973 MUSTTAIL return InterpNext(S);
18974#else
18975 return true;
18976#endif
18977}
18978PRESERVE_NONE
18979static bool Interp_FlipUint16Sint64(InterpState &S) {
18980 Flip<PT_Uint16, PT_Sint64>(S);
18981#if USE_TAILCALLS
18982 MUSTTAIL return InterpNext(S);
18983#else
18984 return true;
18985#endif
18986}
18987PRESERVE_NONE
18988static bool Interp_FlipUint16Uint64(InterpState &S) {
18989 Flip<PT_Uint16, PT_Uint64>(S);
18990#if USE_TAILCALLS
18991 MUSTTAIL return InterpNext(S);
18992#else
18993 return true;
18994#endif
18995}
18996PRESERVE_NONE
18997static bool Interp_FlipUint16IntAP(InterpState &S) {
18998 Flip<PT_Uint16, PT_IntAP>(S);
18999#if USE_TAILCALLS
19000 MUSTTAIL return InterpNext(S);
19001#else
19002 return true;
19003#endif
19004}
19005PRESERVE_NONE
19006static bool Interp_FlipUint16IntAPS(InterpState &S) {
19007 Flip<PT_Uint16, PT_IntAPS>(S);
19008#if USE_TAILCALLS
19009 MUSTTAIL return InterpNext(S);
19010#else
19011 return true;
19012#endif
19013}
19014PRESERVE_NONE
19015static bool Interp_FlipUint16Bool(InterpState &S) {
19016 Flip<PT_Uint16, PT_Bool>(S);
19017#if USE_TAILCALLS
19018 MUSTTAIL return InterpNext(S);
19019#else
19020 return true;
19021#endif
19022}
19023PRESERVE_NONE
19024static bool Interp_FlipUint16FixedPoint(InterpState &S) {
19025 Flip<PT_Uint16, PT_FixedPoint>(S);
19026#if USE_TAILCALLS
19027 MUSTTAIL return InterpNext(S);
19028#else
19029 return true;
19030#endif
19031}
19032PRESERVE_NONE
19033static bool Interp_FlipUint16Ptr(InterpState &S) {
19034 Flip<PT_Uint16, PT_Ptr>(S);
19035#if USE_TAILCALLS
19036 MUSTTAIL return InterpNext(S);
19037#else
19038 return true;
19039#endif
19040}
19041PRESERVE_NONE
19042static bool Interp_FlipUint16MemberPtr(InterpState &S) {
19043 Flip<PT_Uint16, PT_MemberPtr>(S);
19044#if USE_TAILCALLS
19045 MUSTTAIL return InterpNext(S);
19046#else
19047 return true;
19048#endif
19049}
19050PRESERVE_NONE
19051static bool Interp_FlipUint16Float(InterpState &S) {
19052 Flip<PT_Uint16, PT_Float>(S);
19053#if USE_TAILCALLS
19054 MUSTTAIL return InterpNext(S);
19055#else
19056 return true;
19057#endif
19058}
19059PRESERVE_NONE
19060static bool Interp_FlipUint16Reflect(InterpState &S) {
19061 Flip<PT_Uint16, PT_Reflect>(S);
19062#if USE_TAILCALLS
19063 MUSTTAIL return InterpNext(S);
19064#else
19065 return true;
19066#endif
19067}
19068PRESERVE_NONE
19069static bool Interp_FlipSint32Sint8(InterpState &S) {
19070 Flip<PT_Sint32, PT_Sint8>(S);
19071#if USE_TAILCALLS
19072 MUSTTAIL return InterpNext(S);
19073#else
19074 return true;
19075#endif
19076}
19077PRESERVE_NONE
19078static bool Interp_FlipSint32Uint8(InterpState &S) {
19079 Flip<PT_Sint32, PT_Uint8>(S);
19080#if USE_TAILCALLS
19081 MUSTTAIL return InterpNext(S);
19082#else
19083 return true;
19084#endif
19085}
19086PRESERVE_NONE
19087static bool Interp_FlipSint32Sint16(InterpState &S) {
19088 Flip<PT_Sint32, PT_Sint16>(S);
19089#if USE_TAILCALLS
19090 MUSTTAIL return InterpNext(S);
19091#else
19092 return true;
19093#endif
19094}
19095PRESERVE_NONE
19096static bool Interp_FlipSint32Uint16(InterpState &S) {
19097 Flip<PT_Sint32, PT_Uint16>(S);
19098#if USE_TAILCALLS
19099 MUSTTAIL return InterpNext(S);
19100#else
19101 return true;
19102#endif
19103}
19104PRESERVE_NONE
19105static bool Interp_FlipSint32Sint32(InterpState &S) {
19106 Flip<PT_Sint32, PT_Sint32>(S);
19107#if USE_TAILCALLS
19108 MUSTTAIL return InterpNext(S);
19109#else
19110 return true;
19111#endif
19112}
19113PRESERVE_NONE
19114static bool Interp_FlipSint32Uint32(InterpState &S) {
19115 Flip<PT_Sint32, PT_Uint32>(S);
19116#if USE_TAILCALLS
19117 MUSTTAIL return InterpNext(S);
19118#else
19119 return true;
19120#endif
19121}
19122PRESERVE_NONE
19123static bool Interp_FlipSint32Sint64(InterpState &S) {
19124 Flip<PT_Sint32, PT_Sint64>(S);
19125#if USE_TAILCALLS
19126 MUSTTAIL return InterpNext(S);
19127#else
19128 return true;
19129#endif
19130}
19131PRESERVE_NONE
19132static bool Interp_FlipSint32Uint64(InterpState &S) {
19133 Flip<PT_Sint32, PT_Uint64>(S);
19134#if USE_TAILCALLS
19135 MUSTTAIL return InterpNext(S);
19136#else
19137 return true;
19138#endif
19139}
19140PRESERVE_NONE
19141static bool Interp_FlipSint32IntAP(InterpState &S) {
19142 Flip<PT_Sint32, PT_IntAP>(S);
19143#if USE_TAILCALLS
19144 MUSTTAIL return InterpNext(S);
19145#else
19146 return true;
19147#endif
19148}
19149PRESERVE_NONE
19150static bool Interp_FlipSint32IntAPS(InterpState &S) {
19151 Flip<PT_Sint32, PT_IntAPS>(S);
19152#if USE_TAILCALLS
19153 MUSTTAIL return InterpNext(S);
19154#else
19155 return true;
19156#endif
19157}
19158PRESERVE_NONE
19159static bool Interp_FlipSint32Bool(InterpState &S) {
19160 Flip<PT_Sint32, PT_Bool>(S);
19161#if USE_TAILCALLS
19162 MUSTTAIL return InterpNext(S);
19163#else
19164 return true;
19165#endif
19166}
19167PRESERVE_NONE
19168static bool Interp_FlipSint32FixedPoint(InterpState &S) {
19169 Flip<PT_Sint32, PT_FixedPoint>(S);
19170#if USE_TAILCALLS
19171 MUSTTAIL return InterpNext(S);
19172#else
19173 return true;
19174#endif
19175}
19176PRESERVE_NONE
19177static bool Interp_FlipSint32Ptr(InterpState &S) {
19178 Flip<PT_Sint32, PT_Ptr>(S);
19179#if USE_TAILCALLS
19180 MUSTTAIL return InterpNext(S);
19181#else
19182 return true;
19183#endif
19184}
19185PRESERVE_NONE
19186static bool Interp_FlipSint32MemberPtr(InterpState &S) {
19187 Flip<PT_Sint32, PT_MemberPtr>(S);
19188#if USE_TAILCALLS
19189 MUSTTAIL return InterpNext(S);
19190#else
19191 return true;
19192#endif
19193}
19194PRESERVE_NONE
19195static bool Interp_FlipSint32Float(InterpState &S) {
19196 Flip<PT_Sint32, PT_Float>(S);
19197#if USE_TAILCALLS
19198 MUSTTAIL return InterpNext(S);
19199#else
19200 return true;
19201#endif
19202}
19203PRESERVE_NONE
19204static bool Interp_FlipSint32Reflect(InterpState &S) {
19205 Flip<PT_Sint32, PT_Reflect>(S);
19206#if USE_TAILCALLS
19207 MUSTTAIL return InterpNext(S);
19208#else
19209 return true;
19210#endif
19211}
19212PRESERVE_NONE
19213static bool Interp_FlipUint32Sint8(InterpState &S) {
19214 Flip<PT_Uint32, PT_Sint8>(S);
19215#if USE_TAILCALLS
19216 MUSTTAIL return InterpNext(S);
19217#else
19218 return true;
19219#endif
19220}
19221PRESERVE_NONE
19222static bool Interp_FlipUint32Uint8(InterpState &S) {
19223 Flip<PT_Uint32, PT_Uint8>(S);
19224#if USE_TAILCALLS
19225 MUSTTAIL return InterpNext(S);
19226#else
19227 return true;
19228#endif
19229}
19230PRESERVE_NONE
19231static bool Interp_FlipUint32Sint16(InterpState &S) {
19232 Flip<PT_Uint32, PT_Sint16>(S);
19233#if USE_TAILCALLS
19234 MUSTTAIL return InterpNext(S);
19235#else
19236 return true;
19237#endif
19238}
19239PRESERVE_NONE
19240static bool Interp_FlipUint32Uint16(InterpState &S) {
19241 Flip<PT_Uint32, PT_Uint16>(S);
19242#if USE_TAILCALLS
19243 MUSTTAIL return InterpNext(S);
19244#else
19245 return true;
19246#endif
19247}
19248PRESERVE_NONE
19249static bool Interp_FlipUint32Sint32(InterpState &S) {
19250 Flip<PT_Uint32, PT_Sint32>(S);
19251#if USE_TAILCALLS
19252 MUSTTAIL return InterpNext(S);
19253#else
19254 return true;
19255#endif
19256}
19257PRESERVE_NONE
19258static bool Interp_FlipUint32Uint32(InterpState &S) {
19259 Flip<PT_Uint32, PT_Uint32>(S);
19260#if USE_TAILCALLS
19261 MUSTTAIL return InterpNext(S);
19262#else
19263 return true;
19264#endif
19265}
19266PRESERVE_NONE
19267static bool Interp_FlipUint32Sint64(InterpState &S) {
19268 Flip<PT_Uint32, PT_Sint64>(S);
19269#if USE_TAILCALLS
19270 MUSTTAIL return InterpNext(S);
19271#else
19272 return true;
19273#endif
19274}
19275PRESERVE_NONE
19276static bool Interp_FlipUint32Uint64(InterpState &S) {
19277 Flip<PT_Uint32, PT_Uint64>(S);
19278#if USE_TAILCALLS
19279 MUSTTAIL return InterpNext(S);
19280#else
19281 return true;
19282#endif
19283}
19284PRESERVE_NONE
19285static bool Interp_FlipUint32IntAP(InterpState &S) {
19286 Flip<PT_Uint32, PT_IntAP>(S);
19287#if USE_TAILCALLS
19288 MUSTTAIL return InterpNext(S);
19289#else
19290 return true;
19291#endif
19292}
19293PRESERVE_NONE
19294static bool Interp_FlipUint32IntAPS(InterpState &S) {
19295 Flip<PT_Uint32, PT_IntAPS>(S);
19296#if USE_TAILCALLS
19297 MUSTTAIL return InterpNext(S);
19298#else
19299 return true;
19300#endif
19301}
19302PRESERVE_NONE
19303static bool Interp_FlipUint32Bool(InterpState &S) {
19304 Flip<PT_Uint32, PT_Bool>(S);
19305#if USE_TAILCALLS
19306 MUSTTAIL return InterpNext(S);
19307#else
19308 return true;
19309#endif
19310}
19311PRESERVE_NONE
19312static bool Interp_FlipUint32FixedPoint(InterpState &S) {
19313 Flip<PT_Uint32, PT_FixedPoint>(S);
19314#if USE_TAILCALLS
19315 MUSTTAIL return InterpNext(S);
19316#else
19317 return true;
19318#endif
19319}
19320PRESERVE_NONE
19321static bool Interp_FlipUint32Ptr(InterpState &S) {
19322 Flip<PT_Uint32, PT_Ptr>(S);
19323#if USE_TAILCALLS
19324 MUSTTAIL return InterpNext(S);
19325#else
19326 return true;
19327#endif
19328}
19329PRESERVE_NONE
19330static bool Interp_FlipUint32MemberPtr(InterpState &S) {
19331 Flip<PT_Uint32, PT_MemberPtr>(S);
19332#if USE_TAILCALLS
19333 MUSTTAIL return InterpNext(S);
19334#else
19335 return true;
19336#endif
19337}
19338PRESERVE_NONE
19339static bool Interp_FlipUint32Float(InterpState &S) {
19340 Flip<PT_Uint32, PT_Float>(S);
19341#if USE_TAILCALLS
19342 MUSTTAIL return InterpNext(S);
19343#else
19344 return true;
19345#endif
19346}
19347PRESERVE_NONE
19348static bool Interp_FlipUint32Reflect(InterpState &S) {
19349 Flip<PT_Uint32, PT_Reflect>(S);
19350#if USE_TAILCALLS
19351 MUSTTAIL return InterpNext(S);
19352#else
19353 return true;
19354#endif
19355}
19356PRESERVE_NONE
19357static bool Interp_FlipSint64Sint8(InterpState &S) {
19358 Flip<PT_Sint64, PT_Sint8>(S);
19359#if USE_TAILCALLS
19360 MUSTTAIL return InterpNext(S);
19361#else
19362 return true;
19363#endif
19364}
19365PRESERVE_NONE
19366static bool Interp_FlipSint64Uint8(InterpState &S) {
19367 Flip<PT_Sint64, PT_Uint8>(S);
19368#if USE_TAILCALLS
19369 MUSTTAIL return InterpNext(S);
19370#else
19371 return true;
19372#endif
19373}
19374PRESERVE_NONE
19375static bool Interp_FlipSint64Sint16(InterpState &S) {
19376 Flip<PT_Sint64, PT_Sint16>(S);
19377#if USE_TAILCALLS
19378 MUSTTAIL return InterpNext(S);
19379#else
19380 return true;
19381#endif
19382}
19383PRESERVE_NONE
19384static bool Interp_FlipSint64Uint16(InterpState &S) {
19385 Flip<PT_Sint64, PT_Uint16>(S);
19386#if USE_TAILCALLS
19387 MUSTTAIL return InterpNext(S);
19388#else
19389 return true;
19390#endif
19391}
19392PRESERVE_NONE
19393static bool Interp_FlipSint64Sint32(InterpState &S) {
19394 Flip<PT_Sint64, PT_Sint32>(S);
19395#if USE_TAILCALLS
19396 MUSTTAIL return InterpNext(S);
19397#else
19398 return true;
19399#endif
19400}
19401PRESERVE_NONE
19402static bool Interp_FlipSint64Uint32(InterpState &S) {
19403 Flip<PT_Sint64, PT_Uint32>(S);
19404#if USE_TAILCALLS
19405 MUSTTAIL return InterpNext(S);
19406#else
19407 return true;
19408#endif
19409}
19410PRESERVE_NONE
19411static bool Interp_FlipSint64Sint64(InterpState &S) {
19412 Flip<PT_Sint64, PT_Sint64>(S);
19413#if USE_TAILCALLS
19414 MUSTTAIL return InterpNext(S);
19415#else
19416 return true;
19417#endif
19418}
19419PRESERVE_NONE
19420static bool Interp_FlipSint64Uint64(InterpState &S) {
19421 Flip<PT_Sint64, PT_Uint64>(S);
19422#if USE_TAILCALLS
19423 MUSTTAIL return InterpNext(S);
19424#else
19425 return true;
19426#endif
19427}
19428PRESERVE_NONE
19429static bool Interp_FlipSint64IntAP(InterpState &S) {
19430 Flip<PT_Sint64, PT_IntAP>(S);
19431#if USE_TAILCALLS
19432 MUSTTAIL return InterpNext(S);
19433#else
19434 return true;
19435#endif
19436}
19437PRESERVE_NONE
19438static bool Interp_FlipSint64IntAPS(InterpState &S) {
19439 Flip<PT_Sint64, PT_IntAPS>(S);
19440#if USE_TAILCALLS
19441 MUSTTAIL return InterpNext(S);
19442#else
19443 return true;
19444#endif
19445}
19446PRESERVE_NONE
19447static bool Interp_FlipSint64Bool(InterpState &S) {
19448 Flip<PT_Sint64, PT_Bool>(S);
19449#if USE_TAILCALLS
19450 MUSTTAIL return InterpNext(S);
19451#else
19452 return true;
19453#endif
19454}
19455PRESERVE_NONE
19456static bool Interp_FlipSint64FixedPoint(InterpState &S) {
19457 Flip<PT_Sint64, PT_FixedPoint>(S);
19458#if USE_TAILCALLS
19459 MUSTTAIL return InterpNext(S);
19460#else
19461 return true;
19462#endif
19463}
19464PRESERVE_NONE
19465static bool Interp_FlipSint64Ptr(InterpState &S) {
19466 Flip<PT_Sint64, PT_Ptr>(S);
19467#if USE_TAILCALLS
19468 MUSTTAIL return InterpNext(S);
19469#else
19470 return true;
19471#endif
19472}
19473PRESERVE_NONE
19474static bool Interp_FlipSint64MemberPtr(InterpState &S) {
19475 Flip<PT_Sint64, PT_MemberPtr>(S);
19476#if USE_TAILCALLS
19477 MUSTTAIL return InterpNext(S);
19478#else
19479 return true;
19480#endif
19481}
19482PRESERVE_NONE
19483static bool Interp_FlipSint64Float(InterpState &S) {
19484 Flip<PT_Sint64, PT_Float>(S);
19485#if USE_TAILCALLS
19486 MUSTTAIL return InterpNext(S);
19487#else
19488 return true;
19489#endif
19490}
19491PRESERVE_NONE
19492static bool Interp_FlipSint64Reflect(InterpState &S) {
19493 Flip<PT_Sint64, PT_Reflect>(S);
19494#if USE_TAILCALLS
19495 MUSTTAIL return InterpNext(S);
19496#else
19497 return true;
19498#endif
19499}
19500PRESERVE_NONE
19501static bool Interp_FlipUint64Sint8(InterpState &S) {
19502 Flip<PT_Uint64, PT_Sint8>(S);
19503#if USE_TAILCALLS
19504 MUSTTAIL return InterpNext(S);
19505#else
19506 return true;
19507#endif
19508}
19509PRESERVE_NONE
19510static bool Interp_FlipUint64Uint8(InterpState &S) {
19511 Flip<PT_Uint64, PT_Uint8>(S);
19512#if USE_TAILCALLS
19513 MUSTTAIL return InterpNext(S);
19514#else
19515 return true;
19516#endif
19517}
19518PRESERVE_NONE
19519static bool Interp_FlipUint64Sint16(InterpState &S) {
19520 Flip<PT_Uint64, PT_Sint16>(S);
19521#if USE_TAILCALLS
19522 MUSTTAIL return InterpNext(S);
19523#else
19524 return true;
19525#endif
19526}
19527PRESERVE_NONE
19528static bool Interp_FlipUint64Uint16(InterpState &S) {
19529 Flip<PT_Uint64, PT_Uint16>(S);
19530#if USE_TAILCALLS
19531 MUSTTAIL return InterpNext(S);
19532#else
19533 return true;
19534#endif
19535}
19536PRESERVE_NONE
19537static bool Interp_FlipUint64Sint32(InterpState &S) {
19538 Flip<PT_Uint64, PT_Sint32>(S);
19539#if USE_TAILCALLS
19540 MUSTTAIL return InterpNext(S);
19541#else
19542 return true;
19543#endif
19544}
19545PRESERVE_NONE
19546static bool Interp_FlipUint64Uint32(InterpState &S) {
19547 Flip<PT_Uint64, PT_Uint32>(S);
19548#if USE_TAILCALLS
19549 MUSTTAIL return InterpNext(S);
19550#else
19551 return true;
19552#endif
19553}
19554PRESERVE_NONE
19555static bool Interp_FlipUint64Sint64(InterpState &S) {
19556 Flip<PT_Uint64, PT_Sint64>(S);
19557#if USE_TAILCALLS
19558 MUSTTAIL return InterpNext(S);
19559#else
19560 return true;
19561#endif
19562}
19563PRESERVE_NONE
19564static bool Interp_FlipUint64Uint64(InterpState &S) {
19565 Flip<PT_Uint64, PT_Uint64>(S);
19566#if USE_TAILCALLS
19567 MUSTTAIL return InterpNext(S);
19568#else
19569 return true;
19570#endif
19571}
19572PRESERVE_NONE
19573static bool Interp_FlipUint64IntAP(InterpState &S) {
19574 Flip<PT_Uint64, PT_IntAP>(S);
19575#if USE_TAILCALLS
19576 MUSTTAIL return InterpNext(S);
19577#else
19578 return true;
19579#endif
19580}
19581PRESERVE_NONE
19582static bool Interp_FlipUint64IntAPS(InterpState &S) {
19583 Flip<PT_Uint64, PT_IntAPS>(S);
19584#if USE_TAILCALLS
19585 MUSTTAIL return InterpNext(S);
19586#else
19587 return true;
19588#endif
19589}
19590PRESERVE_NONE
19591static bool Interp_FlipUint64Bool(InterpState &S) {
19592 Flip<PT_Uint64, PT_Bool>(S);
19593#if USE_TAILCALLS
19594 MUSTTAIL return InterpNext(S);
19595#else
19596 return true;
19597#endif
19598}
19599PRESERVE_NONE
19600static bool Interp_FlipUint64FixedPoint(InterpState &S) {
19601 Flip<PT_Uint64, PT_FixedPoint>(S);
19602#if USE_TAILCALLS
19603 MUSTTAIL return InterpNext(S);
19604#else
19605 return true;
19606#endif
19607}
19608PRESERVE_NONE
19609static bool Interp_FlipUint64Ptr(InterpState &S) {
19610 Flip<PT_Uint64, PT_Ptr>(S);
19611#if USE_TAILCALLS
19612 MUSTTAIL return InterpNext(S);
19613#else
19614 return true;
19615#endif
19616}
19617PRESERVE_NONE
19618static bool Interp_FlipUint64MemberPtr(InterpState &S) {
19619 Flip<PT_Uint64, PT_MemberPtr>(S);
19620#if USE_TAILCALLS
19621 MUSTTAIL return InterpNext(S);
19622#else
19623 return true;
19624#endif
19625}
19626PRESERVE_NONE
19627static bool Interp_FlipUint64Float(InterpState &S) {
19628 Flip<PT_Uint64, PT_Float>(S);
19629#if USE_TAILCALLS
19630 MUSTTAIL return InterpNext(S);
19631#else
19632 return true;
19633#endif
19634}
19635PRESERVE_NONE
19636static bool Interp_FlipUint64Reflect(InterpState &S) {
19637 Flip<PT_Uint64, PT_Reflect>(S);
19638#if USE_TAILCALLS
19639 MUSTTAIL return InterpNext(S);
19640#else
19641 return true;
19642#endif
19643}
19644PRESERVE_NONE
19645static bool Interp_FlipIntAPSint8(InterpState &S) {
19646 Flip<PT_IntAP, PT_Sint8>(S);
19647#if USE_TAILCALLS
19648 MUSTTAIL return InterpNext(S);
19649#else
19650 return true;
19651#endif
19652}
19653PRESERVE_NONE
19654static bool Interp_FlipIntAPUint8(InterpState &S) {
19655 Flip<PT_IntAP, PT_Uint8>(S);
19656#if USE_TAILCALLS
19657 MUSTTAIL return InterpNext(S);
19658#else
19659 return true;
19660#endif
19661}
19662PRESERVE_NONE
19663static bool Interp_FlipIntAPSint16(InterpState &S) {
19664 Flip<PT_IntAP, PT_Sint16>(S);
19665#if USE_TAILCALLS
19666 MUSTTAIL return InterpNext(S);
19667#else
19668 return true;
19669#endif
19670}
19671PRESERVE_NONE
19672static bool Interp_FlipIntAPUint16(InterpState &S) {
19673 Flip<PT_IntAP, PT_Uint16>(S);
19674#if USE_TAILCALLS
19675 MUSTTAIL return InterpNext(S);
19676#else
19677 return true;
19678#endif
19679}
19680PRESERVE_NONE
19681static bool Interp_FlipIntAPSint32(InterpState &S) {
19682 Flip<PT_IntAP, PT_Sint32>(S);
19683#if USE_TAILCALLS
19684 MUSTTAIL return InterpNext(S);
19685#else
19686 return true;
19687#endif
19688}
19689PRESERVE_NONE
19690static bool Interp_FlipIntAPUint32(InterpState &S) {
19691 Flip<PT_IntAP, PT_Uint32>(S);
19692#if USE_TAILCALLS
19693 MUSTTAIL return InterpNext(S);
19694#else
19695 return true;
19696#endif
19697}
19698PRESERVE_NONE
19699static bool Interp_FlipIntAPSint64(InterpState &S) {
19700 Flip<PT_IntAP, PT_Sint64>(S);
19701#if USE_TAILCALLS
19702 MUSTTAIL return InterpNext(S);
19703#else
19704 return true;
19705#endif
19706}
19707PRESERVE_NONE
19708static bool Interp_FlipIntAPUint64(InterpState &S) {
19709 Flip<PT_IntAP, PT_Uint64>(S);
19710#if USE_TAILCALLS
19711 MUSTTAIL return InterpNext(S);
19712#else
19713 return true;
19714#endif
19715}
19716PRESERVE_NONE
19717static bool Interp_FlipIntAPIntAP(InterpState &S) {
19718 Flip<PT_IntAP, PT_IntAP>(S);
19719#if USE_TAILCALLS
19720 MUSTTAIL return InterpNext(S);
19721#else
19722 return true;
19723#endif
19724}
19725PRESERVE_NONE
19726static bool Interp_FlipIntAPIntAPS(InterpState &S) {
19727 Flip<PT_IntAP, PT_IntAPS>(S);
19728#if USE_TAILCALLS
19729 MUSTTAIL return InterpNext(S);
19730#else
19731 return true;
19732#endif
19733}
19734PRESERVE_NONE
19735static bool Interp_FlipIntAPBool(InterpState &S) {
19736 Flip<PT_IntAP, PT_Bool>(S);
19737#if USE_TAILCALLS
19738 MUSTTAIL return InterpNext(S);
19739#else
19740 return true;
19741#endif
19742}
19743PRESERVE_NONE
19744static bool Interp_FlipIntAPFixedPoint(InterpState &S) {
19745 Flip<PT_IntAP, PT_FixedPoint>(S);
19746#if USE_TAILCALLS
19747 MUSTTAIL return InterpNext(S);
19748#else
19749 return true;
19750#endif
19751}
19752PRESERVE_NONE
19753static bool Interp_FlipIntAPPtr(InterpState &S) {
19754 Flip<PT_IntAP, PT_Ptr>(S);
19755#if USE_TAILCALLS
19756 MUSTTAIL return InterpNext(S);
19757#else
19758 return true;
19759#endif
19760}
19761PRESERVE_NONE
19762static bool Interp_FlipIntAPMemberPtr(InterpState &S) {
19763 Flip<PT_IntAP, PT_MemberPtr>(S);
19764#if USE_TAILCALLS
19765 MUSTTAIL return InterpNext(S);
19766#else
19767 return true;
19768#endif
19769}
19770PRESERVE_NONE
19771static bool Interp_FlipIntAPFloat(InterpState &S) {
19772 Flip<PT_IntAP, PT_Float>(S);
19773#if USE_TAILCALLS
19774 MUSTTAIL return InterpNext(S);
19775#else
19776 return true;
19777#endif
19778}
19779PRESERVE_NONE
19780static bool Interp_FlipIntAPReflect(InterpState &S) {
19781 Flip<PT_IntAP, PT_Reflect>(S);
19782#if USE_TAILCALLS
19783 MUSTTAIL return InterpNext(S);
19784#else
19785 return true;
19786#endif
19787}
19788PRESERVE_NONE
19789static bool Interp_FlipIntAPSSint8(InterpState &S) {
19790 Flip<PT_IntAPS, PT_Sint8>(S);
19791#if USE_TAILCALLS
19792 MUSTTAIL return InterpNext(S);
19793#else
19794 return true;
19795#endif
19796}
19797PRESERVE_NONE
19798static bool Interp_FlipIntAPSUint8(InterpState &S) {
19799 Flip<PT_IntAPS, PT_Uint8>(S);
19800#if USE_TAILCALLS
19801 MUSTTAIL return InterpNext(S);
19802#else
19803 return true;
19804#endif
19805}
19806PRESERVE_NONE
19807static bool Interp_FlipIntAPSSint16(InterpState &S) {
19808 Flip<PT_IntAPS, PT_Sint16>(S);
19809#if USE_TAILCALLS
19810 MUSTTAIL return InterpNext(S);
19811#else
19812 return true;
19813#endif
19814}
19815PRESERVE_NONE
19816static bool Interp_FlipIntAPSUint16(InterpState &S) {
19817 Flip<PT_IntAPS, PT_Uint16>(S);
19818#if USE_TAILCALLS
19819 MUSTTAIL return InterpNext(S);
19820#else
19821 return true;
19822#endif
19823}
19824PRESERVE_NONE
19825static bool Interp_FlipIntAPSSint32(InterpState &S) {
19826 Flip<PT_IntAPS, PT_Sint32>(S);
19827#if USE_TAILCALLS
19828 MUSTTAIL return InterpNext(S);
19829#else
19830 return true;
19831#endif
19832}
19833PRESERVE_NONE
19834static bool Interp_FlipIntAPSUint32(InterpState &S) {
19835 Flip<PT_IntAPS, PT_Uint32>(S);
19836#if USE_TAILCALLS
19837 MUSTTAIL return InterpNext(S);
19838#else
19839 return true;
19840#endif
19841}
19842PRESERVE_NONE
19843static bool Interp_FlipIntAPSSint64(InterpState &S) {
19844 Flip<PT_IntAPS, PT_Sint64>(S);
19845#if USE_TAILCALLS
19846 MUSTTAIL return InterpNext(S);
19847#else
19848 return true;
19849#endif
19850}
19851PRESERVE_NONE
19852static bool Interp_FlipIntAPSUint64(InterpState &S) {
19853 Flip<PT_IntAPS, PT_Uint64>(S);
19854#if USE_TAILCALLS
19855 MUSTTAIL return InterpNext(S);
19856#else
19857 return true;
19858#endif
19859}
19860PRESERVE_NONE
19861static bool Interp_FlipIntAPSIntAP(InterpState &S) {
19862 Flip<PT_IntAPS, PT_IntAP>(S);
19863#if USE_TAILCALLS
19864 MUSTTAIL return InterpNext(S);
19865#else
19866 return true;
19867#endif
19868}
19869PRESERVE_NONE
19870static bool Interp_FlipIntAPSIntAPS(InterpState &S) {
19871 Flip<PT_IntAPS, PT_IntAPS>(S);
19872#if USE_TAILCALLS
19873 MUSTTAIL return InterpNext(S);
19874#else
19875 return true;
19876#endif
19877}
19878PRESERVE_NONE
19879static bool Interp_FlipIntAPSBool(InterpState &S) {
19880 Flip<PT_IntAPS, PT_Bool>(S);
19881#if USE_TAILCALLS
19882 MUSTTAIL return InterpNext(S);
19883#else
19884 return true;
19885#endif
19886}
19887PRESERVE_NONE
19888static bool Interp_FlipIntAPSFixedPoint(InterpState &S) {
19889 Flip<PT_IntAPS, PT_FixedPoint>(S);
19890#if USE_TAILCALLS
19891 MUSTTAIL return InterpNext(S);
19892#else
19893 return true;
19894#endif
19895}
19896PRESERVE_NONE
19897static bool Interp_FlipIntAPSPtr(InterpState &S) {
19898 Flip<PT_IntAPS, PT_Ptr>(S);
19899#if USE_TAILCALLS
19900 MUSTTAIL return InterpNext(S);
19901#else
19902 return true;
19903#endif
19904}
19905PRESERVE_NONE
19906static bool Interp_FlipIntAPSMemberPtr(InterpState &S) {
19907 Flip<PT_IntAPS, PT_MemberPtr>(S);
19908#if USE_TAILCALLS
19909 MUSTTAIL return InterpNext(S);
19910#else
19911 return true;
19912#endif
19913}
19914PRESERVE_NONE
19915static bool Interp_FlipIntAPSFloat(InterpState &S) {
19916 Flip<PT_IntAPS, PT_Float>(S);
19917#if USE_TAILCALLS
19918 MUSTTAIL return InterpNext(S);
19919#else
19920 return true;
19921#endif
19922}
19923PRESERVE_NONE
19924static bool Interp_FlipIntAPSReflect(InterpState &S) {
19925 Flip<PT_IntAPS, PT_Reflect>(S);
19926#if USE_TAILCALLS
19927 MUSTTAIL return InterpNext(S);
19928#else
19929 return true;
19930#endif
19931}
19932PRESERVE_NONE
19933static bool Interp_FlipBoolSint8(InterpState &S) {
19934 Flip<PT_Bool, PT_Sint8>(S);
19935#if USE_TAILCALLS
19936 MUSTTAIL return InterpNext(S);
19937#else
19938 return true;
19939#endif
19940}
19941PRESERVE_NONE
19942static bool Interp_FlipBoolUint8(InterpState &S) {
19943 Flip<PT_Bool, PT_Uint8>(S);
19944#if USE_TAILCALLS
19945 MUSTTAIL return InterpNext(S);
19946#else
19947 return true;
19948#endif
19949}
19950PRESERVE_NONE
19951static bool Interp_FlipBoolSint16(InterpState &S) {
19952 Flip<PT_Bool, PT_Sint16>(S);
19953#if USE_TAILCALLS
19954 MUSTTAIL return InterpNext(S);
19955#else
19956 return true;
19957#endif
19958}
19959PRESERVE_NONE
19960static bool Interp_FlipBoolUint16(InterpState &S) {
19961 Flip<PT_Bool, PT_Uint16>(S);
19962#if USE_TAILCALLS
19963 MUSTTAIL return InterpNext(S);
19964#else
19965 return true;
19966#endif
19967}
19968PRESERVE_NONE
19969static bool Interp_FlipBoolSint32(InterpState &S) {
19970 Flip<PT_Bool, PT_Sint32>(S);
19971#if USE_TAILCALLS
19972 MUSTTAIL return InterpNext(S);
19973#else
19974 return true;
19975#endif
19976}
19977PRESERVE_NONE
19978static bool Interp_FlipBoolUint32(InterpState &S) {
19979 Flip<PT_Bool, PT_Uint32>(S);
19980#if USE_TAILCALLS
19981 MUSTTAIL return InterpNext(S);
19982#else
19983 return true;
19984#endif
19985}
19986PRESERVE_NONE
19987static bool Interp_FlipBoolSint64(InterpState &S) {
19988 Flip<PT_Bool, PT_Sint64>(S);
19989#if USE_TAILCALLS
19990 MUSTTAIL return InterpNext(S);
19991#else
19992 return true;
19993#endif
19994}
19995PRESERVE_NONE
19996static bool Interp_FlipBoolUint64(InterpState &S) {
19997 Flip<PT_Bool, PT_Uint64>(S);
19998#if USE_TAILCALLS
19999 MUSTTAIL return InterpNext(S);
20000#else
20001 return true;
20002#endif
20003}
20004PRESERVE_NONE
20005static bool Interp_FlipBoolIntAP(InterpState &S) {
20006 Flip<PT_Bool, PT_IntAP>(S);
20007#if USE_TAILCALLS
20008 MUSTTAIL return InterpNext(S);
20009#else
20010 return true;
20011#endif
20012}
20013PRESERVE_NONE
20014static bool Interp_FlipBoolIntAPS(InterpState &S) {
20015 Flip<PT_Bool, PT_IntAPS>(S);
20016#if USE_TAILCALLS
20017 MUSTTAIL return InterpNext(S);
20018#else
20019 return true;
20020#endif
20021}
20022PRESERVE_NONE
20023static bool Interp_FlipBoolBool(InterpState &S) {
20024 Flip<PT_Bool, PT_Bool>(S);
20025#if USE_TAILCALLS
20026 MUSTTAIL return InterpNext(S);
20027#else
20028 return true;
20029#endif
20030}
20031PRESERVE_NONE
20032static bool Interp_FlipBoolFixedPoint(InterpState &S) {
20033 Flip<PT_Bool, PT_FixedPoint>(S);
20034#if USE_TAILCALLS
20035 MUSTTAIL return InterpNext(S);
20036#else
20037 return true;
20038#endif
20039}
20040PRESERVE_NONE
20041static bool Interp_FlipBoolPtr(InterpState &S) {
20042 Flip<PT_Bool, PT_Ptr>(S);
20043#if USE_TAILCALLS
20044 MUSTTAIL return InterpNext(S);
20045#else
20046 return true;
20047#endif
20048}
20049PRESERVE_NONE
20050static bool Interp_FlipBoolMemberPtr(InterpState &S) {
20051 Flip<PT_Bool, PT_MemberPtr>(S);
20052#if USE_TAILCALLS
20053 MUSTTAIL return InterpNext(S);
20054#else
20055 return true;
20056#endif
20057}
20058PRESERVE_NONE
20059static bool Interp_FlipBoolFloat(InterpState &S) {
20060 Flip<PT_Bool, PT_Float>(S);
20061#if USE_TAILCALLS
20062 MUSTTAIL return InterpNext(S);
20063#else
20064 return true;
20065#endif
20066}
20067PRESERVE_NONE
20068static bool Interp_FlipBoolReflect(InterpState &S) {
20069 Flip<PT_Bool, PT_Reflect>(S);
20070#if USE_TAILCALLS
20071 MUSTTAIL return InterpNext(S);
20072#else
20073 return true;
20074#endif
20075}
20076PRESERVE_NONE
20077static bool Interp_FlipFixedPointSint8(InterpState &S) {
20078 Flip<PT_FixedPoint, PT_Sint8>(S);
20079#if USE_TAILCALLS
20080 MUSTTAIL return InterpNext(S);
20081#else
20082 return true;
20083#endif
20084}
20085PRESERVE_NONE
20086static bool Interp_FlipFixedPointUint8(InterpState &S) {
20087 Flip<PT_FixedPoint, PT_Uint8>(S);
20088#if USE_TAILCALLS
20089 MUSTTAIL return InterpNext(S);
20090#else
20091 return true;
20092#endif
20093}
20094PRESERVE_NONE
20095static bool Interp_FlipFixedPointSint16(InterpState &S) {
20096 Flip<PT_FixedPoint, PT_Sint16>(S);
20097#if USE_TAILCALLS
20098 MUSTTAIL return InterpNext(S);
20099#else
20100 return true;
20101#endif
20102}
20103PRESERVE_NONE
20104static bool Interp_FlipFixedPointUint16(InterpState &S) {
20105 Flip<PT_FixedPoint, PT_Uint16>(S);
20106#if USE_TAILCALLS
20107 MUSTTAIL return InterpNext(S);
20108#else
20109 return true;
20110#endif
20111}
20112PRESERVE_NONE
20113static bool Interp_FlipFixedPointSint32(InterpState &S) {
20114 Flip<PT_FixedPoint, PT_Sint32>(S);
20115#if USE_TAILCALLS
20116 MUSTTAIL return InterpNext(S);
20117#else
20118 return true;
20119#endif
20120}
20121PRESERVE_NONE
20122static bool Interp_FlipFixedPointUint32(InterpState &S) {
20123 Flip<PT_FixedPoint, PT_Uint32>(S);
20124#if USE_TAILCALLS
20125 MUSTTAIL return InterpNext(S);
20126#else
20127 return true;
20128#endif
20129}
20130PRESERVE_NONE
20131static bool Interp_FlipFixedPointSint64(InterpState &S) {
20132 Flip<PT_FixedPoint, PT_Sint64>(S);
20133#if USE_TAILCALLS
20134 MUSTTAIL return InterpNext(S);
20135#else
20136 return true;
20137#endif
20138}
20139PRESERVE_NONE
20140static bool Interp_FlipFixedPointUint64(InterpState &S) {
20141 Flip<PT_FixedPoint, PT_Uint64>(S);
20142#if USE_TAILCALLS
20143 MUSTTAIL return InterpNext(S);
20144#else
20145 return true;
20146#endif
20147}
20148PRESERVE_NONE
20149static bool Interp_FlipFixedPointIntAP(InterpState &S) {
20150 Flip<PT_FixedPoint, PT_IntAP>(S);
20151#if USE_TAILCALLS
20152 MUSTTAIL return InterpNext(S);
20153#else
20154 return true;
20155#endif
20156}
20157PRESERVE_NONE
20158static bool Interp_FlipFixedPointIntAPS(InterpState &S) {
20159 Flip<PT_FixedPoint, PT_IntAPS>(S);
20160#if USE_TAILCALLS
20161 MUSTTAIL return InterpNext(S);
20162#else
20163 return true;
20164#endif
20165}
20166PRESERVE_NONE
20167static bool Interp_FlipFixedPointBool(InterpState &S) {
20168 Flip<PT_FixedPoint, PT_Bool>(S);
20169#if USE_TAILCALLS
20170 MUSTTAIL return InterpNext(S);
20171#else
20172 return true;
20173#endif
20174}
20175PRESERVE_NONE
20176static bool Interp_FlipFixedPointFixedPoint(InterpState &S) {
20177 Flip<PT_FixedPoint, PT_FixedPoint>(S);
20178#if USE_TAILCALLS
20179 MUSTTAIL return InterpNext(S);
20180#else
20181 return true;
20182#endif
20183}
20184PRESERVE_NONE
20185static bool Interp_FlipFixedPointPtr(InterpState &S) {
20186 Flip<PT_FixedPoint, PT_Ptr>(S);
20187#if USE_TAILCALLS
20188 MUSTTAIL return InterpNext(S);
20189#else
20190 return true;
20191#endif
20192}
20193PRESERVE_NONE
20194static bool Interp_FlipFixedPointMemberPtr(InterpState &S) {
20195 Flip<PT_FixedPoint, PT_MemberPtr>(S);
20196#if USE_TAILCALLS
20197 MUSTTAIL return InterpNext(S);
20198#else
20199 return true;
20200#endif
20201}
20202PRESERVE_NONE
20203static bool Interp_FlipFixedPointFloat(InterpState &S) {
20204 Flip<PT_FixedPoint, PT_Float>(S);
20205#if USE_TAILCALLS
20206 MUSTTAIL return InterpNext(S);
20207#else
20208 return true;
20209#endif
20210}
20211PRESERVE_NONE
20212static bool Interp_FlipFixedPointReflect(InterpState &S) {
20213 Flip<PT_FixedPoint, PT_Reflect>(S);
20214#if USE_TAILCALLS
20215 MUSTTAIL return InterpNext(S);
20216#else
20217 return true;
20218#endif
20219}
20220PRESERVE_NONE
20221static bool Interp_FlipPtrSint8(InterpState &S) {
20222 Flip<PT_Ptr, PT_Sint8>(S);
20223#if USE_TAILCALLS
20224 MUSTTAIL return InterpNext(S);
20225#else
20226 return true;
20227#endif
20228}
20229PRESERVE_NONE
20230static bool Interp_FlipPtrUint8(InterpState &S) {
20231 Flip<PT_Ptr, PT_Uint8>(S);
20232#if USE_TAILCALLS
20233 MUSTTAIL return InterpNext(S);
20234#else
20235 return true;
20236#endif
20237}
20238PRESERVE_NONE
20239static bool Interp_FlipPtrSint16(InterpState &S) {
20240 Flip<PT_Ptr, PT_Sint16>(S);
20241#if USE_TAILCALLS
20242 MUSTTAIL return InterpNext(S);
20243#else
20244 return true;
20245#endif
20246}
20247PRESERVE_NONE
20248static bool Interp_FlipPtrUint16(InterpState &S) {
20249 Flip<PT_Ptr, PT_Uint16>(S);
20250#if USE_TAILCALLS
20251 MUSTTAIL return InterpNext(S);
20252#else
20253 return true;
20254#endif
20255}
20256PRESERVE_NONE
20257static bool Interp_FlipPtrSint32(InterpState &S) {
20258 Flip<PT_Ptr, PT_Sint32>(S);
20259#if USE_TAILCALLS
20260 MUSTTAIL return InterpNext(S);
20261#else
20262 return true;
20263#endif
20264}
20265PRESERVE_NONE
20266static bool Interp_FlipPtrUint32(InterpState &S) {
20267 Flip<PT_Ptr, PT_Uint32>(S);
20268#if USE_TAILCALLS
20269 MUSTTAIL return InterpNext(S);
20270#else
20271 return true;
20272#endif
20273}
20274PRESERVE_NONE
20275static bool Interp_FlipPtrSint64(InterpState &S) {
20276 Flip<PT_Ptr, PT_Sint64>(S);
20277#if USE_TAILCALLS
20278 MUSTTAIL return InterpNext(S);
20279#else
20280 return true;
20281#endif
20282}
20283PRESERVE_NONE
20284static bool Interp_FlipPtrUint64(InterpState &S) {
20285 Flip<PT_Ptr, PT_Uint64>(S);
20286#if USE_TAILCALLS
20287 MUSTTAIL return InterpNext(S);
20288#else
20289 return true;
20290#endif
20291}
20292PRESERVE_NONE
20293static bool Interp_FlipPtrIntAP(InterpState &S) {
20294 Flip<PT_Ptr, PT_IntAP>(S);
20295#if USE_TAILCALLS
20296 MUSTTAIL return InterpNext(S);
20297#else
20298 return true;
20299#endif
20300}
20301PRESERVE_NONE
20302static bool Interp_FlipPtrIntAPS(InterpState &S) {
20303 Flip<PT_Ptr, PT_IntAPS>(S);
20304#if USE_TAILCALLS
20305 MUSTTAIL return InterpNext(S);
20306#else
20307 return true;
20308#endif
20309}
20310PRESERVE_NONE
20311static bool Interp_FlipPtrBool(InterpState &S) {
20312 Flip<PT_Ptr, PT_Bool>(S);
20313#if USE_TAILCALLS
20314 MUSTTAIL return InterpNext(S);
20315#else
20316 return true;
20317#endif
20318}
20319PRESERVE_NONE
20320static bool Interp_FlipPtrFixedPoint(InterpState &S) {
20321 Flip<PT_Ptr, PT_FixedPoint>(S);
20322#if USE_TAILCALLS
20323 MUSTTAIL return InterpNext(S);
20324#else
20325 return true;
20326#endif
20327}
20328PRESERVE_NONE
20329static bool Interp_FlipPtrPtr(InterpState &S) {
20330 Flip<PT_Ptr, PT_Ptr>(S);
20331#if USE_TAILCALLS
20332 MUSTTAIL return InterpNext(S);
20333#else
20334 return true;
20335#endif
20336}
20337PRESERVE_NONE
20338static bool Interp_FlipPtrMemberPtr(InterpState &S) {
20339 Flip<PT_Ptr, PT_MemberPtr>(S);
20340#if USE_TAILCALLS
20341 MUSTTAIL return InterpNext(S);
20342#else
20343 return true;
20344#endif
20345}
20346PRESERVE_NONE
20347static bool Interp_FlipPtrFloat(InterpState &S) {
20348 Flip<PT_Ptr, PT_Float>(S);
20349#if USE_TAILCALLS
20350 MUSTTAIL return InterpNext(S);
20351#else
20352 return true;
20353#endif
20354}
20355PRESERVE_NONE
20356static bool Interp_FlipPtrReflect(InterpState &S) {
20357 Flip<PT_Ptr, PT_Reflect>(S);
20358#if USE_TAILCALLS
20359 MUSTTAIL return InterpNext(S);
20360#else
20361 return true;
20362#endif
20363}
20364PRESERVE_NONE
20365static bool Interp_FlipMemberPtrSint8(InterpState &S) {
20366 Flip<PT_MemberPtr, PT_Sint8>(S);
20367#if USE_TAILCALLS
20368 MUSTTAIL return InterpNext(S);
20369#else
20370 return true;
20371#endif
20372}
20373PRESERVE_NONE
20374static bool Interp_FlipMemberPtrUint8(InterpState &S) {
20375 Flip<PT_MemberPtr, PT_Uint8>(S);
20376#if USE_TAILCALLS
20377 MUSTTAIL return InterpNext(S);
20378#else
20379 return true;
20380#endif
20381}
20382PRESERVE_NONE
20383static bool Interp_FlipMemberPtrSint16(InterpState &S) {
20384 Flip<PT_MemberPtr, PT_Sint16>(S);
20385#if USE_TAILCALLS
20386 MUSTTAIL return InterpNext(S);
20387#else
20388 return true;
20389#endif
20390}
20391PRESERVE_NONE
20392static bool Interp_FlipMemberPtrUint16(InterpState &S) {
20393 Flip<PT_MemberPtr, PT_Uint16>(S);
20394#if USE_TAILCALLS
20395 MUSTTAIL return InterpNext(S);
20396#else
20397 return true;
20398#endif
20399}
20400PRESERVE_NONE
20401static bool Interp_FlipMemberPtrSint32(InterpState &S) {
20402 Flip<PT_MemberPtr, PT_Sint32>(S);
20403#if USE_TAILCALLS
20404 MUSTTAIL return InterpNext(S);
20405#else
20406 return true;
20407#endif
20408}
20409PRESERVE_NONE
20410static bool Interp_FlipMemberPtrUint32(InterpState &S) {
20411 Flip<PT_MemberPtr, PT_Uint32>(S);
20412#if USE_TAILCALLS
20413 MUSTTAIL return InterpNext(S);
20414#else
20415 return true;
20416#endif
20417}
20418PRESERVE_NONE
20419static bool Interp_FlipMemberPtrSint64(InterpState &S) {
20420 Flip<PT_MemberPtr, PT_Sint64>(S);
20421#if USE_TAILCALLS
20422 MUSTTAIL return InterpNext(S);
20423#else
20424 return true;
20425#endif
20426}
20427PRESERVE_NONE
20428static bool Interp_FlipMemberPtrUint64(InterpState &S) {
20429 Flip<PT_MemberPtr, PT_Uint64>(S);
20430#if USE_TAILCALLS
20431 MUSTTAIL return InterpNext(S);
20432#else
20433 return true;
20434#endif
20435}
20436PRESERVE_NONE
20437static bool Interp_FlipMemberPtrIntAP(InterpState &S) {
20438 Flip<PT_MemberPtr, PT_IntAP>(S);
20439#if USE_TAILCALLS
20440 MUSTTAIL return InterpNext(S);
20441#else
20442 return true;
20443#endif
20444}
20445PRESERVE_NONE
20446static bool Interp_FlipMemberPtrIntAPS(InterpState &S) {
20447 Flip<PT_MemberPtr, PT_IntAPS>(S);
20448#if USE_TAILCALLS
20449 MUSTTAIL return InterpNext(S);
20450#else
20451 return true;
20452#endif
20453}
20454PRESERVE_NONE
20455static bool Interp_FlipMemberPtrBool(InterpState &S) {
20456 Flip<PT_MemberPtr, PT_Bool>(S);
20457#if USE_TAILCALLS
20458 MUSTTAIL return InterpNext(S);
20459#else
20460 return true;
20461#endif
20462}
20463PRESERVE_NONE
20464static bool Interp_FlipMemberPtrFixedPoint(InterpState &S) {
20465 Flip<PT_MemberPtr, PT_FixedPoint>(S);
20466#if USE_TAILCALLS
20467 MUSTTAIL return InterpNext(S);
20468#else
20469 return true;
20470#endif
20471}
20472PRESERVE_NONE
20473static bool Interp_FlipMemberPtrPtr(InterpState &S) {
20474 Flip<PT_MemberPtr, PT_Ptr>(S);
20475#if USE_TAILCALLS
20476 MUSTTAIL return InterpNext(S);
20477#else
20478 return true;
20479#endif
20480}
20481PRESERVE_NONE
20482static bool Interp_FlipMemberPtrMemberPtr(InterpState &S) {
20483 Flip<PT_MemberPtr, PT_MemberPtr>(S);
20484#if USE_TAILCALLS
20485 MUSTTAIL return InterpNext(S);
20486#else
20487 return true;
20488#endif
20489}
20490PRESERVE_NONE
20491static bool Interp_FlipMemberPtrFloat(InterpState &S) {
20492 Flip<PT_MemberPtr, PT_Float>(S);
20493#if USE_TAILCALLS
20494 MUSTTAIL return InterpNext(S);
20495#else
20496 return true;
20497#endif
20498}
20499PRESERVE_NONE
20500static bool Interp_FlipMemberPtrReflect(InterpState &S) {
20501 Flip<PT_MemberPtr, PT_Reflect>(S);
20502#if USE_TAILCALLS
20503 MUSTTAIL return InterpNext(S);
20504#else
20505 return true;
20506#endif
20507}
20508PRESERVE_NONE
20509static bool Interp_FlipFloatSint8(InterpState &S) {
20510 Flip<PT_Float, PT_Sint8>(S);
20511#if USE_TAILCALLS
20512 MUSTTAIL return InterpNext(S);
20513#else
20514 return true;
20515#endif
20516}
20517PRESERVE_NONE
20518static bool Interp_FlipFloatUint8(InterpState &S) {
20519 Flip<PT_Float, PT_Uint8>(S);
20520#if USE_TAILCALLS
20521 MUSTTAIL return InterpNext(S);
20522#else
20523 return true;
20524#endif
20525}
20526PRESERVE_NONE
20527static bool Interp_FlipFloatSint16(InterpState &S) {
20528 Flip<PT_Float, PT_Sint16>(S);
20529#if USE_TAILCALLS
20530 MUSTTAIL return InterpNext(S);
20531#else
20532 return true;
20533#endif
20534}
20535PRESERVE_NONE
20536static bool Interp_FlipFloatUint16(InterpState &S) {
20537 Flip<PT_Float, PT_Uint16>(S);
20538#if USE_TAILCALLS
20539 MUSTTAIL return InterpNext(S);
20540#else
20541 return true;
20542#endif
20543}
20544PRESERVE_NONE
20545static bool Interp_FlipFloatSint32(InterpState &S) {
20546 Flip<PT_Float, PT_Sint32>(S);
20547#if USE_TAILCALLS
20548 MUSTTAIL return InterpNext(S);
20549#else
20550 return true;
20551#endif
20552}
20553PRESERVE_NONE
20554static bool Interp_FlipFloatUint32(InterpState &S) {
20555 Flip<PT_Float, PT_Uint32>(S);
20556#if USE_TAILCALLS
20557 MUSTTAIL return InterpNext(S);
20558#else
20559 return true;
20560#endif
20561}
20562PRESERVE_NONE
20563static bool Interp_FlipFloatSint64(InterpState &S) {
20564 Flip<PT_Float, PT_Sint64>(S);
20565#if USE_TAILCALLS
20566 MUSTTAIL return InterpNext(S);
20567#else
20568 return true;
20569#endif
20570}
20571PRESERVE_NONE
20572static bool Interp_FlipFloatUint64(InterpState &S) {
20573 Flip<PT_Float, PT_Uint64>(S);
20574#if USE_TAILCALLS
20575 MUSTTAIL return InterpNext(S);
20576#else
20577 return true;
20578#endif
20579}
20580PRESERVE_NONE
20581static bool Interp_FlipFloatIntAP(InterpState &S) {
20582 Flip<PT_Float, PT_IntAP>(S);
20583#if USE_TAILCALLS
20584 MUSTTAIL return InterpNext(S);
20585#else
20586 return true;
20587#endif
20588}
20589PRESERVE_NONE
20590static bool Interp_FlipFloatIntAPS(InterpState &S) {
20591 Flip<PT_Float, PT_IntAPS>(S);
20592#if USE_TAILCALLS
20593 MUSTTAIL return InterpNext(S);
20594#else
20595 return true;
20596#endif
20597}
20598PRESERVE_NONE
20599static bool Interp_FlipFloatBool(InterpState &S) {
20600 Flip<PT_Float, PT_Bool>(S);
20601#if USE_TAILCALLS
20602 MUSTTAIL return InterpNext(S);
20603#else
20604 return true;
20605#endif
20606}
20607PRESERVE_NONE
20608static bool Interp_FlipFloatFixedPoint(InterpState &S) {
20609 Flip<PT_Float, PT_FixedPoint>(S);
20610#if USE_TAILCALLS
20611 MUSTTAIL return InterpNext(S);
20612#else
20613 return true;
20614#endif
20615}
20616PRESERVE_NONE
20617static bool Interp_FlipFloatPtr(InterpState &S) {
20618 Flip<PT_Float, PT_Ptr>(S);
20619#if USE_TAILCALLS
20620 MUSTTAIL return InterpNext(S);
20621#else
20622 return true;
20623#endif
20624}
20625PRESERVE_NONE
20626static bool Interp_FlipFloatMemberPtr(InterpState &S) {
20627 Flip<PT_Float, PT_MemberPtr>(S);
20628#if USE_TAILCALLS
20629 MUSTTAIL return InterpNext(S);
20630#else
20631 return true;
20632#endif
20633}
20634PRESERVE_NONE
20635static bool Interp_FlipFloatFloat(InterpState &S) {
20636 Flip<PT_Float, PT_Float>(S);
20637#if USE_TAILCALLS
20638 MUSTTAIL return InterpNext(S);
20639#else
20640 return true;
20641#endif
20642}
20643PRESERVE_NONE
20644static bool Interp_FlipFloatReflect(InterpState &S) {
20645 Flip<PT_Float, PT_Reflect>(S);
20646#if USE_TAILCALLS
20647 MUSTTAIL return InterpNext(S);
20648#else
20649 return true;
20650#endif
20651}
20652PRESERVE_NONE
20653static bool Interp_FlipReflectSint8(InterpState &S) {
20654 Flip<PT_Reflect, PT_Sint8>(S);
20655#if USE_TAILCALLS
20656 MUSTTAIL return InterpNext(S);
20657#else
20658 return true;
20659#endif
20660}
20661PRESERVE_NONE
20662static bool Interp_FlipReflectUint8(InterpState &S) {
20663 Flip<PT_Reflect, PT_Uint8>(S);
20664#if USE_TAILCALLS
20665 MUSTTAIL return InterpNext(S);
20666#else
20667 return true;
20668#endif
20669}
20670PRESERVE_NONE
20671static bool Interp_FlipReflectSint16(InterpState &S) {
20672 Flip<PT_Reflect, PT_Sint16>(S);
20673#if USE_TAILCALLS
20674 MUSTTAIL return InterpNext(S);
20675#else
20676 return true;
20677#endif
20678}
20679PRESERVE_NONE
20680static bool Interp_FlipReflectUint16(InterpState &S) {
20681 Flip<PT_Reflect, PT_Uint16>(S);
20682#if USE_TAILCALLS
20683 MUSTTAIL return InterpNext(S);
20684#else
20685 return true;
20686#endif
20687}
20688PRESERVE_NONE
20689static bool Interp_FlipReflectSint32(InterpState &S) {
20690 Flip<PT_Reflect, PT_Sint32>(S);
20691#if USE_TAILCALLS
20692 MUSTTAIL return InterpNext(S);
20693#else
20694 return true;
20695#endif
20696}
20697PRESERVE_NONE
20698static bool Interp_FlipReflectUint32(InterpState &S) {
20699 Flip<PT_Reflect, PT_Uint32>(S);
20700#if USE_TAILCALLS
20701 MUSTTAIL return InterpNext(S);
20702#else
20703 return true;
20704#endif
20705}
20706PRESERVE_NONE
20707static bool Interp_FlipReflectSint64(InterpState &S) {
20708 Flip<PT_Reflect, PT_Sint64>(S);
20709#if USE_TAILCALLS
20710 MUSTTAIL return InterpNext(S);
20711#else
20712 return true;
20713#endif
20714}
20715PRESERVE_NONE
20716static bool Interp_FlipReflectUint64(InterpState &S) {
20717 Flip<PT_Reflect, PT_Uint64>(S);
20718#if USE_TAILCALLS
20719 MUSTTAIL return InterpNext(S);
20720#else
20721 return true;
20722#endif
20723}
20724PRESERVE_NONE
20725static bool Interp_FlipReflectIntAP(InterpState &S) {
20726 Flip<PT_Reflect, PT_IntAP>(S);
20727#if USE_TAILCALLS
20728 MUSTTAIL return InterpNext(S);
20729#else
20730 return true;
20731#endif
20732}
20733PRESERVE_NONE
20734static bool Interp_FlipReflectIntAPS(InterpState &S) {
20735 Flip<PT_Reflect, PT_IntAPS>(S);
20736#if USE_TAILCALLS
20737 MUSTTAIL return InterpNext(S);
20738#else
20739 return true;
20740#endif
20741}
20742PRESERVE_NONE
20743static bool Interp_FlipReflectBool(InterpState &S) {
20744 Flip<PT_Reflect, PT_Bool>(S);
20745#if USE_TAILCALLS
20746 MUSTTAIL return InterpNext(S);
20747#else
20748 return true;
20749#endif
20750}
20751PRESERVE_NONE
20752static bool Interp_FlipReflectFixedPoint(InterpState &S) {
20753 Flip<PT_Reflect, PT_FixedPoint>(S);
20754#if USE_TAILCALLS
20755 MUSTTAIL return InterpNext(S);
20756#else
20757 return true;
20758#endif
20759}
20760PRESERVE_NONE
20761static bool Interp_FlipReflectPtr(InterpState &S) {
20762 Flip<PT_Reflect, PT_Ptr>(S);
20763#if USE_TAILCALLS
20764 MUSTTAIL return InterpNext(S);
20765#else
20766 return true;
20767#endif
20768}
20769PRESERVE_NONE
20770static bool Interp_FlipReflectMemberPtr(InterpState &S) {
20771 Flip<PT_Reflect, PT_MemberPtr>(S);
20772#if USE_TAILCALLS
20773 MUSTTAIL return InterpNext(S);
20774#else
20775 return true;
20776#endif
20777}
20778PRESERVE_NONE
20779static bool Interp_FlipReflectFloat(InterpState &S) {
20780 Flip<PT_Reflect, PT_Float>(S);
20781#if USE_TAILCALLS
20782 MUSTTAIL return InterpNext(S);
20783#else
20784 return true;
20785#endif
20786}
20787PRESERVE_NONE
20788static bool Interp_FlipReflectReflect(InterpState &S) {
20789 Flip<PT_Reflect, PT_Reflect>(S);
20790#if USE_TAILCALLS
20791 MUSTTAIL return InterpNext(S);
20792#else
20793 return true;
20794#endif
20795}
20796#endif
20797#ifdef GET_DISASM
20798case OP_FlipSint8Sint8:
20799 Text.Op = PrintName("FlipSint8Sint8");
20800 break;
20801case OP_FlipSint8Uint8:
20802 Text.Op = PrintName("FlipSint8Uint8");
20803 break;
20804case OP_FlipSint8Sint16:
20805 Text.Op = PrintName("FlipSint8Sint16");
20806 break;
20807case OP_FlipSint8Uint16:
20808 Text.Op = PrintName("FlipSint8Uint16");
20809 break;
20810case OP_FlipSint8Sint32:
20811 Text.Op = PrintName("FlipSint8Sint32");
20812 break;
20813case OP_FlipSint8Uint32:
20814 Text.Op = PrintName("FlipSint8Uint32");
20815 break;
20816case OP_FlipSint8Sint64:
20817 Text.Op = PrintName("FlipSint8Sint64");
20818 break;
20819case OP_FlipSint8Uint64:
20820 Text.Op = PrintName("FlipSint8Uint64");
20821 break;
20822case OP_FlipSint8IntAP:
20823 Text.Op = PrintName("FlipSint8IntAP");
20824 break;
20825case OP_FlipSint8IntAPS:
20826 Text.Op = PrintName("FlipSint8IntAPS");
20827 break;
20828case OP_FlipSint8Bool:
20829 Text.Op = PrintName("FlipSint8Bool");
20830 break;
20831case OP_FlipSint8FixedPoint:
20832 Text.Op = PrintName("FlipSint8FixedPoint");
20833 break;
20834case OP_FlipSint8Ptr:
20835 Text.Op = PrintName("FlipSint8Ptr");
20836 break;
20837case OP_FlipSint8MemberPtr:
20838 Text.Op = PrintName("FlipSint8MemberPtr");
20839 break;
20840case OP_FlipSint8Float:
20841 Text.Op = PrintName("FlipSint8Float");
20842 break;
20843case OP_FlipSint8Reflect:
20844 Text.Op = PrintName("FlipSint8Reflect");
20845 break;
20846case OP_FlipUint8Sint8:
20847 Text.Op = PrintName("FlipUint8Sint8");
20848 break;
20849case OP_FlipUint8Uint8:
20850 Text.Op = PrintName("FlipUint8Uint8");
20851 break;
20852case OP_FlipUint8Sint16:
20853 Text.Op = PrintName("FlipUint8Sint16");
20854 break;
20855case OP_FlipUint8Uint16:
20856 Text.Op = PrintName("FlipUint8Uint16");
20857 break;
20858case OP_FlipUint8Sint32:
20859 Text.Op = PrintName("FlipUint8Sint32");
20860 break;
20861case OP_FlipUint8Uint32:
20862 Text.Op = PrintName("FlipUint8Uint32");
20863 break;
20864case OP_FlipUint8Sint64:
20865 Text.Op = PrintName("FlipUint8Sint64");
20866 break;
20867case OP_FlipUint8Uint64:
20868 Text.Op = PrintName("FlipUint8Uint64");
20869 break;
20870case OP_FlipUint8IntAP:
20871 Text.Op = PrintName("FlipUint8IntAP");
20872 break;
20873case OP_FlipUint8IntAPS:
20874 Text.Op = PrintName("FlipUint8IntAPS");
20875 break;
20876case OP_FlipUint8Bool:
20877 Text.Op = PrintName("FlipUint8Bool");
20878 break;
20879case OP_FlipUint8FixedPoint:
20880 Text.Op = PrintName("FlipUint8FixedPoint");
20881 break;
20882case OP_FlipUint8Ptr:
20883 Text.Op = PrintName("FlipUint8Ptr");
20884 break;
20885case OP_FlipUint8MemberPtr:
20886 Text.Op = PrintName("FlipUint8MemberPtr");
20887 break;
20888case OP_FlipUint8Float:
20889 Text.Op = PrintName("FlipUint8Float");
20890 break;
20891case OP_FlipUint8Reflect:
20892 Text.Op = PrintName("FlipUint8Reflect");
20893 break;
20894case OP_FlipSint16Sint8:
20895 Text.Op = PrintName("FlipSint16Sint8");
20896 break;
20897case OP_FlipSint16Uint8:
20898 Text.Op = PrintName("FlipSint16Uint8");
20899 break;
20900case OP_FlipSint16Sint16:
20901 Text.Op = PrintName("FlipSint16Sint16");
20902 break;
20903case OP_FlipSint16Uint16:
20904 Text.Op = PrintName("FlipSint16Uint16");
20905 break;
20906case OP_FlipSint16Sint32:
20907 Text.Op = PrintName("FlipSint16Sint32");
20908 break;
20909case OP_FlipSint16Uint32:
20910 Text.Op = PrintName("FlipSint16Uint32");
20911 break;
20912case OP_FlipSint16Sint64:
20913 Text.Op = PrintName("FlipSint16Sint64");
20914 break;
20915case OP_FlipSint16Uint64:
20916 Text.Op = PrintName("FlipSint16Uint64");
20917 break;
20918case OP_FlipSint16IntAP:
20919 Text.Op = PrintName("FlipSint16IntAP");
20920 break;
20921case OP_FlipSint16IntAPS:
20922 Text.Op = PrintName("FlipSint16IntAPS");
20923 break;
20924case OP_FlipSint16Bool:
20925 Text.Op = PrintName("FlipSint16Bool");
20926 break;
20927case OP_FlipSint16FixedPoint:
20928 Text.Op = PrintName("FlipSint16FixedPoint");
20929 break;
20930case OP_FlipSint16Ptr:
20931 Text.Op = PrintName("FlipSint16Ptr");
20932 break;
20933case OP_FlipSint16MemberPtr:
20934 Text.Op = PrintName("FlipSint16MemberPtr");
20935 break;
20936case OP_FlipSint16Float:
20937 Text.Op = PrintName("FlipSint16Float");
20938 break;
20939case OP_FlipSint16Reflect:
20940 Text.Op = PrintName("FlipSint16Reflect");
20941 break;
20942case OP_FlipUint16Sint8:
20943 Text.Op = PrintName("FlipUint16Sint8");
20944 break;
20945case OP_FlipUint16Uint8:
20946 Text.Op = PrintName("FlipUint16Uint8");
20947 break;
20948case OP_FlipUint16Sint16:
20949 Text.Op = PrintName("FlipUint16Sint16");
20950 break;
20951case OP_FlipUint16Uint16:
20952 Text.Op = PrintName("FlipUint16Uint16");
20953 break;
20954case OP_FlipUint16Sint32:
20955 Text.Op = PrintName("FlipUint16Sint32");
20956 break;
20957case OP_FlipUint16Uint32:
20958 Text.Op = PrintName("FlipUint16Uint32");
20959 break;
20960case OP_FlipUint16Sint64:
20961 Text.Op = PrintName("FlipUint16Sint64");
20962 break;
20963case OP_FlipUint16Uint64:
20964 Text.Op = PrintName("FlipUint16Uint64");
20965 break;
20966case OP_FlipUint16IntAP:
20967 Text.Op = PrintName("FlipUint16IntAP");
20968 break;
20969case OP_FlipUint16IntAPS:
20970 Text.Op = PrintName("FlipUint16IntAPS");
20971 break;
20972case OP_FlipUint16Bool:
20973 Text.Op = PrintName("FlipUint16Bool");
20974 break;
20975case OP_FlipUint16FixedPoint:
20976 Text.Op = PrintName("FlipUint16FixedPoint");
20977 break;
20978case OP_FlipUint16Ptr:
20979 Text.Op = PrintName("FlipUint16Ptr");
20980 break;
20981case OP_FlipUint16MemberPtr:
20982 Text.Op = PrintName("FlipUint16MemberPtr");
20983 break;
20984case OP_FlipUint16Float:
20985 Text.Op = PrintName("FlipUint16Float");
20986 break;
20987case OP_FlipUint16Reflect:
20988 Text.Op = PrintName("FlipUint16Reflect");
20989 break;
20990case OP_FlipSint32Sint8:
20991 Text.Op = PrintName("FlipSint32Sint8");
20992 break;
20993case OP_FlipSint32Uint8:
20994 Text.Op = PrintName("FlipSint32Uint8");
20995 break;
20996case OP_FlipSint32Sint16:
20997 Text.Op = PrintName("FlipSint32Sint16");
20998 break;
20999case OP_FlipSint32Uint16:
21000 Text.Op = PrintName("FlipSint32Uint16");
21001 break;
21002case OP_FlipSint32Sint32:
21003 Text.Op = PrintName("FlipSint32Sint32");
21004 break;
21005case OP_FlipSint32Uint32:
21006 Text.Op = PrintName("FlipSint32Uint32");
21007 break;
21008case OP_FlipSint32Sint64:
21009 Text.Op = PrintName("FlipSint32Sint64");
21010 break;
21011case OP_FlipSint32Uint64:
21012 Text.Op = PrintName("FlipSint32Uint64");
21013 break;
21014case OP_FlipSint32IntAP:
21015 Text.Op = PrintName("FlipSint32IntAP");
21016 break;
21017case OP_FlipSint32IntAPS:
21018 Text.Op = PrintName("FlipSint32IntAPS");
21019 break;
21020case OP_FlipSint32Bool:
21021 Text.Op = PrintName("FlipSint32Bool");
21022 break;
21023case OP_FlipSint32FixedPoint:
21024 Text.Op = PrintName("FlipSint32FixedPoint");
21025 break;
21026case OP_FlipSint32Ptr:
21027 Text.Op = PrintName("FlipSint32Ptr");
21028 break;
21029case OP_FlipSint32MemberPtr:
21030 Text.Op = PrintName("FlipSint32MemberPtr");
21031 break;
21032case OP_FlipSint32Float:
21033 Text.Op = PrintName("FlipSint32Float");
21034 break;
21035case OP_FlipSint32Reflect:
21036 Text.Op = PrintName("FlipSint32Reflect");
21037 break;
21038case OP_FlipUint32Sint8:
21039 Text.Op = PrintName("FlipUint32Sint8");
21040 break;
21041case OP_FlipUint32Uint8:
21042 Text.Op = PrintName("FlipUint32Uint8");
21043 break;
21044case OP_FlipUint32Sint16:
21045 Text.Op = PrintName("FlipUint32Sint16");
21046 break;
21047case OP_FlipUint32Uint16:
21048 Text.Op = PrintName("FlipUint32Uint16");
21049 break;
21050case OP_FlipUint32Sint32:
21051 Text.Op = PrintName("FlipUint32Sint32");
21052 break;
21053case OP_FlipUint32Uint32:
21054 Text.Op = PrintName("FlipUint32Uint32");
21055 break;
21056case OP_FlipUint32Sint64:
21057 Text.Op = PrintName("FlipUint32Sint64");
21058 break;
21059case OP_FlipUint32Uint64:
21060 Text.Op = PrintName("FlipUint32Uint64");
21061 break;
21062case OP_FlipUint32IntAP:
21063 Text.Op = PrintName("FlipUint32IntAP");
21064 break;
21065case OP_FlipUint32IntAPS:
21066 Text.Op = PrintName("FlipUint32IntAPS");
21067 break;
21068case OP_FlipUint32Bool:
21069 Text.Op = PrintName("FlipUint32Bool");
21070 break;
21071case OP_FlipUint32FixedPoint:
21072 Text.Op = PrintName("FlipUint32FixedPoint");
21073 break;
21074case OP_FlipUint32Ptr:
21075 Text.Op = PrintName("FlipUint32Ptr");
21076 break;
21077case OP_FlipUint32MemberPtr:
21078 Text.Op = PrintName("FlipUint32MemberPtr");
21079 break;
21080case OP_FlipUint32Float:
21081 Text.Op = PrintName("FlipUint32Float");
21082 break;
21083case OP_FlipUint32Reflect:
21084 Text.Op = PrintName("FlipUint32Reflect");
21085 break;
21086case OP_FlipSint64Sint8:
21087 Text.Op = PrintName("FlipSint64Sint8");
21088 break;
21089case OP_FlipSint64Uint8:
21090 Text.Op = PrintName("FlipSint64Uint8");
21091 break;
21092case OP_FlipSint64Sint16:
21093 Text.Op = PrintName("FlipSint64Sint16");
21094 break;
21095case OP_FlipSint64Uint16:
21096 Text.Op = PrintName("FlipSint64Uint16");
21097 break;
21098case OP_FlipSint64Sint32:
21099 Text.Op = PrintName("FlipSint64Sint32");
21100 break;
21101case OP_FlipSint64Uint32:
21102 Text.Op = PrintName("FlipSint64Uint32");
21103 break;
21104case OP_FlipSint64Sint64:
21105 Text.Op = PrintName("FlipSint64Sint64");
21106 break;
21107case OP_FlipSint64Uint64:
21108 Text.Op = PrintName("FlipSint64Uint64");
21109 break;
21110case OP_FlipSint64IntAP:
21111 Text.Op = PrintName("FlipSint64IntAP");
21112 break;
21113case OP_FlipSint64IntAPS:
21114 Text.Op = PrintName("FlipSint64IntAPS");
21115 break;
21116case OP_FlipSint64Bool:
21117 Text.Op = PrintName("FlipSint64Bool");
21118 break;
21119case OP_FlipSint64FixedPoint:
21120 Text.Op = PrintName("FlipSint64FixedPoint");
21121 break;
21122case OP_FlipSint64Ptr:
21123 Text.Op = PrintName("FlipSint64Ptr");
21124 break;
21125case OP_FlipSint64MemberPtr:
21126 Text.Op = PrintName("FlipSint64MemberPtr");
21127 break;
21128case OP_FlipSint64Float:
21129 Text.Op = PrintName("FlipSint64Float");
21130 break;
21131case OP_FlipSint64Reflect:
21132 Text.Op = PrintName("FlipSint64Reflect");
21133 break;
21134case OP_FlipUint64Sint8:
21135 Text.Op = PrintName("FlipUint64Sint8");
21136 break;
21137case OP_FlipUint64Uint8:
21138 Text.Op = PrintName("FlipUint64Uint8");
21139 break;
21140case OP_FlipUint64Sint16:
21141 Text.Op = PrintName("FlipUint64Sint16");
21142 break;
21143case OP_FlipUint64Uint16:
21144 Text.Op = PrintName("FlipUint64Uint16");
21145 break;
21146case OP_FlipUint64Sint32:
21147 Text.Op = PrintName("FlipUint64Sint32");
21148 break;
21149case OP_FlipUint64Uint32:
21150 Text.Op = PrintName("FlipUint64Uint32");
21151 break;
21152case OP_FlipUint64Sint64:
21153 Text.Op = PrintName("FlipUint64Sint64");
21154 break;
21155case OP_FlipUint64Uint64:
21156 Text.Op = PrintName("FlipUint64Uint64");
21157 break;
21158case OP_FlipUint64IntAP:
21159 Text.Op = PrintName("FlipUint64IntAP");
21160 break;
21161case OP_FlipUint64IntAPS:
21162 Text.Op = PrintName("FlipUint64IntAPS");
21163 break;
21164case OP_FlipUint64Bool:
21165 Text.Op = PrintName("FlipUint64Bool");
21166 break;
21167case OP_FlipUint64FixedPoint:
21168 Text.Op = PrintName("FlipUint64FixedPoint");
21169 break;
21170case OP_FlipUint64Ptr:
21171 Text.Op = PrintName("FlipUint64Ptr");
21172 break;
21173case OP_FlipUint64MemberPtr:
21174 Text.Op = PrintName("FlipUint64MemberPtr");
21175 break;
21176case OP_FlipUint64Float:
21177 Text.Op = PrintName("FlipUint64Float");
21178 break;
21179case OP_FlipUint64Reflect:
21180 Text.Op = PrintName("FlipUint64Reflect");
21181 break;
21182case OP_FlipIntAPSint8:
21183 Text.Op = PrintName("FlipIntAPSint8");
21184 break;
21185case OP_FlipIntAPUint8:
21186 Text.Op = PrintName("FlipIntAPUint8");
21187 break;
21188case OP_FlipIntAPSint16:
21189 Text.Op = PrintName("FlipIntAPSint16");
21190 break;
21191case OP_FlipIntAPUint16:
21192 Text.Op = PrintName("FlipIntAPUint16");
21193 break;
21194case OP_FlipIntAPSint32:
21195 Text.Op = PrintName("FlipIntAPSint32");
21196 break;
21197case OP_FlipIntAPUint32:
21198 Text.Op = PrintName("FlipIntAPUint32");
21199 break;
21200case OP_FlipIntAPSint64:
21201 Text.Op = PrintName("FlipIntAPSint64");
21202 break;
21203case OP_FlipIntAPUint64:
21204 Text.Op = PrintName("FlipIntAPUint64");
21205 break;
21206case OP_FlipIntAPIntAP:
21207 Text.Op = PrintName("FlipIntAPIntAP");
21208 break;
21209case OP_FlipIntAPIntAPS:
21210 Text.Op = PrintName("FlipIntAPIntAPS");
21211 break;
21212case OP_FlipIntAPBool:
21213 Text.Op = PrintName("FlipIntAPBool");
21214 break;
21215case OP_FlipIntAPFixedPoint:
21216 Text.Op = PrintName("FlipIntAPFixedPoint");
21217 break;
21218case OP_FlipIntAPPtr:
21219 Text.Op = PrintName("FlipIntAPPtr");
21220 break;
21221case OP_FlipIntAPMemberPtr:
21222 Text.Op = PrintName("FlipIntAPMemberPtr");
21223 break;
21224case OP_FlipIntAPFloat:
21225 Text.Op = PrintName("FlipIntAPFloat");
21226 break;
21227case OP_FlipIntAPReflect:
21228 Text.Op = PrintName("FlipIntAPReflect");
21229 break;
21230case OP_FlipIntAPSSint8:
21231 Text.Op = PrintName("FlipIntAPSSint8");
21232 break;
21233case OP_FlipIntAPSUint8:
21234 Text.Op = PrintName("FlipIntAPSUint8");
21235 break;
21236case OP_FlipIntAPSSint16:
21237 Text.Op = PrintName("FlipIntAPSSint16");
21238 break;
21239case OP_FlipIntAPSUint16:
21240 Text.Op = PrintName("FlipIntAPSUint16");
21241 break;
21242case OP_FlipIntAPSSint32:
21243 Text.Op = PrintName("FlipIntAPSSint32");
21244 break;
21245case OP_FlipIntAPSUint32:
21246 Text.Op = PrintName("FlipIntAPSUint32");
21247 break;
21248case OP_FlipIntAPSSint64:
21249 Text.Op = PrintName("FlipIntAPSSint64");
21250 break;
21251case OP_FlipIntAPSUint64:
21252 Text.Op = PrintName("FlipIntAPSUint64");
21253 break;
21254case OP_FlipIntAPSIntAP:
21255 Text.Op = PrintName("FlipIntAPSIntAP");
21256 break;
21257case OP_FlipIntAPSIntAPS:
21258 Text.Op = PrintName("FlipIntAPSIntAPS");
21259 break;
21260case OP_FlipIntAPSBool:
21261 Text.Op = PrintName("FlipIntAPSBool");
21262 break;
21263case OP_FlipIntAPSFixedPoint:
21264 Text.Op = PrintName("FlipIntAPSFixedPoint");
21265 break;
21266case OP_FlipIntAPSPtr:
21267 Text.Op = PrintName("FlipIntAPSPtr");
21268 break;
21269case OP_FlipIntAPSMemberPtr:
21270 Text.Op = PrintName("FlipIntAPSMemberPtr");
21271 break;
21272case OP_FlipIntAPSFloat:
21273 Text.Op = PrintName("FlipIntAPSFloat");
21274 break;
21275case OP_FlipIntAPSReflect:
21276 Text.Op = PrintName("FlipIntAPSReflect");
21277 break;
21278case OP_FlipBoolSint8:
21279 Text.Op = PrintName("FlipBoolSint8");
21280 break;
21281case OP_FlipBoolUint8:
21282 Text.Op = PrintName("FlipBoolUint8");
21283 break;
21284case OP_FlipBoolSint16:
21285 Text.Op = PrintName("FlipBoolSint16");
21286 break;
21287case OP_FlipBoolUint16:
21288 Text.Op = PrintName("FlipBoolUint16");
21289 break;
21290case OP_FlipBoolSint32:
21291 Text.Op = PrintName("FlipBoolSint32");
21292 break;
21293case OP_FlipBoolUint32:
21294 Text.Op = PrintName("FlipBoolUint32");
21295 break;
21296case OP_FlipBoolSint64:
21297 Text.Op = PrintName("FlipBoolSint64");
21298 break;
21299case OP_FlipBoolUint64:
21300 Text.Op = PrintName("FlipBoolUint64");
21301 break;
21302case OP_FlipBoolIntAP:
21303 Text.Op = PrintName("FlipBoolIntAP");
21304 break;
21305case OP_FlipBoolIntAPS:
21306 Text.Op = PrintName("FlipBoolIntAPS");
21307 break;
21308case OP_FlipBoolBool:
21309 Text.Op = PrintName("FlipBoolBool");
21310 break;
21311case OP_FlipBoolFixedPoint:
21312 Text.Op = PrintName("FlipBoolFixedPoint");
21313 break;
21314case OP_FlipBoolPtr:
21315 Text.Op = PrintName("FlipBoolPtr");
21316 break;
21317case OP_FlipBoolMemberPtr:
21318 Text.Op = PrintName("FlipBoolMemberPtr");
21319 break;
21320case OP_FlipBoolFloat:
21321 Text.Op = PrintName("FlipBoolFloat");
21322 break;
21323case OP_FlipBoolReflect:
21324 Text.Op = PrintName("FlipBoolReflect");
21325 break;
21326case OP_FlipFixedPointSint8:
21327 Text.Op = PrintName("FlipFixedPointSint8");
21328 break;
21329case OP_FlipFixedPointUint8:
21330 Text.Op = PrintName("FlipFixedPointUint8");
21331 break;
21332case OP_FlipFixedPointSint16:
21333 Text.Op = PrintName("FlipFixedPointSint16");
21334 break;
21335case OP_FlipFixedPointUint16:
21336 Text.Op = PrintName("FlipFixedPointUint16");
21337 break;
21338case OP_FlipFixedPointSint32:
21339 Text.Op = PrintName("FlipFixedPointSint32");
21340 break;
21341case OP_FlipFixedPointUint32:
21342 Text.Op = PrintName("FlipFixedPointUint32");
21343 break;
21344case OP_FlipFixedPointSint64:
21345 Text.Op = PrintName("FlipFixedPointSint64");
21346 break;
21347case OP_FlipFixedPointUint64:
21348 Text.Op = PrintName("FlipFixedPointUint64");
21349 break;
21350case OP_FlipFixedPointIntAP:
21351 Text.Op = PrintName("FlipFixedPointIntAP");
21352 break;
21353case OP_FlipFixedPointIntAPS:
21354 Text.Op = PrintName("FlipFixedPointIntAPS");
21355 break;
21356case OP_FlipFixedPointBool:
21357 Text.Op = PrintName("FlipFixedPointBool");
21358 break;
21359case OP_FlipFixedPointFixedPoint:
21360 Text.Op = PrintName("FlipFixedPointFixedPoint");
21361 break;
21362case OP_FlipFixedPointPtr:
21363 Text.Op = PrintName("FlipFixedPointPtr");
21364 break;
21365case OP_FlipFixedPointMemberPtr:
21366 Text.Op = PrintName("FlipFixedPointMemberPtr");
21367 break;
21368case OP_FlipFixedPointFloat:
21369 Text.Op = PrintName("FlipFixedPointFloat");
21370 break;
21371case OP_FlipFixedPointReflect:
21372 Text.Op = PrintName("FlipFixedPointReflect");
21373 break;
21374case OP_FlipPtrSint8:
21375 Text.Op = PrintName("FlipPtrSint8");
21376 break;
21377case OP_FlipPtrUint8:
21378 Text.Op = PrintName("FlipPtrUint8");
21379 break;
21380case OP_FlipPtrSint16:
21381 Text.Op = PrintName("FlipPtrSint16");
21382 break;
21383case OP_FlipPtrUint16:
21384 Text.Op = PrintName("FlipPtrUint16");
21385 break;
21386case OP_FlipPtrSint32:
21387 Text.Op = PrintName("FlipPtrSint32");
21388 break;
21389case OP_FlipPtrUint32:
21390 Text.Op = PrintName("FlipPtrUint32");
21391 break;
21392case OP_FlipPtrSint64:
21393 Text.Op = PrintName("FlipPtrSint64");
21394 break;
21395case OP_FlipPtrUint64:
21396 Text.Op = PrintName("FlipPtrUint64");
21397 break;
21398case OP_FlipPtrIntAP:
21399 Text.Op = PrintName("FlipPtrIntAP");
21400 break;
21401case OP_FlipPtrIntAPS:
21402 Text.Op = PrintName("FlipPtrIntAPS");
21403 break;
21404case OP_FlipPtrBool:
21405 Text.Op = PrintName("FlipPtrBool");
21406 break;
21407case OP_FlipPtrFixedPoint:
21408 Text.Op = PrintName("FlipPtrFixedPoint");
21409 break;
21410case OP_FlipPtrPtr:
21411 Text.Op = PrintName("FlipPtrPtr");
21412 break;
21413case OP_FlipPtrMemberPtr:
21414 Text.Op = PrintName("FlipPtrMemberPtr");
21415 break;
21416case OP_FlipPtrFloat:
21417 Text.Op = PrintName("FlipPtrFloat");
21418 break;
21419case OP_FlipPtrReflect:
21420 Text.Op = PrintName("FlipPtrReflect");
21421 break;
21422case OP_FlipMemberPtrSint8:
21423 Text.Op = PrintName("FlipMemberPtrSint8");
21424 break;
21425case OP_FlipMemberPtrUint8:
21426 Text.Op = PrintName("FlipMemberPtrUint8");
21427 break;
21428case OP_FlipMemberPtrSint16:
21429 Text.Op = PrintName("FlipMemberPtrSint16");
21430 break;
21431case OP_FlipMemberPtrUint16:
21432 Text.Op = PrintName("FlipMemberPtrUint16");
21433 break;
21434case OP_FlipMemberPtrSint32:
21435 Text.Op = PrintName("FlipMemberPtrSint32");
21436 break;
21437case OP_FlipMemberPtrUint32:
21438 Text.Op = PrintName("FlipMemberPtrUint32");
21439 break;
21440case OP_FlipMemberPtrSint64:
21441 Text.Op = PrintName("FlipMemberPtrSint64");
21442 break;
21443case OP_FlipMemberPtrUint64:
21444 Text.Op = PrintName("FlipMemberPtrUint64");
21445 break;
21446case OP_FlipMemberPtrIntAP:
21447 Text.Op = PrintName("FlipMemberPtrIntAP");
21448 break;
21449case OP_FlipMemberPtrIntAPS:
21450 Text.Op = PrintName("FlipMemberPtrIntAPS");
21451 break;
21452case OP_FlipMemberPtrBool:
21453 Text.Op = PrintName("FlipMemberPtrBool");
21454 break;
21455case OP_FlipMemberPtrFixedPoint:
21456 Text.Op = PrintName("FlipMemberPtrFixedPoint");
21457 break;
21458case OP_FlipMemberPtrPtr:
21459 Text.Op = PrintName("FlipMemberPtrPtr");
21460 break;
21461case OP_FlipMemberPtrMemberPtr:
21462 Text.Op = PrintName("FlipMemberPtrMemberPtr");
21463 break;
21464case OP_FlipMemberPtrFloat:
21465 Text.Op = PrintName("FlipMemberPtrFloat");
21466 break;
21467case OP_FlipMemberPtrReflect:
21468 Text.Op = PrintName("FlipMemberPtrReflect");
21469 break;
21470case OP_FlipFloatSint8:
21471 Text.Op = PrintName("FlipFloatSint8");
21472 break;
21473case OP_FlipFloatUint8:
21474 Text.Op = PrintName("FlipFloatUint8");
21475 break;
21476case OP_FlipFloatSint16:
21477 Text.Op = PrintName("FlipFloatSint16");
21478 break;
21479case OP_FlipFloatUint16:
21480 Text.Op = PrintName("FlipFloatUint16");
21481 break;
21482case OP_FlipFloatSint32:
21483 Text.Op = PrintName("FlipFloatSint32");
21484 break;
21485case OP_FlipFloatUint32:
21486 Text.Op = PrintName("FlipFloatUint32");
21487 break;
21488case OP_FlipFloatSint64:
21489 Text.Op = PrintName("FlipFloatSint64");
21490 break;
21491case OP_FlipFloatUint64:
21492 Text.Op = PrintName("FlipFloatUint64");
21493 break;
21494case OP_FlipFloatIntAP:
21495 Text.Op = PrintName("FlipFloatIntAP");
21496 break;
21497case OP_FlipFloatIntAPS:
21498 Text.Op = PrintName("FlipFloatIntAPS");
21499 break;
21500case OP_FlipFloatBool:
21501 Text.Op = PrintName("FlipFloatBool");
21502 break;
21503case OP_FlipFloatFixedPoint:
21504 Text.Op = PrintName("FlipFloatFixedPoint");
21505 break;
21506case OP_FlipFloatPtr:
21507 Text.Op = PrintName("FlipFloatPtr");
21508 break;
21509case OP_FlipFloatMemberPtr:
21510 Text.Op = PrintName("FlipFloatMemberPtr");
21511 break;
21512case OP_FlipFloatFloat:
21513 Text.Op = PrintName("FlipFloatFloat");
21514 break;
21515case OP_FlipFloatReflect:
21516 Text.Op = PrintName("FlipFloatReflect");
21517 break;
21518case OP_FlipReflectSint8:
21519 Text.Op = PrintName("FlipReflectSint8");
21520 break;
21521case OP_FlipReflectUint8:
21522 Text.Op = PrintName("FlipReflectUint8");
21523 break;
21524case OP_FlipReflectSint16:
21525 Text.Op = PrintName("FlipReflectSint16");
21526 break;
21527case OP_FlipReflectUint16:
21528 Text.Op = PrintName("FlipReflectUint16");
21529 break;
21530case OP_FlipReflectSint32:
21531 Text.Op = PrintName("FlipReflectSint32");
21532 break;
21533case OP_FlipReflectUint32:
21534 Text.Op = PrintName("FlipReflectUint32");
21535 break;
21536case OP_FlipReflectSint64:
21537 Text.Op = PrintName("FlipReflectSint64");
21538 break;
21539case OP_FlipReflectUint64:
21540 Text.Op = PrintName("FlipReflectUint64");
21541 break;
21542case OP_FlipReflectIntAP:
21543 Text.Op = PrintName("FlipReflectIntAP");
21544 break;
21545case OP_FlipReflectIntAPS:
21546 Text.Op = PrintName("FlipReflectIntAPS");
21547 break;
21548case OP_FlipReflectBool:
21549 Text.Op = PrintName("FlipReflectBool");
21550 break;
21551case OP_FlipReflectFixedPoint:
21552 Text.Op = PrintName("FlipReflectFixedPoint");
21553 break;
21554case OP_FlipReflectPtr:
21555 Text.Op = PrintName("FlipReflectPtr");
21556 break;
21557case OP_FlipReflectMemberPtr:
21558 Text.Op = PrintName("FlipReflectMemberPtr");
21559 break;
21560case OP_FlipReflectFloat:
21561 Text.Op = PrintName("FlipReflectFloat");
21562 break;
21563case OP_FlipReflectReflect:
21564 Text.Op = PrintName("FlipReflectReflect");
21565 break;
21566#endif
21567#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
21568bool emitFlipSint8Sint8(SourceInfo);
21569bool emitFlipSint8Uint8(SourceInfo);
21570bool emitFlipSint8Sint16(SourceInfo);
21571bool emitFlipSint8Uint16(SourceInfo);
21572bool emitFlipSint8Sint32(SourceInfo);
21573bool emitFlipSint8Uint32(SourceInfo);
21574bool emitFlipSint8Sint64(SourceInfo);
21575bool emitFlipSint8Uint64(SourceInfo);
21576bool emitFlipSint8IntAP(SourceInfo);
21577bool emitFlipSint8IntAPS(SourceInfo);
21578bool emitFlipSint8Bool(SourceInfo);
21579bool emitFlipSint8FixedPoint(SourceInfo);
21580bool emitFlipSint8Ptr(SourceInfo);
21581bool emitFlipSint8MemberPtr(SourceInfo);
21582bool emitFlipSint8Float(SourceInfo);
21583bool emitFlipSint8Reflect(SourceInfo);
21584bool emitFlipUint8Sint8(SourceInfo);
21585bool emitFlipUint8Uint8(SourceInfo);
21586bool emitFlipUint8Sint16(SourceInfo);
21587bool emitFlipUint8Uint16(SourceInfo);
21588bool emitFlipUint8Sint32(SourceInfo);
21589bool emitFlipUint8Uint32(SourceInfo);
21590bool emitFlipUint8Sint64(SourceInfo);
21591bool emitFlipUint8Uint64(SourceInfo);
21592bool emitFlipUint8IntAP(SourceInfo);
21593bool emitFlipUint8IntAPS(SourceInfo);
21594bool emitFlipUint8Bool(SourceInfo);
21595bool emitFlipUint8FixedPoint(SourceInfo);
21596bool emitFlipUint8Ptr(SourceInfo);
21597bool emitFlipUint8MemberPtr(SourceInfo);
21598bool emitFlipUint8Float(SourceInfo);
21599bool emitFlipUint8Reflect(SourceInfo);
21600bool emitFlipSint16Sint8(SourceInfo);
21601bool emitFlipSint16Uint8(SourceInfo);
21602bool emitFlipSint16Sint16(SourceInfo);
21603bool emitFlipSint16Uint16(SourceInfo);
21604bool emitFlipSint16Sint32(SourceInfo);
21605bool emitFlipSint16Uint32(SourceInfo);
21606bool emitFlipSint16Sint64(SourceInfo);
21607bool emitFlipSint16Uint64(SourceInfo);
21608bool emitFlipSint16IntAP(SourceInfo);
21609bool emitFlipSint16IntAPS(SourceInfo);
21610bool emitFlipSint16Bool(SourceInfo);
21611bool emitFlipSint16FixedPoint(SourceInfo);
21612bool emitFlipSint16Ptr(SourceInfo);
21613bool emitFlipSint16MemberPtr(SourceInfo);
21614bool emitFlipSint16Float(SourceInfo);
21615bool emitFlipSint16Reflect(SourceInfo);
21616bool emitFlipUint16Sint8(SourceInfo);
21617bool emitFlipUint16Uint8(SourceInfo);
21618bool emitFlipUint16Sint16(SourceInfo);
21619bool emitFlipUint16Uint16(SourceInfo);
21620bool emitFlipUint16Sint32(SourceInfo);
21621bool emitFlipUint16Uint32(SourceInfo);
21622bool emitFlipUint16Sint64(SourceInfo);
21623bool emitFlipUint16Uint64(SourceInfo);
21624bool emitFlipUint16IntAP(SourceInfo);
21625bool emitFlipUint16IntAPS(SourceInfo);
21626bool emitFlipUint16Bool(SourceInfo);
21627bool emitFlipUint16FixedPoint(SourceInfo);
21628bool emitFlipUint16Ptr(SourceInfo);
21629bool emitFlipUint16MemberPtr(SourceInfo);
21630bool emitFlipUint16Float(SourceInfo);
21631bool emitFlipUint16Reflect(SourceInfo);
21632bool emitFlipSint32Sint8(SourceInfo);
21633bool emitFlipSint32Uint8(SourceInfo);
21634bool emitFlipSint32Sint16(SourceInfo);
21635bool emitFlipSint32Uint16(SourceInfo);
21636bool emitFlipSint32Sint32(SourceInfo);
21637bool emitFlipSint32Uint32(SourceInfo);
21638bool emitFlipSint32Sint64(SourceInfo);
21639bool emitFlipSint32Uint64(SourceInfo);
21640bool emitFlipSint32IntAP(SourceInfo);
21641bool emitFlipSint32IntAPS(SourceInfo);
21642bool emitFlipSint32Bool(SourceInfo);
21643bool emitFlipSint32FixedPoint(SourceInfo);
21644bool emitFlipSint32Ptr(SourceInfo);
21645bool emitFlipSint32MemberPtr(SourceInfo);
21646bool emitFlipSint32Float(SourceInfo);
21647bool emitFlipSint32Reflect(SourceInfo);
21648bool emitFlipUint32Sint8(SourceInfo);
21649bool emitFlipUint32Uint8(SourceInfo);
21650bool emitFlipUint32Sint16(SourceInfo);
21651bool emitFlipUint32Uint16(SourceInfo);
21652bool emitFlipUint32Sint32(SourceInfo);
21653bool emitFlipUint32Uint32(SourceInfo);
21654bool emitFlipUint32Sint64(SourceInfo);
21655bool emitFlipUint32Uint64(SourceInfo);
21656bool emitFlipUint32IntAP(SourceInfo);
21657bool emitFlipUint32IntAPS(SourceInfo);
21658bool emitFlipUint32Bool(SourceInfo);
21659bool emitFlipUint32FixedPoint(SourceInfo);
21660bool emitFlipUint32Ptr(SourceInfo);
21661bool emitFlipUint32MemberPtr(SourceInfo);
21662bool emitFlipUint32Float(SourceInfo);
21663bool emitFlipUint32Reflect(SourceInfo);
21664bool emitFlipSint64Sint8(SourceInfo);
21665bool emitFlipSint64Uint8(SourceInfo);
21666bool emitFlipSint64Sint16(SourceInfo);
21667bool emitFlipSint64Uint16(SourceInfo);
21668bool emitFlipSint64Sint32(SourceInfo);
21669bool emitFlipSint64Uint32(SourceInfo);
21670bool emitFlipSint64Sint64(SourceInfo);
21671bool emitFlipSint64Uint64(SourceInfo);
21672bool emitFlipSint64IntAP(SourceInfo);
21673bool emitFlipSint64IntAPS(SourceInfo);
21674bool emitFlipSint64Bool(SourceInfo);
21675bool emitFlipSint64FixedPoint(SourceInfo);
21676bool emitFlipSint64Ptr(SourceInfo);
21677bool emitFlipSint64MemberPtr(SourceInfo);
21678bool emitFlipSint64Float(SourceInfo);
21679bool emitFlipSint64Reflect(SourceInfo);
21680bool emitFlipUint64Sint8(SourceInfo);
21681bool emitFlipUint64Uint8(SourceInfo);
21682bool emitFlipUint64Sint16(SourceInfo);
21683bool emitFlipUint64Uint16(SourceInfo);
21684bool emitFlipUint64Sint32(SourceInfo);
21685bool emitFlipUint64Uint32(SourceInfo);
21686bool emitFlipUint64Sint64(SourceInfo);
21687bool emitFlipUint64Uint64(SourceInfo);
21688bool emitFlipUint64IntAP(SourceInfo);
21689bool emitFlipUint64IntAPS(SourceInfo);
21690bool emitFlipUint64Bool(SourceInfo);
21691bool emitFlipUint64FixedPoint(SourceInfo);
21692bool emitFlipUint64Ptr(SourceInfo);
21693bool emitFlipUint64MemberPtr(SourceInfo);
21694bool emitFlipUint64Float(SourceInfo);
21695bool emitFlipUint64Reflect(SourceInfo);
21696bool emitFlipIntAPSint8(SourceInfo);
21697bool emitFlipIntAPUint8(SourceInfo);
21698bool emitFlipIntAPSint16(SourceInfo);
21699bool emitFlipIntAPUint16(SourceInfo);
21700bool emitFlipIntAPSint32(SourceInfo);
21701bool emitFlipIntAPUint32(SourceInfo);
21702bool emitFlipIntAPSint64(SourceInfo);
21703bool emitFlipIntAPUint64(SourceInfo);
21704bool emitFlipIntAPIntAP(SourceInfo);
21705bool emitFlipIntAPIntAPS(SourceInfo);
21706bool emitFlipIntAPBool(SourceInfo);
21707bool emitFlipIntAPFixedPoint(SourceInfo);
21708bool emitFlipIntAPPtr(SourceInfo);
21709bool emitFlipIntAPMemberPtr(SourceInfo);
21710bool emitFlipIntAPFloat(SourceInfo);
21711bool emitFlipIntAPReflect(SourceInfo);
21712bool emitFlipIntAPSSint8(SourceInfo);
21713bool emitFlipIntAPSUint8(SourceInfo);
21714bool emitFlipIntAPSSint16(SourceInfo);
21715bool emitFlipIntAPSUint16(SourceInfo);
21716bool emitFlipIntAPSSint32(SourceInfo);
21717bool emitFlipIntAPSUint32(SourceInfo);
21718bool emitFlipIntAPSSint64(SourceInfo);
21719bool emitFlipIntAPSUint64(SourceInfo);
21720bool emitFlipIntAPSIntAP(SourceInfo);
21721bool emitFlipIntAPSIntAPS(SourceInfo);
21722bool emitFlipIntAPSBool(SourceInfo);
21723bool emitFlipIntAPSFixedPoint(SourceInfo);
21724bool emitFlipIntAPSPtr(SourceInfo);
21725bool emitFlipIntAPSMemberPtr(SourceInfo);
21726bool emitFlipIntAPSFloat(SourceInfo);
21727bool emitFlipIntAPSReflect(SourceInfo);
21728bool emitFlipBoolSint8(SourceInfo);
21729bool emitFlipBoolUint8(SourceInfo);
21730bool emitFlipBoolSint16(SourceInfo);
21731bool emitFlipBoolUint16(SourceInfo);
21732bool emitFlipBoolSint32(SourceInfo);
21733bool emitFlipBoolUint32(SourceInfo);
21734bool emitFlipBoolSint64(SourceInfo);
21735bool emitFlipBoolUint64(SourceInfo);
21736bool emitFlipBoolIntAP(SourceInfo);
21737bool emitFlipBoolIntAPS(SourceInfo);
21738bool emitFlipBoolBool(SourceInfo);
21739bool emitFlipBoolFixedPoint(SourceInfo);
21740bool emitFlipBoolPtr(SourceInfo);
21741bool emitFlipBoolMemberPtr(SourceInfo);
21742bool emitFlipBoolFloat(SourceInfo);
21743bool emitFlipBoolReflect(SourceInfo);
21744bool emitFlipFixedPointSint8(SourceInfo);
21745bool emitFlipFixedPointUint8(SourceInfo);
21746bool emitFlipFixedPointSint16(SourceInfo);
21747bool emitFlipFixedPointUint16(SourceInfo);
21748bool emitFlipFixedPointSint32(SourceInfo);
21749bool emitFlipFixedPointUint32(SourceInfo);
21750bool emitFlipFixedPointSint64(SourceInfo);
21751bool emitFlipFixedPointUint64(SourceInfo);
21752bool emitFlipFixedPointIntAP(SourceInfo);
21753bool emitFlipFixedPointIntAPS(SourceInfo);
21754bool emitFlipFixedPointBool(SourceInfo);
21755bool emitFlipFixedPointFixedPoint(SourceInfo);
21756bool emitFlipFixedPointPtr(SourceInfo);
21757bool emitFlipFixedPointMemberPtr(SourceInfo);
21758bool emitFlipFixedPointFloat(SourceInfo);
21759bool emitFlipFixedPointReflect(SourceInfo);
21760bool emitFlipPtrSint8(SourceInfo);
21761bool emitFlipPtrUint8(SourceInfo);
21762bool emitFlipPtrSint16(SourceInfo);
21763bool emitFlipPtrUint16(SourceInfo);
21764bool emitFlipPtrSint32(SourceInfo);
21765bool emitFlipPtrUint32(SourceInfo);
21766bool emitFlipPtrSint64(SourceInfo);
21767bool emitFlipPtrUint64(SourceInfo);
21768bool emitFlipPtrIntAP(SourceInfo);
21769bool emitFlipPtrIntAPS(SourceInfo);
21770bool emitFlipPtrBool(SourceInfo);
21771bool emitFlipPtrFixedPoint(SourceInfo);
21772bool emitFlipPtrPtr(SourceInfo);
21773bool emitFlipPtrMemberPtr(SourceInfo);
21774bool emitFlipPtrFloat(SourceInfo);
21775bool emitFlipPtrReflect(SourceInfo);
21776bool emitFlipMemberPtrSint8(SourceInfo);
21777bool emitFlipMemberPtrUint8(SourceInfo);
21778bool emitFlipMemberPtrSint16(SourceInfo);
21779bool emitFlipMemberPtrUint16(SourceInfo);
21780bool emitFlipMemberPtrSint32(SourceInfo);
21781bool emitFlipMemberPtrUint32(SourceInfo);
21782bool emitFlipMemberPtrSint64(SourceInfo);
21783bool emitFlipMemberPtrUint64(SourceInfo);
21784bool emitFlipMemberPtrIntAP(SourceInfo);
21785bool emitFlipMemberPtrIntAPS(SourceInfo);
21786bool emitFlipMemberPtrBool(SourceInfo);
21787bool emitFlipMemberPtrFixedPoint(SourceInfo);
21788bool emitFlipMemberPtrPtr(SourceInfo);
21789bool emitFlipMemberPtrMemberPtr(SourceInfo);
21790bool emitFlipMemberPtrFloat(SourceInfo);
21791bool emitFlipMemberPtrReflect(SourceInfo);
21792bool emitFlipFloatSint8(SourceInfo);
21793bool emitFlipFloatUint8(SourceInfo);
21794bool emitFlipFloatSint16(SourceInfo);
21795bool emitFlipFloatUint16(SourceInfo);
21796bool emitFlipFloatSint32(SourceInfo);
21797bool emitFlipFloatUint32(SourceInfo);
21798bool emitFlipFloatSint64(SourceInfo);
21799bool emitFlipFloatUint64(SourceInfo);
21800bool emitFlipFloatIntAP(SourceInfo);
21801bool emitFlipFloatIntAPS(SourceInfo);
21802bool emitFlipFloatBool(SourceInfo);
21803bool emitFlipFloatFixedPoint(SourceInfo);
21804bool emitFlipFloatPtr(SourceInfo);
21805bool emitFlipFloatMemberPtr(SourceInfo);
21806bool emitFlipFloatFloat(SourceInfo);
21807bool emitFlipFloatReflect(SourceInfo);
21808bool emitFlipReflectSint8(SourceInfo);
21809bool emitFlipReflectUint8(SourceInfo);
21810bool emitFlipReflectSint16(SourceInfo);
21811bool emitFlipReflectUint16(SourceInfo);
21812bool emitFlipReflectSint32(SourceInfo);
21813bool emitFlipReflectUint32(SourceInfo);
21814bool emitFlipReflectSint64(SourceInfo);
21815bool emitFlipReflectUint64(SourceInfo);
21816bool emitFlipReflectIntAP(SourceInfo);
21817bool emitFlipReflectIntAPS(SourceInfo);
21818bool emitFlipReflectBool(SourceInfo);
21819bool emitFlipReflectFixedPoint(SourceInfo);
21820bool emitFlipReflectPtr(SourceInfo);
21821bool emitFlipReflectMemberPtr(SourceInfo);
21822bool emitFlipReflectFloat(SourceInfo);
21823bool emitFlipReflectReflect(SourceInfo);
21824#endif
21825#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
21826[[nodiscard]] bool emitFlip(PrimType, PrimType, SourceInfo I);
21827#endif
21828#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
21829bool
21830#if defined(GET_EVAL_IMPL)
21831EvalEmitter
21832#else
21833ByteCodeEmitter
21834#endif
21835::emitFlip(PrimType T0, PrimType T1, SourceInfo I) {
21836 switch (T0) {
21837 case PT_Sint8:
21838 switch (T1) {
21839 case PT_Sint8:
21840 return emitFlipSint8Sint8(I);
21841 case PT_Uint8:
21842 return emitFlipSint8Uint8(I);
21843 case PT_Sint16:
21844 return emitFlipSint8Sint16(I);
21845 case PT_Uint16:
21846 return emitFlipSint8Uint16(I);
21847 case PT_Sint32:
21848 return emitFlipSint8Sint32(I);
21849 case PT_Uint32:
21850 return emitFlipSint8Uint32(I);
21851 case PT_Sint64:
21852 return emitFlipSint8Sint64(I);
21853 case PT_Uint64:
21854 return emitFlipSint8Uint64(I);
21855 case PT_IntAP:
21856 return emitFlipSint8IntAP(I);
21857 case PT_IntAPS:
21858 return emitFlipSint8IntAPS(I);
21859 case PT_Bool:
21860 return emitFlipSint8Bool(I);
21861 case PT_FixedPoint:
21862 return emitFlipSint8FixedPoint(I);
21863 case PT_Ptr:
21864 return emitFlipSint8Ptr(I);
21865 case PT_MemberPtr:
21866 return emitFlipSint8MemberPtr(I);
21867 case PT_Float:
21868 return emitFlipSint8Float(I);
21869 case PT_Reflect:
21870 return emitFlipSint8Reflect(I);
21871 }
21872 llvm_unreachable("invalid enum value");
21873 case PT_Uint8:
21874 switch (T1) {
21875 case PT_Sint8:
21876 return emitFlipUint8Sint8(I);
21877 case PT_Uint8:
21878 return emitFlipUint8Uint8(I);
21879 case PT_Sint16:
21880 return emitFlipUint8Sint16(I);
21881 case PT_Uint16:
21882 return emitFlipUint8Uint16(I);
21883 case PT_Sint32:
21884 return emitFlipUint8Sint32(I);
21885 case PT_Uint32:
21886 return emitFlipUint8Uint32(I);
21887 case PT_Sint64:
21888 return emitFlipUint8Sint64(I);
21889 case PT_Uint64:
21890 return emitFlipUint8Uint64(I);
21891 case PT_IntAP:
21892 return emitFlipUint8IntAP(I);
21893 case PT_IntAPS:
21894 return emitFlipUint8IntAPS(I);
21895 case PT_Bool:
21896 return emitFlipUint8Bool(I);
21897 case PT_FixedPoint:
21898 return emitFlipUint8FixedPoint(I);
21899 case PT_Ptr:
21900 return emitFlipUint8Ptr(I);
21901 case PT_MemberPtr:
21902 return emitFlipUint8MemberPtr(I);
21903 case PT_Float:
21904 return emitFlipUint8Float(I);
21905 case PT_Reflect:
21906 return emitFlipUint8Reflect(I);
21907 }
21908 llvm_unreachable("invalid enum value");
21909 case PT_Sint16:
21910 switch (T1) {
21911 case PT_Sint8:
21912 return emitFlipSint16Sint8(I);
21913 case PT_Uint8:
21914 return emitFlipSint16Uint8(I);
21915 case PT_Sint16:
21916 return emitFlipSint16Sint16(I);
21917 case PT_Uint16:
21918 return emitFlipSint16Uint16(I);
21919 case PT_Sint32:
21920 return emitFlipSint16Sint32(I);
21921 case PT_Uint32:
21922 return emitFlipSint16Uint32(I);
21923 case PT_Sint64:
21924 return emitFlipSint16Sint64(I);
21925 case PT_Uint64:
21926 return emitFlipSint16Uint64(I);
21927 case PT_IntAP:
21928 return emitFlipSint16IntAP(I);
21929 case PT_IntAPS:
21930 return emitFlipSint16IntAPS(I);
21931 case PT_Bool:
21932 return emitFlipSint16Bool(I);
21933 case PT_FixedPoint:
21934 return emitFlipSint16FixedPoint(I);
21935 case PT_Ptr:
21936 return emitFlipSint16Ptr(I);
21937 case PT_MemberPtr:
21938 return emitFlipSint16MemberPtr(I);
21939 case PT_Float:
21940 return emitFlipSint16Float(I);
21941 case PT_Reflect:
21942 return emitFlipSint16Reflect(I);
21943 }
21944 llvm_unreachable("invalid enum value");
21945 case PT_Uint16:
21946 switch (T1) {
21947 case PT_Sint8:
21948 return emitFlipUint16Sint8(I);
21949 case PT_Uint8:
21950 return emitFlipUint16Uint8(I);
21951 case PT_Sint16:
21952 return emitFlipUint16Sint16(I);
21953 case PT_Uint16:
21954 return emitFlipUint16Uint16(I);
21955 case PT_Sint32:
21956 return emitFlipUint16Sint32(I);
21957 case PT_Uint32:
21958 return emitFlipUint16Uint32(I);
21959 case PT_Sint64:
21960 return emitFlipUint16Sint64(I);
21961 case PT_Uint64:
21962 return emitFlipUint16Uint64(I);
21963 case PT_IntAP:
21964 return emitFlipUint16IntAP(I);
21965 case PT_IntAPS:
21966 return emitFlipUint16IntAPS(I);
21967 case PT_Bool:
21968 return emitFlipUint16Bool(I);
21969 case PT_FixedPoint:
21970 return emitFlipUint16FixedPoint(I);
21971 case PT_Ptr:
21972 return emitFlipUint16Ptr(I);
21973 case PT_MemberPtr:
21974 return emitFlipUint16MemberPtr(I);
21975 case PT_Float:
21976 return emitFlipUint16Float(I);
21977 case PT_Reflect:
21978 return emitFlipUint16Reflect(I);
21979 }
21980 llvm_unreachable("invalid enum value");
21981 case PT_Sint32:
21982 switch (T1) {
21983 case PT_Sint8:
21984 return emitFlipSint32Sint8(I);
21985 case PT_Uint8:
21986 return emitFlipSint32Uint8(I);
21987 case PT_Sint16:
21988 return emitFlipSint32Sint16(I);
21989 case PT_Uint16:
21990 return emitFlipSint32Uint16(I);
21991 case PT_Sint32:
21992 return emitFlipSint32Sint32(I);
21993 case PT_Uint32:
21994 return emitFlipSint32Uint32(I);
21995 case PT_Sint64:
21996 return emitFlipSint32Sint64(I);
21997 case PT_Uint64:
21998 return emitFlipSint32Uint64(I);
21999 case PT_IntAP:
22000 return emitFlipSint32IntAP(I);
22001 case PT_IntAPS:
22002 return emitFlipSint32IntAPS(I);
22003 case PT_Bool:
22004 return emitFlipSint32Bool(I);
22005 case PT_FixedPoint:
22006 return emitFlipSint32FixedPoint(I);
22007 case PT_Ptr:
22008 return emitFlipSint32Ptr(I);
22009 case PT_MemberPtr:
22010 return emitFlipSint32MemberPtr(I);
22011 case PT_Float:
22012 return emitFlipSint32Float(I);
22013 case PT_Reflect:
22014 return emitFlipSint32Reflect(I);
22015 }
22016 llvm_unreachable("invalid enum value");
22017 case PT_Uint32:
22018 switch (T1) {
22019 case PT_Sint8:
22020 return emitFlipUint32Sint8(I);
22021 case PT_Uint8:
22022 return emitFlipUint32Uint8(I);
22023 case PT_Sint16:
22024 return emitFlipUint32Sint16(I);
22025 case PT_Uint16:
22026 return emitFlipUint32Uint16(I);
22027 case PT_Sint32:
22028 return emitFlipUint32Sint32(I);
22029 case PT_Uint32:
22030 return emitFlipUint32Uint32(I);
22031 case PT_Sint64:
22032 return emitFlipUint32Sint64(I);
22033 case PT_Uint64:
22034 return emitFlipUint32Uint64(I);
22035 case PT_IntAP:
22036 return emitFlipUint32IntAP(I);
22037 case PT_IntAPS:
22038 return emitFlipUint32IntAPS(I);
22039 case PT_Bool:
22040 return emitFlipUint32Bool(I);
22041 case PT_FixedPoint:
22042 return emitFlipUint32FixedPoint(I);
22043 case PT_Ptr:
22044 return emitFlipUint32Ptr(I);
22045 case PT_MemberPtr:
22046 return emitFlipUint32MemberPtr(I);
22047 case PT_Float:
22048 return emitFlipUint32Float(I);
22049 case PT_Reflect:
22050 return emitFlipUint32Reflect(I);
22051 }
22052 llvm_unreachable("invalid enum value");
22053 case PT_Sint64:
22054 switch (T1) {
22055 case PT_Sint8:
22056 return emitFlipSint64Sint8(I);
22057 case PT_Uint8:
22058 return emitFlipSint64Uint8(I);
22059 case PT_Sint16:
22060 return emitFlipSint64Sint16(I);
22061 case PT_Uint16:
22062 return emitFlipSint64Uint16(I);
22063 case PT_Sint32:
22064 return emitFlipSint64Sint32(I);
22065 case PT_Uint32:
22066 return emitFlipSint64Uint32(I);
22067 case PT_Sint64:
22068 return emitFlipSint64Sint64(I);
22069 case PT_Uint64:
22070 return emitFlipSint64Uint64(I);
22071 case PT_IntAP:
22072 return emitFlipSint64IntAP(I);
22073 case PT_IntAPS:
22074 return emitFlipSint64IntAPS(I);
22075 case PT_Bool:
22076 return emitFlipSint64Bool(I);
22077 case PT_FixedPoint:
22078 return emitFlipSint64FixedPoint(I);
22079 case PT_Ptr:
22080 return emitFlipSint64Ptr(I);
22081 case PT_MemberPtr:
22082 return emitFlipSint64MemberPtr(I);
22083 case PT_Float:
22084 return emitFlipSint64Float(I);
22085 case PT_Reflect:
22086 return emitFlipSint64Reflect(I);
22087 }
22088 llvm_unreachable("invalid enum value");
22089 case PT_Uint64:
22090 switch (T1) {
22091 case PT_Sint8:
22092 return emitFlipUint64Sint8(I);
22093 case PT_Uint8:
22094 return emitFlipUint64Uint8(I);
22095 case PT_Sint16:
22096 return emitFlipUint64Sint16(I);
22097 case PT_Uint16:
22098 return emitFlipUint64Uint16(I);
22099 case PT_Sint32:
22100 return emitFlipUint64Sint32(I);
22101 case PT_Uint32:
22102 return emitFlipUint64Uint32(I);
22103 case PT_Sint64:
22104 return emitFlipUint64Sint64(I);
22105 case PT_Uint64:
22106 return emitFlipUint64Uint64(I);
22107 case PT_IntAP:
22108 return emitFlipUint64IntAP(I);
22109 case PT_IntAPS:
22110 return emitFlipUint64IntAPS(I);
22111 case PT_Bool:
22112 return emitFlipUint64Bool(I);
22113 case PT_FixedPoint:
22114 return emitFlipUint64FixedPoint(I);
22115 case PT_Ptr:
22116 return emitFlipUint64Ptr(I);
22117 case PT_MemberPtr:
22118 return emitFlipUint64MemberPtr(I);
22119 case PT_Float:
22120 return emitFlipUint64Float(I);
22121 case PT_Reflect:
22122 return emitFlipUint64Reflect(I);
22123 }
22124 llvm_unreachable("invalid enum value");
22125 case PT_IntAP:
22126 switch (T1) {
22127 case PT_Sint8:
22128 return emitFlipIntAPSint8(I);
22129 case PT_Uint8:
22130 return emitFlipIntAPUint8(I);
22131 case PT_Sint16:
22132 return emitFlipIntAPSint16(I);
22133 case PT_Uint16:
22134 return emitFlipIntAPUint16(I);
22135 case PT_Sint32:
22136 return emitFlipIntAPSint32(I);
22137 case PT_Uint32:
22138 return emitFlipIntAPUint32(I);
22139 case PT_Sint64:
22140 return emitFlipIntAPSint64(I);
22141 case PT_Uint64:
22142 return emitFlipIntAPUint64(I);
22143 case PT_IntAP:
22144 return emitFlipIntAPIntAP(I);
22145 case PT_IntAPS:
22146 return emitFlipIntAPIntAPS(I);
22147 case PT_Bool:
22148 return emitFlipIntAPBool(I);
22149 case PT_FixedPoint:
22150 return emitFlipIntAPFixedPoint(I);
22151 case PT_Ptr:
22152 return emitFlipIntAPPtr(I);
22153 case PT_MemberPtr:
22154 return emitFlipIntAPMemberPtr(I);
22155 case PT_Float:
22156 return emitFlipIntAPFloat(I);
22157 case PT_Reflect:
22158 return emitFlipIntAPReflect(I);
22159 }
22160 llvm_unreachable("invalid enum value");
22161 case PT_IntAPS:
22162 switch (T1) {
22163 case PT_Sint8:
22164 return emitFlipIntAPSSint8(I);
22165 case PT_Uint8:
22166 return emitFlipIntAPSUint8(I);
22167 case PT_Sint16:
22168 return emitFlipIntAPSSint16(I);
22169 case PT_Uint16:
22170 return emitFlipIntAPSUint16(I);
22171 case PT_Sint32:
22172 return emitFlipIntAPSSint32(I);
22173 case PT_Uint32:
22174 return emitFlipIntAPSUint32(I);
22175 case PT_Sint64:
22176 return emitFlipIntAPSSint64(I);
22177 case PT_Uint64:
22178 return emitFlipIntAPSUint64(I);
22179 case PT_IntAP:
22180 return emitFlipIntAPSIntAP(I);
22181 case PT_IntAPS:
22182 return emitFlipIntAPSIntAPS(I);
22183 case PT_Bool:
22184 return emitFlipIntAPSBool(I);
22185 case PT_FixedPoint:
22186 return emitFlipIntAPSFixedPoint(I);
22187 case PT_Ptr:
22188 return emitFlipIntAPSPtr(I);
22189 case PT_MemberPtr:
22190 return emitFlipIntAPSMemberPtr(I);
22191 case PT_Float:
22192 return emitFlipIntAPSFloat(I);
22193 case PT_Reflect:
22194 return emitFlipIntAPSReflect(I);
22195 }
22196 llvm_unreachable("invalid enum value");
22197 case PT_Bool:
22198 switch (T1) {
22199 case PT_Sint8:
22200 return emitFlipBoolSint8(I);
22201 case PT_Uint8:
22202 return emitFlipBoolUint8(I);
22203 case PT_Sint16:
22204 return emitFlipBoolSint16(I);
22205 case PT_Uint16:
22206 return emitFlipBoolUint16(I);
22207 case PT_Sint32:
22208 return emitFlipBoolSint32(I);
22209 case PT_Uint32:
22210 return emitFlipBoolUint32(I);
22211 case PT_Sint64:
22212 return emitFlipBoolSint64(I);
22213 case PT_Uint64:
22214 return emitFlipBoolUint64(I);
22215 case PT_IntAP:
22216 return emitFlipBoolIntAP(I);
22217 case PT_IntAPS:
22218 return emitFlipBoolIntAPS(I);
22219 case PT_Bool:
22220 return emitFlipBoolBool(I);
22221 case PT_FixedPoint:
22222 return emitFlipBoolFixedPoint(I);
22223 case PT_Ptr:
22224 return emitFlipBoolPtr(I);
22225 case PT_MemberPtr:
22226 return emitFlipBoolMemberPtr(I);
22227 case PT_Float:
22228 return emitFlipBoolFloat(I);
22229 case PT_Reflect:
22230 return emitFlipBoolReflect(I);
22231 }
22232 llvm_unreachable("invalid enum value");
22233 case PT_FixedPoint:
22234 switch (T1) {
22235 case PT_Sint8:
22236 return emitFlipFixedPointSint8(I);
22237 case PT_Uint8:
22238 return emitFlipFixedPointUint8(I);
22239 case PT_Sint16:
22240 return emitFlipFixedPointSint16(I);
22241 case PT_Uint16:
22242 return emitFlipFixedPointUint16(I);
22243 case PT_Sint32:
22244 return emitFlipFixedPointSint32(I);
22245 case PT_Uint32:
22246 return emitFlipFixedPointUint32(I);
22247 case PT_Sint64:
22248 return emitFlipFixedPointSint64(I);
22249 case PT_Uint64:
22250 return emitFlipFixedPointUint64(I);
22251 case PT_IntAP:
22252 return emitFlipFixedPointIntAP(I);
22253 case PT_IntAPS:
22254 return emitFlipFixedPointIntAPS(I);
22255 case PT_Bool:
22256 return emitFlipFixedPointBool(I);
22257 case PT_FixedPoint:
22258 return emitFlipFixedPointFixedPoint(I);
22259 case PT_Ptr:
22260 return emitFlipFixedPointPtr(I);
22261 case PT_MemberPtr:
22262 return emitFlipFixedPointMemberPtr(I);
22263 case PT_Float:
22264 return emitFlipFixedPointFloat(I);
22265 case PT_Reflect:
22266 return emitFlipFixedPointReflect(I);
22267 }
22268 llvm_unreachable("invalid enum value");
22269 case PT_Ptr:
22270 switch (T1) {
22271 case PT_Sint8:
22272 return emitFlipPtrSint8(I);
22273 case PT_Uint8:
22274 return emitFlipPtrUint8(I);
22275 case PT_Sint16:
22276 return emitFlipPtrSint16(I);
22277 case PT_Uint16:
22278 return emitFlipPtrUint16(I);
22279 case PT_Sint32:
22280 return emitFlipPtrSint32(I);
22281 case PT_Uint32:
22282 return emitFlipPtrUint32(I);
22283 case PT_Sint64:
22284 return emitFlipPtrSint64(I);
22285 case PT_Uint64:
22286 return emitFlipPtrUint64(I);
22287 case PT_IntAP:
22288 return emitFlipPtrIntAP(I);
22289 case PT_IntAPS:
22290 return emitFlipPtrIntAPS(I);
22291 case PT_Bool:
22292 return emitFlipPtrBool(I);
22293 case PT_FixedPoint:
22294 return emitFlipPtrFixedPoint(I);
22295 case PT_Ptr:
22296 return emitFlipPtrPtr(I);
22297 case PT_MemberPtr:
22298 return emitFlipPtrMemberPtr(I);
22299 case PT_Float:
22300 return emitFlipPtrFloat(I);
22301 case PT_Reflect:
22302 return emitFlipPtrReflect(I);
22303 }
22304 llvm_unreachable("invalid enum value");
22305 case PT_MemberPtr:
22306 switch (T1) {
22307 case PT_Sint8:
22308 return emitFlipMemberPtrSint8(I);
22309 case PT_Uint8:
22310 return emitFlipMemberPtrUint8(I);
22311 case PT_Sint16:
22312 return emitFlipMemberPtrSint16(I);
22313 case PT_Uint16:
22314 return emitFlipMemberPtrUint16(I);
22315 case PT_Sint32:
22316 return emitFlipMemberPtrSint32(I);
22317 case PT_Uint32:
22318 return emitFlipMemberPtrUint32(I);
22319 case PT_Sint64:
22320 return emitFlipMemberPtrSint64(I);
22321 case PT_Uint64:
22322 return emitFlipMemberPtrUint64(I);
22323 case PT_IntAP:
22324 return emitFlipMemberPtrIntAP(I);
22325 case PT_IntAPS:
22326 return emitFlipMemberPtrIntAPS(I);
22327 case PT_Bool:
22328 return emitFlipMemberPtrBool(I);
22329 case PT_FixedPoint:
22330 return emitFlipMemberPtrFixedPoint(I);
22331 case PT_Ptr:
22332 return emitFlipMemberPtrPtr(I);
22333 case PT_MemberPtr:
22334 return emitFlipMemberPtrMemberPtr(I);
22335 case PT_Float:
22336 return emitFlipMemberPtrFloat(I);
22337 case PT_Reflect:
22338 return emitFlipMemberPtrReflect(I);
22339 }
22340 llvm_unreachable("invalid enum value");
22341 case PT_Float:
22342 switch (T1) {
22343 case PT_Sint8:
22344 return emitFlipFloatSint8(I);
22345 case PT_Uint8:
22346 return emitFlipFloatUint8(I);
22347 case PT_Sint16:
22348 return emitFlipFloatSint16(I);
22349 case PT_Uint16:
22350 return emitFlipFloatUint16(I);
22351 case PT_Sint32:
22352 return emitFlipFloatSint32(I);
22353 case PT_Uint32:
22354 return emitFlipFloatUint32(I);
22355 case PT_Sint64:
22356 return emitFlipFloatSint64(I);
22357 case PT_Uint64:
22358 return emitFlipFloatUint64(I);
22359 case PT_IntAP:
22360 return emitFlipFloatIntAP(I);
22361 case PT_IntAPS:
22362 return emitFlipFloatIntAPS(I);
22363 case PT_Bool:
22364 return emitFlipFloatBool(I);
22365 case PT_FixedPoint:
22366 return emitFlipFloatFixedPoint(I);
22367 case PT_Ptr:
22368 return emitFlipFloatPtr(I);
22369 case PT_MemberPtr:
22370 return emitFlipFloatMemberPtr(I);
22371 case PT_Float:
22372 return emitFlipFloatFloat(I);
22373 case PT_Reflect:
22374 return emitFlipFloatReflect(I);
22375 }
22376 llvm_unreachable("invalid enum value");
22377 case PT_Reflect:
22378 switch (T1) {
22379 case PT_Sint8:
22380 return emitFlipReflectSint8(I);
22381 case PT_Uint8:
22382 return emitFlipReflectUint8(I);
22383 case PT_Sint16:
22384 return emitFlipReflectSint16(I);
22385 case PT_Uint16:
22386 return emitFlipReflectUint16(I);
22387 case PT_Sint32:
22388 return emitFlipReflectSint32(I);
22389 case PT_Uint32:
22390 return emitFlipReflectUint32(I);
22391 case PT_Sint64:
22392 return emitFlipReflectSint64(I);
22393 case PT_Uint64:
22394 return emitFlipReflectUint64(I);
22395 case PT_IntAP:
22396 return emitFlipReflectIntAP(I);
22397 case PT_IntAPS:
22398 return emitFlipReflectIntAPS(I);
22399 case PT_Bool:
22400 return emitFlipReflectBool(I);
22401 case PT_FixedPoint:
22402 return emitFlipReflectFixedPoint(I);
22403 case PT_Ptr:
22404 return emitFlipReflectPtr(I);
22405 case PT_MemberPtr:
22406 return emitFlipReflectMemberPtr(I);
22407 case PT_Float:
22408 return emitFlipReflectFloat(I);
22409 case PT_Reflect:
22410 return emitFlipReflectReflect(I);
22411 }
22412 llvm_unreachable("invalid enum value");
22413 }
22414 llvm_unreachable("invalid enum value");
22415}
22416#endif
22417#ifdef GET_LINK_IMPL
22418bool ByteCodeEmitter::emitFlipSint8Sint8(SourceInfo L) {
22419 return emitOp<>(OP_FlipSint8Sint8, L);
22420}
22421bool ByteCodeEmitter::emitFlipSint8Uint8(SourceInfo L) {
22422 return emitOp<>(OP_FlipSint8Uint8, L);
22423}
22424bool ByteCodeEmitter::emitFlipSint8Sint16(SourceInfo L) {
22425 return emitOp<>(OP_FlipSint8Sint16, L);
22426}
22427bool ByteCodeEmitter::emitFlipSint8Uint16(SourceInfo L) {
22428 return emitOp<>(OP_FlipSint8Uint16, L);
22429}
22430bool ByteCodeEmitter::emitFlipSint8Sint32(SourceInfo L) {
22431 return emitOp<>(OP_FlipSint8Sint32, L);
22432}
22433bool ByteCodeEmitter::emitFlipSint8Uint32(SourceInfo L) {
22434 return emitOp<>(OP_FlipSint8Uint32, L);
22435}
22436bool ByteCodeEmitter::emitFlipSint8Sint64(SourceInfo L) {
22437 return emitOp<>(OP_FlipSint8Sint64, L);
22438}
22439bool ByteCodeEmitter::emitFlipSint8Uint64(SourceInfo L) {
22440 return emitOp<>(OP_FlipSint8Uint64, L);
22441}
22442bool ByteCodeEmitter::emitFlipSint8IntAP(SourceInfo L) {
22443 return emitOp<>(OP_FlipSint8IntAP, L);
22444}
22445bool ByteCodeEmitter::emitFlipSint8IntAPS(SourceInfo L) {
22446 return emitOp<>(OP_FlipSint8IntAPS, L);
22447}
22448bool ByteCodeEmitter::emitFlipSint8Bool(SourceInfo L) {
22449 return emitOp<>(OP_FlipSint8Bool, L);
22450}
22451bool ByteCodeEmitter::emitFlipSint8FixedPoint(SourceInfo L) {
22452 return emitOp<>(OP_FlipSint8FixedPoint, L);
22453}
22454bool ByteCodeEmitter::emitFlipSint8Ptr(SourceInfo L) {
22455 return emitOp<>(OP_FlipSint8Ptr, L);
22456}
22457bool ByteCodeEmitter::emitFlipSint8MemberPtr(SourceInfo L) {
22458 return emitOp<>(OP_FlipSint8MemberPtr, L);
22459}
22460bool ByteCodeEmitter::emitFlipSint8Float(SourceInfo L) {
22461 return emitOp<>(OP_FlipSint8Float, L);
22462}
22463bool ByteCodeEmitter::emitFlipSint8Reflect(SourceInfo L) {
22464 return emitOp<>(OP_FlipSint8Reflect, L);
22465}
22466bool ByteCodeEmitter::emitFlipUint8Sint8(SourceInfo L) {
22467 return emitOp<>(OP_FlipUint8Sint8, L);
22468}
22469bool ByteCodeEmitter::emitFlipUint8Uint8(SourceInfo L) {
22470 return emitOp<>(OP_FlipUint8Uint8, L);
22471}
22472bool ByteCodeEmitter::emitFlipUint8Sint16(SourceInfo L) {
22473 return emitOp<>(OP_FlipUint8Sint16, L);
22474}
22475bool ByteCodeEmitter::emitFlipUint8Uint16(SourceInfo L) {
22476 return emitOp<>(OP_FlipUint8Uint16, L);
22477}
22478bool ByteCodeEmitter::emitFlipUint8Sint32(SourceInfo L) {
22479 return emitOp<>(OP_FlipUint8Sint32, L);
22480}
22481bool ByteCodeEmitter::emitFlipUint8Uint32(SourceInfo L) {
22482 return emitOp<>(OP_FlipUint8Uint32, L);
22483}
22484bool ByteCodeEmitter::emitFlipUint8Sint64(SourceInfo L) {
22485 return emitOp<>(OP_FlipUint8Sint64, L);
22486}
22487bool ByteCodeEmitter::emitFlipUint8Uint64(SourceInfo L) {
22488 return emitOp<>(OP_FlipUint8Uint64, L);
22489}
22490bool ByteCodeEmitter::emitFlipUint8IntAP(SourceInfo L) {
22491 return emitOp<>(OP_FlipUint8IntAP, L);
22492}
22493bool ByteCodeEmitter::emitFlipUint8IntAPS(SourceInfo L) {
22494 return emitOp<>(OP_FlipUint8IntAPS, L);
22495}
22496bool ByteCodeEmitter::emitFlipUint8Bool(SourceInfo L) {
22497 return emitOp<>(OP_FlipUint8Bool, L);
22498}
22499bool ByteCodeEmitter::emitFlipUint8FixedPoint(SourceInfo L) {
22500 return emitOp<>(OP_FlipUint8FixedPoint, L);
22501}
22502bool ByteCodeEmitter::emitFlipUint8Ptr(SourceInfo L) {
22503 return emitOp<>(OP_FlipUint8Ptr, L);
22504}
22505bool ByteCodeEmitter::emitFlipUint8MemberPtr(SourceInfo L) {
22506 return emitOp<>(OP_FlipUint8MemberPtr, L);
22507}
22508bool ByteCodeEmitter::emitFlipUint8Float(SourceInfo L) {
22509 return emitOp<>(OP_FlipUint8Float, L);
22510}
22511bool ByteCodeEmitter::emitFlipUint8Reflect(SourceInfo L) {
22512 return emitOp<>(OP_FlipUint8Reflect, L);
22513}
22514bool ByteCodeEmitter::emitFlipSint16Sint8(SourceInfo L) {
22515 return emitOp<>(OP_FlipSint16Sint8, L);
22516}
22517bool ByteCodeEmitter::emitFlipSint16Uint8(SourceInfo L) {
22518 return emitOp<>(OP_FlipSint16Uint8, L);
22519}
22520bool ByteCodeEmitter::emitFlipSint16Sint16(SourceInfo L) {
22521 return emitOp<>(OP_FlipSint16Sint16, L);
22522}
22523bool ByteCodeEmitter::emitFlipSint16Uint16(SourceInfo L) {
22524 return emitOp<>(OP_FlipSint16Uint16, L);
22525}
22526bool ByteCodeEmitter::emitFlipSint16Sint32(SourceInfo L) {
22527 return emitOp<>(OP_FlipSint16Sint32, L);
22528}
22529bool ByteCodeEmitter::emitFlipSint16Uint32(SourceInfo L) {
22530 return emitOp<>(OP_FlipSint16Uint32, L);
22531}
22532bool ByteCodeEmitter::emitFlipSint16Sint64(SourceInfo L) {
22533 return emitOp<>(OP_FlipSint16Sint64, L);
22534}
22535bool ByteCodeEmitter::emitFlipSint16Uint64(SourceInfo L) {
22536 return emitOp<>(OP_FlipSint16Uint64, L);
22537}
22538bool ByteCodeEmitter::emitFlipSint16IntAP(SourceInfo L) {
22539 return emitOp<>(OP_FlipSint16IntAP, L);
22540}
22541bool ByteCodeEmitter::emitFlipSint16IntAPS(SourceInfo L) {
22542 return emitOp<>(OP_FlipSint16IntAPS, L);
22543}
22544bool ByteCodeEmitter::emitFlipSint16Bool(SourceInfo L) {
22545 return emitOp<>(OP_FlipSint16Bool, L);
22546}
22547bool ByteCodeEmitter::emitFlipSint16FixedPoint(SourceInfo L) {
22548 return emitOp<>(OP_FlipSint16FixedPoint, L);
22549}
22550bool ByteCodeEmitter::emitFlipSint16Ptr(SourceInfo L) {
22551 return emitOp<>(OP_FlipSint16Ptr, L);
22552}
22553bool ByteCodeEmitter::emitFlipSint16MemberPtr(SourceInfo L) {
22554 return emitOp<>(OP_FlipSint16MemberPtr, L);
22555}
22556bool ByteCodeEmitter::emitFlipSint16Float(SourceInfo L) {
22557 return emitOp<>(OP_FlipSint16Float, L);
22558}
22559bool ByteCodeEmitter::emitFlipSint16Reflect(SourceInfo L) {
22560 return emitOp<>(OP_FlipSint16Reflect, L);
22561}
22562bool ByteCodeEmitter::emitFlipUint16Sint8(SourceInfo L) {
22563 return emitOp<>(OP_FlipUint16Sint8, L);
22564}
22565bool ByteCodeEmitter::emitFlipUint16Uint8(SourceInfo L) {
22566 return emitOp<>(OP_FlipUint16Uint8, L);
22567}
22568bool ByteCodeEmitter::emitFlipUint16Sint16(SourceInfo L) {
22569 return emitOp<>(OP_FlipUint16Sint16, L);
22570}
22571bool ByteCodeEmitter::emitFlipUint16Uint16(SourceInfo L) {
22572 return emitOp<>(OP_FlipUint16Uint16, L);
22573}
22574bool ByteCodeEmitter::emitFlipUint16Sint32(SourceInfo L) {
22575 return emitOp<>(OP_FlipUint16Sint32, L);
22576}
22577bool ByteCodeEmitter::emitFlipUint16Uint32(SourceInfo L) {
22578 return emitOp<>(OP_FlipUint16Uint32, L);
22579}
22580bool ByteCodeEmitter::emitFlipUint16Sint64(SourceInfo L) {
22581 return emitOp<>(OP_FlipUint16Sint64, L);
22582}
22583bool ByteCodeEmitter::emitFlipUint16Uint64(SourceInfo L) {
22584 return emitOp<>(OP_FlipUint16Uint64, L);
22585}
22586bool ByteCodeEmitter::emitFlipUint16IntAP(SourceInfo L) {
22587 return emitOp<>(OP_FlipUint16IntAP, L);
22588}
22589bool ByteCodeEmitter::emitFlipUint16IntAPS(SourceInfo L) {
22590 return emitOp<>(OP_FlipUint16IntAPS, L);
22591}
22592bool ByteCodeEmitter::emitFlipUint16Bool(SourceInfo L) {
22593 return emitOp<>(OP_FlipUint16Bool, L);
22594}
22595bool ByteCodeEmitter::emitFlipUint16FixedPoint(SourceInfo L) {
22596 return emitOp<>(OP_FlipUint16FixedPoint, L);
22597}
22598bool ByteCodeEmitter::emitFlipUint16Ptr(SourceInfo L) {
22599 return emitOp<>(OP_FlipUint16Ptr, L);
22600}
22601bool ByteCodeEmitter::emitFlipUint16MemberPtr(SourceInfo L) {
22602 return emitOp<>(OP_FlipUint16MemberPtr, L);
22603}
22604bool ByteCodeEmitter::emitFlipUint16Float(SourceInfo L) {
22605 return emitOp<>(OP_FlipUint16Float, L);
22606}
22607bool ByteCodeEmitter::emitFlipUint16Reflect(SourceInfo L) {
22608 return emitOp<>(OP_FlipUint16Reflect, L);
22609}
22610bool ByteCodeEmitter::emitFlipSint32Sint8(SourceInfo L) {
22611 return emitOp<>(OP_FlipSint32Sint8, L);
22612}
22613bool ByteCodeEmitter::emitFlipSint32Uint8(SourceInfo L) {
22614 return emitOp<>(OP_FlipSint32Uint8, L);
22615}
22616bool ByteCodeEmitter::emitFlipSint32Sint16(SourceInfo L) {
22617 return emitOp<>(OP_FlipSint32Sint16, L);
22618}
22619bool ByteCodeEmitter::emitFlipSint32Uint16(SourceInfo L) {
22620 return emitOp<>(OP_FlipSint32Uint16, L);
22621}
22622bool ByteCodeEmitter::emitFlipSint32Sint32(SourceInfo L) {
22623 return emitOp<>(OP_FlipSint32Sint32, L);
22624}
22625bool ByteCodeEmitter::emitFlipSint32Uint32(SourceInfo L) {
22626 return emitOp<>(OP_FlipSint32Uint32, L);
22627}
22628bool ByteCodeEmitter::emitFlipSint32Sint64(SourceInfo L) {
22629 return emitOp<>(OP_FlipSint32Sint64, L);
22630}
22631bool ByteCodeEmitter::emitFlipSint32Uint64(SourceInfo L) {
22632 return emitOp<>(OP_FlipSint32Uint64, L);
22633}
22634bool ByteCodeEmitter::emitFlipSint32IntAP(SourceInfo L) {
22635 return emitOp<>(OP_FlipSint32IntAP, L);
22636}
22637bool ByteCodeEmitter::emitFlipSint32IntAPS(SourceInfo L) {
22638 return emitOp<>(OP_FlipSint32IntAPS, L);
22639}
22640bool ByteCodeEmitter::emitFlipSint32Bool(SourceInfo L) {
22641 return emitOp<>(OP_FlipSint32Bool, L);
22642}
22643bool ByteCodeEmitter::emitFlipSint32FixedPoint(SourceInfo L) {
22644 return emitOp<>(OP_FlipSint32FixedPoint, L);
22645}
22646bool ByteCodeEmitter::emitFlipSint32Ptr(SourceInfo L) {
22647 return emitOp<>(OP_FlipSint32Ptr, L);
22648}
22649bool ByteCodeEmitter::emitFlipSint32MemberPtr(SourceInfo L) {
22650 return emitOp<>(OP_FlipSint32MemberPtr, L);
22651}
22652bool ByteCodeEmitter::emitFlipSint32Float(SourceInfo L) {
22653 return emitOp<>(OP_FlipSint32Float, L);
22654}
22655bool ByteCodeEmitter::emitFlipSint32Reflect(SourceInfo L) {
22656 return emitOp<>(OP_FlipSint32Reflect, L);
22657}
22658bool ByteCodeEmitter::emitFlipUint32Sint8(SourceInfo L) {
22659 return emitOp<>(OP_FlipUint32Sint8, L);
22660}
22661bool ByteCodeEmitter::emitFlipUint32Uint8(SourceInfo L) {
22662 return emitOp<>(OP_FlipUint32Uint8, L);
22663}
22664bool ByteCodeEmitter::emitFlipUint32Sint16(SourceInfo L) {
22665 return emitOp<>(OP_FlipUint32Sint16, L);
22666}
22667bool ByteCodeEmitter::emitFlipUint32Uint16(SourceInfo L) {
22668 return emitOp<>(OP_FlipUint32Uint16, L);
22669}
22670bool ByteCodeEmitter::emitFlipUint32Sint32(SourceInfo L) {
22671 return emitOp<>(OP_FlipUint32Sint32, L);
22672}
22673bool ByteCodeEmitter::emitFlipUint32Uint32(SourceInfo L) {
22674 return emitOp<>(OP_FlipUint32Uint32, L);
22675}
22676bool ByteCodeEmitter::emitFlipUint32Sint64(SourceInfo L) {
22677 return emitOp<>(OP_FlipUint32Sint64, L);
22678}
22679bool ByteCodeEmitter::emitFlipUint32Uint64(SourceInfo L) {
22680 return emitOp<>(OP_FlipUint32Uint64, L);
22681}
22682bool ByteCodeEmitter::emitFlipUint32IntAP(SourceInfo L) {
22683 return emitOp<>(OP_FlipUint32IntAP, L);
22684}
22685bool ByteCodeEmitter::emitFlipUint32IntAPS(SourceInfo L) {
22686 return emitOp<>(OP_FlipUint32IntAPS, L);
22687}
22688bool ByteCodeEmitter::emitFlipUint32Bool(SourceInfo L) {
22689 return emitOp<>(OP_FlipUint32Bool, L);
22690}
22691bool ByteCodeEmitter::emitFlipUint32FixedPoint(SourceInfo L) {
22692 return emitOp<>(OP_FlipUint32FixedPoint, L);
22693}
22694bool ByteCodeEmitter::emitFlipUint32Ptr(SourceInfo L) {
22695 return emitOp<>(OP_FlipUint32Ptr, L);
22696}
22697bool ByteCodeEmitter::emitFlipUint32MemberPtr(SourceInfo L) {
22698 return emitOp<>(OP_FlipUint32MemberPtr, L);
22699}
22700bool ByteCodeEmitter::emitFlipUint32Float(SourceInfo L) {
22701 return emitOp<>(OP_FlipUint32Float, L);
22702}
22703bool ByteCodeEmitter::emitFlipUint32Reflect(SourceInfo L) {
22704 return emitOp<>(OP_FlipUint32Reflect, L);
22705}
22706bool ByteCodeEmitter::emitFlipSint64Sint8(SourceInfo L) {
22707 return emitOp<>(OP_FlipSint64Sint8, L);
22708}
22709bool ByteCodeEmitter::emitFlipSint64Uint8(SourceInfo L) {
22710 return emitOp<>(OP_FlipSint64Uint8, L);
22711}
22712bool ByteCodeEmitter::emitFlipSint64Sint16(SourceInfo L) {
22713 return emitOp<>(OP_FlipSint64Sint16, L);
22714}
22715bool ByteCodeEmitter::emitFlipSint64Uint16(SourceInfo L) {
22716 return emitOp<>(OP_FlipSint64Uint16, L);
22717}
22718bool ByteCodeEmitter::emitFlipSint64Sint32(SourceInfo L) {
22719 return emitOp<>(OP_FlipSint64Sint32, L);
22720}
22721bool ByteCodeEmitter::emitFlipSint64Uint32(SourceInfo L) {
22722 return emitOp<>(OP_FlipSint64Uint32, L);
22723}
22724bool ByteCodeEmitter::emitFlipSint64Sint64(SourceInfo L) {
22725 return emitOp<>(OP_FlipSint64Sint64, L);
22726}
22727bool ByteCodeEmitter::emitFlipSint64Uint64(SourceInfo L) {
22728 return emitOp<>(OP_FlipSint64Uint64, L);
22729}
22730bool ByteCodeEmitter::emitFlipSint64IntAP(SourceInfo L) {
22731 return emitOp<>(OP_FlipSint64IntAP, L);
22732}
22733bool ByteCodeEmitter::emitFlipSint64IntAPS(SourceInfo L) {
22734 return emitOp<>(OP_FlipSint64IntAPS, L);
22735}
22736bool ByteCodeEmitter::emitFlipSint64Bool(SourceInfo L) {
22737 return emitOp<>(OP_FlipSint64Bool, L);
22738}
22739bool ByteCodeEmitter::emitFlipSint64FixedPoint(SourceInfo L) {
22740 return emitOp<>(OP_FlipSint64FixedPoint, L);
22741}
22742bool ByteCodeEmitter::emitFlipSint64Ptr(SourceInfo L) {
22743 return emitOp<>(OP_FlipSint64Ptr, L);
22744}
22745bool ByteCodeEmitter::emitFlipSint64MemberPtr(SourceInfo L) {
22746 return emitOp<>(OP_FlipSint64MemberPtr, L);
22747}
22748bool ByteCodeEmitter::emitFlipSint64Float(SourceInfo L) {
22749 return emitOp<>(OP_FlipSint64Float, L);
22750}
22751bool ByteCodeEmitter::emitFlipSint64Reflect(SourceInfo L) {
22752 return emitOp<>(OP_FlipSint64Reflect, L);
22753}
22754bool ByteCodeEmitter::emitFlipUint64Sint8(SourceInfo L) {
22755 return emitOp<>(OP_FlipUint64Sint8, L);
22756}
22757bool ByteCodeEmitter::emitFlipUint64Uint8(SourceInfo L) {
22758 return emitOp<>(OP_FlipUint64Uint8, L);
22759}
22760bool ByteCodeEmitter::emitFlipUint64Sint16(SourceInfo L) {
22761 return emitOp<>(OP_FlipUint64Sint16, L);
22762}
22763bool ByteCodeEmitter::emitFlipUint64Uint16(SourceInfo L) {
22764 return emitOp<>(OP_FlipUint64Uint16, L);
22765}
22766bool ByteCodeEmitter::emitFlipUint64Sint32(SourceInfo L) {
22767 return emitOp<>(OP_FlipUint64Sint32, L);
22768}
22769bool ByteCodeEmitter::emitFlipUint64Uint32(SourceInfo L) {
22770 return emitOp<>(OP_FlipUint64Uint32, L);
22771}
22772bool ByteCodeEmitter::emitFlipUint64Sint64(SourceInfo L) {
22773 return emitOp<>(OP_FlipUint64Sint64, L);
22774}
22775bool ByteCodeEmitter::emitFlipUint64Uint64(SourceInfo L) {
22776 return emitOp<>(OP_FlipUint64Uint64, L);
22777}
22778bool ByteCodeEmitter::emitFlipUint64IntAP(SourceInfo L) {
22779 return emitOp<>(OP_FlipUint64IntAP, L);
22780}
22781bool ByteCodeEmitter::emitFlipUint64IntAPS(SourceInfo L) {
22782 return emitOp<>(OP_FlipUint64IntAPS, L);
22783}
22784bool ByteCodeEmitter::emitFlipUint64Bool(SourceInfo L) {
22785 return emitOp<>(OP_FlipUint64Bool, L);
22786}
22787bool ByteCodeEmitter::emitFlipUint64FixedPoint(SourceInfo L) {
22788 return emitOp<>(OP_FlipUint64FixedPoint, L);
22789}
22790bool ByteCodeEmitter::emitFlipUint64Ptr(SourceInfo L) {
22791 return emitOp<>(OP_FlipUint64Ptr, L);
22792}
22793bool ByteCodeEmitter::emitFlipUint64MemberPtr(SourceInfo L) {
22794 return emitOp<>(OP_FlipUint64MemberPtr, L);
22795}
22796bool ByteCodeEmitter::emitFlipUint64Float(SourceInfo L) {
22797 return emitOp<>(OP_FlipUint64Float, L);
22798}
22799bool ByteCodeEmitter::emitFlipUint64Reflect(SourceInfo L) {
22800 return emitOp<>(OP_FlipUint64Reflect, L);
22801}
22802bool ByteCodeEmitter::emitFlipIntAPSint8(SourceInfo L) {
22803 return emitOp<>(OP_FlipIntAPSint8, L);
22804}
22805bool ByteCodeEmitter::emitFlipIntAPUint8(SourceInfo L) {
22806 return emitOp<>(OP_FlipIntAPUint8, L);
22807}
22808bool ByteCodeEmitter::emitFlipIntAPSint16(SourceInfo L) {
22809 return emitOp<>(OP_FlipIntAPSint16, L);
22810}
22811bool ByteCodeEmitter::emitFlipIntAPUint16(SourceInfo L) {
22812 return emitOp<>(OP_FlipIntAPUint16, L);
22813}
22814bool ByteCodeEmitter::emitFlipIntAPSint32(SourceInfo L) {
22815 return emitOp<>(OP_FlipIntAPSint32, L);
22816}
22817bool ByteCodeEmitter::emitFlipIntAPUint32(SourceInfo L) {
22818 return emitOp<>(OP_FlipIntAPUint32, L);
22819}
22820bool ByteCodeEmitter::emitFlipIntAPSint64(SourceInfo L) {
22821 return emitOp<>(OP_FlipIntAPSint64, L);
22822}
22823bool ByteCodeEmitter::emitFlipIntAPUint64(SourceInfo L) {
22824 return emitOp<>(OP_FlipIntAPUint64, L);
22825}
22826bool ByteCodeEmitter::emitFlipIntAPIntAP(SourceInfo L) {
22827 return emitOp<>(OP_FlipIntAPIntAP, L);
22828}
22829bool ByteCodeEmitter::emitFlipIntAPIntAPS(SourceInfo L) {
22830 return emitOp<>(OP_FlipIntAPIntAPS, L);
22831}
22832bool ByteCodeEmitter::emitFlipIntAPBool(SourceInfo L) {
22833 return emitOp<>(OP_FlipIntAPBool, L);
22834}
22835bool ByteCodeEmitter::emitFlipIntAPFixedPoint(SourceInfo L) {
22836 return emitOp<>(OP_FlipIntAPFixedPoint, L);
22837}
22838bool ByteCodeEmitter::emitFlipIntAPPtr(SourceInfo L) {
22839 return emitOp<>(OP_FlipIntAPPtr, L);
22840}
22841bool ByteCodeEmitter::emitFlipIntAPMemberPtr(SourceInfo L) {
22842 return emitOp<>(OP_FlipIntAPMemberPtr, L);
22843}
22844bool ByteCodeEmitter::emitFlipIntAPFloat(SourceInfo L) {
22845 return emitOp<>(OP_FlipIntAPFloat, L);
22846}
22847bool ByteCodeEmitter::emitFlipIntAPReflect(SourceInfo L) {
22848 return emitOp<>(OP_FlipIntAPReflect, L);
22849}
22850bool ByteCodeEmitter::emitFlipIntAPSSint8(SourceInfo L) {
22851 return emitOp<>(OP_FlipIntAPSSint8, L);
22852}
22853bool ByteCodeEmitter::emitFlipIntAPSUint8(SourceInfo L) {
22854 return emitOp<>(OP_FlipIntAPSUint8, L);
22855}
22856bool ByteCodeEmitter::emitFlipIntAPSSint16(SourceInfo L) {
22857 return emitOp<>(OP_FlipIntAPSSint16, L);
22858}
22859bool ByteCodeEmitter::emitFlipIntAPSUint16(SourceInfo L) {
22860 return emitOp<>(OP_FlipIntAPSUint16, L);
22861}
22862bool ByteCodeEmitter::emitFlipIntAPSSint32(SourceInfo L) {
22863 return emitOp<>(OP_FlipIntAPSSint32, L);
22864}
22865bool ByteCodeEmitter::emitFlipIntAPSUint32(SourceInfo L) {
22866 return emitOp<>(OP_FlipIntAPSUint32, L);
22867}
22868bool ByteCodeEmitter::emitFlipIntAPSSint64(SourceInfo L) {
22869 return emitOp<>(OP_FlipIntAPSSint64, L);
22870}
22871bool ByteCodeEmitter::emitFlipIntAPSUint64(SourceInfo L) {
22872 return emitOp<>(OP_FlipIntAPSUint64, L);
22873}
22874bool ByteCodeEmitter::emitFlipIntAPSIntAP(SourceInfo L) {
22875 return emitOp<>(OP_FlipIntAPSIntAP, L);
22876}
22877bool ByteCodeEmitter::emitFlipIntAPSIntAPS(SourceInfo L) {
22878 return emitOp<>(OP_FlipIntAPSIntAPS, L);
22879}
22880bool ByteCodeEmitter::emitFlipIntAPSBool(SourceInfo L) {
22881 return emitOp<>(OP_FlipIntAPSBool, L);
22882}
22883bool ByteCodeEmitter::emitFlipIntAPSFixedPoint(SourceInfo L) {
22884 return emitOp<>(OP_FlipIntAPSFixedPoint, L);
22885}
22886bool ByteCodeEmitter::emitFlipIntAPSPtr(SourceInfo L) {
22887 return emitOp<>(OP_FlipIntAPSPtr, L);
22888}
22889bool ByteCodeEmitter::emitFlipIntAPSMemberPtr(SourceInfo L) {
22890 return emitOp<>(OP_FlipIntAPSMemberPtr, L);
22891}
22892bool ByteCodeEmitter::emitFlipIntAPSFloat(SourceInfo L) {
22893 return emitOp<>(OP_FlipIntAPSFloat, L);
22894}
22895bool ByteCodeEmitter::emitFlipIntAPSReflect(SourceInfo L) {
22896 return emitOp<>(OP_FlipIntAPSReflect, L);
22897}
22898bool ByteCodeEmitter::emitFlipBoolSint8(SourceInfo L) {
22899 return emitOp<>(OP_FlipBoolSint8, L);
22900}
22901bool ByteCodeEmitter::emitFlipBoolUint8(SourceInfo L) {
22902 return emitOp<>(OP_FlipBoolUint8, L);
22903}
22904bool ByteCodeEmitter::emitFlipBoolSint16(SourceInfo L) {
22905 return emitOp<>(OP_FlipBoolSint16, L);
22906}
22907bool ByteCodeEmitter::emitFlipBoolUint16(SourceInfo L) {
22908 return emitOp<>(OP_FlipBoolUint16, L);
22909}
22910bool ByteCodeEmitter::emitFlipBoolSint32(SourceInfo L) {
22911 return emitOp<>(OP_FlipBoolSint32, L);
22912}
22913bool ByteCodeEmitter::emitFlipBoolUint32(SourceInfo L) {
22914 return emitOp<>(OP_FlipBoolUint32, L);
22915}
22916bool ByteCodeEmitter::emitFlipBoolSint64(SourceInfo L) {
22917 return emitOp<>(OP_FlipBoolSint64, L);
22918}
22919bool ByteCodeEmitter::emitFlipBoolUint64(SourceInfo L) {
22920 return emitOp<>(OP_FlipBoolUint64, L);
22921}
22922bool ByteCodeEmitter::emitFlipBoolIntAP(SourceInfo L) {
22923 return emitOp<>(OP_FlipBoolIntAP, L);
22924}
22925bool ByteCodeEmitter::emitFlipBoolIntAPS(SourceInfo L) {
22926 return emitOp<>(OP_FlipBoolIntAPS, L);
22927}
22928bool ByteCodeEmitter::emitFlipBoolBool(SourceInfo L) {
22929 return emitOp<>(OP_FlipBoolBool, L);
22930}
22931bool ByteCodeEmitter::emitFlipBoolFixedPoint(SourceInfo L) {
22932 return emitOp<>(OP_FlipBoolFixedPoint, L);
22933}
22934bool ByteCodeEmitter::emitFlipBoolPtr(SourceInfo L) {
22935 return emitOp<>(OP_FlipBoolPtr, L);
22936}
22937bool ByteCodeEmitter::emitFlipBoolMemberPtr(SourceInfo L) {
22938 return emitOp<>(OP_FlipBoolMemberPtr, L);
22939}
22940bool ByteCodeEmitter::emitFlipBoolFloat(SourceInfo L) {
22941 return emitOp<>(OP_FlipBoolFloat, L);
22942}
22943bool ByteCodeEmitter::emitFlipBoolReflect(SourceInfo L) {
22944 return emitOp<>(OP_FlipBoolReflect, L);
22945}
22946bool ByteCodeEmitter::emitFlipFixedPointSint8(SourceInfo L) {
22947 return emitOp<>(OP_FlipFixedPointSint8, L);
22948}
22949bool ByteCodeEmitter::emitFlipFixedPointUint8(SourceInfo L) {
22950 return emitOp<>(OP_FlipFixedPointUint8, L);
22951}
22952bool ByteCodeEmitter::emitFlipFixedPointSint16(SourceInfo L) {
22953 return emitOp<>(OP_FlipFixedPointSint16, L);
22954}
22955bool ByteCodeEmitter::emitFlipFixedPointUint16(SourceInfo L) {
22956 return emitOp<>(OP_FlipFixedPointUint16, L);
22957}
22958bool ByteCodeEmitter::emitFlipFixedPointSint32(SourceInfo L) {
22959 return emitOp<>(OP_FlipFixedPointSint32, L);
22960}
22961bool ByteCodeEmitter::emitFlipFixedPointUint32(SourceInfo L) {
22962 return emitOp<>(OP_FlipFixedPointUint32, L);
22963}
22964bool ByteCodeEmitter::emitFlipFixedPointSint64(SourceInfo L) {
22965 return emitOp<>(OP_FlipFixedPointSint64, L);
22966}
22967bool ByteCodeEmitter::emitFlipFixedPointUint64(SourceInfo L) {
22968 return emitOp<>(OP_FlipFixedPointUint64, L);
22969}
22970bool ByteCodeEmitter::emitFlipFixedPointIntAP(SourceInfo L) {
22971 return emitOp<>(OP_FlipFixedPointIntAP, L);
22972}
22973bool ByteCodeEmitter::emitFlipFixedPointIntAPS(SourceInfo L) {
22974 return emitOp<>(OP_FlipFixedPointIntAPS, L);
22975}
22976bool ByteCodeEmitter::emitFlipFixedPointBool(SourceInfo L) {
22977 return emitOp<>(OP_FlipFixedPointBool, L);
22978}
22979bool ByteCodeEmitter::emitFlipFixedPointFixedPoint(SourceInfo L) {
22980 return emitOp<>(OP_FlipFixedPointFixedPoint, L);
22981}
22982bool ByteCodeEmitter::emitFlipFixedPointPtr(SourceInfo L) {
22983 return emitOp<>(OP_FlipFixedPointPtr, L);
22984}
22985bool ByteCodeEmitter::emitFlipFixedPointMemberPtr(SourceInfo L) {
22986 return emitOp<>(OP_FlipFixedPointMemberPtr, L);
22987}
22988bool ByteCodeEmitter::emitFlipFixedPointFloat(SourceInfo L) {
22989 return emitOp<>(OP_FlipFixedPointFloat, L);
22990}
22991bool ByteCodeEmitter::emitFlipFixedPointReflect(SourceInfo L) {
22992 return emitOp<>(OP_FlipFixedPointReflect, L);
22993}
22994bool ByteCodeEmitter::emitFlipPtrSint8(SourceInfo L) {
22995 return emitOp<>(OP_FlipPtrSint8, L);
22996}
22997bool ByteCodeEmitter::emitFlipPtrUint8(SourceInfo L) {
22998 return emitOp<>(OP_FlipPtrUint8, L);
22999}
23000bool ByteCodeEmitter::emitFlipPtrSint16(SourceInfo L) {
23001 return emitOp<>(OP_FlipPtrSint16, L);
23002}
23003bool ByteCodeEmitter::emitFlipPtrUint16(SourceInfo L) {
23004 return emitOp<>(OP_FlipPtrUint16, L);
23005}
23006bool ByteCodeEmitter::emitFlipPtrSint32(SourceInfo L) {
23007 return emitOp<>(OP_FlipPtrSint32, L);
23008}
23009bool ByteCodeEmitter::emitFlipPtrUint32(SourceInfo L) {
23010 return emitOp<>(OP_FlipPtrUint32, L);
23011}
23012bool ByteCodeEmitter::emitFlipPtrSint64(SourceInfo L) {
23013 return emitOp<>(OP_FlipPtrSint64, L);
23014}
23015bool ByteCodeEmitter::emitFlipPtrUint64(SourceInfo L) {
23016 return emitOp<>(OP_FlipPtrUint64, L);
23017}
23018bool ByteCodeEmitter::emitFlipPtrIntAP(SourceInfo L) {
23019 return emitOp<>(OP_FlipPtrIntAP, L);
23020}
23021bool ByteCodeEmitter::emitFlipPtrIntAPS(SourceInfo L) {
23022 return emitOp<>(OP_FlipPtrIntAPS, L);
23023}
23024bool ByteCodeEmitter::emitFlipPtrBool(SourceInfo L) {
23025 return emitOp<>(OP_FlipPtrBool, L);
23026}
23027bool ByteCodeEmitter::emitFlipPtrFixedPoint(SourceInfo L) {
23028 return emitOp<>(OP_FlipPtrFixedPoint, L);
23029}
23030bool ByteCodeEmitter::emitFlipPtrPtr(SourceInfo L) {
23031 return emitOp<>(OP_FlipPtrPtr, L);
23032}
23033bool ByteCodeEmitter::emitFlipPtrMemberPtr(SourceInfo L) {
23034 return emitOp<>(OP_FlipPtrMemberPtr, L);
23035}
23036bool ByteCodeEmitter::emitFlipPtrFloat(SourceInfo L) {
23037 return emitOp<>(OP_FlipPtrFloat, L);
23038}
23039bool ByteCodeEmitter::emitFlipPtrReflect(SourceInfo L) {
23040 return emitOp<>(OP_FlipPtrReflect, L);
23041}
23042bool ByteCodeEmitter::emitFlipMemberPtrSint8(SourceInfo L) {
23043 return emitOp<>(OP_FlipMemberPtrSint8, L);
23044}
23045bool ByteCodeEmitter::emitFlipMemberPtrUint8(SourceInfo L) {
23046 return emitOp<>(OP_FlipMemberPtrUint8, L);
23047}
23048bool ByteCodeEmitter::emitFlipMemberPtrSint16(SourceInfo L) {
23049 return emitOp<>(OP_FlipMemberPtrSint16, L);
23050}
23051bool ByteCodeEmitter::emitFlipMemberPtrUint16(SourceInfo L) {
23052 return emitOp<>(OP_FlipMemberPtrUint16, L);
23053}
23054bool ByteCodeEmitter::emitFlipMemberPtrSint32(SourceInfo L) {
23055 return emitOp<>(OP_FlipMemberPtrSint32, L);
23056}
23057bool ByteCodeEmitter::emitFlipMemberPtrUint32(SourceInfo L) {
23058 return emitOp<>(OP_FlipMemberPtrUint32, L);
23059}
23060bool ByteCodeEmitter::emitFlipMemberPtrSint64(SourceInfo L) {
23061 return emitOp<>(OP_FlipMemberPtrSint64, L);
23062}
23063bool ByteCodeEmitter::emitFlipMemberPtrUint64(SourceInfo L) {
23064 return emitOp<>(OP_FlipMemberPtrUint64, L);
23065}
23066bool ByteCodeEmitter::emitFlipMemberPtrIntAP(SourceInfo L) {
23067 return emitOp<>(OP_FlipMemberPtrIntAP, L);
23068}
23069bool ByteCodeEmitter::emitFlipMemberPtrIntAPS(SourceInfo L) {
23070 return emitOp<>(OP_FlipMemberPtrIntAPS, L);
23071}
23072bool ByteCodeEmitter::emitFlipMemberPtrBool(SourceInfo L) {
23073 return emitOp<>(OP_FlipMemberPtrBool, L);
23074}
23075bool ByteCodeEmitter::emitFlipMemberPtrFixedPoint(SourceInfo L) {
23076 return emitOp<>(OP_FlipMemberPtrFixedPoint, L);
23077}
23078bool ByteCodeEmitter::emitFlipMemberPtrPtr(SourceInfo L) {
23079 return emitOp<>(OP_FlipMemberPtrPtr, L);
23080}
23081bool ByteCodeEmitter::emitFlipMemberPtrMemberPtr(SourceInfo L) {
23082 return emitOp<>(OP_FlipMemberPtrMemberPtr, L);
23083}
23084bool ByteCodeEmitter::emitFlipMemberPtrFloat(SourceInfo L) {
23085 return emitOp<>(OP_FlipMemberPtrFloat, L);
23086}
23087bool ByteCodeEmitter::emitFlipMemberPtrReflect(SourceInfo L) {
23088 return emitOp<>(OP_FlipMemberPtrReflect, L);
23089}
23090bool ByteCodeEmitter::emitFlipFloatSint8(SourceInfo L) {
23091 return emitOp<>(OP_FlipFloatSint8, L);
23092}
23093bool ByteCodeEmitter::emitFlipFloatUint8(SourceInfo L) {
23094 return emitOp<>(OP_FlipFloatUint8, L);
23095}
23096bool ByteCodeEmitter::emitFlipFloatSint16(SourceInfo L) {
23097 return emitOp<>(OP_FlipFloatSint16, L);
23098}
23099bool ByteCodeEmitter::emitFlipFloatUint16(SourceInfo L) {
23100 return emitOp<>(OP_FlipFloatUint16, L);
23101}
23102bool ByteCodeEmitter::emitFlipFloatSint32(SourceInfo L) {
23103 return emitOp<>(OP_FlipFloatSint32, L);
23104}
23105bool ByteCodeEmitter::emitFlipFloatUint32(SourceInfo L) {
23106 return emitOp<>(OP_FlipFloatUint32, L);
23107}
23108bool ByteCodeEmitter::emitFlipFloatSint64(SourceInfo L) {
23109 return emitOp<>(OP_FlipFloatSint64, L);
23110}
23111bool ByteCodeEmitter::emitFlipFloatUint64(SourceInfo L) {
23112 return emitOp<>(OP_FlipFloatUint64, L);
23113}
23114bool ByteCodeEmitter::emitFlipFloatIntAP(SourceInfo L) {
23115 return emitOp<>(OP_FlipFloatIntAP, L);
23116}
23117bool ByteCodeEmitter::emitFlipFloatIntAPS(SourceInfo L) {
23118 return emitOp<>(OP_FlipFloatIntAPS, L);
23119}
23120bool ByteCodeEmitter::emitFlipFloatBool(SourceInfo L) {
23121 return emitOp<>(OP_FlipFloatBool, L);
23122}
23123bool ByteCodeEmitter::emitFlipFloatFixedPoint(SourceInfo L) {
23124 return emitOp<>(OP_FlipFloatFixedPoint, L);
23125}
23126bool ByteCodeEmitter::emitFlipFloatPtr(SourceInfo L) {
23127 return emitOp<>(OP_FlipFloatPtr, L);
23128}
23129bool ByteCodeEmitter::emitFlipFloatMemberPtr(SourceInfo L) {
23130 return emitOp<>(OP_FlipFloatMemberPtr, L);
23131}
23132bool ByteCodeEmitter::emitFlipFloatFloat(SourceInfo L) {
23133 return emitOp<>(OP_FlipFloatFloat, L);
23134}
23135bool ByteCodeEmitter::emitFlipFloatReflect(SourceInfo L) {
23136 return emitOp<>(OP_FlipFloatReflect, L);
23137}
23138bool ByteCodeEmitter::emitFlipReflectSint8(SourceInfo L) {
23139 return emitOp<>(OP_FlipReflectSint8, L);
23140}
23141bool ByteCodeEmitter::emitFlipReflectUint8(SourceInfo L) {
23142 return emitOp<>(OP_FlipReflectUint8, L);
23143}
23144bool ByteCodeEmitter::emitFlipReflectSint16(SourceInfo L) {
23145 return emitOp<>(OP_FlipReflectSint16, L);
23146}
23147bool ByteCodeEmitter::emitFlipReflectUint16(SourceInfo L) {
23148 return emitOp<>(OP_FlipReflectUint16, L);
23149}
23150bool ByteCodeEmitter::emitFlipReflectSint32(SourceInfo L) {
23151 return emitOp<>(OP_FlipReflectSint32, L);
23152}
23153bool ByteCodeEmitter::emitFlipReflectUint32(SourceInfo L) {
23154 return emitOp<>(OP_FlipReflectUint32, L);
23155}
23156bool ByteCodeEmitter::emitFlipReflectSint64(SourceInfo L) {
23157 return emitOp<>(OP_FlipReflectSint64, L);
23158}
23159bool ByteCodeEmitter::emitFlipReflectUint64(SourceInfo L) {
23160 return emitOp<>(OP_FlipReflectUint64, L);
23161}
23162bool ByteCodeEmitter::emitFlipReflectIntAP(SourceInfo L) {
23163 return emitOp<>(OP_FlipReflectIntAP, L);
23164}
23165bool ByteCodeEmitter::emitFlipReflectIntAPS(SourceInfo L) {
23166 return emitOp<>(OP_FlipReflectIntAPS, L);
23167}
23168bool ByteCodeEmitter::emitFlipReflectBool(SourceInfo L) {
23169 return emitOp<>(OP_FlipReflectBool, L);
23170}
23171bool ByteCodeEmitter::emitFlipReflectFixedPoint(SourceInfo L) {
23172 return emitOp<>(OP_FlipReflectFixedPoint, L);
23173}
23174bool ByteCodeEmitter::emitFlipReflectPtr(SourceInfo L) {
23175 return emitOp<>(OP_FlipReflectPtr, L);
23176}
23177bool ByteCodeEmitter::emitFlipReflectMemberPtr(SourceInfo L) {
23178 return emitOp<>(OP_FlipReflectMemberPtr, L);
23179}
23180bool ByteCodeEmitter::emitFlipReflectFloat(SourceInfo L) {
23181 return emitOp<>(OP_FlipReflectFloat, L);
23182}
23183bool ByteCodeEmitter::emitFlipReflectReflect(SourceInfo L) {
23184 return emitOp<>(OP_FlipReflectReflect, L);
23185}
23186#endif
23187#ifdef GET_EVAL_IMPL
23188bool EvalEmitter::emitFlipSint8Sint8(SourceInfo L) {
23189 if (!isActive()) return true;
23190 CurrentSource = L;
23191 return Flip<PT_Sint8, PT_Sint8>(S);
23192}
23193bool EvalEmitter::emitFlipSint8Uint8(SourceInfo L) {
23194 if (!isActive()) return true;
23195 CurrentSource = L;
23196 return Flip<PT_Sint8, PT_Uint8>(S);
23197}
23198bool EvalEmitter::emitFlipSint8Sint16(SourceInfo L) {
23199 if (!isActive()) return true;
23200 CurrentSource = L;
23201 return Flip<PT_Sint8, PT_Sint16>(S);
23202}
23203bool EvalEmitter::emitFlipSint8Uint16(SourceInfo L) {
23204 if (!isActive()) return true;
23205 CurrentSource = L;
23206 return Flip<PT_Sint8, PT_Uint16>(S);
23207}
23208bool EvalEmitter::emitFlipSint8Sint32(SourceInfo L) {
23209 if (!isActive()) return true;
23210 CurrentSource = L;
23211 return Flip<PT_Sint8, PT_Sint32>(S);
23212}
23213bool EvalEmitter::emitFlipSint8Uint32(SourceInfo L) {
23214 if (!isActive()) return true;
23215 CurrentSource = L;
23216 return Flip<PT_Sint8, PT_Uint32>(S);
23217}
23218bool EvalEmitter::emitFlipSint8Sint64(SourceInfo L) {
23219 if (!isActive()) return true;
23220 CurrentSource = L;
23221 return Flip<PT_Sint8, PT_Sint64>(S);
23222}
23223bool EvalEmitter::emitFlipSint8Uint64(SourceInfo L) {
23224 if (!isActive()) return true;
23225 CurrentSource = L;
23226 return Flip<PT_Sint8, PT_Uint64>(S);
23227}
23228bool EvalEmitter::emitFlipSint8IntAP(SourceInfo L) {
23229 if (!isActive()) return true;
23230 CurrentSource = L;
23231 return Flip<PT_Sint8, PT_IntAP>(S);
23232}
23233bool EvalEmitter::emitFlipSint8IntAPS(SourceInfo L) {
23234 if (!isActive()) return true;
23235 CurrentSource = L;
23236 return Flip<PT_Sint8, PT_IntAPS>(S);
23237}
23238bool EvalEmitter::emitFlipSint8Bool(SourceInfo L) {
23239 if (!isActive()) return true;
23240 CurrentSource = L;
23241 return Flip<PT_Sint8, PT_Bool>(S);
23242}
23243bool EvalEmitter::emitFlipSint8FixedPoint(SourceInfo L) {
23244 if (!isActive()) return true;
23245 CurrentSource = L;
23246 return Flip<PT_Sint8, PT_FixedPoint>(S);
23247}
23248bool EvalEmitter::emitFlipSint8Ptr(SourceInfo L) {
23249 if (!isActive()) return true;
23250 CurrentSource = L;
23251 return Flip<PT_Sint8, PT_Ptr>(S);
23252}
23253bool EvalEmitter::emitFlipSint8MemberPtr(SourceInfo L) {
23254 if (!isActive()) return true;
23255 CurrentSource = L;
23256 return Flip<PT_Sint8, PT_MemberPtr>(S);
23257}
23258bool EvalEmitter::emitFlipSint8Float(SourceInfo L) {
23259 if (!isActive()) return true;
23260 CurrentSource = L;
23261 return Flip<PT_Sint8, PT_Float>(S);
23262}
23263bool EvalEmitter::emitFlipSint8Reflect(SourceInfo L) {
23264 if (!isActive()) return true;
23265 CurrentSource = L;
23266 return Flip<PT_Sint8, PT_Reflect>(S);
23267}
23268bool EvalEmitter::emitFlipUint8Sint8(SourceInfo L) {
23269 if (!isActive()) return true;
23270 CurrentSource = L;
23271 return Flip<PT_Uint8, PT_Sint8>(S);
23272}
23273bool EvalEmitter::emitFlipUint8Uint8(SourceInfo L) {
23274 if (!isActive()) return true;
23275 CurrentSource = L;
23276 return Flip<PT_Uint8, PT_Uint8>(S);
23277}
23278bool EvalEmitter::emitFlipUint8Sint16(SourceInfo L) {
23279 if (!isActive()) return true;
23280 CurrentSource = L;
23281 return Flip<PT_Uint8, PT_Sint16>(S);
23282}
23283bool EvalEmitter::emitFlipUint8Uint16(SourceInfo L) {
23284 if (!isActive()) return true;
23285 CurrentSource = L;
23286 return Flip<PT_Uint8, PT_Uint16>(S);
23287}
23288bool EvalEmitter::emitFlipUint8Sint32(SourceInfo L) {
23289 if (!isActive()) return true;
23290 CurrentSource = L;
23291 return Flip<PT_Uint8, PT_Sint32>(S);
23292}
23293bool EvalEmitter::emitFlipUint8Uint32(SourceInfo L) {
23294 if (!isActive()) return true;
23295 CurrentSource = L;
23296 return Flip<PT_Uint8, PT_Uint32>(S);
23297}
23298bool EvalEmitter::emitFlipUint8Sint64(SourceInfo L) {
23299 if (!isActive()) return true;
23300 CurrentSource = L;
23301 return Flip<PT_Uint8, PT_Sint64>(S);
23302}
23303bool EvalEmitter::emitFlipUint8Uint64(SourceInfo L) {
23304 if (!isActive()) return true;
23305 CurrentSource = L;
23306 return Flip<PT_Uint8, PT_Uint64>(S);
23307}
23308bool EvalEmitter::emitFlipUint8IntAP(SourceInfo L) {
23309 if (!isActive()) return true;
23310 CurrentSource = L;
23311 return Flip<PT_Uint8, PT_IntAP>(S);
23312}
23313bool EvalEmitter::emitFlipUint8IntAPS(SourceInfo L) {
23314 if (!isActive()) return true;
23315 CurrentSource = L;
23316 return Flip<PT_Uint8, PT_IntAPS>(S);
23317}
23318bool EvalEmitter::emitFlipUint8Bool(SourceInfo L) {
23319 if (!isActive()) return true;
23320 CurrentSource = L;
23321 return Flip<PT_Uint8, PT_Bool>(S);
23322}
23323bool EvalEmitter::emitFlipUint8FixedPoint(SourceInfo L) {
23324 if (!isActive()) return true;
23325 CurrentSource = L;
23326 return Flip<PT_Uint8, PT_FixedPoint>(S);
23327}
23328bool EvalEmitter::emitFlipUint8Ptr(SourceInfo L) {
23329 if (!isActive()) return true;
23330 CurrentSource = L;
23331 return Flip<PT_Uint8, PT_Ptr>(S);
23332}
23333bool EvalEmitter::emitFlipUint8MemberPtr(SourceInfo L) {
23334 if (!isActive()) return true;
23335 CurrentSource = L;
23336 return Flip<PT_Uint8, PT_MemberPtr>(S);
23337}
23338bool EvalEmitter::emitFlipUint8Float(SourceInfo L) {
23339 if (!isActive()) return true;
23340 CurrentSource = L;
23341 return Flip<PT_Uint8, PT_Float>(S);
23342}
23343bool EvalEmitter::emitFlipUint8Reflect(SourceInfo L) {
23344 if (!isActive()) return true;
23345 CurrentSource = L;
23346 return Flip<PT_Uint8, PT_Reflect>(S);
23347}
23348bool EvalEmitter::emitFlipSint16Sint8(SourceInfo L) {
23349 if (!isActive()) return true;
23350 CurrentSource = L;
23351 return Flip<PT_Sint16, PT_Sint8>(S);
23352}
23353bool EvalEmitter::emitFlipSint16Uint8(SourceInfo L) {
23354 if (!isActive()) return true;
23355 CurrentSource = L;
23356 return Flip<PT_Sint16, PT_Uint8>(S);
23357}
23358bool EvalEmitter::emitFlipSint16Sint16(SourceInfo L) {
23359 if (!isActive()) return true;
23360 CurrentSource = L;
23361 return Flip<PT_Sint16, PT_Sint16>(S);
23362}
23363bool EvalEmitter::emitFlipSint16Uint16(SourceInfo L) {
23364 if (!isActive()) return true;
23365 CurrentSource = L;
23366 return Flip<PT_Sint16, PT_Uint16>(S);
23367}
23368bool EvalEmitter::emitFlipSint16Sint32(SourceInfo L) {
23369 if (!isActive()) return true;
23370 CurrentSource = L;
23371 return Flip<PT_Sint16, PT_Sint32>(S);
23372}
23373bool EvalEmitter::emitFlipSint16Uint32(SourceInfo L) {
23374 if (!isActive()) return true;
23375 CurrentSource = L;
23376 return Flip<PT_Sint16, PT_Uint32>(S);
23377}
23378bool EvalEmitter::emitFlipSint16Sint64(SourceInfo L) {
23379 if (!isActive()) return true;
23380 CurrentSource = L;
23381 return Flip<PT_Sint16, PT_Sint64>(S);
23382}
23383bool EvalEmitter::emitFlipSint16Uint64(SourceInfo L) {
23384 if (!isActive()) return true;
23385 CurrentSource = L;
23386 return Flip<PT_Sint16, PT_Uint64>(S);
23387}
23388bool EvalEmitter::emitFlipSint16IntAP(SourceInfo L) {
23389 if (!isActive()) return true;
23390 CurrentSource = L;
23391 return Flip<PT_Sint16, PT_IntAP>(S);
23392}
23393bool EvalEmitter::emitFlipSint16IntAPS(SourceInfo L) {
23394 if (!isActive()) return true;
23395 CurrentSource = L;
23396 return Flip<PT_Sint16, PT_IntAPS>(S);
23397}
23398bool EvalEmitter::emitFlipSint16Bool(SourceInfo L) {
23399 if (!isActive()) return true;
23400 CurrentSource = L;
23401 return Flip<PT_Sint16, PT_Bool>(S);
23402}
23403bool EvalEmitter::emitFlipSint16FixedPoint(SourceInfo L) {
23404 if (!isActive()) return true;
23405 CurrentSource = L;
23406 return Flip<PT_Sint16, PT_FixedPoint>(S);
23407}
23408bool EvalEmitter::emitFlipSint16Ptr(SourceInfo L) {
23409 if (!isActive()) return true;
23410 CurrentSource = L;
23411 return Flip<PT_Sint16, PT_Ptr>(S);
23412}
23413bool EvalEmitter::emitFlipSint16MemberPtr(SourceInfo L) {
23414 if (!isActive()) return true;
23415 CurrentSource = L;
23416 return Flip<PT_Sint16, PT_MemberPtr>(S);
23417}
23418bool EvalEmitter::emitFlipSint16Float(SourceInfo L) {
23419 if (!isActive()) return true;
23420 CurrentSource = L;
23421 return Flip<PT_Sint16, PT_Float>(S);
23422}
23423bool EvalEmitter::emitFlipSint16Reflect(SourceInfo L) {
23424 if (!isActive()) return true;
23425 CurrentSource = L;
23426 return Flip<PT_Sint16, PT_Reflect>(S);
23427}
23428bool EvalEmitter::emitFlipUint16Sint8(SourceInfo L) {
23429 if (!isActive()) return true;
23430 CurrentSource = L;
23431 return Flip<PT_Uint16, PT_Sint8>(S);
23432}
23433bool EvalEmitter::emitFlipUint16Uint8(SourceInfo L) {
23434 if (!isActive()) return true;
23435 CurrentSource = L;
23436 return Flip<PT_Uint16, PT_Uint8>(S);
23437}
23438bool EvalEmitter::emitFlipUint16Sint16(SourceInfo L) {
23439 if (!isActive()) return true;
23440 CurrentSource = L;
23441 return Flip<PT_Uint16, PT_Sint16>(S);
23442}
23443bool EvalEmitter::emitFlipUint16Uint16(SourceInfo L) {
23444 if (!isActive()) return true;
23445 CurrentSource = L;
23446 return Flip<PT_Uint16, PT_Uint16>(S);
23447}
23448bool EvalEmitter::emitFlipUint16Sint32(SourceInfo L) {
23449 if (!isActive()) return true;
23450 CurrentSource = L;
23451 return Flip<PT_Uint16, PT_Sint32>(S);
23452}
23453bool EvalEmitter::emitFlipUint16Uint32(SourceInfo L) {
23454 if (!isActive()) return true;
23455 CurrentSource = L;
23456 return Flip<PT_Uint16, PT_Uint32>(S);
23457}
23458bool EvalEmitter::emitFlipUint16Sint64(SourceInfo L) {
23459 if (!isActive()) return true;
23460 CurrentSource = L;
23461 return Flip<PT_Uint16, PT_Sint64>(S);
23462}
23463bool EvalEmitter::emitFlipUint16Uint64(SourceInfo L) {
23464 if (!isActive()) return true;
23465 CurrentSource = L;
23466 return Flip<PT_Uint16, PT_Uint64>(S);
23467}
23468bool EvalEmitter::emitFlipUint16IntAP(SourceInfo L) {
23469 if (!isActive()) return true;
23470 CurrentSource = L;
23471 return Flip<PT_Uint16, PT_IntAP>(S);
23472}
23473bool EvalEmitter::emitFlipUint16IntAPS(SourceInfo L) {
23474 if (!isActive()) return true;
23475 CurrentSource = L;
23476 return Flip<PT_Uint16, PT_IntAPS>(S);
23477}
23478bool EvalEmitter::emitFlipUint16Bool(SourceInfo L) {
23479 if (!isActive()) return true;
23480 CurrentSource = L;
23481 return Flip<PT_Uint16, PT_Bool>(S);
23482}
23483bool EvalEmitter::emitFlipUint16FixedPoint(SourceInfo L) {
23484 if (!isActive()) return true;
23485 CurrentSource = L;
23486 return Flip<PT_Uint16, PT_FixedPoint>(S);
23487}
23488bool EvalEmitter::emitFlipUint16Ptr(SourceInfo L) {
23489 if (!isActive()) return true;
23490 CurrentSource = L;
23491 return Flip<PT_Uint16, PT_Ptr>(S);
23492}
23493bool EvalEmitter::emitFlipUint16MemberPtr(SourceInfo L) {
23494 if (!isActive()) return true;
23495 CurrentSource = L;
23496 return Flip<PT_Uint16, PT_MemberPtr>(S);
23497}
23498bool EvalEmitter::emitFlipUint16Float(SourceInfo L) {
23499 if (!isActive()) return true;
23500 CurrentSource = L;
23501 return Flip<PT_Uint16, PT_Float>(S);
23502}
23503bool EvalEmitter::emitFlipUint16Reflect(SourceInfo L) {
23504 if (!isActive()) return true;
23505 CurrentSource = L;
23506 return Flip<PT_Uint16, PT_Reflect>(S);
23507}
23508bool EvalEmitter::emitFlipSint32Sint8(SourceInfo L) {
23509 if (!isActive()) return true;
23510 CurrentSource = L;
23511 return Flip<PT_Sint32, PT_Sint8>(S);
23512}
23513bool EvalEmitter::emitFlipSint32Uint8(SourceInfo L) {
23514 if (!isActive()) return true;
23515 CurrentSource = L;
23516 return Flip<PT_Sint32, PT_Uint8>(S);
23517}
23518bool EvalEmitter::emitFlipSint32Sint16(SourceInfo L) {
23519 if (!isActive()) return true;
23520 CurrentSource = L;
23521 return Flip<PT_Sint32, PT_Sint16>(S);
23522}
23523bool EvalEmitter::emitFlipSint32Uint16(SourceInfo L) {
23524 if (!isActive()) return true;
23525 CurrentSource = L;
23526 return Flip<PT_Sint32, PT_Uint16>(S);
23527}
23528bool EvalEmitter::emitFlipSint32Sint32(SourceInfo L) {
23529 if (!isActive()) return true;
23530 CurrentSource = L;
23531 return Flip<PT_Sint32, PT_Sint32>(S);
23532}
23533bool EvalEmitter::emitFlipSint32Uint32(SourceInfo L) {
23534 if (!isActive()) return true;
23535 CurrentSource = L;
23536 return Flip<PT_Sint32, PT_Uint32>(S);
23537}
23538bool EvalEmitter::emitFlipSint32Sint64(SourceInfo L) {
23539 if (!isActive()) return true;
23540 CurrentSource = L;
23541 return Flip<PT_Sint32, PT_Sint64>(S);
23542}
23543bool EvalEmitter::emitFlipSint32Uint64(SourceInfo L) {
23544 if (!isActive()) return true;
23545 CurrentSource = L;
23546 return Flip<PT_Sint32, PT_Uint64>(S);
23547}
23548bool EvalEmitter::emitFlipSint32IntAP(SourceInfo L) {
23549 if (!isActive()) return true;
23550 CurrentSource = L;
23551 return Flip<PT_Sint32, PT_IntAP>(S);
23552}
23553bool EvalEmitter::emitFlipSint32IntAPS(SourceInfo L) {
23554 if (!isActive()) return true;
23555 CurrentSource = L;
23556 return Flip<PT_Sint32, PT_IntAPS>(S);
23557}
23558bool EvalEmitter::emitFlipSint32Bool(SourceInfo L) {
23559 if (!isActive()) return true;
23560 CurrentSource = L;
23561 return Flip<PT_Sint32, PT_Bool>(S);
23562}
23563bool EvalEmitter::emitFlipSint32FixedPoint(SourceInfo L) {
23564 if (!isActive()) return true;
23565 CurrentSource = L;
23566 return Flip<PT_Sint32, PT_FixedPoint>(S);
23567}
23568bool EvalEmitter::emitFlipSint32Ptr(SourceInfo L) {
23569 if (!isActive()) return true;
23570 CurrentSource = L;
23571 return Flip<PT_Sint32, PT_Ptr>(S);
23572}
23573bool EvalEmitter::emitFlipSint32MemberPtr(SourceInfo L) {
23574 if (!isActive()) return true;
23575 CurrentSource = L;
23576 return Flip<PT_Sint32, PT_MemberPtr>(S);
23577}
23578bool EvalEmitter::emitFlipSint32Float(SourceInfo L) {
23579 if (!isActive()) return true;
23580 CurrentSource = L;
23581 return Flip<PT_Sint32, PT_Float>(S);
23582}
23583bool EvalEmitter::emitFlipSint32Reflect(SourceInfo L) {
23584 if (!isActive()) return true;
23585 CurrentSource = L;
23586 return Flip<PT_Sint32, PT_Reflect>(S);
23587}
23588bool EvalEmitter::emitFlipUint32Sint8(SourceInfo L) {
23589 if (!isActive()) return true;
23590 CurrentSource = L;
23591 return Flip<PT_Uint32, PT_Sint8>(S);
23592}
23593bool EvalEmitter::emitFlipUint32Uint8(SourceInfo L) {
23594 if (!isActive()) return true;
23595 CurrentSource = L;
23596 return Flip<PT_Uint32, PT_Uint8>(S);
23597}
23598bool EvalEmitter::emitFlipUint32Sint16(SourceInfo L) {
23599 if (!isActive()) return true;
23600 CurrentSource = L;
23601 return Flip<PT_Uint32, PT_Sint16>(S);
23602}
23603bool EvalEmitter::emitFlipUint32Uint16(SourceInfo L) {
23604 if (!isActive()) return true;
23605 CurrentSource = L;
23606 return Flip<PT_Uint32, PT_Uint16>(S);
23607}
23608bool EvalEmitter::emitFlipUint32Sint32(SourceInfo L) {
23609 if (!isActive()) return true;
23610 CurrentSource = L;
23611 return Flip<PT_Uint32, PT_Sint32>(S);
23612}
23613bool EvalEmitter::emitFlipUint32Uint32(SourceInfo L) {
23614 if (!isActive()) return true;
23615 CurrentSource = L;
23616 return Flip<PT_Uint32, PT_Uint32>(S);
23617}
23618bool EvalEmitter::emitFlipUint32Sint64(SourceInfo L) {
23619 if (!isActive()) return true;
23620 CurrentSource = L;
23621 return Flip<PT_Uint32, PT_Sint64>(S);
23622}
23623bool EvalEmitter::emitFlipUint32Uint64(SourceInfo L) {
23624 if (!isActive()) return true;
23625 CurrentSource = L;
23626 return Flip<PT_Uint32, PT_Uint64>(S);
23627}
23628bool EvalEmitter::emitFlipUint32IntAP(SourceInfo L) {
23629 if (!isActive()) return true;
23630 CurrentSource = L;
23631 return Flip<PT_Uint32, PT_IntAP>(S);
23632}
23633bool EvalEmitter::emitFlipUint32IntAPS(SourceInfo L) {
23634 if (!isActive()) return true;
23635 CurrentSource = L;
23636 return Flip<PT_Uint32, PT_IntAPS>(S);
23637}
23638bool EvalEmitter::emitFlipUint32Bool(SourceInfo L) {
23639 if (!isActive()) return true;
23640 CurrentSource = L;
23641 return Flip<PT_Uint32, PT_Bool>(S);
23642}
23643bool EvalEmitter::emitFlipUint32FixedPoint(SourceInfo L) {
23644 if (!isActive()) return true;
23645 CurrentSource = L;
23646 return Flip<PT_Uint32, PT_FixedPoint>(S);
23647}
23648bool EvalEmitter::emitFlipUint32Ptr(SourceInfo L) {
23649 if (!isActive()) return true;
23650 CurrentSource = L;
23651 return Flip<PT_Uint32, PT_Ptr>(S);
23652}
23653bool EvalEmitter::emitFlipUint32MemberPtr(SourceInfo L) {
23654 if (!isActive()) return true;
23655 CurrentSource = L;
23656 return Flip<PT_Uint32, PT_MemberPtr>(S);
23657}
23658bool EvalEmitter::emitFlipUint32Float(SourceInfo L) {
23659 if (!isActive()) return true;
23660 CurrentSource = L;
23661 return Flip<PT_Uint32, PT_Float>(S);
23662}
23663bool EvalEmitter::emitFlipUint32Reflect(SourceInfo L) {
23664 if (!isActive()) return true;
23665 CurrentSource = L;
23666 return Flip<PT_Uint32, PT_Reflect>(S);
23667}
23668bool EvalEmitter::emitFlipSint64Sint8(SourceInfo L) {
23669 if (!isActive()) return true;
23670 CurrentSource = L;
23671 return Flip<PT_Sint64, PT_Sint8>(S);
23672}
23673bool EvalEmitter::emitFlipSint64Uint8(SourceInfo L) {
23674 if (!isActive()) return true;
23675 CurrentSource = L;
23676 return Flip<PT_Sint64, PT_Uint8>(S);
23677}
23678bool EvalEmitter::emitFlipSint64Sint16(SourceInfo L) {
23679 if (!isActive()) return true;
23680 CurrentSource = L;
23681 return Flip<PT_Sint64, PT_Sint16>(S);
23682}
23683bool EvalEmitter::emitFlipSint64Uint16(SourceInfo L) {
23684 if (!isActive()) return true;
23685 CurrentSource = L;
23686 return Flip<PT_Sint64, PT_Uint16>(S);
23687}
23688bool EvalEmitter::emitFlipSint64Sint32(SourceInfo L) {
23689 if (!isActive()) return true;
23690 CurrentSource = L;
23691 return Flip<PT_Sint64, PT_Sint32>(S);
23692}
23693bool EvalEmitter::emitFlipSint64Uint32(SourceInfo L) {
23694 if (!isActive()) return true;
23695 CurrentSource = L;
23696 return Flip<PT_Sint64, PT_Uint32>(S);
23697}
23698bool EvalEmitter::emitFlipSint64Sint64(SourceInfo L) {
23699 if (!isActive()) return true;
23700 CurrentSource = L;
23701 return Flip<PT_Sint64, PT_Sint64>(S);
23702}
23703bool EvalEmitter::emitFlipSint64Uint64(SourceInfo L) {
23704 if (!isActive()) return true;
23705 CurrentSource = L;
23706 return Flip<PT_Sint64, PT_Uint64>(S);
23707}
23708bool EvalEmitter::emitFlipSint64IntAP(SourceInfo L) {
23709 if (!isActive()) return true;
23710 CurrentSource = L;
23711 return Flip<PT_Sint64, PT_IntAP>(S);
23712}
23713bool EvalEmitter::emitFlipSint64IntAPS(SourceInfo L) {
23714 if (!isActive()) return true;
23715 CurrentSource = L;
23716 return Flip<PT_Sint64, PT_IntAPS>(S);
23717}
23718bool EvalEmitter::emitFlipSint64Bool(SourceInfo L) {
23719 if (!isActive()) return true;
23720 CurrentSource = L;
23721 return Flip<PT_Sint64, PT_Bool>(S);
23722}
23723bool EvalEmitter::emitFlipSint64FixedPoint(SourceInfo L) {
23724 if (!isActive()) return true;
23725 CurrentSource = L;
23726 return Flip<PT_Sint64, PT_FixedPoint>(S);
23727}
23728bool EvalEmitter::emitFlipSint64Ptr(SourceInfo L) {
23729 if (!isActive()) return true;
23730 CurrentSource = L;
23731 return Flip<PT_Sint64, PT_Ptr>(S);
23732}
23733bool EvalEmitter::emitFlipSint64MemberPtr(SourceInfo L) {
23734 if (!isActive()) return true;
23735 CurrentSource = L;
23736 return Flip<PT_Sint64, PT_MemberPtr>(S);
23737}
23738bool EvalEmitter::emitFlipSint64Float(SourceInfo L) {
23739 if (!isActive()) return true;
23740 CurrentSource = L;
23741 return Flip<PT_Sint64, PT_Float>(S);
23742}
23743bool EvalEmitter::emitFlipSint64Reflect(SourceInfo L) {
23744 if (!isActive()) return true;
23745 CurrentSource = L;
23746 return Flip<PT_Sint64, PT_Reflect>(S);
23747}
23748bool EvalEmitter::emitFlipUint64Sint8(SourceInfo L) {
23749 if (!isActive()) return true;
23750 CurrentSource = L;
23751 return Flip<PT_Uint64, PT_Sint8>(S);
23752}
23753bool EvalEmitter::emitFlipUint64Uint8(SourceInfo L) {
23754 if (!isActive()) return true;
23755 CurrentSource = L;
23756 return Flip<PT_Uint64, PT_Uint8>(S);
23757}
23758bool EvalEmitter::emitFlipUint64Sint16(SourceInfo L) {
23759 if (!isActive()) return true;
23760 CurrentSource = L;
23761 return Flip<PT_Uint64, PT_Sint16>(S);
23762}
23763bool EvalEmitter::emitFlipUint64Uint16(SourceInfo L) {
23764 if (!isActive()) return true;
23765 CurrentSource = L;
23766 return Flip<PT_Uint64, PT_Uint16>(S);
23767}
23768bool EvalEmitter::emitFlipUint64Sint32(SourceInfo L) {
23769 if (!isActive()) return true;
23770 CurrentSource = L;
23771 return Flip<PT_Uint64, PT_Sint32>(S);
23772}
23773bool EvalEmitter::emitFlipUint64Uint32(SourceInfo L) {
23774 if (!isActive()) return true;
23775 CurrentSource = L;
23776 return Flip<PT_Uint64, PT_Uint32>(S);
23777}
23778bool EvalEmitter::emitFlipUint64Sint64(SourceInfo L) {
23779 if (!isActive()) return true;
23780 CurrentSource = L;
23781 return Flip<PT_Uint64, PT_Sint64>(S);
23782}
23783bool EvalEmitter::emitFlipUint64Uint64(SourceInfo L) {
23784 if (!isActive()) return true;
23785 CurrentSource = L;
23786 return Flip<PT_Uint64, PT_Uint64>(S);
23787}
23788bool EvalEmitter::emitFlipUint64IntAP(SourceInfo L) {
23789 if (!isActive()) return true;
23790 CurrentSource = L;
23791 return Flip<PT_Uint64, PT_IntAP>(S);
23792}
23793bool EvalEmitter::emitFlipUint64IntAPS(SourceInfo L) {
23794 if (!isActive()) return true;
23795 CurrentSource = L;
23796 return Flip<PT_Uint64, PT_IntAPS>(S);
23797}
23798bool EvalEmitter::emitFlipUint64Bool(SourceInfo L) {
23799 if (!isActive()) return true;
23800 CurrentSource = L;
23801 return Flip<PT_Uint64, PT_Bool>(S);
23802}
23803bool EvalEmitter::emitFlipUint64FixedPoint(SourceInfo L) {
23804 if (!isActive()) return true;
23805 CurrentSource = L;
23806 return Flip<PT_Uint64, PT_FixedPoint>(S);
23807}
23808bool EvalEmitter::emitFlipUint64Ptr(SourceInfo L) {
23809 if (!isActive()) return true;
23810 CurrentSource = L;
23811 return Flip<PT_Uint64, PT_Ptr>(S);
23812}
23813bool EvalEmitter::emitFlipUint64MemberPtr(SourceInfo L) {
23814 if (!isActive()) return true;
23815 CurrentSource = L;
23816 return Flip<PT_Uint64, PT_MemberPtr>(S);
23817}
23818bool EvalEmitter::emitFlipUint64Float(SourceInfo L) {
23819 if (!isActive()) return true;
23820 CurrentSource = L;
23821 return Flip<PT_Uint64, PT_Float>(S);
23822}
23823bool EvalEmitter::emitFlipUint64Reflect(SourceInfo L) {
23824 if (!isActive()) return true;
23825 CurrentSource = L;
23826 return Flip<PT_Uint64, PT_Reflect>(S);
23827}
23828bool EvalEmitter::emitFlipIntAPSint8(SourceInfo L) {
23829 if (!isActive()) return true;
23830 CurrentSource = L;
23831 return Flip<PT_IntAP, PT_Sint8>(S);
23832}
23833bool EvalEmitter::emitFlipIntAPUint8(SourceInfo L) {
23834 if (!isActive()) return true;
23835 CurrentSource = L;
23836 return Flip<PT_IntAP, PT_Uint8>(S);
23837}
23838bool EvalEmitter::emitFlipIntAPSint16(SourceInfo L) {
23839 if (!isActive()) return true;
23840 CurrentSource = L;
23841 return Flip<PT_IntAP, PT_Sint16>(S);
23842}
23843bool EvalEmitter::emitFlipIntAPUint16(SourceInfo L) {
23844 if (!isActive()) return true;
23845 CurrentSource = L;
23846 return Flip<PT_IntAP, PT_Uint16>(S);
23847}
23848bool EvalEmitter::emitFlipIntAPSint32(SourceInfo L) {
23849 if (!isActive()) return true;
23850 CurrentSource = L;
23851 return Flip<PT_IntAP, PT_Sint32>(S);
23852}
23853bool EvalEmitter::emitFlipIntAPUint32(SourceInfo L) {
23854 if (!isActive()) return true;
23855 CurrentSource = L;
23856 return Flip<PT_IntAP, PT_Uint32>(S);
23857}
23858bool EvalEmitter::emitFlipIntAPSint64(SourceInfo L) {
23859 if (!isActive()) return true;
23860 CurrentSource = L;
23861 return Flip<PT_IntAP, PT_Sint64>(S);
23862}
23863bool EvalEmitter::emitFlipIntAPUint64(SourceInfo L) {
23864 if (!isActive()) return true;
23865 CurrentSource = L;
23866 return Flip<PT_IntAP, PT_Uint64>(S);
23867}
23868bool EvalEmitter::emitFlipIntAPIntAP(SourceInfo L) {
23869 if (!isActive()) return true;
23870 CurrentSource = L;
23871 return Flip<PT_IntAP, PT_IntAP>(S);
23872}
23873bool EvalEmitter::emitFlipIntAPIntAPS(SourceInfo L) {
23874 if (!isActive()) return true;
23875 CurrentSource = L;
23876 return Flip<PT_IntAP, PT_IntAPS>(S);
23877}
23878bool EvalEmitter::emitFlipIntAPBool(SourceInfo L) {
23879 if (!isActive()) return true;
23880 CurrentSource = L;
23881 return Flip<PT_IntAP, PT_Bool>(S);
23882}
23883bool EvalEmitter::emitFlipIntAPFixedPoint(SourceInfo L) {
23884 if (!isActive()) return true;
23885 CurrentSource = L;
23886 return Flip<PT_IntAP, PT_FixedPoint>(S);
23887}
23888bool EvalEmitter::emitFlipIntAPPtr(SourceInfo L) {
23889 if (!isActive()) return true;
23890 CurrentSource = L;
23891 return Flip<PT_IntAP, PT_Ptr>(S);
23892}
23893bool EvalEmitter::emitFlipIntAPMemberPtr(SourceInfo L) {
23894 if (!isActive()) return true;
23895 CurrentSource = L;
23896 return Flip<PT_IntAP, PT_MemberPtr>(S);
23897}
23898bool EvalEmitter::emitFlipIntAPFloat(SourceInfo L) {
23899 if (!isActive()) return true;
23900 CurrentSource = L;
23901 return Flip<PT_IntAP, PT_Float>(S);
23902}
23903bool EvalEmitter::emitFlipIntAPReflect(SourceInfo L) {
23904 if (!isActive()) return true;
23905 CurrentSource = L;
23906 return Flip<PT_IntAP, PT_Reflect>(S);
23907}
23908bool EvalEmitter::emitFlipIntAPSSint8(SourceInfo L) {
23909 if (!isActive()) return true;
23910 CurrentSource = L;
23911 return Flip<PT_IntAPS, PT_Sint8>(S);
23912}
23913bool EvalEmitter::emitFlipIntAPSUint8(SourceInfo L) {
23914 if (!isActive()) return true;
23915 CurrentSource = L;
23916 return Flip<PT_IntAPS, PT_Uint8>(S);
23917}
23918bool EvalEmitter::emitFlipIntAPSSint16(SourceInfo L) {
23919 if (!isActive()) return true;
23920 CurrentSource = L;
23921 return Flip<PT_IntAPS, PT_Sint16>(S);
23922}
23923bool EvalEmitter::emitFlipIntAPSUint16(SourceInfo L) {
23924 if (!isActive()) return true;
23925 CurrentSource = L;
23926 return Flip<PT_IntAPS, PT_Uint16>(S);
23927}
23928bool EvalEmitter::emitFlipIntAPSSint32(SourceInfo L) {
23929 if (!isActive()) return true;
23930 CurrentSource = L;
23931 return Flip<PT_IntAPS, PT_Sint32>(S);
23932}
23933bool EvalEmitter::emitFlipIntAPSUint32(SourceInfo L) {
23934 if (!isActive()) return true;
23935 CurrentSource = L;
23936 return Flip<PT_IntAPS, PT_Uint32>(S);
23937}
23938bool EvalEmitter::emitFlipIntAPSSint64(SourceInfo L) {
23939 if (!isActive()) return true;
23940 CurrentSource = L;
23941 return Flip<PT_IntAPS, PT_Sint64>(S);
23942}
23943bool EvalEmitter::emitFlipIntAPSUint64(SourceInfo L) {
23944 if (!isActive()) return true;
23945 CurrentSource = L;
23946 return Flip<PT_IntAPS, PT_Uint64>(S);
23947}
23948bool EvalEmitter::emitFlipIntAPSIntAP(SourceInfo L) {
23949 if (!isActive()) return true;
23950 CurrentSource = L;
23951 return Flip<PT_IntAPS, PT_IntAP>(S);
23952}
23953bool EvalEmitter::emitFlipIntAPSIntAPS(SourceInfo L) {
23954 if (!isActive()) return true;
23955 CurrentSource = L;
23956 return Flip<PT_IntAPS, PT_IntAPS>(S);
23957}
23958bool EvalEmitter::emitFlipIntAPSBool(SourceInfo L) {
23959 if (!isActive()) return true;
23960 CurrentSource = L;
23961 return Flip<PT_IntAPS, PT_Bool>(S);
23962}
23963bool EvalEmitter::emitFlipIntAPSFixedPoint(SourceInfo L) {
23964 if (!isActive()) return true;
23965 CurrentSource = L;
23966 return Flip<PT_IntAPS, PT_FixedPoint>(S);
23967}
23968bool EvalEmitter::emitFlipIntAPSPtr(SourceInfo L) {
23969 if (!isActive()) return true;
23970 CurrentSource = L;
23971 return Flip<PT_IntAPS, PT_Ptr>(S);
23972}
23973bool EvalEmitter::emitFlipIntAPSMemberPtr(SourceInfo L) {
23974 if (!isActive()) return true;
23975 CurrentSource = L;
23976 return Flip<PT_IntAPS, PT_MemberPtr>(S);
23977}
23978bool EvalEmitter::emitFlipIntAPSFloat(SourceInfo L) {
23979 if (!isActive()) return true;
23980 CurrentSource = L;
23981 return Flip<PT_IntAPS, PT_Float>(S);
23982}
23983bool EvalEmitter::emitFlipIntAPSReflect(SourceInfo L) {
23984 if (!isActive()) return true;
23985 CurrentSource = L;
23986 return Flip<PT_IntAPS, PT_Reflect>(S);
23987}
23988bool EvalEmitter::emitFlipBoolSint8(SourceInfo L) {
23989 if (!isActive()) return true;
23990 CurrentSource = L;
23991 return Flip<PT_Bool, PT_Sint8>(S);
23992}
23993bool EvalEmitter::emitFlipBoolUint8(SourceInfo L) {
23994 if (!isActive()) return true;
23995 CurrentSource = L;
23996 return Flip<PT_Bool, PT_Uint8>(S);
23997}
23998bool EvalEmitter::emitFlipBoolSint16(SourceInfo L) {
23999 if (!isActive()) return true;
24000 CurrentSource = L;
24001 return Flip<PT_Bool, PT_Sint16>(S);
24002}
24003bool EvalEmitter::emitFlipBoolUint16(SourceInfo L) {
24004 if (!isActive()) return true;
24005 CurrentSource = L;
24006 return Flip<PT_Bool, PT_Uint16>(S);
24007}
24008bool EvalEmitter::emitFlipBoolSint32(SourceInfo L) {
24009 if (!isActive()) return true;
24010 CurrentSource = L;
24011 return Flip<PT_Bool, PT_Sint32>(S);
24012}
24013bool EvalEmitter::emitFlipBoolUint32(SourceInfo L) {
24014 if (!isActive()) return true;
24015 CurrentSource = L;
24016 return Flip<PT_Bool, PT_Uint32>(S);
24017}
24018bool EvalEmitter::emitFlipBoolSint64(SourceInfo L) {
24019 if (!isActive()) return true;
24020 CurrentSource = L;
24021 return Flip<PT_Bool, PT_Sint64>(S);
24022}
24023bool EvalEmitter::emitFlipBoolUint64(SourceInfo L) {
24024 if (!isActive()) return true;
24025 CurrentSource = L;
24026 return Flip<PT_Bool, PT_Uint64>(S);
24027}
24028bool EvalEmitter::emitFlipBoolIntAP(SourceInfo L) {
24029 if (!isActive()) return true;
24030 CurrentSource = L;
24031 return Flip<PT_Bool, PT_IntAP>(S);
24032}
24033bool EvalEmitter::emitFlipBoolIntAPS(SourceInfo L) {
24034 if (!isActive()) return true;
24035 CurrentSource = L;
24036 return Flip<PT_Bool, PT_IntAPS>(S);
24037}
24038bool EvalEmitter::emitFlipBoolBool(SourceInfo L) {
24039 if (!isActive()) return true;
24040 CurrentSource = L;
24041 return Flip<PT_Bool, PT_Bool>(S);
24042}
24043bool EvalEmitter::emitFlipBoolFixedPoint(SourceInfo L) {
24044 if (!isActive()) return true;
24045 CurrentSource = L;
24046 return Flip<PT_Bool, PT_FixedPoint>(S);
24047}
24048bool EvalEmitter::emitFlipBoolPtr(SourceInfo L) {
24049 if (!isActive()) return true;
24050 CurrentSource = L;
24051 return Flip<PT_Bool, PT_Ptr>(S);
24052}
24053bool EvalEmitter::emitFlipBoolMemberPtr(SourceInfo L) {
24054 if (!isActive()) return true;
24055 CurrentSource = L;
24056 return Flip<PT_Bool, PT_MemberPtr>(S);
24057}
24058bool EvalEmitter::emitFlipBoolFloat(SourceInfo L) {
24059 if (!isActive()) return true;
24060 CurrentSource = L;
24061 return Flip<PT_Bool, PT_Float>(S);
24062}
24063bool EvalEmitter::emitFlipBoolReflect(SourceInfo L) {
24064 if (!isActive()) return true;
24065 CurrentSource = L;
24066 return Flip<PT_Bool, PT_Reflect>(S);
24067}
24068bool EvalEmitter::emitFlipFixedPointSint8(SourceInfo L) {
24069 if (!isActive()) return true;
24070 CurrentSource = L;
24071 return Flip<PT_FixedPoint, PT_Sint8>(S);
24072}
24073bool EvalEmitter::emitFlipFixedPointUint8(SourceInfo L) {
24074 if (!isActive()) return true;
24075 CurrentSource = L;
24076 return Flip<PT_FixedPoint, PT_Uint8>(S);
24077}
24078bool EvalEmitter::emitFlipFixedPointSint16(SourceInfo L) {
24079 if (!isActive()) return true;
24080 CurrentSource = L;
24081 return Flip<PT_FixedPoint, PT_Sint16>(S);
24082}
24083bool EvalEmitter::emitFlipFixedPointUint16(SourceInfo L) {
24084 if (!isActive()) return true;
24085 CurrentSource = L;
24086 return Flip<PT_FixedPoint, PT_Uint16>(S);
24087}
24088bool EvalEmitter::emitFlipFixedPointSint32(SourceInfo L) {
24089 if (!isActive()) return true;
24090 CurrentSource = L;
24091 return Flip<PT_FixedPoint, PT_Sint32>(S);
24092}
24093bool EvalEmitter::emitFlipFixedPointUint32(SourceInfo L) {
24094 if (!isActive()) return true;
24095 CurrentSource = L;
24096 return Flip<PT_FixedPoint, PT_Uint32>(S);
24097}
24098bool EvalEmitter::emitFlipFixedPointSint64(SourceInfo L) {
24099 if (!isActive()) return true;
24100 CurrentSource = L;
24101 return Flip<PT_FixedPoint, PT_Sint64>(S);
24102}
24103bool EvalEmitter::emitFlipFixedPointUint64(SourceInfo L) {
24104 if (!isActive()) return true;
24105 CurrentSource = L;
24106 return Flip<PT_FixedPoint, PT_Uint64>(S);
24107}
24108bool EvalEmitter::emitFlipFixedPointIntAP(SourceInfo L) {
24109 if (!isActive()) return true;
24110 CurrentSource = L;
24111 return Flip<PT_FixedPoint, PT_IntAP>(S);
24112}
24113bool EvalEmitter::emitFlipFixedPointIntAPS(SourceInfo L) {
24114 if (!isActive()) return true;
24115 CurrentSource = L;
24116 return Flip<PT_FixedPoint, PT_IntAPS>(S);
24117}
24118bool EvalEmitter::emitFlipFixedPointBool(SourceInfo L) {
24119 if (!isActive()) return true;
24120 CurrentSource = L;
24121 return Flip<PT_FixedPoint, PT_Bool>(S);
24122}
24123bool EvalEmitter::emitFlipFixedPointFixedPoint(SourceInfo L) {
24124 if (!isActive()) return true;
24125 CurrentSource = L;
24126 return Flip<PT_FixedPoint, PT_FixedPoint>(S);
24127}
24128bool EvalEmitter::emitFlipFixedPointPtr(SourceInfo L) {
24129 if (!isActive()) return true;
24130 CurrentSource = L;
24131 return Flip<PT_FixedPoint, PT_Ptr>(S);
24132}
24133bool EvalEmitter::emitFlipFixedPointMemberPtr(SourceInfo L) {
24134 if (!isActive()) return true;
24135 CurrentSource = L;
24136 return Flip<PT_FixedPoint, PT_MemberPtr>(S);
24137}
24138bool EvalEmitter::emitFlipFixedPointFloat(SourceInfo L) {
24139 if (!isActive()) return true;
24140 CurrentSource = L;
24141 return Flip<PT_FixedPoint, PT_Float>(S);
24142}
24143bool EvalEmitter::emitFlipFixedPointReflect(SourceInfo L) {
24144 if (!isActive()) return true;
24145 CurrentSource = L;
24146 return Flip<PT_FixedPoint, PT_Reflect>(S);
24147}
24148bool EvalEmitter::emitFlipPtrSint8(SourceInfo L) {
24149 if (!isActive()) return true;
24150 CurrentSource = L;
24151 return Flip<PT_Ptr, PT_Sint8>(S);
24152}
24153bool EvalEmitter::emitFlipPtrUint8(SourceInfo L) {
24154 if (!isActive()) return true;
24155 CurrentSource = L;
24156 return Flip<PT_Ptr, PT_Uint8>(S);
24157}
24158bool EvalEmitter::emitFlipPtrSint16(SourceInfo L) {
24159 if (!isActive()) return true;
24160 CurrentSource = L;
24161 return Flip<PT_Ptr, PT_Sint16>(S);
24162}
24163bool EvalEmitter::emitFlipPtrUint16(SourceInfo L) {
24164 if (!isActive()) return true;
24165 CurrentSource = L;
24166 return Flip<PT_Ptr, PT_Uint16>(S);
24167}
24168bool EvalEmitter::emitFlipPtrSint32(SourceInfo L) {
24169 if (!isActive()) return true;
24170 CurrentSource = L;
24171 return Flip<PT_Ptr, PT_Sint32>(S);
24172}
24173bool EvalEmitter::emitFlipPtrUint32(SourceInfo L) {
24174 if (!isActive()) return true;
24175 CurrentSource = L;
24176 return Flip<PT_Ptr, PT_Uint32>(S);
24177}
24178bool EvalEmitter::emitFlipPtrSint64(SourceInfo L) {
24179 if (!isActive()) return true;
24180 CurrentSource = L;
24181 return Flip<PT_Ptr, PT_Sint64>(S);
24182}
24183bool EvalEmitter::emitFlipPtrUint64(SourceInfo L) {
24184 if (!isActive()) return true;
24185 CurrentSource = L;
24186 return Flip<PT_Ptr, PT_Uint64>(S);
24187}
24188bool EvalEmitter::emitFlipPtrIntAP(SourceInfo L) {
24189 if (!isActive()) return true;
24190 CurrentSource = L;
24191 return Flip<PT_Ptr, PT_IntAP>(S);
24192}
24193bool EvalEmitter::emitFlipPtrIntAPS(SourceInfo L) {
24194 if (!isActive()) return true;
24195 CurrentSource = L;
24196 return Flip<PT_Ptr, PT_IntAPS>(S);
24197}
24198bool EvalEmitter::emitFlipPtrBool(SourceInfo L) {
24199 if (!isActive()) return true;
24200 CurrentSource = L;
24201 return Flip<PT_Ptr, PT_Bool>(S);
24202}
24203bool EvalEmitter::emitFlipPtrFixedPoint(SourceInfo L) {
24204 if (!isActive()) return true;
24205 CurrentSource = L;
24206 return Flip<PT_Ptr, PT_FixedPoint>(S);
24207}
24208bool EvalEmitter::emitFlipPtrPtr(SourceInfo L) {
24209 if (!isActive()) return true;
24210 CurrentSource = L;
24211 return Flip<PT_Ptr, PT_Ptr>(S);
24212}
24213bool EvalEmitter::emitFlipPtrMemberPtr(SourceInfo L) {
24214 if (!isActive()) return true;
24215 CurrentSource = L;
24216 return Flip<PT_Ptr, PT_MemberPtr>(S);
24217}
24218bool EvalEmitter::emitFlipPtrFloat(SourceInfo L) {
24219 if (!isActive()) return true;
24220 CurrentSource = L;
24221 return Flip<PT_Ptr, PT_Float>(S);
24222}
24223bool EvalEmitter::emitFlipPtrReflect(SourceInfo L) {
24224 if (!isActive()) return true;
24225 CurrentSource = L;
24226 return Flip<PT_Ptr, PT_Reflect>(S);
24227}
24228bool EvalEmitter::emitFlipMemberPtrSint8(SourceInfo L) {
24229 if (!isActive()) return true;
24230 CurrentSource = L;
24231 return Flip<PT_MemberPtr, PT_Sint8>(S);
24232}
24233bool EvalEmitter::emitFlipMemberPtrUint8(SourceInfo L) {
24234 if (!isActive()) return true;
24235 CurrentSource = L;
24236 return Flip<PT_MemberPtr, PT_Uint8>(S);
24237}
24238bool EvalEmitter::emitFlipMemberPtrSint16(SourceInfo L) {
24239 if (!isActive()) return true;
24240 CurrentSource = L;
24241 return Flip<PT_MemberPtr, PT_Sint16>(S);
24242}
24243bool EvalEmitter::emitFlipMemberPtrUint16(SourceInfo L) {
24244 if (!isActive()) return true;
24245 CurrentSource = L;
24246 return Flip<PT_MemberPtr, PT_Uint16>(S);
24247}
24248bool EvalEmitter::emitFlipMemberPtrSint32(SourceInfo L) {
24249 if (!isActive()) return true;
24250 CurrentSource = L;
24251 return Flip<PT_MemberPtr, PT_Sint32>(S);
24252}
24253bool EvalEmitter::emitFlipMemberPtrUint32(SourceInfo L) {
24254 if (!isActive()) return true;
24255 CurrentSource = L;
24256 return Flip<PT_MemberPtr, PT_Uint32>(S);
24257}
24258bool EvalEmitter::emitFlipMemberPtrSint64(SourceInfo L) {
24259 if (!isActive()) return true;
24260 CurrentSource = L;
24261 return Flip<PT_MemberPtr, PT_Sint64>(S);
24262}
24263bool EvalEmitter::emitFlipMemberPtrUint64(SourceInfo L) {
24264 if (!isActive()) return true;
24265 CurrentSource = L;
24266 return Flip<PT_MemberPtr, PT_Uint64>(S);
24267}
24268bool EvalEmitter::emitFlipMemberPtrIntAP(SourceInfo L) {
24269 if (!isActive()) return true;
24270 CurrentSource = L;
24271 return Flip<PT_MemberPtr, PT_IntAP>(S);
24272}
24273bool EvalEmitter::emitFlipMemberPtrIntAPS(SourceInfo L) {
24274 if (!isActive()) return true;
24275 CurrentSource = L;
24276 return Flip<PT_MemberPtr, PT_IntAPS>(S);
24277}
24278bool EvalEmitter::emitFlipMemberPtrBool(SourceInfo L) {
24279 if (!isActive()) return true;
24280 CurrentSource = L;
24281 return Flip<PT_MemberPtr, PT_Bool>(S);
24282}
24283bool EvalEmitter::emitFlipMemberPtrFixedPoint(SourceInfo L) {
24284 if (!isActive()) return true;
24285 CurrentSource = L;
24286 return Flip<PT_MemberPtr, PT_FixedPoint>(S);
24287}
24288bool EvalEmitter::emitFlipMemberPtrPtr(SourceInfo L) {
24289 if (!isActive()) return true;
24290 CurrentSource = L;
24291 return Flip<PT_MemberPtr, PT_Ptr>(S);
24292}
24293bool EvalEmitter::emitFlipMemberPtrMemberPtr(SourceInfo L) {
24294 if (!isActive()) return true;
24295 CurrentSource = L;
24296 return Flip<PT_MemberPtr, PT_MemberPtr>(S);
24297}
24298bool EvalEmitter::emitFlipMemberPtrFloat(SourceInfo L) {
24299 if (!isActive()) return true;
24300 CurrentSource = L;
24301 return Flip<PT_MemberPtr, PT_Float>(S);
24302}
24303bool EvalEmitter::emitFlipMemberPtrReflect(SourceInfo L) {
24304 if (!isActive()) return true;
24305 CurrentSource = L;
24306 return Flip<PT_MemberPtr, PT_Reflect>(S);
24307}
24308bool EvalEmitter::emitFlipFloatSint8(SourceInfo L) {
24309 if (!isActive()) return true;
24310 CurrentSource = L;
24311 return Flip<PT_Float, PT_Sint8>(S);
24312}
24313bool EvalEmitter::emitFlipFloatUint8(SourceInfo L) {
24314 if (!isActive()) return true;
24315 CurrentSource = L;
24316 return Flip<PT_Float, PT_Uint8>(S);
24317}
24318bool EvalEmitter::emitFlipFloatSint16(SourceInfo L) {
24319 if (!isActive()) return true;
24320 CurrentSource = L;
24321 return Flip<PT_Float, PT_Sint16>(S);
24322}
24323bool EvalEmitter::emitFlipFloatUint16(SourceInfo L) {
24324 if (!isActive()) return true;
24325 CurrentSource = L;
24326 return Flip<PT_Float, PT_Uint16>(S);
24327}
24328bool EvalEmitter::emitFlipFloatSint32(SourceInfo L) {
24329 if (!isActive()) return true;
24330 CurrentSource = L;
24331 return Flip<PT_Float, PT_Sint32>(S);
24332}
24333bool EvalEmitter::emitFlipFloatUint32(SourceInfo L) {
24334 if (!isActive()) return true;
24335 CurrentSource = L;
24336 return Flip<PT_Float, PT_Uint32>(S);
24337}
24338bool EvalEmitter::emitFlipFloatSint64(SourceInfo L) {
24339 if (!isActive()) return true;
24340 CurrentSource = L;
24341 return Flip<PT_Float, PT_Sint64>(S);
24342}
24343bool EvalEmitter::emitFlipFloatUint64(SourceInfo L) {
24344 if (!isActive()) return true;
24345 CurrentSource = L;
24346 return Flip<PT_Float, PT_Uint64>(S);
24347}
24348bool EvalEmitter::emitFlipFloatIntAP(SourceInfo L) {
24349 if (!isActive()) return true;
24350 CurrentSource = L;
24351 return Flip<PT_Float, PT_IntAP>(S);
24352}
24353bool EvalEmitter::emitFlipFloatIntAPS(SourceInfo L) {
24354 if (!isActive()) return true;
24355 CurrentSource = L;
24356 return Flip<PT_Float, PT_IntAPS>(S);
24357}
24358bool EvalEmitter::emitFlipFloatBool(SourceInfo L) {
24359 if (!isActive()) return true;
24360 CurrentSource = L;
24361 return Flip<PT_Float, PT_Bool>(S);
24362}
24363bool EvalEmitter::emitFlipFloatFixedPoint(SourceInfo L) {
24364 if (!isActive()) return true;
24365 CurrentSource = L;
24366 return Flip<PT_Float, PT_FixedPoint>(S);
24367}
24368bool EvalEmitter::emitFlipFloatPtr(SourceInfo L) {
24369 if (!isActive()) return true;
24370 CurrentSource = L;
24371 return Flip<PT_Float, PT_Ptr>(S);
24372}
24373bool EvalEmitter::emitFlipFloatMemberPtr(SourceInfo L) {
24374 if (!isActive()) return true;
24375 CurrentSource = L;
24376 return Flip<PT_Float, PT_MemberPtr>(S);
24377}
24378bool EvalEmitter::emitFlipFloatFloat(SourceInfo L) {
24379 if (!isActive()) return true;
24380 CurrentSource = L;
24381 return Flip<PT_Float, PT_Float>(S);
24382}
24383bool EvalEmitter::emitFlipFloatReflect(SourceInfo L) {
24384 if (!isActive()) return true;
24385 CurrentSource = L;
24386 return Flip<PT_Float, PT_Reflect>(S);
24387}
24388bool EvalEmitter::emitFlipReflectSint8(SourceInfo L) {
24389 if (!isActive()) return true;
24390 CurrentSource = L;
24391 return Flip<PT_Reflect, PT_Sint8>(S);
24392}
24393bool EvalEmitter::emitFlipReflectUint8(SourceInfo L) {
24394 if (!isActive()) return true;
24395 CurrentSource = L;
24396 return Flip<PT_Reflect, PT_Uint8>(S);
24397}
24398bool EvalEmitter::emitFlipReflectSint16(SourceInfo L) {
24399 if (!isActive()) return true;
24400 CurrentSource = L;
24401 return Flip<PT_Reflect, PT_Sint16>(S);
24402}
24403bool EvalEmitter::emitFlipReflectUint16(SourceInfo L) {
24404 if (!isActive()) return true;
24405 CurrentSource = L;
24406 return Flip<PT_Reflect, PT_Uint16>(S);
24407}
24408bool EvalEmitter::emitFlipReflectSint32(SourceInfo L) {
24409 if (!isActive()) return true;
24410 CurrentSource = L;
24411 return Flip<PT_Reflect, PT_Sint32>(S);
24412}
24413bool EvalEmitter::emitFlipReflectUint32(SourceInfo L) {
24414 if (!isActive()) return true;
24415 CurrentSource = L;
24416 return Flip<PT_Reflect, PT_Uint32>(S);
24417}
24418bool EvalEmitter::emitFlipReflectSint64(SourceInfo L) {
24419 if (!isActive()) return true;
24420 CurrentSource = L;
24421 return Flip<PT_Reflect, PT_Sint64>(S);
24422}
24423bool EvalEmitter::emitFlipReflectUint64(SourceInfo L) {
24424 if (!isActive()) return true;
24425 CurrentSource = L;
24426 return Flip<PT_Reflect, PT_Uint64>(S);
24427}
24428bool EvalEmitter::emitFlipReflectIntAP(SourceInfo L) {
24429 if (!isActive()) return true;
24430 CurrentSource = L;
24431 return Flip<PT_Reflect, PT_IntAP>(S);
24432}
24433bool EvalEmitter::emitFlipReflectIntAPS(SourceInfo L) {
24434 if (!isActive()) return true;
24435 CurrentSource = L;
24436 return Flip<PT_Reflect, PT_IntAPS>(S);
24437}
24438bool EvalEmitter::emitFlipReflectBool(SourceInfo L) {
24439 if (!isActive()) return true;
24440 CurrentSource = L;
24441 return Flip<PT_Reflect, PT_Bool>(S);
24442}
24443bool EvalEmitter::emitFlipReflectFixedPoint(SourceInfo L) {
24444 if (!isActive()) return true;
24445 CurrentSource = L;
24446 return Flip<PT_Reflect, PT_FixedPoint>(S);
24447}
24448bool EvalEmitter::emitFlipReflectPtr(SourceInfo L) {
24449 if (!isActive()) return true;
24450 CurrentSource = L;
24451 return Flip<PT_Reflect, PT_Ptr>(S);
24452}
24453bool EvalEmitter::emitFlipReflectMemberPtr(SourceInfo L) {
24454 if (!isActive()) return true;
24455 CurrentSource = L;
24456 return Flip<PT_Reflect, PT_MemberPtr>(S);
24457}
24458bool EvalEmitter::emitFlipReflectFloat(SourceInfo L) {
24459 if (!isActive()) return true;
24460 CurrentSource = L;
24461 return Flip<PT_Reflect, PT_Float>(S);
24462}
24463bool EvalEmitter::emitFlipReflectReflect(SourceInfo L) {
24464 if (!isActive()) return true;
24465 CurrentSource = L;
24466 return Flip<PT_Reflect, PT_Reflect>(S);
24467}
24468#endif
24469#ifdef GET_OPCODE_NAMES
24470OP_FnPtrCast,
24471#endif
24472#ifdef GET_INTERPFN_LIST
24473&Interp_FnPtrCast,
24474#endif
24475#ifdef GET_INTERPFN_DISPATCHERS
24476PRESERVE_NONE
24477static bool Interp_FnPtrCast(InterpState &S) {
24478 if (!FnPtrCast(S, S.PC)) return false;
24479#if USE_TAILCALLS
24480 MUSTTAIL return InterpNext(S);
24481#else
24482 return true;
24483#endif
24484}
24485#endif
24486#ifdef GET_DISASM
24487case OP_FnPtrCast:
24488 Text.Op = PrintName("FnPtrCast");
24489 break;
24490#endif
24491#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
24492bool emitFnPtrCast(SourceInfo);
24493#endif
24494#ifdef GET_LINK_IMPL
24495bool ByteCodeEmitter::emitFnPtrCast(SourceInfo L) {
24496 return emitOp<>(OP_FnPtrCast, L);
24497}
24498#endif
24499#ifdef GET_EVAL_IMPL
24500bool EvalEmitter::emitFnPtrCast(SourceInfo L) {
24501 if (!isActive()) return true;
24502 CurrentSource = L;
24503 return FnPtrCast(S, CodePtr());
24504}
24505#endif
24506#ifdef GET_OPCODE_NAMES
24507OP_Free,
24508#endif
24509#ifdef GET_INTERPFN_LIST
24510&Interp_Free,
24511#endif
24512#ifdef GET_INTERPFN_DISPATCHERS
24513PRESERVE_NONE
24514static bool Interp_Free(InterpState &S) {
24515 {
24516 CodePtr OpPC = S.PC;
24517 const auto V0 = ReadArg<bool>(S, S.PC);
24518 const auto V1 = ReadArg<bool>(S, S.PC);
24519 if (!Free(S, OpPC, V0, V1)) return false;
24520 }
24521#if USE_TAILCALLS
24522 MUSTTAIL return InterpNext(S);
24523#else
24524 return true;
24525#endif
24526}
24527#endif
24528#ifdef GET_DISASM
24529case OP_Free:
24530 Text.Op = PrintName("Free");
24531 Text.Args.push_back(printArg<bool>(PC));
24532 Text.Args.push_back(printArg<bool>(PC));
24533 break;
24534#endif
24535#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
24536bool emitFree( bool , bool , SourceInfo);
24537#endif
24538#ifdef GET_LINK_IMPL
24539bool ByteCodeEmitter::emitFree( bool A0, bool A1, SourceInfo L) {
24540 return emitOp<bool, bool>(OP_Free, A0, A1, L);
24541}
24542#endif
24543#ifdef GET_EVAL_IMPL
24544bool EvalEmitter::emitFree( bool A0, bool A1, SourceInfo L) {
24545 if (!isActive()) return true;
24546 CurrentSource = L;
24547 return Free(S, CodePtr(), A0, A1);
24548}
24549#endif
24550#ifdef GET_OPCODE_NAMES
24551OP_GESint8,
24552OP_GEUint8,
24553OP_GESint16,
24554OP_GEUint16,
24555OP_GESint32,
24556OP_GEUint32,
24557OP_GESint64,
24558OP_GEUint64,
24559OP_GEIntAP,
24560OP_GEIntAPS,
24561OP_GEBool,
24562OP_GEFixedPoint,
24563OP_GEPtr,
24564OP_GEFloat,
24565#endif
24566#ifdef GET_INTERPFN_LIST
24567&Interp_GESint8,
24568&Interp_GEUint8,
24569&Interp_GESint16,
24570&Interp_GEUint16,
24571&Interp_GESint32,
24572&Interp_GEUint32,
24573&Interp_GESint64,
24574&Interp_GEUint64,
24575&Interp_GEIntAP,
24576&Interp_GEIntAPS,
24577&Interp_GEBool,
24578&Interp_GEFixedPoint,
24579&Interp_GEPtr,
24580&Interp_GEFloat,
24581#endif
24582#ifdef GET_INTERPFN_DISPATCHERS
24583PRESERVE_NONE
24584static bool Interp_GESint8(InterpState &S) {
24585 if (!GE<PT_Sint8>(S, S.PC)) return false;
24586#if USE_TAILCALLS
24587 MUSTTAIL return InterpNext(S);
24588#else
24589 return true;
24590#endif
24591}
24592PRESERVE_NONE
24593static bool Interp_GEUint8(InterpState &S) {
24594 if (!GE<PT_Uint8>(S, S.PC)) return false;
24595#if USE_TAILCALLS
24596 MUSTTAIL return InterpNext(S);
24597#else
24598 return true;
24599#endif
24600}
24601PRESERVE_NONE
24602static bool Interp_GESint16(InterpState &S) {
24603 if (!GE<PT_Sint16>(S, S.PC)) return false;
24604#if USE_TAILCALLS
24605 MUSTTAIL return InterpNext(S);
24606#else
24607 return true;
24608#endif
24609}
24610PRESERVE_NONE
24611static bool Interp_GEUint16(InterpState &S) {
24612 if (!GE<PT_Uint16>(S, S.PC)) return false;
24613#if USE_TAILCALLS
24614 MUSTTAIL return InterpNext(S);
24615#else
24616 return true;
24617#endif
24618}
24619PRESERVE_NONE
24620static bool Interp_GESint32(InterpState &S) {
24621 if (!GE<PT_Sint32>(S, S.PC)) return false;
24622#if USE_TAILCALLS
24623 MUSTTAIL return InterpNext(S);
24624#else
24625 return true;
24626#endif
24627}
24628PRESERVE_NONE
24629static bool Interp_GEUint32(InterpState &S) {
24630 if (!GE<PT_Uint32>(S, S.PC)) return false;
24631#if USE_TAILCALLS
24632 MUSTTAIL return InterpNext(S);
24633#else
24634 return true;
24635#endif
24636}
24637PRESERVE_NONE
24638static bool Interp_GESint64(InterpState &S) {
24639 if (!GE<PT_Sint64>(S, S.PC)) return false;
24640#if USE_TAILCALLS
24641 MUSTTAIL return InterpNext(S);
24642#else
24643 return true;
24644#endif
24645}
24646PRESERVE_NONE
24647static bool Interp_GEUint64(InterpState &S) {
24648 if (!GE<PT_Uint64>(S, S.PC)) return false;
24649#if USE_TAILCALLS
24650 MUSTTAIL return InterpNext(S);
24651#else
24652 return true;
24653#endif
24654}
24655PRESERVE_NONE
24656static bool Interp_GEIntAP(InterpState &S) {
24657 if (!GE<PT_IntAP>(S, S.PC)) return false;
24658#if USE_TAILCALLS
24659 MUSTTAIL return InterpNext(S);
24660#else
24661 return true;
24662#endif
24663}
24664PRESERVE_NONE
24665static bool Interp_GEIntAPS(InterpState &S) {
24666 if (!GE<PT_IntAPS>(S, S.PC)) return false;
24667#if USE_TAILCALLS
24668 MUSTTAIL return InterpNext(S);
24669#else
24670 return true;
24671#endif
24672}
24673PRESERVE_NONE
24674static bool Interp_GEBool(InterpState &S) {
24675 if (!GE<PT_Bool>(S, S.PC)) return false;
24676#if USE_TAILCALLS
24677 MUSTTAIL return InterpNext(S);
24678#else
24679 return true;
24680#endif
24681}
24682PRESERVE_NONE
24683static bool Interp_GEFixedPoint(InterpState &S) {
24684 if (!GE<PT_FixedPoint>(S, S.PC)) return false;
24685#if USE_TAILCALLS
24686 MUSTTAIL return InterpNext(S);
24687#else
24688 return true;
24689#endif
24690}
24691PRESERVE_NONE
24692static bool Interp_GEPtr(InterpState &S) {
24693 if (!GE<PT_Ptr>(S, S.PC)) return false;
24694#if USE_TAILCALLS
24695 MUSTTAIL return InterpNext(S);
24696#else
24697 return true;
24698#endif
24699}
24700PRESERVE_NONE
24701static bool Interp_GEFloat(InterpState &S) {
24702 if (!GE<PT_Float>(S, S.PC)) return false;
24703#if USE_TAILCALLS
24704 MUSTTAIL return InterpNext(S);
24705#else
24706 return true;
24707#endif
24708}
24709#endif
24710#ifdef GET_DISASM
24711case OP_GESint8:
24712 Text.Op = PrintName("GESint8");
24713 break;
24714case OP_GEUint8:
24715 Text.Op = PrintName("GEUint8");
24716 break;
24717case OP_GESint16:
24718 Text.Op = PrintName("GESint16");
24719 break;
24720case OP_GEUint16:
24721 Text.Op = PrintName("GEUint16");
24722 break;
24723case OP_GESint32:
24724 Text.Op = PrintName("GESint32");
24725 break;
24726case OP_GEUint32:
24727 Text.Op = PrintName("GEUint32");
24728 break;
24729case OP_GESint64:
24730 Text.Op = PrintName("GESint64");
24731 break;
24732case OP_GEUint64:
24733 Text.Op = PrintName("GEUint64");
24734 break;
24735case OP_GEIntAP:
24736 Text.Op = PrintName("GEIntAP");
24737 break;
24738case OP_GEIntAPS:
24739 Text.Op = PrintName("GEIntAPS");
24740 break;
24741case OP_GEBool:
24742 Text.Op = PrintName("GEBool");
24743 break;
24744case OP_GEFixedPoint:
24745 Text.Op = PrintName("GEFixedPoint");
24746 break;
24747case OP_GEPtr:
24748 Text.Op = PrintName("GEPtr");
24749 break;
24750case OP_GEFloat:
24751 Text.Op = PrintName("GEFloat");
24752 break;
24753#endif
24754#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
24755bool emitGESint8(SourceInfo);
24756bool emitGEUint8(SourceInfo);
24757bool emitGESint16(SourceInfo);
24758bool emitGEUint16(SourceInfo);
24759bool emitGESint32(SourceInfo);
24760bool emitGEUint32(SourceInfo);
24761bool emitGESint64(SourceInfo);
24762bool emitGEUint64(SourceInfo);
24763bool emitGEIntAP(SourceInfo);
24764bool emitGEIntAPS(SourceInfo);
24765bool emitGEBool(SourceInfo);
24766bool emitGEFixedPoint(SourceInfo);
24767bool emitGEPtr(SourceInfo);
24768bool emitGEFloat(SourceInfo);
24769#endif
24770#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
24771[[nodiscard]] bool emitGE(PrimType, SourceInfo I);
24772#endif
24773#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
24774bool
24775#if defined(GET_EVAL_IMPL)
24776EvalEmitter
24777#else
24778ByteCodeEmitter
24779#endif
24780::emitGE(PrimType T0, SourceInfo I) {
24781 switch (T0) {
24782 case PT_Sint8:
24783 return emitGESint8(I);
24784 case PT_Uint8:
24785 return emitGEUint8(I);
24786 case PT_Sint16:
24787 return emitGESint16(I);
24788 case PT_Uint16:
24789 return emitGEUint16(I);
24790 case PT_Sint32:
24791 return emitGESint32(I);
24792 case PT_Uint32:
24793 return emitGEUint32(I);
24794 case PT_Sint64:
24795 return emitGESint64(I);
24796 case PT_Uint64:
24797 return emitGEUint64(I);
24798 case PT_IntAP:
24799 return emitGEIntAP(I);
24800 case PT_IntAPS:
24801 return emitGEIntAPS(I);
24802 case PT_Bool:
24803 return emitGEBool(I);
24804 case PT_FixedPoint:
24805 return emitGEFixedPoint(I);
24806 case PT_Ptr:
24807 return emitGEPtr(I);
24808 case PT_Float:
24809 return emitGEFloat(I);
24810 default: llvm_unreachable("invalid type: emitGE");
24811 }
24812 llvm_unreachable("invalid enum value");
24813}
24814#endif
24815#ifdef GET_LINK_IMPL
24816bool ByteCodeEmitter::emitGESint8(SourceInfo L) {
24817 return emitOp<>(OP_GESint8, L);
24818}
24819bool ByteCodeEmitter::emitGEUint8(SourceInfo L) {
24820 return emitOp<>(OP_GEUint8, L);
24821}
24822bool ByteCodeEmitter::emitGESint16(SourceInfo L) {
24823 return emitOp<>(OP_GESint16, L);
24824}
24825bool ByteCodeEmitter::emitGEUint16(SourceInfo L) {
24826 return emitOp<>(OP_GEUint16, L);
24827}
24828bool ByteCodeEmitter::emitGESint32(SourceInfo L) {
24829 return emitOp<>(OP_GESint32, L);
24830}
24831bool ByteCodeEmitter::emitGEUint32(SourceInfo L) {
24832 return emitOp<>(OP_GEUint32, L);
24833}
24834bool ByteCodeEmitter::emitGESint64(SourceInfo L) {
24835 return emitOp<>(OP_GESint64, L);
24836}
24837bool ByteCodeEmitter::emitGEUint64(SourceInfo L) {
24838 return emitOp<>(OP_GEUint64, L);
24839}
24840bool ByteCodeEmitter::emitGEIntAP(SourceInfo L) {
24841 return emitOp<>(OP_GEIntAP, L);
24842}
24843bool ByteCodeEmitter::emitGEIntAPS(SourceInfo L) {
24844 return emitOp<>(OP_GEIntAPS, L);
24845}
24846bool ByteCodeEmitter::emitGEBool(SourceInfo L) {
24847 return emitOp<>(OP_GEBool, L);
24848}
24849bool ByteCodeEmitter::emitGEFixedPoint(SourceInfo L) {
24850 return emitOp<>(OP_GEFixedPoint, L);
24851}
24852bool ByteCodeEmitter::emitGEPtr(SourceInfo L) {
24853 return emitOp<>(OP_GEPtr, L);
24854}
24855bool ByteCodeEmitter::emitGEFloat(SourceInfo L) {
24856 return emitOp<>(OP_GEFloat, L);
24857}
24858#endif
24859#ifdef GET_EVAL_IMPL
24860bool EvalEmitter::emitGESint8(SourceInfo L) {
24861 if (!isActive()) return true;
24862 CurrentSource = L;
24863 return GE<PT_Sint8>(S, CodePtr());
24864}
24865bool EvalEmitter::emitGEUint8(SourceInfo L) {
24866 if (!isActive()) return true;
24867 CurrentSource = L;
24868 return GE<PT_Uint8>(S, CodePtr());
24869}
24870bool EvalEmitter::emitGESint16(SourceInfo L) {
24871 if (!isActive()) return true;
24872 CurrentSource = L;
24873 return GE<PT_Sint16>(S, CodePtr());
24874}
24875bool EvalEmitter::emitGEUint16(SourceInfo L) {
24876 if (!isActive()) return true;
24877 CurrentSource = L;
24878 return GE<PT_Uint16>(S, CodePtr());
24879}
24880bool EvalEmitter::emitGESint32(SourceInfo L) {
24881 if (!isActive()) return true;
24882 CurrentSource = L;
24883 return GE<PT_Sint32>(S, CodePtr());
24884}
24885bool EvalEmitter::emitGEUint32(SourceInfo L) {
24886 if (!isActive()) return true;
24887 CurrentSource = L;
24888 return GE<PT_Uint32>(S, CodePtr());
24889}
24890bool EvalEmitter::emitGESint64(SourceInfo L) {
24891 if (!isActive()) return true;
24892 CurrentSource = L;
24893 return GE<PT_Sint64>(S, CodePtr());
24894}
24895bool EvalEmitter::emitGEUint64(SourceInfo L) {
24896 if (!isActive()) return true;
24897 CurrentSource = L;
24898 return GE<PT_Uint64>(S, CodePtr());
24899}
24900bool EvalEmitter::emitGEIntAP(SourceInfo L) {
24901 if (!isActive()) return true;
24902 CurrentSource = L;
24903 return GE<PT_IntAP>(S, CodePtr());
24904}
24905bool EvalEmitter::emitGEIntAPS(SourceInfo L) {
24906 if (!isActive()) return true;
24907 CurrentSource = L;
24908 return GE<PT_IntAPS>(S, CodePtr());
24909}
24910bool EvalEmitter::emitGEBool(SourceInfo L) {
24911 if (!isActive()) return true;
24912 CurrentSource = L;
24913 return GE<PT_Bool>(S, CodePtr());
24914}
24915bool EvalEmitter::emitGEFixedPoint(SourceInfo L) {
24916 if (!isActive()) return true;
24917 CurrentSource = L;
24918 return GE<PT_FixedPoint>(S, CodePtr());
24919}
24920bool EvalEmitter::emitGEPtr(SourceInfo L) {
24921 if (!isActive()) return true;
24922 CurrentSource = L;
24923 return GE<PT_Ptr>(S, CodePtr());
24924}
24925bool EvalEmitter::emitGEFloat(SourceInfo L) {
24926 if (!isActive()) return true;
24927 CurrentSource = L;
24928 return GE<PT_Float>(S, CodePtr());
24929}
24930#endif
24931#ifdef GET_OPCODE_NAMES
24932OP_GTSint8,
24933OP_GTUint8,
24934OP_GTSint16,
24935OP_GTUint16,
24936OP_GTSint32,
24937OP_GTUint32,
24938OP_GTSint64,
24939OP_GTUint64,
24940OP_GTIntAP,
24941OP_GTIntAPS,
24942OP_GTBool,
24943OP_GTFixedPoint,
24944OP_GTPtr,
24945OP_GTFloat,
24946#endif
24947#ifdef GET_INTERPFN_LIST
24948&Interp_GTSint8,
24949&Interp_GTUint8,
24950&Interp_GTSint16,
24951&Interp_GTUint16,
24952&Interp_GTSint32,
24953&Interp_GTUint32,
24954&Interp_GTSint64,
24955&Interp_GTUint64,
24956&Interp_GTIntAP,
24957&Interp_GTIntAPS,
24958&Interp_GTBool,
24959&Interp_GTFixedPoint,
24960&Interp_GTPtr,
24961&Interp_GTFloat,
24962#endif
24963#ifdef GET_INTERPFN_DISPATCHERS
24964PRESERVE_NONE
24965static bool Interp_GTSint8(InterpState &S) {
24966 if (!GT<PT_Sint8>(S, S.PC)) return false;
24967#if USE_TAILCALLS
24968 MUSTTAIL return InterpNext(S);
24969#else
24970 return true;
24971#endif
24972}
24973PRESERVE_NONE
24974static bool Interp_GTUint8(InterpState &S) {
24975 if (!GT<PT_Uint8>(S, S.PC)) return false;
24976#if USE_TAILCALLS
24977 MUSTTAIL return InterpNext(S);
24978#else
24979 return true;
24980#endif
24981}
24982PRESERVE_NONE
24983static bool Interp_GTSint16(InterpState &S) {
24984 if (!GT<PT_Sint16>(S, S.PC)) return false;
24985#if USE_TAILCALLS
24986 MUSTTAIL return InterpNext(S);
24987#else
24988 return true;
24989#endif
24990}
24991PRESERVE_NONE
24992static bool Interp_GTUint16(InterpState &S) {
24993 if (!GT<PT_Uint16>(S, S.PC)) return false;
24994#if USE_TAILCALLS
24995 MUSTTAIL return InterpNext(S);
24996#else
24997 return true;
24998#endif
24999}
25000PRESERVE_NONE
25001static bool Interp_GTSint32(InterpState &S) {
25002 if (!GT<PT_Sint32>(S, S.PC)) return false;
25003#if USE_TAILCALLS
25004 MUSTTAIL return InterpNext(S);
25005#else
25006 return true;
25007#endif
25008}
25009PRESERVE_NONE
25010static bool Interp_GTUint32(InterpState &S) {
25011 if (!GT<PT_Uint32>(S, S.PC)) return false;
25012#if USE_TAILCALLS
25013 MUSTTAIL return InterpNext(S);
25014#else
25015 return true;
25016#endif
25017}
25018PRESERVE_NONE
25019static bool Interp_GTSint64(InterpState &S) {
25020 if (!GT<PT_Sint64>(S, S.PC)) return false;
25021#if USE_TAILCALLS
25022 MUSTTAIL return InterpNext(S);
25023#else
25024 return true;
25025#endif
25026}
25027PRESERVE_NONE
25028static bool Interp_GTUint64(InterpState &S) {
25029 if (!GT<PT_Uint64>(S, S.PC)) return false;
25030#if USE_TAILCALLS
25031 MUSTTAIL return InterpNext(S);
25032#else
25033 return true;
25034#endif
25035}
25036PRESERVE_NONE
25037static bool Interp_GTIntAP(InterpState &S) {
25038 if (!GT<PT_IntAP>(S, S.PC)) return false;
25039#if USE_TAILCALLS
25040 MUSTTAIL return InterpNext(S);
25041#else
25042 return true;
25043#endif
25044}
25045PRESERVE_NONE
25046static bool Interp_GTIntAPS(InterpState &S) {
25047 if (!GT<PT_IntAPS>(S, S.PC)) return false;
25048#if USE_TAILCALLS
25049 MUSTTAIL return InterpNext(S);
25050#else
25051 return true;
25052#endif
25053}
25054PRESERVE_NONE
25055static bool Interp_GTBool(InterpState &S) {
25056 if (!GT<PT_Bool>(S, S.PC)) return false;
25057#if USE_TAILCALLS
25058 MUSTTAIL return InterpNext(S);
25059#else
25060 return true;
25061#endif
25062}
25063PRESERVE_NONE
25064static bool Interp_GTFixedPoint(InterpState &S) {
25065 if (!GT<PT_FixedPoint>(S, S.PC)) return false;
25066#if USE_TAILCALLS
25067 MUSTTAIL return InterpNext(S);
25068#else
25069 return true;
25070#endif
25071}
25072PRESERVE_NONE
25073static bool Interp_GTPtr(InterpState &S) {
25074 if (!GT<PT_Ptr>(S, S.PC)) return false;
25075#if USE_TAILCALLS
25076 MUSTTAIL return InterpNext(S);
25077#else
25078 return true;
25079#endif
25080}
25081PRESERVE_NONE
25082static bool Interp_GTFloat(InterpState &S) {
25083 if (!GT<PT_Float>(S, S.PC)) return false;
25084#if USE_TAILCALLS
25085 MUSTTAIL return InterpNext(S);
25086#else
25087 return true;
25088#endif
25089}
25090#endif
25091#ifdef GET_DISASM
25092case OP_GTSint8:
25093 Text.Op = PrintName("GTSint8");
25094 break;
25095case OP_GTUint8:
25096 Text.Op = PrintName("GTUint8");
25097 break;
25098case OP_GTSint16:
25099 Text.Op = PrintName("GTSint16");
25100 break;
25101case OP_GTUint16:
25102 Text.Op = PrintName("GTUint16");
25103 break;
25104case OP_GTSint32:
25105 Text.Op = PrintName("GTSint32");
25106 break;
25107case OP_GTUint32:
25108 Text.Op = PrintName("GTUint32");
25109 break;
25110case OP_GTSint64:
25111 Text.Op = PrintName("GTSint64");
25112 break;
25113case OP_GTUint64:
25114 Text.Op = PrintName("GTUint64");
25115 break;
25116case OP_GTIntAP:
25117 Text.Op = PrintName("GTIntAP");
25118 break;
25119case OP_GTIntAPS:
25120 Text.Op = PrintName("GTIntAPS");
25121 break;
25122case OP_GTBool:
25123 Text.Op = PrintName("GTBool");
25124 break;
25125case OP_GTFixedPoint:
25126 Text.Op = PrintName("GTFixedPoint");
25127 break;
25128case OP_GTPtr:
25129 Text.Op = PrintName("GTPtr");
25130 break;
25131case OP_GTFloat:
25132 Text.Op = PrintName("GTFloat");
25133 break;
25134#endif
25135#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
25136bool emitGTSint8(SourceInfo);
25137bool emitGTUint8(SourceInfo);
25138bool emitGTSint16(SourceInfo);
25139bool emitGTUint16(SourceInfo);
25140bool emitGTSint32(SourceInfo);
25141bool emitGTUint32(SourceInfo);
25142bool emitGTSint64(SourceInfo);
25143bool emitGTUint64(SourceInfo);
25144bool emitGTIntAP(SourceInfo);
25145bool emitGTIntAPS(SourceInfo);
25146bool emitGTBool(SourceInfo);
25147bool emitGTFixedPoint(SourceInfo);
25148bool emitGTPtr(SourceInfo);
25149bool emitGTFloat(SourceInfo);
25150#endif
25151#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
25152[[nodiscard]] bool emitGT(PrimType, SourceInfo I);
25153#endif
25154#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
25155bool
25156#if defined(GET_EVAL_IMPL)
25157EvalEmitter
25158#else
25159ByteCodeEmitter
25160#endif
25161::emitGT(PrimType T0, SourceInfo I) {
25162 switch (T0) {
25163 case PT_Sint8:
25164 return emitGTSint8(I);
25165 case PT_Uint8:
25166 return emitGTUint8(I);
25167 case PT_Sint16:
25168 return emitGTSint16(I);
25169 case PT_Uint16:
25170 return emitGTUint16(I);
25171 case PT_Sint32:
25172 return emitGTSint32(I);
25173 case PT_Uint32:
25174 return emitGTUint32(I);
25175 case PT_Sint64:
25176 return emitGTSint64(I);
25177 case PT_Uint64:
25178 return emitGTUint64(I);
25179 case PT_IntAP:
25180 return emitGTIntAP(I);
25181 case PT_IntAPS:
25182 return emitGTIntAPS(I);
25183 case PT_Bool:
25184 return emitGTBool(I);
25185 case PT_FixedPoint:
25186 return emitGTFixedPoint(I);
25187 case PT_Ptr:
25188 return emitGTPtr(I);
25189 case PT_Float:
25190 return emitGTFloat(I);
25191 default: llvm_unreachable("invalid type: emitGT");
25192 }
25193 llvm_unreachable("invalid enum value");
25194}
25195#endif
25196#ifdef GET_LINK_IMPL
25197bool ByteCodeEmitter::emitGTSint8(SourceInfo L) {
25198 return emitOp<>(OP_GTSint8, L);
25199}
25200bool ByteCodeEmitter::emitGTUint8(SourceInfo L) {
25201 return emitOp<>(OP_GTUint8, L);
25202}
25203bool ByteCodeEmitter::emitGTSint16(SourceInfo L) {
25204 return emitOp<>(OP_GTSint16, L);
25205}
25206bool ByteCodeEmitter::emitGTUint16(SourceInfo L) {
25207 return emitOp<>(OP_GTUint16, L);
25208}
25209bool ByteCodeEmitter::emitGTSint32(SourceInfo L) {
25210 return emitOp<>(OP_GTSint32, L);
25211}
25212bool ByteCodeEmitter::emitGTUint32(SourceInfo L) {
25213 return emitOp<>(OP_GTUint32, L);
25214}
25215bool ByteCodeEmitter::emitGTSint64(SourceInfo L) {
25216 return emitOp<>(OP_GTSint64, L);
25217}
25218bool ByteCodeEmitter::emitGTUint64(SourceInfo L) {
25219 return emitOp<>(OP_GTUint64, L);
25220}
25221bool ByteCodeEmitter::emitGTIntAP(SourceInfo L) {
25222 return emitOp<>(OP_GTIntAP, L);
25223}
25224bool ByteCodeEmitter::emitGTIntAPS(SourceInfo L) {
25225 return emitOp<>(OP_GTIntAPS, L);
25226}
25227bool ByteCodeEmitter::emitGTBool(SourceInfo L) {
25228 return emitOp<>(OP_GTBool, L);
25229}
25230bool ByteCodeEmitter::emitGTFixedPoint(SourceInfo L) {
25231 return emitOp<>(OP_GTFixedPoint, L);
25232}
25233bool ByteCodeEmitter::emitGTPtr(SourceInfo L) {
25234 return emitOp<>(OP_GTPtr, L);
25235}
25236bool ByteCodeEmitter::emitGTFloat(SourceInfo L) {
25237 return emitOp<>(OP_GTFloat, L);
25238}
25239#endif
25240#ifdef GET_EVAL_IMPL
25241bool EvalEmitter::emitGTSint8(SourceInfo L) {
25242 if (!isActive()) return true;
25243 CurrentSource = L;
25244 return GT<PT_Sint8>(S, CodePtr());
25245}
25246bool EvalEmitter::emitGTUint8(SourceInfo L) {
25247 if (!isActive()) return true;
25248 CurrentSource = L;
25249 return GT<PT_Uint8>(S, CodePtr());
25250}
25251bool EvalEmitter::emitGTSint16(SourceInfo L) {
25252 if (!isActive()) return true;
25253 CurrentSource = L;
25254 return GT<PT_Sint16>(S, CodePtr());
25255}
25256bool EvalEmitter::emitGTUint16(SourceInfo L) {
25257 if (!isActive()) return true;
25258 CurrentSource = L;
25259 return GT<PT_Uint16>(S, CodePtr());
25260}
25261bool EvalEmitter::emitGTSint32(SourceInfo L) {
25262 if (!isActive()) return true;
25263 CurrentSource = L;
25264 return GT<PT_Sint32>(S, CodePtr());
25265}
25266bool EvalEmitter::emitGTUint32(SourceInfo L) {
25267 if (!isActive()) return true;
25268 CurrentSource = L;
25269 return GT<PT_Uint32>(S, CodePtr());
25270}
25271bool EvalEmitter::emitGTSint64(SourceInfo L) {
25272 if (!isActive()) return true;
25273 CurrentSource = L;
25274 return GT<PT_Sint64>(S, CodePtr());
25275}
25276bool EvalEmitter::emitGTUint64(SourceInfo L) {
25277 if (!isActive()) return true;
25278 CurrentSource = L;
25279 return GT<PT_Uint64>(S, CodePtr());
25280}
25281bool EvalEmitter::emitGTIntAP(SourceInfo L) {
25282 if (!isActive()) return true;
25283 CurrentSource = L;
25284 return GT<PT_IntAP>(S, CodePtr());
25285}
25286bool EvalEmitter::emitGTIntAPS(SourceInfo L) {
25287 if (!isActive()) return true;
25288 CurrentSource = L;
25289 return GT<PT_IntAPS>(S, CodePtr());
25290}
25291bool EvalEmitter::emitGTBool(SourceInfo L) {
25292 if (!isActive()) return true;
25293 CurrentSource = L;
25294 return GT<PT_Bool>(S, CodePtr());
25295}
25296bool EvalEmitter::emitGTFixedPoint(SourceInfo L) {
25297 if (!isActive()) return true;
25298 CurrentSource = L;
25299 return GT<PT_FixedPoint>(S, CodePtr());
25300}
25301bool EvalEmitter::emitGTPtr(SourceInfo L) {
25302 if (!isActive()) return true;
25303 CurrentSource = L;
25304 return GT<PT_Ptr>(S, CodePtr());
25305}
25306bool EvalEmitter::emitGTFloat(SourceInfo L) {
25307 if (!isActive()) return true;
25308 CurrentSource = L;
25309 return GT<PT_Float>(S, CodePtr());
25310}
25311#endif
25312#ifdef GET_OPCODE_NAMES
25313OP_GetFieldSint8,
25314OP_GetFieldUint8,
25315OP_GetFieldSint16,
25316OP_GetFieldUint16,
25317OP_GetFieldSint32,
25318OP_GetFieldUint32,
25319OP_GetFieldSint64,
25320OP_GetFieldUint64,
25321OP_GetFieldIntAP,
25322OP_GetFieldIntAPS,
25323OP_GetFieldBool,
25324OP_GetFieldFixedPoint,
25325OP_GetFieldPtr,
25326OP_GetFieldMemberPtr,
25327OP_GetFieldFloat,
25328OP_GetFieldReflect,
25329#endif
25330#ifdef GET_INTERPFN_LIST
25331&Interp_GetFieldSint8,
25332&Interp_GetFieldUint8,
25333&Interp_GetFieldSint16,
25334&Interp_GetFieldUint16,
25335&Interp_GetFieldSint32,
25336&Interp_GetFieldUint32,
25337&Interp_GetFieldSint64,
25338&Interp_GetFieldUint64,
25339&Interp_GetFieldIntAP,
25340&Interp_GetFieldIntAPS,
25341&Interp_GetFieldBool,
25342&Interp_GetFieldFixedPoint,
25343&Interp_GetFieldPtr,
25344&Interp_GetFieldMemberPtr,
25345&Interp_GetFieldFloat,
25346&Interp_GetFieldReflect,
25347#endif
25348#ifdef GET_INTERPFN_DISPATCHERS
25349PRESERVE_NONE
25350static bool Interp_GetFieldSint8(InterpState &S) {
25351 {
25352 CodePtr OpPC = S.PC;
25353 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25354 if (!GetField<PT_Sint8>(S, OpPC, V0)) return false;
25355 }
25356#if USE_TAILCALLS
25357 MUSTTAIL return InterpNext(S);
25358#else
25359 return true;
25360#endif
25361}
25362PRESERVE_NONE
25363static bool Interp_GetFieldUint8(InterpState &S) {
25364 {
25365 CodePtr OpPC = S.PC;
25366 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25367 if (!GetField<PT_Uint8>(S, OpPC, V0)) return false;
25368 }
25369#if USE_TAILCALLS
25370 MUSTTAIL return InterpNext(S);
25371#else
25372 return true;
25373#endif
25374}
25375PRESERVE_NONE
25376static bool Interp_GetFieldSint16(InterpState &S) {
25377 {
25378 CodePtr OpPC = S.PC;
25379 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25380 if (!GetField<PT_Sint16>(S, OpPC, V0)) return false;
25381 }
25382#if USE_TAILCALLS
25383 MUSTTAIL return InterpNext(S);
25384#else
25385 return true;
25386#endif
25387}
25388PRESERVE_NONE
25389static bool Interp_GetFieldUint16(InterpState &S) {
25390 {
25391 CodePtr OpPC = S.PC;
25392 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25393 if (!GetField<PT_Uint16>(S, OpPC, V0)) return false;
25394 }
25395#if USE_TAILCALLS
25396 MUSTTAIL return InterpNext(S);
25397#else
25398 return true;
25399#endif
25400}
25401PRESERVE_NONE
25402static bool Interp_GetFieldSint32(InterpState &S) {
25403 {
25404 CodePtr OpPC = S.PC;
25405 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25406 if (!GetField<PT_Sint32>(S, OpPC, V0)) return false;
25407 }
25408#if USE_TAILCALLS
25409 MUSTTAIL return InterpNext(S);
25410#else
25411 return true;
25412#endif
25413}
25414PRESERVE_NONE
25415static bool Interp_GetFieldUint32(InterpState &S) {
25416 {
25417 CodePtr OpPC = S.PC;
25418 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25419 if (!GetField<PT_Uint32>(S, OpPC, V0)) return false;
25420 }
25421#if USE_TAILCALLS
25422 MUSTTAIL return InterpNext(S);
25423#else
25424 return true;
25425#endif
25426}
25427PRESERVE_NONE
25428static bool Interp_GetFieldSint64(InterpState &S) {
25429 {
25430 CodePtr OpPC = S.PC;
25431 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25432 if (!GetField<PT_Sint64>(S, OpPC, V0)) return false;
25433 }
25434#if USE_TAILCALLS
25435 MUSTTAIL return InterpNext(S);
25436#else
25437 return true;
25438#endif
25439}
25440PRESERVE_NONE
25441static bool Interp_GetFieldUint64(InterpState &S) {
25442 {
25443 CodePtr OpPC = S.PC;
25444 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25445 if (!GetField<PT_Uint64>(S, OpPC, V0)) return false;
25446 }
25447#if USE_TAILCALLS
25448 MUSTTAIL return InterpNext(S);
25449#else
25450 return true;
25451#endif
25452}
25453PRESERVE_NONE
25454static bool Interp_GetFieldIntAP(InterpState &S) {
25455 {
25456 CodePtr OpPC = S.PC;
25457 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25458 if (!GetField<PT_IntAP>(S, OpPC, V0)) return false;
25459 }
25460#if USE_TAILCALLS
25461 MUSTTAIL return InterpNext(S);
25462#else
25463 return true;
25464#endif
25465}
25466PRESERVE_NONE
25467static bool Interp_GetFieldIntAPS(InterpState &S) {
25468 {
25469 CodePtr OpPC = S.PC;
25470 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25471 if (!GetField<PT_IntAPS>(S, OpPC, V0)) return false;
25472 }
25473#if USE_TAILCALLS
25474 MUSTTAIL return InterpNext(S);
25475#else
25476 return true;
25477#endif
25478}
25479PRESERVE_NONE
25480static bool Interp_GetFieldBool(InterpState &S) {
25481 {
25482 CodePtr OpPC = S.PC;
25483 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25484 if (!GetField<PT_Bool>(S, OpPC, V0)) return false;
25485 }
25486#if USE_TAILCALLS
25487 MUSTTAIL return InterpNext(S);
25488#else
25489 return true;
25490#endif
25491}
25492PRESERVE_NONE
25493static bool Interp_GetFieldFixedPoint(InterpState &S) {
25494 {
25495 CodePtr OpPC = S.PC;
25496 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25497 if (!GetField<PT_FixedPoint>(S, OpPC, V0)) return false;
25498 }
25499#if USE_TAILCALLS
25500 MUSTTAIL return InterpNext(S);
25501#else
25502 return true;
25503#endif
25504}
25505PRESERVE_NONE
25506static bool Interp_GetFieldPtr(InterpState &S) {
25507 {
25508 CodePtr OpPC = S.PC;
25509 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25510 if (!GetField<PT_Ptr>(S, OpPC, V0)) return false;
25511 }
25512#if USE_TAILCALLS
25513 MUSTTAIL return InterpNext(S);
25514#else
25515 return true;
25516#endif
25517}
25518PRESERVE_NONE
25519static bool Interp_GetFieldMemberPtr(InterpState &S) {
25520 {
25521 CodePtr OpPC = S.PC;
25522 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25523 if (!GetField<PT_MemberPtr>(S, OpPC, V0)) return false;
25524 }
25525#if USE_TAILCALLS
25526 MUSTTAIL return InterpNext(S);
25527#else
25528 return true;
25529#endif
25530}
25531PRESERVE_NONE
25532static bool Interp_GetFieldFloat(InterpState &S) {
25533 {
25534 CodePtr OpPC = S.PC;
25535 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25536 if (!GetField<PT_Float>(S, OpPC, V0)) return false;
25537 }
25538#if USE_TAILCALLS
25539 MUSTTAIL return InterpNext(S);
25540#else
25541 return true;
25542#endif
25543}
25544PRESERVE_NONE
25545static bool Interp_GetFieldReflect(InterpState &S) {
25546 {
25547 CodePtr OpPC = S.PC;
25548 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25549 if (!GetField<PT_Reflect>(S, OpPC, V0)) return false;
25550 }
25551#if USE_TAILCALLS
25552 MUSTTAIL return InterpNext(S);
25553#else
25554 return true;
25555#endif
25556}
25557#endif
25558#ifdef GET_DISASM
25559case OP_GetFieldSint8:
25560 Text.Op = PrintName("GetFieldSint8");
25561 Text.Args.push_back(printArg<uint32_t>(PC));
25562 break;
25563case OP_GetFieldUint8:
25564 Text.Op = PrintName("GetFieldUint8");
25565 Text.Args.push_back(printArg<uint32_t>(PC));
25566 break;
25567case OP_GetFieldSint16:
25568 Text.Op = PrintName("GetFieldSint16");
25569 Text.Args.push_back(printArg<uint32_t>(PC));
25570 break;
25571case OP_GetFieldUint16:
25572 Text.Op = PrintName("GetFieldUint16");
25573 Text.Args.push_back(printArg<uint32_t>(PC));
25574 break;
25575case OP_GetFieldSint32:
25576 Text.Op = PrintName("GetFieldSint32");
25577 Text.Args.push_back(printArg<uint32_t>(PC));
25578 break;
25579case OP_GetFieldUint32:
25580 Text.Op = PrintName("GetFieldUint32");
25581 Text.Args.push_back(printArg<uint32_t>(PC));
25582 break;
25583case OP_GetFieldSint64:
25584 Text.Op = PrintName("GetFieldSint64");
25585 Text.Args.push_back(printArg<uint32_t>(PC));
25586 break;
25587case OP_GetFieldUint64:
25588 Text.Op = PrintName("GetFieldUint64");
25589 Text.Args.push_back(printArg<uint32_t>(PC));
25590 break;
25591case OP_GetFieldIntAP:
25592 Text.Op = PrintName("GetFieldIntAP");
25593 Text.Args.push_back(printArg<uint32_t>(PC));
25594 break;
25595case OP_GetFieldIntAPS:
25596 Text.Op = PrintName("GetFieldIntAPS");
25597 Text.Args.push_back(printArg<uint32_t>(PC));
25598 break;
25599case OP_GetFieldBool:
25600 Text.Op = PrintName("GetFieldBool");
25601 Text.Args.push_back(printArg<uint32_t>(PC));
25602 break;
25603case OP_GetFieldFixedPoint:
25604 Text.Op = PrintName("GetFieldFixedPoint");
25605 Text.Args.push_back(printArg<uint32_t>(PC));
25606 break;
25607case OP_GetFieldPtr:
25608 Text.Op = PrintName("GetFieldPtr");
25609 Text.Args.push_back(printArg<uint32_t>(PC));
25610 break;
25611case OP_GetFieldMemberPtr:
25612 Text.Op = PrintName("GetFieldMemberPtr");
25613 Text.Args.push_back(printArg<uint32_t>(PC));
25614 break;
25615case OP_GetFieldFloat:
25616 Text.Op = PrintName("GetFieldFloat");
25617 Text.Args.push_back(printArg<uint32_t>(PC));
25618 break;
25619case OP_GetFieldReflect:
25620 Text.Op = PrintName("GetFieldReflect");
25621 Text.Args.push_back(printArg<uint32_t>(PC));
25622 break;
25623#endif
25624#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
25625bool emitGetFieldSint8( uint32_t , SourceInfo);
25626bool emitGetFieldUint8( uint32_t , SourceInfo);
25627bool emitGetFieldSint16( uint32_t , SourceInfo);
25628bool emitGetFieldUint16( uint32_t , SourceInfo);
25629bool emitGetFieldSint32( uint32_t , SourceInfo);
25630bool emitGetFieldUint32( uint32_t , SourceInfo);
25631bool emitGetFieldSint64( uint32_t , SourceInfo);
25632bool emitGetFieldUint64( uint32_t , SourceInfo);
25633bool emitGetFieldIntAP( uint32_t , SourceInfo);
25634bool emitGetFieldIntAPS( uint32_t , SourceInfo);
25635bool emitGetFieldBool( uint32_t , SourceInfo);
25636bool emitGetFieldFixedPoint( uint32_t , SourceInfo);
25637bool emitGetFieldPtr( uint32_t , SourceInfo);
25638bool emitGetFieldMemberPtr( uint32_t , SourceInfo);
25639bool emitGetFieldFloat( uint32_t , SourceInfo);
25640bool emitGetFieldReflect( uint32_t , SourceInfo);
25641#endif
25642#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
25643[[nodiscard]] bool emitGetField(PrimType, uint32_t, SourceInfo I);
25644#endif
25645#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
25646bool
25647#if defined(GET_EVAL_IMPL)
25648EvalEmitter
25649#else
25650ByteCodeEmitter
25651#endif
25652::emitGetField(PrimType T0, uint32_t A0, SourceInfo I) {
25653 switch (T0) {
25654 case PT_Sint8:
25655 return emitGetFieldSint8(A0, I);
25656 case PT_Uint8:
25657 return emitGetFieldUint8(A0, I);
25658 case PT_Sint16:
25659 return emitGetFieldSint16(A0, I);
25660 case PT_Uint16:
25661 return emitGetFieldUint16(A0, I);
25662 case PT_Sint32:
25663 return emitGetFieldSint32(A0, I);
25664 case PT_Uint32:
25665 return emitGetFieldUint32(A0, I);
25666 case PT_Sint64:
25667 return emitGetFieldSint64(A0, I);
25668 case PT_Uint64:
25669 return emitGetFieldUint64(A0, I);
25670 case PT_IntAP:
25671 return emitGetFieldIntAP(A0, I);
25672 case PT_IntAPS:
25673 return emitGetFieldIntAPS(A0, I);
25674 case PT_Bool:
25675 return emitGetFieldBool(A0, I);
25676 case PT_FixedPoint:
25677 return emitGetFieldFixedPoint(A0, I);
25678 case PT_Ptr:
25679 return emitGetFieldPtr(A0, I);
25680 case PT_MemberPtr:
25681 return emitGetFieldMemberPtr(A0, I);
25682 case PT_Float:
25683 return emitGetFieldFloat(A0, I);
25684 case PT_Reflect:
25685 return emitGetFieldReflect(A0, I);
25686 }
25687 llvm_unreachable("invalid enum value");
25688}
25689#endif
25690#ifdef GET_LINK_IMPL
25691bool ByteCodeEmitter::emitGetFieldSint8( uint32_t A0, SourceInfo L) {
25692 return emitOp<uint32_t>(OP_GetFieldSint8, A0, L);
25693}
25694bool ByteCodeEmitter::emitGetFieldUint8( uint32_t A0, SourceInfo L) {
25695 return emitOp<uint32_t>(OP_GetFieldUint8, A0, L);
25696}
25697bool ByteCodeEmitter::emitGetFieldSint16( uint32_t A0, SourceInfo L) {
25698 return emitOp<uint32_t>(OP_GetFieldSint16, A0, L);
25699}
25700bool ByteCodeEmitter::emitGetFieldUint16( uint32_t A0, SourceInfo L) {
25701 return emitOp<uint32_t>(OP_GetFieldUint16, A0, L);
25702}
25703bool ByteCodeEmitter::emitGetFieldSint32( uint32_t A0, SourceInfo L) {
25704 return emitOp<uint32_t>(OP_GetFieldSint32, A0, L);
25705}
25706bool ByteCodeEmitter::emitGetFieldUint32( uint32_t A0, SourceInfo L) {
25707 return emitOp<uint32_t>(OP_GetFieldUint32, A0, L);
25708}
25709bool ByteCodeEmitter::emitGetFieldSint64( uint32_t A0, SourceInfo L) {
25710 return emitOp<uint32_t>(OP_GetFieldSint64, A0, L);
25711}
25712bool ByteCodeEmitter::emitGetFieldUint64( uint32_t A0, SourceInfo L) {
25713 return emitOp<uint32_t>(OP_GetFieldUint64, A0, L);
25714}
25715bool ByteCodeEmitter::emitGetFieldIntAP( uint32_t A0, SourceInfo L) {
25716 return emitOp<uint32_t>(OP_GetFieldIntAP, A0, L);
25717}
25718bool ByteCodeEmitter::emitGetFieldIntAPS( uint32_t A0, SourceInfo L) {
25719 return emitOp<uint32_t>(OP_GetFieldIntAPS, A0, L);
25720}
25721bool ByteCodeEmitter::emitGetFieldBool( uint32_t A0, SourceInfo L) {
25722 return emitOp<uint32_t>(OP_GetFieldBool, A0, L);
25723}
25724bool ByteCodeEmitter::emitGetFieldFixedPoint( uint32_t A0, SourceInfo L) {
25725 return emitOp<uint32_t>(OP_GetFieldFixedPoint, A0, L);
25726}
25727bool ByteCodeEmitter::emitGetFieldPtr( uint32_t A0, SourceInfo L) {
25728 return emitOp<uint32_t>(OP_GetFieldPtr, A0, L);
25729}
25730bool ByteCodeEmitter::emitGetFieldMemberPtr( uint32_t A0, SourceInfo L) {
25731 return emitOp<uint32_t>(OP_GetFieldMemberPtr, A0, L);
25732}
25733bool ByteCodeEmitter::emitGetFieldFloat( uint32_t A0, SourceInfo L) {
25734 return emitOp<uint32_t>(OP_GetFieldFloat, A0, L);
25735}
25736bool ByteCodeEmitter::emitGetFieldReflect( uint32_t A0, SourceInfo L) {
25737 return emitOp<uint32_t>(OP_GetFieldReflect, A0, L);
25738}
25739#endif
25740#ifdef GET_EVAL_IMPL
25741bool EvalEmitter::emitGetFieldSint8( uint32_t A0, SourceInfo L) {
25742 if (!isActive()) return true;
25743 CurrentSource = L;
25744 return GetField<PT_Sint8>(S, CodePtr(), A0);
25745}
25746bool EvalEmitter::emitGetFieldUint8( uint32_t A0, SourceInfo L) {
25747 if (!isActive()) return true;
25748 CurrentSource = L;
25749 return GetField<PT_Uint8>(S, CodePtr(), A0);
25750}
25751bool EvalEmitter::emitGetFieldSint16( uint32_t A0, SourceInfo L) {
25752 if (!isActive()) return true;
25753 CurrentSource = L;
25754 return GetField<PT_Sint16>(S, CodePtr(), A0);
25755}
25756bool EvalEmitter::emitGetFieldUint16( uint32_t A0, SourceInfo L) {
25757 if (!isActive()) return true;
25758 CurrentSource = L;
25759 return GetField<PT_Uint16>(S, CodePtr(), A0);
25760}
25761bool EvalEmitter::emitGetFieldSint32( uint32_t A0, SourceInfo L) {
25762 if (!isActive()) return true;
25763 CurrentSource = L;
25764 return GetField<PT_Sint32>(S, CodePtr(), A0);
25765}
25766bool EvalEmitter::emitGetFieldUint32( uint32_t A0, SourceInfo L) {
25767 if (!isActive()) return true;
25768 CurrentSource = L;
25769 return GetField<PT_Uint32>(S, CodePtr(), A0);
25770}
25771bool EvalEmitter::emitGetFieldSint64( uint32_t A0, SourceInfo L) {
25772 if (!isActive()) return true;
25773 CurrentSource = L;
25774 return GetField<PT_Sint64>(S, CodePtr(), A0);
25775}
25776bool EvalEmitter::emitGetFieldUint64( uint32_t A0, SourceInfo L) {
25777 if (!isActive()) return true;
25778 CurrentSource = L;
25779 return GetField<PT_Uint64>(S, CodePtr(), A0);
25780}
25781bool EvalEmitter::emitGetFieldIntAP( uint32_t A0, SourceInfo L) {
25782 if (!isActive()) return true;
25783 CurrentSource = L;
25784 return GetField<PT_IntAP>(S, CodePtr(), A0);
25785}
25786bool EvalEmitter::emitGetFieldIntAPS( uint32_t A0, SourceInfo L) {
25787 if (!isActive()) return true;
25788 CurrentSource = L;
25789 return GetField<PT_IntAPS>(S, CodePtr(), A0);
25790}
25791bool EvalEmitter::emitGetFieldBool( uint32_t A0, SourceInfo L) {
25792 if (!isActive()) return true;
25793 CurrentSource = L;
25794 return GetField<PT_Bool>(S, CodePtr(), A0);
25795}
25796bool EvalEmitter::emitGetFieldFixedPoint( uint32_t A0, SourceInfo L) {
25797 if (!isActive()) return true;
25798 CurrentSource = L;
25799 return GetField<PT_FixedPoint>(S, CodePtr(), A0);
25800}
25801bool EvalEmitter::emitGetFieldPtr( uint32_t A0, SourceInfo L) {
25802 if (!isActive()) return true;
25803 CurrentSource = L;
25804 return GetField<PT_Ptr>(S, CodePtr(), A0);
25805}
25806bool EvalEmitter::emitGetFieldMemberPtr( uint32_t A0, SourceInfo L) {
25807 if (!isActive()) return true;
25808 CurrentSource = L;
25809 return GetField<PT_MemberPtr>(S, CodePtr(), A0);
25810}
25811bool EvalEmitter::emitGetFieldFloat( uint32_t A0, SourceInfo L) {
25812 if (!isActive()) return true;
25813 CurrentSource = L;
25814 return GetField<PT_Float>(S, CodePtr(), A0);
25815}
25816bool EvalEmitter::emitGetFieldReflect( uint32_t A0, SourceInfo L) {
25817 if (!isActive()) return true;
25818 CurrentSource = L;
25819 return GetField<PT_Reflect>(S, CodePtr(), A0);
25820}
25821#endif
25822#ifdef GET_OPCODE_NAMES
25823OP_GetFieldPopSint8,
25824OP_GetFieldPopUint8,
25825OP_GetFieldPopSint16,
25826OP_GetFieldPopUint16,
25827OP_GetFieldPopSint32,
25828OP_GetFieldPopUint32,
25829OP_GetFieldPopSint64,
25830OP_GetFieldPopUint64,
25831OP_GetFieldPopIntAP,
25832OP_GetFieldPopIntAPS,
25833OP_GetFieldPopBool,
25834OP_GetFieldPopFixedPoint,
25835OP_GetFieldPopPtr,
25836OP_GetFieldPopMemberPtr,
25837OP_GetFieldPopFloat,
25838OP_GetFieldPopReflect,
25839#endif
25840#ifdef GET_INTERPFN_LIST
25841&Interp_GetFieldPopSint8,
25842&Interp_GetFieldPopUint8,
25843&Interp_GetFieldPopSint16,
25844&Interp_GetFieldPopUint16,
25845&Interp_GetFieldPopSint32,
25846&Interp_GetFieldPopUint32,
25847&Interp_GetFieldPopSint64,
25848&Interp_GetFieldPopUint64,
25849&Interp_GetFieldPopIntAP,
25850&Interp_GetFieldPopIntAPS,
25851&Interp_GetFieldPopBool,
25852&Interp_GetFieldPopFixedPoint,
25853&Interp_GetFieldPopPtr,
25854&Interp_GetFieldPopMemberPtr,
25855&Interp_GetFieldPopFloat,
25856&Interp_GetFieldPopReflect,
25857#endif
25858#ifdef GET_INTERPFN_DISPATCHERS
25859PRESERVE_NONE
25860static bool Interp_GetFieldPopSint8(InterpState &S) {
25861 {
25862 CodePtr OpPC = S.PC;
25863 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25864 if (!GetFieldPop<PT_Sint8>(S, OpPC, V0)) return false;
25865 }
25866#if USE_TAILCALLS
25867 MUSTTAIL return InterpNext(S);
25868#else
25869 return true;
25870#endif
25871}
25872PRESERVE_NONE
25873static bool Interp_GetFieldPopUint8(InterpState &S) {
25874 {
25875 CodePtr OpPC = S.PC;
25876 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25877 if (!GetFieldPop<PT_Uint8>(S, OpPC, V0)) return false;
25878 }
25879#if USE_TAILCALLS
25880 MUSTTAIL return InterpNext(S);
25881#else
25882 return true;
25883#endif
25884}
25885PRESERVE_NONE
25886static bool Interp_GetFieldPopSint16(InterpState &S) {
25887 {
25888 CodePtr OpPC = S.PC;
25889 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25890 if (!GetFieldPop<PT_Sint16>(S, OpPC, V0)) return false;
25891 }
25892#if USE_TAILCALLS
25893 MUSTTAIL return InterpNext(S);
25894#else
25895 return true;
25896#endif
25897}
25898PRESERVE_NONE
25899static bool Interp_GetFieldPopUint16(InterpState &S) {
25900 {
25901 CodePtr OpPC = S.PC;
25902 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25903 if (!GetFieldPop<PT_Uint16>(S, OpPC, V0)) return false;
25904 }
25905#if USE_TAILCALLS
25906 MUSTTAIL return InterpNext(S);
25907#else
25908 return true;
25909#endif
25910}
25911PRESERVE_NONE
25912static bool Interp_GetFieldPopSint32(InterpState &S) {
25913 {
25914 CodePtr OpPC = S.PC;
25915 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25916 if (!GetFieldPop<PT_Sint32>(S, OpPC, V0)) return false;
25917 }
25918#if USE_TAILCALLS
25919 MUSTTAIL return InterpNext(S);
25920#else
25921 return true;
25922#endif
25923}
25924PRESERVE_NONE
25925static bool Interp_GetFieldPopUint32(InterpState &S) {
25926 {
25927 CodePtr OpPC = S.PC;
25928 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25929 if (!GetFieldPop<PT_Uint32>(S, OpPC, V0)) return false;
25930 }
25931#if USE_TAILCALLS
25932 MUSTTAIL return InterpNext(S);
25933#else
25934 return true;
25935#endif
25936}
25937PRESERVE_NONE
25938static bool Interp_GetFieldPopSint64(InterpState &S) {
25939 {
25940 CodePtr OpPC = S.PC;
25941 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25942 if (!GetFieldPop<PT_Sint64>(S, OpPC, V0)) return false;
25943 }
25944#if USE_TAILCALLS
25945 MUSTTAIL return InterpNext(S);
25946#else
25947 return true;
25948#endif
25949}
25950PRESERVE_NONE
25951static bool Interp_GetFieldPopUint64(InterpState &S) {
25952 {
25953 CodePtr OpPC = S.PC;
25954 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25955 if (!GetFieldPop<PT_Uint64>(S, OpPC, V0)) return false;
25956 }
25957#if USE_TAILCALLS
25958 MUSTTAIL return InterpNext(S);
25959#else
25960 return true;
25961#endif
25962}
25963PRESERVE_NONE
25964static bool Interp_GetFieldPopIntAP(InterpState &S) {
25965 {
25966 CodePtr OpPC = S.PC;
25967 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25968 if (!GetFieldPop<PT_IntAP>(S, OpPC, V0)) return false;
25969 }
25970#if USE_TAILCALLS
25971 MUSTTAIL return InterpNext(S);
25972#else
25973 return true;
25974#endif
25975}
25976PRESERVE_NONE
25977static bool Interp_GetFieldPopIntAPS(InterpState &S) {
25978 {
25979 CodePtr OpPC = S.PC;
25980 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25981 if (!GetFieldPop<PT_IntAPS>(S, OpPC, V0)) return false;
25982 }
25983#if USE_TAILCALLS
25984 MUSTTAIL return InterpNext(S);
25985#else
25986 return true;
25987#endif
25988}
25989PRESERVE_NONE
25990static bool Interp_GetFieldPopBool(InterpState &S) {
25991 {
25992 CodePtr OpPC = S.PC;
25993 const auto V0 = ReadArg<uint32_t>(S, S.PC);
25994 if (!GetFieldPop<PT_Bool>(S, OpPC, V0)) return false;
25995 }
25996#if USE_TAILCALLS
25997 MUSTTAIL return InterpNext(S);
25998#else
25999 return true;
26000#endif
26001}
26002PRESERVE_NONE
26003static bool Interp_GetFieldPopFixedPoint(InterpState &S) {
26004 {
26005 CodePtr OpPC = S.PC;
26006 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26007 if (!GetFieldPop<PT_FixedPoint>(S, OpPC, V0)) return false;
26008 }
26009#if USE_TAILCALLS
26010 MUSTTAIL return InterpNext(S);
26011#else
26012 return true;
26013#endif
26014}
26015PRESERVE_NONE
26016static bool Interp_GetFieldPopPtr(InterpState &S) {
26017 {
26018 CodePtr OpPC = S.PC;
26019 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26020 if (!GetFieldPop<PT_Ptr>(S, OpPC, V0)) return false;
26021 }
26022#if USE_TAILCALLS
26023 MUSTTAIL return InterpNext(S);
26024#else
26025 return true;
26026#endif
26027}
26028PRESERVE_NONE
26029static bool Interp_GetFieldPopMemberPtr(InterpState &S) {
26030 {
26031 CodePtr OpPC = S.PC;
26032 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26033 if (!GetFieldPop<PT_MemberPtr>(S, OpPC, V0)) return false;
26034 }
26035#if USE_TAILCALLS
26036 MUSTTAIL return InterpNext(S);
26037#else
26038 return true;
26039#endif
26040}
26041PRESERVE_NONE
26042static bool Interp_GetFieldPopFloat(InterpState &S) {
26043 {
26044 CodePtr OpPC = S.PC;
26045 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26046 if (!GetFieldPop<PT_Float>(S, OpPC, V0)) return false;
26047 }
26048#if USE_TAILCALLS
26049 MUSTTAIL return InterpNext(S);
26050#else
26051 return true;
26052#endif
26053}
26054PRESERVE_NONE
26055static bool Interp_GetFieldPopReflect(InterpState &S) {
26056 {
26057 CodePtr OpPC = S.PC;
26058 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26059 if (!GetFieldPop<PT_Reflect>(S, OpPC, V0)) return false;
26060 }
26061#if USE_TAILCALLS
26062 MUSTTAIL return InterpNext(S);
26063#else
26064 return true;
26065#endif
26066}
26067#endif
26068#ifdef GET_DISASM
26069case OP_GetFieldPopSint8:
26070 Text.Op = PrintName("GetFieldPopSint8");
26071 Text.Args.push_back(printArg<uint32_t>(PC));
26072 break;
26073case OP_GetFieldPopUint8:
26074 Text.Op = PrintName("GetFieldPopUint8");
26075 Text.Args.push_back(printArg<uint32_t>(PC));
26076 break;
26077case OP_GetFieldPopSint16:
26078 Text.Op = PrintName("GetFieldPopSint16");
26079 Text.Args.push_back(printArg<uint32_t>(PC));
26080 break;
26081case OP_GetFieldPopUint16:
26082 Text.Op = PrintName("GetFieldPopUint16");
26083 Text.Args.push_back(printArg<uint32_t>(PC));
26084 break;
26085case OP_GetFieldPopSint32:
26086 Text.Op = PrintName("GetFieldPopSint32");
26087 Text.Args.push_back(printArg<uint32_t>(PC));
26088 break;
26089case OP_GetFieldPopUint32:
26090 Text.Op = PrintName("GetFieldPopUint32");
26091 Text.Args.push_back(printArg<uint32_t>(PC));
26092 break;
26093case OP_GetFieldPopSint64:
26094 Text.Op = PrintName("GetFieldPopSint64");
26095 Text.Args.push_back(printArg<uint32_t>(PC));
26096 break;
26097case OP_GetFieldPopUint64:
26098 Text.Op = PrintName("GetFieldPopUint64");
26099 Text.Args.push_back(printArg<uint32_t>(PC));
26100 break;
26101case OP_GetFieldPopIntAP:
26102 Text.Op = PrintName("GetFieldPopIntAP");
26103 Text.Args.push_back(printArg<uint32_t>(PC));
26104 break;
26105case OP_GetFieldPopIntAPS:
26106 Text.Op = PrintName("GetFieldPopIntAPS");
26107 Text.Args.push_back(printArg<uint32_t>(PC));
26108 break;
26109case OP_GetFieldPopBool:
26110 Text.Op = PrintName("GetFieldPopBool");
26111 Text.Args.push_back(printArg<uint32_t>(PC));
26112 break;
26113case OP_GetFieldPopFixedPoint:
26114 Text.Op = PrintName("GetFieldPopFixedPoint");
26115 Text.Args.push_back(printArg<uint32_t>(PC));
26116 break;
26117case OP_GetFieldPopPtr:
26118 Text.Op = PrintName("GetFieldPopPtr");
26119 Text.Args.push_back(printArg<uint32_t>(PC));
26120 break;
26121case OP_GetFieldPopMemberPtr:
26122 Text.Op = PrintName("GetFieldPopMemberPtr");
26123 Text.Args.push_back(printArg<uint32_t>(PC));
26124 break;
26125case OP_GetFieldPopFloat:
26126 Text.Op = PrintName("GetFieldPopFloat");
26127 Text.Args.push_back(printArg<uint32_t>(PC));
26128 break;
26129case OP_GetFieldPopReflect:
26130 Text.Op = PrintName("GetFieldPopReflect");
26131 Text.Args.push_back(printArg<uint32_t>(PC));
26132 break;
26133#endif
26134#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26135bool emitGetFieldPopSint8( uint32_t , SourceInfo);
26136bool emitGetFieldPopUint8( uint32_t , SourceInfo);
26137bool emitGetFieldPopSint16( uint32_t , SourceInfo);
26138bool emitGetFieldPopUint16( uint32_t , SourceInfo);
26139bool emitGetFieldPopSint32( uint32_t , SourceInfo);
26140bool emitGetFieldPopUint32( uint32_t , SourceInfo);
26141bool emitGetFieldPopSint64( uint32_t , SourceInfo);
26142bool emitGetFieldPopUint64( uint32_t , SourceInfo);
26143bool emitGetFieldPopIntAP( uint32_t , SourceInfo);
26144bool emitGetFieldPopIntAPS( uint32_t , SourceInfo);
26145bool emitGetFieldPopBool( uint32_t , SourceInfo);
26146bool emitGetFieldPopFixedPoint( uint32_t , SourceInfo);
26147bool emitGetFieldPopPtr( uint32_t , SourceInfo);
26148bool emitGetFieldPopMemberPtr( uint32_t , SourceInfo);
26149bool emitGetFieldPopFloat( uint32_t , SourceInfo);
26150bool emitGetFieldPopReflect( uint32_t , SourceInfo);
26151#endif
26152#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26153[[nodiscard]] bool emitGetFieldPop(PrimType, uint32_t, SourceInfo I);
26154#endif
26155#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
26156bool
26157#if defined(GET_EVAL_IMPL)
26158EvalEmitter
26159#else
26160ByteCodeEmitter
26161#endif
26162::emitGetFieldPop(PrimType T0, uint32_t A0, SourceInfo I) {
26163 switch (T0) {
26164 case PT_Sint8:
26165 return emitGetFieldPopSint8(A0, I);
26166 case PT_Uint8:
26167 return emitGetFieldPopUint8(A0, I);
26168 case PT_Sint16:
26169 return emitGetFieldPopSint16(A0, I);
26170 case PT_Uint16:
26171 return emitGetFieldPopUint16(A0, I);
26172 case PT_Sint32:
26173 return emitGetFieldPopSint32(A0, I);
26174 case PT_Uint32:
26175 return emitGetFieldPopUint32(A0, I);
26176 case PT_Sint64:
26177 return emitGetFieldPopSint64(A0, I);
26178 case PT_Uint64:
26179 return emitGetFieldPopUint64(A0, I);
26180 case PT_IntAP:
26181 return emitGetFieldPopIntAP(A0, I);
26182 case PT_IntAPS:
26183 return emitGetFieldPopIntAPS(A0, I);
26184 case PT_Bool:
26185 return emitGetFieldPopBool(A0, I);
26186 case PT_FixedPoint:
26187 return emitGetFieldPopFixedPoint(A0, I);
26188 case PT_Ptr:
26189 return emitGetFieldPopPtr(A0, I);
26190 case PT_MemberPtr:
26191 return emitGetFieldPopMemberPtr(A0, I);
26192 case PT_Float:
26193 return emitGetFieldPopFloat(A0, I);
26194 case PT_Reflect:
26195 return emitGetFieldPopReflect(A0, I);
26196 }
26197 llvm_unreachable("invalid enum value");
26198}
26199#endif
26200#ifdef GET_LINK_IMPL
26201bool ByteCodeEmitter::emitGetFieldPopSint8( uint32_t A0, SourceInfo L) {
26202 return emitOp<uint32_t>(OP_GetFieldPopSint8, A0, L);
26203}
26204bool ByteCodeEmitter::emitGetFieldPopUint8( uint32_t A0, SourceInfo L) {
26205 return emitOp<uint32_t>(OP_GetFieldPopUint8, A0, L);
26206}
26207bool ByteCodeEmitter::emitGetFieldPopSint16( uint32_t A0, SourceInfo L) {
26208 return emitOp<uint32_t>(OP_GetFieldPopSint16, A0, L);
26209}
26210bool ByteCodeEmitter::emitGetFieldPopUint16( uint32_t A0, SourceInfo L) {
26211 return emitOp<uint32_t>(OP_GetFieldPopUint16, A0, L);
26212}
26213bool ByteCodeEmitter::emitGetFieldPopSint32( uint32_t A0, SourceInfo L) {
26214 return emitOp<uint32_t>(OP_GetFieldPopSint32, A0, L);
26215}
26216bool ByteCodeEmitter::emitGetFieldPopUint32( uint32_t A0, SourceInfo L) {
26217 return emitOp<uint32_t>(OP_GetFieldPopUint32, A0, L);
26218}
26219bool ByteCodeEmitter::emitGetFieldPopSint64( uint32_t A0, SourceInfo L) {
26220 return emitOp<uint32_t>(OP_GetFieldPopSint64, A0, L);
26221}
26222bool ByteCodeEmitter::emitGetFieldPopUint64( uint32_t A0, SourceInfo L) {
26223 return emitOp<uint32_t>(OP_GetFieldPopUint64, A0, L);
26224}
26225bool ByteCodeEmitter::emitGetFieldPopIntAP( uint32_t A0, SourceInfo L) {
26226 return emitOp<uint32_t>(OP_GetFieldPopIntAP, A0, L);
26227}
26228bool ByteCodeEmitter::emitGetFieldPopIntAPS( uint32_t A0, SourceInfo L) {
26229 return emitOp<uint32_t>(OP_GetFieldPopIntAPS, A0, L);
26230}
26231bool ByteCodeEmitter::emitGetFieldPopBool( uint32_t A0, SourceInfo L) {
26232 return emitOp<uint32_t>(OP_GetFieldPopBool, A0, L);
26233}
26234bool ByteCodeEmitter::emitGetFieldPopFixedPoint( uint32_t A0, SourceInfo L) {
26235 return emitOp<uint32_t>(OP_GetFieldPopFixedPoint, A0, L);
26236}
26237bool ByteCodeEmitter::emitGetFieldPopPtr( uint32_t A0, SourceInfo L) {
26238 return emitOp<uint32_t>(OP_GetFieldPopPtr, A0, L);
26239}
26240bool ByteCodeEmitter::emitGetFieldPopMemberPtr( uint32_t A0, SourceInfo L) {
26241 return emitOp<uint32_t>(OP_GetFieldPopMemberPtr, A0, L);
26242}
26243bool ByteCodeEmitter::emitGetFieldPopFloat( uint32_t A0, SourceInfo L) {
26244 return emitOp<uint32_t>(OP_GetFieldPopFloat, A0, L);
26245}
26246bool ByteCodeEmitter::emitGetFieldPopReflect( uint32_t A0, SourceInfo L) {
26247 return emitOp<uint32_t>(OP_GetFieldPopReflect, A0, L);
26248}
26249#endif
26250#ifdef GET_EVAL_IMPL
26251bool EvalEmitter::emitGetFieldPopSint8( uint32_t A0, SourceInfo L) {
26252 if (!isActive()) return true;
26253 CurrentSource = L;
26254 return GetFieldPop<PT_Sint8>(S, CodePtr(), A0);
26255}
26256bool EvalEmitter::emitGetFieldPopUint8( uint32_t A0, SourceInfo L) {
26257 if (!isActive()) return true;
26258 CurrentSource = L;
26259 return GetFieldPop<PT_Uint8>(S, CodePtr(), A0);
26260}
26261bool EvalEmitter::emitGetFieldPopSint16( uint32_t A0, SourceInfo L) {
26262 if (!isActive()) return true;
26263 CurrentSource = L;
26264 return GetFieldPop<PT_Sint16>(S, CodePtr(), A0);
26265}
26266bool EvalEmitter::emitGetFieldPopUint16( uint32_t A0, SourceInfo L) {
26267 if (!isActive()) return true;
26268 CurrentSource = L;
26269 return GetFieldPop<PT_Uint16>(S, CodePtr(), A0);
26270}
26271bool EvalEmitter::emitGetFieldPopSint32( uint32_t A0, SourceInfo L) {
26272 if (!isActive()) return true;
26273 CurrentSource = L;
26274 return GetFieldPop<PT_Sint32>(S, CodePtr(), A0);
26275}
26276bool EvalEmitter::emitGetFieldPopUint32( uint32_t A0, SourceInfo L) {
26277 if (!isActive()) return true;
26278 CurrentSource = L;
26279 return GetFieldPop<PT_Uint32>(S, CodePtr(), A0);
26280}
26281bool EvalEmitter::emitGetFieldPopSint64( uint32_t A0, SourceInfo L) {
26282 if (!isActive()) return true;
26283 CurrentSource = L;
26284 return GetFieldPop<PT_Sint64>(S, CodePtr(), A0);
26285}
26286bool EvalEmitter::emitGetFieldPopUint64( uint32_t A0, SourceInfo L) {
26287 if (!isActive()) return true;
26288 CurrentSource = L;
26289 return GetFieldPop<PT_Uint64>(S, CodePtr(), A0);
26290}
26291bool EvalEmitter::emitGetFieldPopIntAP( uint32_t A0, SourceInfo L) {
26292 if (!isActive()) return true;
26293 CurrentSource = L;
26294 return GetFieldPop<PT_IntAP>(S, CodePtr(), A0);
26295}
26296bool EvalEmitter::emitGetFieldPopIntAPS( uint32_t A0, SourceInfo L) {
26297 if (!isActive()) return true;
26298 CurrentSource = L;
26299 return GetFieldPop<PT_IntAPS>(S, CodePtr(), A0);
26300}
26301bool EvalEmitter::emitGetFieldPopBool( uint32_t A0, SourceInfo L) {
26302 if (!isActive()) return true;
26303 CurrentSource = L;
26304 return GetFieldPop<PT_Bool>(S, CodePtr(), A0);
26305}
26306bool EvalEmitter::emitGetFieldPopFixedPoint( uint32_t A0, SourceInfo L) {
26307 if (!isActive()) return true;
26308 CurrentSource = L;
26309 return GetFieldPop<PT_FixedPoint>(S, CodePtr(), A0);
26310}
26311bool EvalEmitter::emitGetFieldPopPtr( uint32_t A0, SourceInfo L) {
26312 if (!isActive()) return true;
26313 CurrentSource = L;
26314 return GetFieldPop<PT_Ptr>(S, CodePtr(), A0);
26315}
26316bool EvalEmitter::emitGetFieldPopMemberPtr( uint32_t A0, SourceInfo L) {
26317 if (!isActive()) return true;
26318 CurrentSource = L;
26319 return GetFieldPop<PT_MemberPtr>(S, CodePtr(), A0);
26320}
26321bool EvalEmitter::emitGetFieldPopFloat( uint32_t A0, SourceInfo L) {
26322 if (!isActive()) return true;
26323 CurrentSource = L;
26324 return GetFieldPop<PT_Float>(S, CodePtr(), A0);
26325}
26326bool EvalEmitter::emitGetFieldPopReflect( uint32_t A0, SourceInfo L) {
26327 if (!isActive()) return true;
26328 CurrentSource = L;
26329 return GetFieldPop<PT_Reflect>(S, CodePtr(), A0);
26330}
26331#endif
26332#ifdef GET_OPCODE_NAMES
26333OP_GetFnPtr,
26334#endif
26335#ifdef GET_INTERPFN_LIST
26336&Interp_GetFnPtr,
26337#endif
26338#ifdef GET_INTERPFN_DISPATCHERS
26339PRESERVE_NONE
26340static bool Interp_GetFnPtr(InterpState &S) {
26341 {
26342 const auto V0 = ReadArg<const Function *>(S, S.PC);
26343 GetFnPtr(S, V0);
26344 }
26345#if USE_TAILCALLS
26346 MUSTTAIL return InterpNext(S);
26347#else
26348 return true;
26349#endif
26350}
26351#endif
26352#ifdef GET_DISASM
26353case OP_GetFnPtr:
26354 Text.Op = PrintName("GetFnPtr");
26355 Text.Args.push_back(printArg<const Function *>(PC));
26356 break;
26357#endif
26358#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26359bool emitGetFnPtr( const Function * , SourceInfo);
26360#endif
26361#ifdef GET_LINK_IMPL
26362bool ByteCodeEmitter::emitGetFnPtr( const Function * A0, SourceInfo L) {
26363 return emitOp<const Function *>(OP_GetFnPtr, A0, L);
26364}
26365#endif
26366#ifdef GET_EVAL_IMPL
26367bool EvalEmitter::emitGetFnPtr( const Function * A0, SourceInfo L) {
26368 if (!isActive()) return true;
26369 CurrentSource = L;
26370 return GetFnPtr(S, A0);
26371}
26372#endif
26373#ifdef GET_OPCODE_NAMES
26374OP_GetGlobalSint8,
26375OP_GetGlobalUint8,
26376OP_GetGlobalSint16,
26377OP_GetGlobalUint16,
26378OP_GetGlobalSint32,
26379OP_GetGlobalUint32,
26380OP_GetGlobalSint64,
26381OP_GetGlobalUint64,
26382OP_GetGlobalIntAP,
26383OP_GetGlobalIntAPS,
26384OP_GetGlobalBool,
26385OP_GetGlobalFixedPoint,
26386OP_GetGlobalPtr,
26387OP_GetGlobalMemberPtr,
26388OP_GetGlobalFloat,
26389OP_GetGlobalReflect,
26390#endif
26391#ifdef GET_INTERPFN_LIST
26392&Interp_GetGlobalSint8,
26393&Interp_GetGlobalUint8,
26394&Interp_GetGlobalSint16,
26395&Interp_GetGlobalUint16,
26396&Interp_GetGlobalSint32,
26397&Interp_GetGlobalUint32,
26398&Interp_GetGlobalSint64,
26399&Interp_GetGlobalUint64,
26400&Interp_GetGlobalIntAP,
26401&Interp_GetGlobalIntAPS,
26402&Interp_GetGlobalBool,
26403&Interp_GetGlobalFixedPoint,
26404&Interp_GetGlobalPtr,
26405&Interp_GetGlobalMemberPtr,
26406&Interp_GetGlobalFloat,
26407&Interp_GetGlobalReflect,
26408#endif
26409#ifdef GET_INTERPFN_DISPATCHERS
26410PRESERVE_NONE
26411static bool Interp_GetGlobalSint8(InterpState &S) {
26412 {
26413 CodePtr OpPC = S.PC;
26414 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26415 if (!GetGlobal<PT_Sint8>(S, OpPC, V0)) return false;
26416 }
26417#if USE_TAILCALLS
26418 MUSTTAIL return InterpNext(S);
26419#else
26420 return true;
26421#endif
26422}
26423PRESERVE_NONE
26424static bool Interp_GetGlobalUint8(InterpState &S) {
26425 {
26426 CodePtr OpPC = S.PC;
26427 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26428 if (!GetGlobal<PT_Uint8>(S, OpPC, V0)) return false;
26429 }
26430#if USE_TAILCALLS
26431 MUSTTAIL return InterpNext(S);
26432#else
26433 return true;
26434#endif
26435}
26436PRESERVE_NONE
26437static bool Interp_GetGlobalSint16(InterpState &S) {
26438 {
26439 CodePtr OpPC = S.PC;
26440 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26441 if (!GetGlobal<PT_Sint16>(S, OpPC, V0)) return false;
26442 }
26443#if USE_TAILCALLS
26444 MUSTTAIL return InterpNext(S);
26445#else
26446 return true;
26447#endif
26448}
26449PRESERVE_NONE
26450static bool Interp_GetGlobalUint16(InterpState &S) {
26451 {
26452 CodePtr OpPC = S.PC;
26453 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26454 if (!GetGlobal<PT_Uint16>(S, OpPC, V0)) return false;
26455 }
26456#if USE_TAILCALLS
26457 MUSTTAIL return InterpNext(S);
26458#else
26459 return true;
26460#endif
26461}
26462PRESERVE_NONE
26463static bool Interp_GetGlobalSint32(InterpState &S) {
26464 {
26465 CodePtr OpPC = S.PC;
26466 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26467 if (!GetGlobal<PT_Sint32>(S, OpPC, V0)) return false;
26468 }
26469#if USE_TAILCALLS
26470 MUSTTAIL return InterpNext(S);
26471#else
26472 return true;
26473#endif
26474}
26475PRESERVE_NONE
26476static bool Interp_GetGlobalUint32(InterpState &S) {
26477 {
26478 CodePtr OpPC = S.PC;
26479 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26480 if (!GetGlobal<PT_Uint32>(S, OpPC, V0)) return false;
26481 }
26482#if USE_TAILCALLS
26483 MUSTTAIL return InterpNext(S);
26484#else
26485 return true;
26486#endif
26487}
26488PRESERVE_NONE
26489static bool Interp_GetGlobalSint64(InterpState &S) {
26490 {
26491 CodePtr OpPC = S.PC;
26492 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26493 if (!GetGlobal<PT_Sint64>(S, OpPC, V0)) return false;
26494 }
26495#if USE_TAILCALLS
26496 MUSTTAIL return InterpNext(S);
26497#else
26498 return true;
26499#endif
26500}
26501PRESERVE_NONE
26502static bool Interp_GetGlobalUint64(InterpState &S) {
26503 {
26504 CodePtr OpPC = S.PC;
26505 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26506 if (!GetGlobal<PT_Uint64>(S, OpPC, V0)) return false;
26507 }
26508#if USE_TAILCALLS
26509 MUSTTAIL return InterpNext(S);
26510#else
26511 return true;
26512#endif
26513}
26514PRESERVE_NONE
26515static bool Interp_GetGlobalIntAP(InterpState &S) {
26516 {
26517 CodePtr OpPC = S.PC;
26518 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26519 if (!GetGlobal<PT_IntAP>(S, OpPC, V0)) return false;
26520 }
26521#if USE_TAILCALLS
26522 MUSTTAIL return InterpNext(S);
26523#else
26524 return true;
26525#endif
26526}
26527PRESERVE_NONE
26528static bool Interp_GetGlobalIntAPS(InterpState &S) {
26529 {
26530 CodePtr OpPC = S.PC;
26531 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26532 if (!GetGlobal<PT_IntAPS>(S, OpPC, V0)) return false;
26533 }
26534#if USE_TAILCALLS
26535 MUSTTAIL return InterpNext(S);
26536#else
26537 return true;
26538#endif
26539}
26540PRESERVE_NONE
26541static bool Interp_GetGlobalBool(InterpState &S) {
26542 {
26543 CodePtr OpPC = S.PC;
26544 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26545 if (!GetGlobal<PT_Bool>(S, OpPC, V0)) return false;
26546 }
26547#if USE_TAILCALLS
26548 MUSTTAIL return InterpNext(S);
26549#else
26550 return true;
26551#endif
26552}
26553PRESERVE_NONE
26554static bool Interp_GetGlobalFixedPoint(InterpState &S) {
26555 {
26556 CodePtr OpPC = S.PC;
26557 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26558 if (!GetGlobal<PT_FixedPoint>(S, OpPC, V0)) return false;
26559 }
26560#if USE_TAILCALLS
26561 MUSTTAIL return InterpNext(S);
26562#else
26563 return true;
26564#endif
26565}
26566PRESERVE_NONE
26567static bool Interp_GetGlobalPtr(InterpState &S) {
26568 {
26569 CodePtr OpPC = S.PC;
26570 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26571 if (!GetGlobal<PT_Ptr>(S, OpPC, V0)) return false;
26572 }
26573#if USE_TAILCALLS
26574 MUSTTAIL return InterpNext(S);
26575#else
26576 return true;
26577#endif
26578}
26579PRESERVE_NONE
26580static bool Interp_GetGlobalMemberPtr(InterpState &S) {
26581 {
26582 CodePtr OpPC = S.PC;
26583 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26584 if (!GetGlobal<PT_MemberPtr>(S, OpPC, V0)) return false;
26585 }
26586#if USE_TAILCALLS
26587 MUSTTAIL return InterpNext(S);
26588#else
26589 return true;
26590#endif
26591}
26592PRESERVE_NONE
26593static bool Interp_GetGlobalFloat(InterpState &S) {
26594 {
26595 CodePtr OpPC = S.PC;
26596 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26597 if (!GetGlobal<PT_Float>(S, OpPC, V0)) return false;
26598 }
26599#if USE_TAILCALLS
26600 MUSTTAIL return InterpNext(S);
26601#else
26602 return true;
26603#endif
26604}
26605PRESERVE_NONE
26606static bool Interp_GetGlobalReflect(InterpState &S) {
26607 {
26608 CodePtr OpPC = S.PC;
26609 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26610 if (!GetGlobal<PT_Reflect>(S, OpPC, V0)) return false;
26611 }
26612#if USE_TAILCALLS
26613 MUSTTAIL return InterpNext(S);
26614#else
26615 return true;
26616#endif
26617}
26618#endif
26619#ifdef GET_DISASM
26620case OP_GetGlobalSint8:
26621 Text.Op = PrintName("GetGlobalSint8");
26622 Text.Args.push_back(printArg<uint32_t>(PC));
26623 break;
26624case OP_GetGlobalUint8:
26625 Text.Op = PrintName("GetGlobalUint8");
26626 Text.Args.push_back(printArg<uint32_t>(PC));
26627 break;
26628case OP_GetGlobalSint16:
26629 Text.Op = PrintName("GetGlobalSint16");
26630 Text.Args.push_back(printArg<uint32_t>(PC));
26631 break;
26632case OP_GetGlobalUint16:
26633 Text.Op = PrintName("GetGlobalUint16");
26634 Text.Args.push_back(printArg<uint32_t>(PC));
26635 break;
26636case OP_GetGlobalSint32:
26637 Text.Op = PrintName("GetGlobalSint32");
26638 Text.Args.push_back(printArg<uint32_t>(PC));
26639 break;
26640case OP_GetGlobalUint32:
26641 Text.Op = PrintName("GetGlobalUint32");
26642 Text.Args.push_back(printArg<uint32_t>(PC));
26643 break;
26644case OP_GetGlobalSint64:
26645 Text.Op = PrintName("GetGlobalSint64");
26646 Text.Args.push_back(printArg<uint32_t>(PC));
26647 break;
26648case OP_GetGlobalUint64:
26649 Text.Op = PrintName("GetGlobalUint64");
26650 Text.Args.push_back(printArg<uint32_t>(PC));
26651 break;
26652case OP_GetGlobalIntAP:
26653 Text.Op = PrintName("GetGlobalIntAP");
26654 Text.Args.push_back(printArg<uint32_t>(PC));
26655 break;
26656case OP_GetGlobalIntAPS:
26657 Text.Op = PrintName("GetGlobalIntAPS");
26658 Text.Args.push_back(printArg<uint32_t>(PC));
26659 break;
26660case OP_GetGlobalBool:
26661 Text.Op = PrintName("GetGlobalBool");
26662 Text.Args.push_back(printArg<uint32_t>(PC));
26663 break;
26664case OP_GetGlobalFixedPoint:
26665 Text.Op = PrintName("GetGlobalFixedPoint");
26666 Text.Args.push_back(printArg<uint32_t>(PC));
26667 break;
26668case OP_GetGlobalPtr:
26669 Text.Op = PrintName("GetGlobalPtr");
26670 Text.Args.push_back(printArg<uint32_t>(PC));
26671 break;
26672case OP_GetGlobalMemberPtr:
26673 Text.Op = PrintName("GetGlobalMemberPtr");
26674 Text.Args.push_back(printArg<uint32_t>(PC));
26675 break;
26676case OP_GetGlobalFloat:
26677 Text.Op = PrintName("GetGlobalFloat");
26678 Text.Args.push_back(printArg<uint32_t>(PC));
26679 break;
26680case OP_GetGlobalReflect:
26681 Text.Op = PrintName("GetGlobalReflect");
26682 Text.Args.push_back(printArg<uint32_t>(PC));
26683 break;
26684#endif
26685#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26686bool emitGetGlobalSint8( uint32_t , SourceInfo);
26687bool emitGetGlobalUint8( uint32_t , SourceInfo);
26688bool emitGetGlobalSint16( uint32_t , SourceInfo);
26689bool emitGetGlobalUint16( uint32_t , SourceInfo);
26690bool emitGetGlobalSint32( uint32_t , SourceInfo);
26691bool emitGetGlobalUint32( uint32_t , SourceInfo);
26692bool emitGetGlobalSint64( uint32_t , SourceInfo);
26693bool emitGetGlobalUint64( uint32_t , SourceInfo);
26694bool emitGetGlobalIntAP( uint32_t , SourceInfo);
26695bool emitGetGlobalIntAPS( uint32_t , SourceInfo);
26696bool emitGetGlobalBool( uint32_t , SourceInfo);
26697bool emitGetGlobalFixedPoint( uint32_t , SourceInfo);
26698bool emitGetGlobalPtr( uint32_t , SourceInfo);
26699bool emitGetGlobalMemberPtr( uint32_t , SourceInfo);
26700bool emitGetGlobalFloat( uint32_t , SourceInfo);
26701bool emitGetGlobalReflect( uint32_t , SourceInfo);
26702#endif
26703#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
26704[[nodiscard]] bool emitGetGlobal(PrimType, uint32_t, SourceInfo I);
26705#endif
26706#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
26707bool
26708#if defined(GET_EVAL_IMPL)
26709EvalEmitter
26710#else
26711ByteCodeEmitter
26712#endif
26713::emitGetGlobal(PrimType T0, uint32_t A0, SourceInfo I) {
26714 switch (T0) {
26715 case PT_Sint8:
26716 return emitGetGlobalSint8(A0, I);
26717 case PT_Uint8:
26718 return emitGetGlobalUint8(A0, I);
26719 case PT_Sint16:
26720 return emitGetGlobalSint16(A0, I);
26721 case PT_Uint16:
26722 return emitGetGlobalUint16(A0, I);
26723 case PT_Sint32:
26724 return emitGetGlobalSint32(A0, I);
26725 case PT_Uint32:
26726 return emitGetGlobalUint32(A0, I);
26727 case PT_Sint64:
26728 return emitGetGlobalSint64(A0, I);
26729 case PT_Uint64:
26730 return emitGetGlobalUint64(A0, I);
26731 case PT_IntAP:
26732 return emitGetGlobalIntAP(A0, I);
26733 case PT_IntAPS:
26734 return emitGetGlobalIntAPS(A0, I);
26735 case PT_Bool:
26736 return emitGetGlobalBool(A0, I);
26737 case PT_FixedPoint:
26738 return emitGetGlobalFixedPoint(A0, I);
26739 case PT_Ptr:
26740 return emitGetGlobalPtr(A0, I);
26741 case PT_MemberPtr:
26742 return emitGetGlobalMemberPtr(A0, I);
26743 case PT_Float:
26744 return emitGetGlobalFloat(A0, I);
26745 case PT_Reflect:
26746 return emitGetGlobalReflect(A0, I);
26747 }
26748 llvm_unreachable("invalid enum value");
26749}
26750#endif
26751#ifdef GET_LINK_IMPL
26752bool ByteCodeEmitter::emitGetGlobalSint8( uint32_t A0, SourceInfo L) {
26753 return emitOp<uint32_t>(OP_GetGlobalSint8, A0, L);
26754}
26755bool ByteCodeEmitter::emitGetGlobalUint8( uint32_t A0, SourceInfo L) {
26756 return emitOp<uint32_t>(OP_GetGlobalUint8, A0, L);
26757}
26758bool ByteCodeEmitter::emitGetGlobalSint16( uint32_t A0, SourceInfo L) {
26759 return emitOp<uint32_t>(OP_GetGlobalSint16, A0, L);
26760}
26761bool ByteCodeEmitter::emitGetGlobalUint16( uint32_t A0, SourceInfo L) {
26762 return emitOp<uint32_t>(OP_GetGlobalUint16, A0, L);
26763}
26764bool ByteCodeEmitter::emitGetGlobalSint32( uint32_t A0, SourceInfo L) {
26765 return emitOp<uint32_t>(OP_GetGlobalSint32, A0, L);
26766}
26767bool ByteCodeEmitter::emitGetGlobalUint32( uint32_t A0, SourceInfo L) {
26768 return emitOp<uint32_t>(OP_GetGlobalUint32, A0, L);
26769}
26770bool ByteCodeEmitter::emitGetGlobalSint64( uint32_t A0, SourceInfo L) {
26771 return emitOp<uint32_t>(OP_GetGlobalSint64, A0, L);
26772}
26773bool ByteCodeEmitter::emitGetGlobalUint64( uint32_t A0, SourceInfo L) {
26774 return emitOp<uint32_t>(OP_GetGlobalUint64, A0, L);
26775}
26776bool ByteCodeEmitter::emitGetGlobalIntAP( uint32_t A0, SourceInfo L) {
26777 return emitOp<uint32_t>(OP_GetGlobalIntAP, A0, L);
26778}
26779bool ByteCodeEmitter::emitGetGlobalIntAPS( uint32_t A0, SourceInfo L) {
26780 return emitOp<uint32_t>(OP_GetGlobalIntAPS, A0, L);
26781}
26782bool ByteCodeEmitter::emitGetGlobalBool( uint32_t A0, SourceInfo L) {
26783 return emitOp<uint32_t>(OP_GetGlobalBool, A0, L);
26784}
26785bool ByteCodeEmitter::emitGetGlobalFixedPoint( uint32_t A0, SourceInfo L) {
26786 return emitOp<uint32_t>(OP_GetGlobalFixedPoint, A0, L);
26787}
26788bool ByteCodeEmitter::emitGetGlobalPtr( uint32_t A0, SourceInfo L) {
26789 return emitOp<uint32_t>(OP_GetGlobalPtr, A0, L);
26790}
26791bool ByteCodeEmitter::emitGetGlobalMemberPtr( uint32_t A0, SourceInfo L) {
26792 return emitOp<uint32_t>(OP_GetGlobalMemberPtr, A0, L);
26793}
26794bool ByteCodeEmitter::emitGetGlobalFloat( uint32_t A0, SourceInfo L) {
26795 return emitOp<uint32_t>(OP_GetGlobalFloat, A0, L);
26796}
26797bool ByteCodeEmitter::emitGetGlobalReflect( uint32_t A0, SourceInfo L) {
26798 return emitOp<uint32_t>(OP_GetGlobalReflect, A0, L);
26799}
26800#endif
26801#ifdef GET_EVAL_IMPL
26802bool EvalEmitter::emitGetGlobalSint8( uint32_t A0, SourceInfo L) {
26803 if (!isActive()) return true;
26804 CurrentSource = L;
26805 return GetGlobal<PT_Sint8>(S, CodePtr(), A0);
26806}
26807bool EvalEmitter::emitGetGlobalUint8( uint32_t A0, SourceInfo L) {
26808 if (!isActive()) return true;
26809 CurrentSource = L;
26810 return GetGlobal<PT_Uint8>(S, CodePtr(), A0);
26811}
26812bool EvalEmitter::emitGetGlobalSint16( uint32_t A0, SourceInfo L) {
26813 if (!isActive()) return true;
26814 CurrentSource = L;
26815 return GetGlobal<PT_Sint16>(S, CodePtr(), A0);
26816}
26817bool EvalEmitter::emitGetGlobalUint16( uint32_t A0, SourceInfo L) {
26818 if (!isActive()) return true;
26819 CurrentSource = L;
26820 return GetGlobal<PT_Uint16>(S, CodePtr(), A0);
26821}
26822bool EvalEmitter::emitGetGlobalSint32( uint32_t A0, SourceInfo L) {
26823 if (!isActive()) return true;
26824 CurrentSource = L;
26825 return GetGlobal<PT_Sint32>(S, CodePtr(), A0);
26826}
26827bool EvalEmitter::emitGetGlobalUint32( uint32_t A0, SourceInfo L) {
26828 if (!isActive()) return true;
26829 CurrentSource = L;
26830 return GetGlobal<PT_Uint32>(S, CodePtr(), A0);
26831}
26832bool EvalEmitter::emitGetGlobalSint64( uint32_t A0, SourceInfo L) {
26833 if (!isActive()) return true;
26834 CurrentSource = L;
26835 return GetGlobal<PT_Sint64>(S, CodePtr(), A0);
26836}
26837bool EvalEmitter::emitGetGlobalUint64( uint32_t A0, SourceInfo L) {
26838 if (!isActive()) return true;
26839 CurrentSource = L;
26840 return GetGlobal<PT_Uint64>(S, CodePtr(), A0);
26841}
26842bool EvalEmitter::emitGetGlobalIntAP( uint32_t A0, SourceInfo L) {
26843 if (!isActive()) return true;
26844 CurrentSource = L;
26845 return GetGlobal<PT_IntAP>(S, CodePtr(), A0);
26846}
26847bool EvalEmitter::emitGetGlobalIntAPS( uint32_t A0, SourceInfo L) {
26848 if (!isActive()) return true;
26849 CurrentSource = L;
26850 return GetGlobal<PT_IntAPS>(S, CodePtr(), A0);
26851}
26852bool EvalEmitter::emitGetGlobalBool( uint32_t A0, SourceInfo L) {
26853 if (!isActive()) return true;
26854 CurrentSource = L;
26855 return GetGlobal<PT_Bool>(S, CodePtr(), A0);
26856}
26857bool EvalEmitter::emitGetGlobalFixedPoint( uint32_t A0, SourceInfo L) {
26858 if (!isActive()) return true;
26859 CurrentSource = L;
26860 return GetGlobal<PT_FixedPoint>(S, CodePtr(), A0);
26861}
26862bool EvalEmitter::emitGetGlobalPtr( uint32_t A0, SourceInfo L) {
26863 if (!isActive()) return true;
26864 CurrentSource = L;
26865 return GetGlobal<PT_Ptr>(S, CodePtr(), A0);
26866}
26867bool EvalEmitter::emitGetGlobalMemberPtr( uint32_t A0, SourceInfo L) {
26868 if (!isActive()) return true;
26869 CurrentSource = L;
26870 return GetGlobal<PT_MemberPtr>(S, CodePtr(), A0);
26871}
26872bool EvalEmitter::emitGetGlobalFloat( uint32_t A0, SourceInfo L) {
26873 if (!isActive()) return true;
26874 CurrentSource = L;
26875 return GetGlobal<PT_Float>(S, CodePtr(), A0);
26876}
26877bool EvalEmitter::emitGetGlobalReflect( uint32_t A0, SourceInfo L) {
26878 if (!isActive()) return true;
26879 CurrentSource = L;
26880 return GetGlobal<PT_Reflect>(S, CodePtr(), A0);
26881}
26882#endif
26883#ifdef GET_OPCODE_NAMES
26884OP_GetGlobalUncheckedSint8,
26885OP_GetGlobalUncheckedUint8,
26886OP_GetGlobalUncheckedSint16,
26887OP_GetGlobalUncheckedUint16,
26888OP_GetGlobalUncheckedSint32,
26889OP_GetGlobalUncheckedUint32,
26890OP_GetGlobalUncheckedSint64,
26891OP_GetGlobalUncheckedUint64,
26892OP_GetGlobalUncheckedIntAP,
26893OP_GetGlobalUncheckedIntAPS,
26894OP_GetGlobalUncheckedBool,
26895OP_GetGlobalUncheckedFixedPoint,
26896OP_GetGlobalUncheckedPtr,
26897OP_GetGlobalUncheckedMemberPtr,
26898OP_GetGlobalUncheckedFloat,
26899OP_GetGlobalUncheckedReflect,
26900#endif
26901#ifdef GET_INTERPFN_LIST
26902&Interp_GetGlobalUncheckedSint8,
26903&Interp_GetGlobalUncheckedUint8,
26904&Interp_GetGlobalUncheckedSint16,
26905&Interp_GetGlobalUncheckedUint16,
26906&Interp_GetGlobalUncheckedSint32,
26907&Interp_GetGlobalUncheckedUint32,
26908&Interp_GetGlobalUncheckedSint64,
26909&Interp_GetGlobalUncheckedUint64,
26910&Interp_GetGlobalUncheckedIntAP,
26911&Interp_GetGlobalUncheckedIntAPS,
26912&Interp_GetGlobalUncheckedBool,
26913&Interp_GetGlobalUncheckedFixedPoint,
26914&Interp_GetGlobalUncheckedPtr,
26915&Interp_GetGlobalUncheckedMemberPtr,
26916&Interp_GetGlobalUncheckedFloat,
26917&Interp_GetGlobalUncheckedReflect,
26918#endif
26919#ifdef GET_INTERPFN_DISPATCHERS
26920PRESERVE_NONE
26921static bool Interp_GetGlobalUncheckedSint8(InterpState &S) {
26922 {
26923 CodePtr OpPC = S.PC;
26924 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26925 if (!GetGlobalUnchecked<PT_Sint8>(S, OpPC, V0)) return false;
26926 }
26927#if USE_TAILCALLS
26928 MUSTTAIL return InterpNext(S);
26929#else
26930 return true;
26931#endif
26932}
26933PRESERVE_NONE
26934static bool Interp_GetGlobalUncheckedUint8(InterpState &S) {
26935 {
26936 CodePtr OpPC = S.PC;
26937 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26938 if (!GetGlobalUnchecked<PT_Uint8>(S, OpPC, V0)) return false;
26939 }
26940#if USE_TAILCALLS
26941 MUSTTAIL return InterpNext(S);
26942#else
26943 return true;
26944#endif
26945}
26946PRESERVE_NONE
26947static bool Interp_GetGlobalUncheckedSint16(InterpState &S) {
26948 {
26949 CodePtr OpPC = S.PC;
26950 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26951 if (!GetGlobalUnchecked<PT_Sint16>(S, OpPC, V0)) return false;
26952 }
26953#if USE_TAILCALLS
26954 MUSTTAIL return InterpNext(S);
26955#else
26956 return true;
26957#endif
26958}
26959PRESERVE_NONE
26960static bool Interp_GetGlobalUncheckedUint16(InterpState &S) {
26961 {
26962 CodePtr OpPC = S.PC;
26963 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26964 if (!GetGlobalUnchecked<PT_Uint16>(S, OpPC, V0)) return false;
26965 }
26966#if USE_TAILCALLS
26967 MUSTTAIL return InterpNext(S);
26968#else
26969 return true;
26970#endif
26971}
26972PRESERVE_NONE
26973static bool Interp_GetGlobalUncheckedSint32(InterpState &S) {
26974 {
26975 CodePtr OpPC = S.PC;
26976 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26977 if (!GetGlobalUnchecked<PT_Sint32>(S, OpPC, V0)) return false;
26978 }
26979#if USE_TAILCALLS
26980 MUSTTAIL return InterpNext(S);
26981#else
26982 return true;
26983#endif
26984}
26985PRESERVE_NONE
26986static bool Interp_GetGlobalUncheckedUint32(InterpState &S) {
26987 {
26988 CodePtr OpPC = S.PC;
26989 const auto V0 = ReadArg<uint32_t>(S, S.PC);
26990 if (!GetGlobalUnchecked<PT_Uint32>(S, OpPC, V0)) return false;
26991 }
26992#if USE_TAILCALLS
26993 MUSTTAIL return InterpNext(S);
26994#else
26995 return true;
26996#endif
26997}
26998PRESERVE_NONE
26999static bool Interp_GetGlobalUncheckedSint64(InterpState &S) {
27000 {
27001 CodePtr OpPC = S.PC;
27002 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27003 if (!GetGlobalUnchecked<PT_Sint64>(S, OpPC, V0)) return false;
27004 }
27005#if USE_TAILCALLS
27006 MUSTTAIL return InterpNext(S);
27007#else
27008 return true;
27009#endif
27010}
27011PRESERVE_NONE
27012static bool Interp_GetGlobalUncheckedUint64(InterpState &S) {
27013 {
27014 CodePtr OpPC = S.PC;
27015 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27016 if (!GetGlobalUnchecked<PT_Uint64>(S, OpPC, V0)) return false;
27017 }
27018#if USE_TAILCALLS
27019 MUSTTAIL return InterpNext(S);
27020#else
27021 return true;
27022#endif
27023}
27024PRESERVE_NONE
27025static bool Interp_GetGlobalUncheckedIntAP(InterpState &S) {
27026 {
27027 CodePtr OpPC = S.PC;
27028 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27029 if (!GetGlobalUnchecked<PT_IntAP>(S, OpPC, V0)) return false;
27030 }
27031#if USE_TAILCALLS
27032 MUSTTAIL return InterpNext(S);
27033#else
27034 return true;
27035#endif
27036}
27037PRESERVE_NONE
27038static bool Interp_GetGlobalUncheckedIntAPS(InterpState &S) {
27039 {
27040 CodePtr OpPC = S.PC;
27041 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27042 if (!GetGlobalUnchecked<PT_IntAPS>(S, OpPC, V0)) return false;
27043 }
27044#if USE_TAILCALLS
27045 MUSTTAIL return InterpNext(S);
27046#else
27047 return true;
27048#endif
27049}
27050PRESERVE_NONE
27051static bool Interp_GetGlobalUncheckedBool(InterpState &S) {
27052 {
27053 CodePtr OpPC = S.PC;
27054 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27055 if (!GetGlobalUnchecked<PT_Bool>(S, OpPC, V0)) return false;
27056 }
27057#if USE_TAILCALLS
27058 MUSTTAIL return InterpNext(S);
27059#else
27060 return true;
27061#endif
27062}
27063PRESERVE_NONE
27064static bool Interp_GetGlobalUncheckedFixedPoint(InterpState &S) {
27065 {
27066 CodePtr OpPC = S.PC;
27067 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27068 if (!GetGlobalUnchecked<PT_FixedPoint>(S, OpPC, V0)) return false;
27069 }
27070#if USE_TAILCALLS
27071 MUSTTAIL return InterpNext(S);
27072#else
27073 return true;
27074#endif
27075}
27076PRESERVE_NONE
27077static bool Interp_GetGlobalUncheckedPtr(InterpState &S) {
27078 {
27079 CodePtr OpPC = S.PC;
27080 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27081 if (!GetGlobalUnchecked<PT_Ptr>(S, OpPC, V0)) return false;
27082 }
27083#if USE_TAILCALLS
27084 MUSTTAIL return InterpNext(S);
27085#else
27086 return true;
27087#endif
27088}
27089PRESERVE_NONE
27090static bool Interp_GetGlobalUncheckedMemberPtr(InterpState &S) {
27091 {
27092 CodePtr OpPC = S.PC;
27093 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27094 if (!GetGlobalUnchecked<PT_MemberPtr>(S, OpPC, V0)) return false;
27095 }
27096#if USE_TAILCALLS
27097 MUSTTAIL return InterpNext(S);
27098#else
27099 return true;
27100#endif
27101}
27102PRESERVE_NONE
27103static bool Interp_GetGlobalUncheckedFloat(InterpState &S) {
27104 {
27105 CodePtr OpPC = S.PC;
27106 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27107 if (!GetGlobalUnchecked<PT_Float>(S, OpPC, V0)) return false;
27108 }
27109#if USE_TAILCALLS
27110 MUSTTAIL return InterpNext(S);
27111#else
27112 return true;
27113#endif
27114}
27115PRESERVE_NONE
27116static bool Interp_GetGlobalUncheckedReflect(InterpState &S) {
27117 {
27118 CodePtr OpPC = S.PC;
27119 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27120 if (!GetGlobalUnchecked<PT_Reflect>(S, OpPC, V0)) return false;
27121 }
27122#if USE_TAILCALLS
27123 MUSTTAIL return InterpNext(S);
27124#else
27125 return true;
27126#endif
27127}
27128#endif
27129#ifdef GET_DISASM
27130case OP_GetGlobalUncheckedSint8:
27131 Text.Op = PrintName("GetGlobalUncheckedSint8");
27132 Text.Args.push_back(printArg<uint32_t>(PC));
27133 break;
27134case OP_GetGlobalUncheckedUint8:
27135 Text.Op = PrintName("GetGlobalUncheckedUint8");
27136 Text.Args.push_back(printArg<uint32_t>(PC));
27137 break;
27138case OP_GetGlobalUncheckedSint16:
27139 Text.Op = PrintName("GetGlobalUncheckedSint16");
27140 Text.Args.push_back(printArg<uint32_t>(PC));
27141 break;
27142case OP_GetGlobalUncheckedUint16:
27143 Text.Op = PrintName("GetGlobalUncheckedUint16");
27144 Text.Args.push_back(printArg<uint32_t>(PC));
27145 break;
27146case OP_GetGlobalUncheckedSint32:
27147 Text.Op = PrintName("GetGlobalUncheckedSint32");
27148 Text.Args.push_back(printArg<uint32_t>(PC));
27149 break;
27150case OP_GetGlobalUncheckedUint32:
27151 Text.Op = PrintName("GetGlobalUncheckedUint32");
27152 Text.Args.push_back(printArg<uint32_t>(PC));
27153 break;
27154case OP_GetGlobalUncheckedSint64:
27155 Text.Op = PrintName("GetGlobalUncheckedSint64");
27156 Text.Args.push_back(printArg<uint32_t>(PC));
27157 break;
27158case OP_GetGlobalUncheckedUint64:
27159 Text.Op = PrintName("GetGlobalUncheckedUint64");
27160 Text.Args.push_back(printArg<uint32_t>(PC));
27161 break;
27162case OP_GetGlobalUncheckedIntAP:
27163 Text.Op = PrintName("GetGlobalUncheckedIntAP");
27164 Text.Args.push_back(printArg<uint32_t>(PC));
27165 break;
27166case OP_GetGlobalUncheckedIntAPS:
27167 Text.Op = PrintName("GetGlobalUncheckedIntAPS");
27168 Text.Args.push_back(printArg<uint32_t>(PC));
27169 break;
27170case OP_GetGlobalUncheckedBool:
27171 Text.Op = PrintName("GetGlobalUncheckedBool");
27172 Text.Args.push_back(printArg<uint32_t>(PC));
27173 break;
27174case OP_GetGlobalUncheckedFixedPoint:
27175 Text.Op = PrintName("GetGlobalUncheckedFixedPoint");
27176 Text.Args.push_back(printArg<uint32_t>(PC));
27177 break;
27178case OP_GetGlobalUncheckedPtr:
27179 Text.Op = PrintName("GetGlobalUncheckedPtr");
27180 Text.Args.push_back(printArg<uint32_t>(PC));
27181 break;
27182case OP_GetGlobalUncheckedMemberPtr:
27183 Text.Op = PrintName("GetGlobalUncheckedMemberPtr");
27184 Text.Args.push_back(printArg<uint32_t>(PC));
27185 break;
27186case OP_GetGlobalUncheckedFloat:
27187 Text.Op = PrintName("GetGlobalUncheckedFloat");
27188 Text.Args.push_back(printArg<uint32_t>(PC));
27189 break;
27190case OP_GetGlobalUncheckedReflect:
27191 Text.Op = PrintName("GetGlobalUncheckedReflect");
27192 Text.Args.push_back(printArg<uint32_t>(PC));
27193 break;
27194#endif
27195#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27196bool emitGetGlobalUncheckedSint8( uint32_t , SourceInfo);
27197bool emitGetGlobalUncheckedUint8( uint32_t , SourceInfo);
27198bool emitGetGlobalUncheckedSint16( uint32_t , SourceInfo);
27199bool emitGetGlobalUncheckedUint16( uint32_t , SourceInfo);
27200bool emitGetGlobalUncheckedSint32( uint32_t , SourceInfo);
27201bool emitGetGlobalUncheckedUint32( uint32_t , SourceInfo);
27202bool emitGetGlobalUncheckedSint64( uint32_t , SourceInfo);
27203bool emitGetGlobalUncheckedUint64( uint32_t , SourceInfo);
27204bool emitGetGlobalUncheckedIntAP( uint32_t , SourceInfo);
27205bool emitGetGlobalUncheckedIntAPS( uint32_t , SourceInfo);
27206bool emitGetGlobalUncheckedBool( uint32_t , SourceInfo);
27207bool emitGetGlobalUncheckedFixedPoint( uint32_t , SourceInfo);
27208bool emitGetGlobalUncheckedPtr( uint32_t , SourceInfo);
27209bool emitGetGlobalUncheckedMemberPtr( uint32_t , SourceInfo);
27210bool emitGetGlobalUncheckedFloat( uint32_t , SourceInfo);
27211bool emitGetGlobalUncheckedReflect( uint32_t , SourceInfo);
27212#endif
27213#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27214[[nodiscard]] bool emitGetGlobalUnchecked(PrimType, uint32_t, SourceInfo I);
27215#endif
27216#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
27217bool
27218#if defined(GET_EVAL_IMPL)
27219EvalEmitter
27220#else
27221ByteCodeEmitter
27222#endif
27223::emitGetGlobalUnchecked(PrimType T0, uint32_t A0, SourceInfo I) {
27224 switch (T0) {
27225 case PT_Sint8:
27226 return emitGetGlobalUncheckedSint8(A0, I);
27227 case PT_Uint8:
27228 return emitGetGlobalUncheckedUint8(A0, I);
27229 case PT_Sint16:
27230 return emitGetGlobalUncheckedSint16(A0, I);
27231 case PT_Uint16:
27232 return emitGetGlobalUncheckedUint16(A0, I);
27233 case PT_Sint32:
27234 return emitGetGlobalUncheckedSint32(A0, I);
27235 case PT_Uint32:
27236 return emitGetGlobalUncheckedUint32(A0, I);
27237 case PT_Sint64:
27238 return emitGetGlobalUncheckedSint64(A0, I);
27239 case PT_Uint64:
27240 return emitGetGlobalUncheckedUint64(A0, I);
27241 case PT_IntAP:
27242 return emitGetGlobalUncheckedIntAP(A0, I);
27243 case PT_IntAPS:
27244 return emitGetGlobalUncheckedIntAPS(A0, I);
27245 case PT_Bool:
27246 return emitGetGlobalUncheckedBool(A0, I);
27247 case PT_FixedPoint:
27248 return emitGetGlobalUncheckedFixedPoint(A0, I);
27249 case PT_Ptr:
27250 return emitGetGlobalUncheckedPtr(A0, I);
27251 case PT_MemberPtr:
27252 return emitGetGlobalUncheckedMemberPtr(A0, I);
27253 case PT_Float:
27254 return emitGetGlobalUncheckedFloat(A0, I);
27255 case PT_Reflect:
27256 return emitGetGlobalUncheckedReflect(A0, I);
27257 }
27258 llvm_unreachable("invalid enum value");
27259}
27260#endif
27261#ifdef GET_LINK_IMPL
27262bool ByteCodeEmitter::emitGetGlobalUncheckedSint8( uint32_t A0, SourceInfo L) {
27263 return emitOp<uint32_t>(OP_GetGlobalUncheckedSint8, A0, L);
27264}
27265bool ByteCodeEmitter::emitGetGlobalUncheckedUint8( uint32_t A0, SourceInfo L) {
27266 return emitOp<uint32_t>(OP_GetGlobalUncheckedUint8, A0, L);
27267}
27268bool ByteCodeEmitter::emitGetGlobalUncheckedSint16( uint32_t A0, SourceInfo L) {
27269 return emitOp<uint32_t>(OP_GetGlobalUncheckedSint16, A0, L);
27270}
27271bool ByteCodeEmitter::emitGetGlobalUncheckedUint16( uint32_t A0, SourceInfo L) {
27272 return emitOp<uint32_t>(OP_GetGlobalUncheckedUint16, A0, L);
27273}
27274bool ByteCodeEmitter::emitGetGlobalUncheckedSint32( uint32_t A0, SourceInfo L) {
27275 return emitOp<uint32_t>(OP_GetGlobalUncheckedSint32, A0, L);
27276}
27277bool ByteCodeEmitter::emitGetGlobalUncheckedUint32( uint32_t A0, SourceInfo L) {
27278 return emitOp<uint32_t>(OP_GetGlobalUncheckedUint32, A0, L);
27279}
27280bool ByteCodeEmitter::emitGetGlobalUncheckedSint64( uint32_t A0, SourceInfo L) {
27281 return emitOp<uint32_t>(OP_GetGlobalUncheckedSint64, A0, L);
27282}
27283bool ByteCodeEmitter::emitGetGlobalUncheckedUint64( uint32_t A0, SourceInfo L) {
27284 return emitOp<uint32_t>(OP_GetGlobalUncheckedUint64, A0, L);
27285}
27286bool ByteCodeEmitter::emitGetGlobalUncheckedIntAP( uint32_t A0, SourceInfo L) {
27287 return emitOp<uint32_t>(OP_GetGlobalUncheckedIntAP, A0, L);
27288}
27289bool ByteCodeEmitter::emitGetGlobalUncheckedIntAPS( uint32_t A0, SourceInfo L) {
27290 return emitOp<uint32_t>(OP_GetGlobalUncheckedIntAPS, A0, L);
27291}
27292bool ByteCodeEmitter::emitGetGlobalUncheckedBool( uint32_t A0, SourceInfo L) {
27293 return emitOp<uint32_t>(OP_GetGlobalUncheckedBool, A0, L);
27294}
27295bool ByteCodeEmitter::emitGetGlobalUncheckedFixedPoint( uint32_t A0, SourceInfo L) {
27296 return emitOp<uint32_t>(OP_GetGlobalUncheckedFixedPoint, A0, L);
27297}
27298bool ByteCodeEmitter::emitGetGlobalUncheckedPtr( uint32_t A0, SourceInfo L) {
27299 return emitOp<uint32_t>(OP_GetGlobalUncheckedPtr, A0, L);
27300}
27301bool ByteCodeEmitter::emitGetGlobalUncheckedMemberPtr( uint32_t A0, SourceInfo L) {
27302 return emitOp<uint32_t>(OP_GetGlobalUncheckedMemberPtr, A0, L);
27303}
27304bool ByteCodeEmitter::emitGetGlobalUncheckedFloat( uint32_t A0, SourceInfo L) {
27305 return emitOp<uint32_t>(OP_GetGlobalUncheckedFloat, A0, L);
27306}
27307bool ByteCodeEmitter::emitGetGlobalUncheckedReflect( uint32_t A0, SourceInfo L) {
27308 return emitOp<uint32_t>(OP_GetGlobalUncheckedReflect, A0, L);
27309}
27310#endif
27311#ifdef GET_EVAL_IMPL
27312bool EvalEmitter::emitGetGlobalUncheckedSint8( uint32_t A0, SourceInfo L) {
27313 if (!isActive()) return true;
27314 CurrentSource = L;
27315 return GetGlobalUnchecked<PT_Sint8>(S, CodePtr(), A0);
27316}
27317bool EvalEmitter::emitGetGlobalUncheckedUint8( uint32_t A0, SourceInfo L) {
27318 if (!isActive()) return true;
27319 CurrentSource = L;
27320 return GetGlobalUnchecked<PT_Uint8>(S, CodePtr(), A0);
27321}
27322bool EvalEmitter::emitGetGlobalUncheckedSint16( uint32_t A0, SourceInfo L) {
27323 if (!isActive()) return true;
27324 CurrentSource = L;
27325 return GetGlobalUnchecked<PT_Sint16>(S, CodePtr(), A0);
27326}
27327bool EvalEmitter::emitGetGlobalUncheckedUint16( uint32_t A0, SourceInfo L) {
27328 if (!isActive()) return true;
27329 CurrentSource = L;
27330 return GetGlobalUnchecked<PT_Uint16>(S, CodePtr(), A0);
27331}
27332bool EvalEmitter::emitGetGlobalUncheckedSint32( uint32_t A0, SourceInfo L) {
27333 if (!isActive()) return true;
27334 CurrentSource = L;
27335 return GetGlobalUnchecked<PT_Sint32>(S, CodePtr(), A0);
27336}
27337bool EvalEmitter::emitGetGlobalUncheckedUint32( uint32_t A0, SourceInfo L) {
27338 if (!isActive()) return true;
27339 CurrentSource = L;
27340 return GetGlobalUnchecked<PT_Uint32>(S, CodePtr(), A0);
27341}
27342bool EvalEmitter::emitGetGlobalUncheckedSint64( uint32_t A0, SourceInfo L) {
27343 if (!isActive()) return true;
27344 CurrentSource = L;
27345 return GetGlobalUnchecked<PT_Sint64>(S, CodePtr(), A0);
27346}
27347bool EvalEmitter::emitGetGlobalUncheckedUint64( uint32_t A0, SourceInfo L) {
27348 if (!isActive()) return true;
27349 CurrentSource = L;
27350 return GetGlobalUnchecked<PT_Uint64>(S, CodePtr(), A0);
27351}
27352bool EvalEmitter::emitGetGlobalUncheckedIntAP( uint32_t A0, SourceInfo L) {
27353 if (!isActive()) return true;
27354 CurrentSource = L;
27355 return GetGlobalUnchecked<PT_IntAP>(S, CodePtr(), A0);
27356}
27357bool EvalEmitter::emitGetGlobalUncheckedIntAPS( uint32_t A0, SourceInfo L) {
27358 if (!isActive()) return true;
27359 CurrentSource = L;
27360 return GetGlobalUnchecked<PT_IntAPS>(S, CodePtr(), A0);
27361}
27362bool EvalEmitter::emitGetGlobalUncheckedBool( uint32_t A0, SourceInfo L) {
27363 if (!isActive()) return true;
27364 CurrentSource = L;
27365 return GetGlobalUnchecked<PT_Bool>(S, CodePtr(), A0);
27366}
27367bool EvalEmitter::emitGetGlobalUncheckedFixedPoint( uint32_t A0, SourceInfo L) {
27368 if (!isActive()) return true;
27369 CurrentSource = L;
27370 return GetGlobalUnchecked<PT_FixedPoint>(S, CodePtr(), A0);
27371}
27372bool EvalEmitter::emitGetGlobalUncheckedPtr( uint32_t A0, SourceInfo L) {
27373 if (!isActive()) return true;
27374 CurrentSource = L;
27375 return GetGlobalUnchecked<PT_Ptr>(S, CodePtr(), A0);
27376}
27377bool EvalEmitter::emitGetGlobalUncheckedMemberPtr( uint32_t A0, SourceInfo L) {
27378 if (!isActive()) return true;
27379 CurrentSource = L;
27380 return GetGlobalUnchecked<PT_MemberPtr>(S, CodePtr(), A0);
27381}
27382bool EvalEmitter::emitGetGlobalUncheckedFloat( uint32_t A0, SourceInfo L) {
27383 if (!isActive()) return true;
27384 CurrentSource = L;
27385 return GetGlobalUnchecked<PT_Float>(S, CodePtr(), A0);
27386}
27387bool EvalEmitter::emitGetGlobalUncheckedReflect( uint32_t A0, SourceInfo L) {
27388 if (!isActive()) return true;
27389 CurrentSource = L;
27390 return GetGlobalUnchecked<PT_Reflect>(S, CodePtr(), A0);
27391}
27392#endif
27393#ifdef GET_OPCODE_NAMES
27394OP_GetIntPtrSint8,
27395OP_GetIntPtrUint8,
27396OP_GetIntPtrSint16,
27397OP_GetIntPtrUint16,
27398OP_GetIntPtrSint32,
27399OP_GetIntPtrUint32,
27400OP_GetIntPtrSint64,
27401OP_GetIntPtrUint64,
27402OP_GetIntPtrIntAP,
27403OP_GetIntPtrIntAPS,
27404OP_GetIntPtrBool,
27405OP_GetIntPtrFixedPoint,
27406#endif
27407#ifdef GET_INTERPFN_LIST
27408&Interp_GetIntPtrSint8,
27409&Interp_GetIntPtrUint8,
27410&Interp_GetIntPtrSint16,
27411&Interp_GetIntPtrUint16,
27412&Interp_GetIntPtrSint32,
27413&Interp_GetIntPtrUint32,
27414&Interp_GetIntPtrSint64,
27415&Interp_GetIntPtrUint64,
27416&Interp_GetIntPtrIntAP,
27417&Interp_GetIntPtrIntAPS,
27418&Interp_GetIntPtrBool,
27419&Interp_GetIntPtrFixedPoint,
27420#endif
27421#ifdef GET_INTERPFN_DISPATCHERS
27422PRESERVE_NONE
27423static bool Interp_GetIntPtrSint8(InterpState &S) {
27424 {
27425 CodePtr OpPC = S.PC;
27426 const auto V0 = ReadArg<const Type *>(S, S.PC);
27427 if (!GetIntPtr<PT_Sint8>(S, OpPC, V0)) return false;
27428 }
27429#if USE_TAILCALLS
27430 MUSTTAIL return InterpNext(S);
27431#else
27432 return true;
27433#endif
27434}
27435PRESERVE_NONE
27436static bool Interp_GetIntPtrUint8(InterpState &S) {
27437 {
27438 CodePtr OpPC = S.PC;
27439 const auto V0 = ReadArg<const Type *>(S, S.PC);
27440 if (!GetIntPtr<PT_Uint8>(S, OpPC, V0)) return false;
27441 }
27442#if USE_TAILCALLS
27443 MUSTTAIL return InterpNext(S);
27444#else
27445 return true;
27446#endif
27447}
27448PRESERVE_NONE
27449static bool Interp_GetIntPtrSint16(InterpState &S) {
27450 {
27451 CodePtr OpPC = S.PC;
27452 const auto V0 = ReadArg<const Type *>(S, S.PC);
27453 if (!GetIntPtr<PT_Sint16>(S, OpPC, V0)) return false;
27454 }
27455#if USE_TAILCALLS
27456 MUSTTAIL return InterpNext(S);
27457#else
27458 return true;
27459#endif
27460}
27461PRESERVE_NONE
27462static bool Interp_GetIntPtrUint16(InterpState &S) {
27463 {
27464 CodePtr OpPC = S.PC;
27465 const auto V0 = ReadArg<const Type *>(S, S.PC);
27466 if (!GetIntPtr<PT_Uint16>(S, OpPC, V0)) return false;
27467 }
27468#if USE_TAILCALLS
27469 MUSTTAIL return InterpNext(S);
27470#else
27471 return true;
27472#endif
27473}
27474PRESERVE_NONE
27475static bool Interp_GetIntPtrSint32(InterpState &S) {
27476 {
27477 CodePtr OpPC = S.PC;
27478 const auto V0 = ReadArg<const Type *>(S, S.PC);
27479 if (!GetIntPtr<PT_Sint32>(S, OpPC, V0)) return false;
27480 }
27481#if USE_TAILCALLS
27482 MUSTTAIL return InterpNext(S);
27483#else
27484 return true;
27485#endif
27486}
27487PRESERVE_NONE
27488static bool Interp_GetIntPtrUint32(InterpState &S) {
27489 {
27490 CodePtr OpPC = S.PC;
27491 const auto V0 = ReadArg<const Type *>(S, S.PC);
27492 if (!GetIntPtr<PT_Uint32>(S, OpPC, V0)) return false;
27493 }
27494#if USE_TAILCALLS
27495 MUSTTAIL return InterpNext(S);
27496#else
27497 return true;
27498#endif
27499}
27500PRESERVE_NONE
27501static bool Interp_GetIntPtrSint64(InterpState &S) {
27502 {
27503 CodePtr OpPC = S.PC;
27504 const auto V0 = ReadArg<const Type *>(S, S.PC);
27505 if (!GetIntPtr<PT_Sint64>(S, OpPC, V0)) return false;
27506 }
27507#if USE_TAILCALLS
27508 MUSTTAIL return InterpNext(S);
27509#else
27510 return true;
27511#endif
27512}
27513PRESERVE_NONE
27514static bool Interp_GetIntPtrUint64(InterpState &S) {
27515 {
27516 CodePtr OpPC = S.PC;
27517 const auto V0 = ReadArg<const Type *>(S, S.PC);
27518 if (!GetIntPtr<PT_Uint64>(S, OpPC, V0)) return false;
27519 }
27520#if USE_TAILCALLS
27521 MUSTTAIL return InterpNext(S);
27522#else
27523 return true;
27524#endif
27525}
27526PRESERVE_NONE
27527static bool Interp_GetIntPtrIntAP(InterpState &S) {
27528 {
27529 CodePtr OpPC = S.PC;
27530 const auto V0 = ReadArg<const Type *>(S, S.PC);
27531 if (!GetIntPtr<PT_IntAP>(S, OpPC, V0)) return false;
27532 }
27533#if USE_TAILCALLS
27534 MUSTTAIL return InterpNext(S);
27535#else
27536 return true;
27537#endif
27538}
27539PRESERVE_NONE
27540static bool Interp_GetIntPtrIntAPS(InterpState &S) {
27541 {
27542 CodePtr OpPC = S.PC;
27543 const auto V0 = ReadArg<const Type *>(S, S.PC);
27544 if (!GetIntPtr<PT_IntAPS>(S, OpPC, V0)) return false;
27545 }
27546#if USE_TAILCALLS
27547 MUSTTAIL return InterpNext(S);
27548#else
27549 return true;
27550#endif
27551}
27552PRESERVE_NONE
27553static bool Interp_GetIntPtrBool(InterpState &S) {
27554 {
27555 CodePtr OpPC = S.PC;
27556 const auto V0 = ReadArg<const Type *>(S, S.PC);
27557 if (!GetIntPtr<PT_Bool>(S, OpPC, V0)) return false;
27558 }
27559#if USE_TAILCALLS
27560 MUSTTAIL return InterpNext(S);
27561#else
27562 return true;
27563#endif
27564}
27565PRESERVE_NONE
27566static bool Interp_GetIntPtrFixedPoint(InterpState &S) {
27567 {
27568 CodePtr OpPC = S.PC;
27569 const auto V0 = ReadArg<const Type *>(S, S.PC);
27570 if (!GetIntPtr<PT_FixedPoint>(S, OpPC, V0)) return false;
27571 }
27572#if USE_TAILCALLS
27573 MUSTTAIL return InterpNext(S);
27574#else
27575 return true;
27576#endif
27577}
27578#endif
27579#ifdef GET_DISASM
27580case OP_GetIntPtrSint8:
27581 Text.Op = PrintName("GetIntPtrSint8");
27582 Text.Args.push_back(printArg<const Type *>(PC));
27583 break;
27584case OP_GetIntPtrUint8:
27585 Text.Op = PrintName("GetIntPtrUint8");
27586 Text.Args.push_back(printArg<const Type *>(PC));
27587 break;
27588case OP_GetIntPtrSint16:
27589 Text.Op = PrintName("GetIntPtrSint16");
27590 Text.Args.push_back(printArg<const Type *>(PC));
27591 break;
27592case OP_GetIntPtrUint16:
27593 Text.Op = PrintName("GetIntPtrUint16");
27594 Text.Args.push_back(printArg<const Type *>(PC));
27595 break;
27596case OP_GetIntPtrSint32:
27597 Text.Op = PrintName("GetIntPtrSint32");
27598 Text.Args.push_back(printArg<const Type *>(PC));
27599 break;
27600case OP_GetIntPtrUint32:
27601 Text.Op = PrintName("GetIntPtrUint32");
27602 Text.Args.push_back(printArg<const Type *>(PC));
27603 break;
27604case OP_GetIntPtrSint64:
27605 Text.Op = PrintName("GetIntPtrSint64");
27606 Text.Args.push_back(printArg<const Type *>(PC));
27607 break;
27608case OP_GetIntPtrUint64:
27609 Text.Op = PrintName("GetIntPtrUint64");
27610 Text.Args.push_back(printArg<const Type *>(PC));
27611 break;
27612case OP_GetIntPtrIntAP:
27613 Text.Op = PrintName("GetIntPtrIntAP");
27614 Text.Args.push_back(printArg<const Type *>(PC));
27615 break;
27616case OP_GetIntPtrIntAPS:
27617 Text.Op = PrintName("GetIntPtrIntAPS");
27618 Text.Args.push_back(printArg<const Type *>(PC));
27619 break;
27620case OP_GetIntPtrBool:
27621 Text.Op = PrintName("GetIntPtrBool");
27622 Text.Args.push_back(printArg<const Type *>(PC));
27623 break;
27624case OP_GetIntPtrFixedPoint:
27625 Text.Op = PrintName("GetIntPtrFixedPoint");
27626 Text.Args.push_back(printArg<const Type *>(PC));
27627 break;
27628#endif
27629#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27630bool emitGetIntPtrSint8( const Type * , SourceInfo);
27631bool emitGetIntPtrUint8( const Type * , SourceInfo);
27632bool emitGetIntPtrSint16( const Type * , SourceInfo);
27633bool emitGetIntPtrUint16( const Type * , SourceInfo);
27634bool emitGetIntPtrSint32( const Type * , SourceInfo);
27635bool emitGetIntPtrUint32( const Type * , SourceInfo);
27636bool emitGetIntPtrSint64( const Type * , SourceInfo);
27637bool emitGetIntPtrUint64( const Type * , SourceInfo);
27638bool emitGetIntPtrIntAP( const Type * , SourceInfo);
27639bool emitGetIntPtrIntAPS( const Type * , SourceInfo);
27640bool emitGetIntPtrBool( const Type * , SourceInfo);
27641bool emitGetIntPtrFixedPoint( const Type * , SourceInfo);
27642#endif
27643#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
27644[[nodiscard]] bool emitGetIntPtr(PrimType, const Type *, SourceInfo I);
27645#endif
27646#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
27647bool
27648#if defined(GET_EVAL_IMPL)
27649EvalEmitter
27650#else
27651ByteCodeEmitter
27652#endif
27653::emitGetIntPtr(PrimType T0, const Type * A0, SourceInfo I) {
27654 switch (T0) {
27655 case PT_Sint8:
27656 return emitGetIntPtrSint8(A0, I);
27657 case PT_Uint8:
27658 return emitGetIntPtrUint8(A0, I);
27659 case PT_Sint16:
27660 return emitGetIntPtrSint16(A0, I);
27661 case PT_Uint16:
27662 return emitGetIntPtrUint16(A0, I);
27663 case PT_Sint32:
27664 return emitGetIntPtrSint32(A0, I);
27665 case PT_Uint32:
27666 return emitGetIntPtrUint32(A0, I);
27667 case PT_Sint64:
27668 return emitGetIntPtrSint64(A0, I);
27669 case PT_Uint64:
27670 return emitGetIntPtrUint64(A0, I);
27671 case PT_IntAP:
27672 return emitGetIntPtrIntAP(A0, I);
27673 case PT_IntAPS:
27674 return emitGetIntPtrIntAPS(A0, I);
27675 case PT_Bool:
27676 return emitGetIntPtrBool(A0, I);
27677 case PT_FixedPoint:
27678 return emitGetIntPtrFixedPoint(A0, I);
27679 default: llvm_unreachable("invalid type: emitGetIntPtr");
27680 }
27681 llvm_unreachable("invalid enum value");
27682}
27683#endif
27684#ifdef GET_LINK_IMPL
27685bool ByteCodeEmitter::emitGetIntPtrSint8( const Type * A0, SourceInfo L) {
27686 return emitOp<const Type *>(OP_GetIntPtrSint8, A0, L);
27687}
27688bool ByteCodeEmitter::emitGetIntPtrUint8( const Type * A0, SourceInfo L) {
27689 return emitOp<const Type *>(OP_GetIntPtrUint8, A0, L);
27690}
27691bool ByteCodeEmitter::emitGetIntPtrSint16( const Type * A0, SourceInfo L) {
27692 return emitOp<const Type *>(OP_GetIntPtrSint16, A0, L);
27693}
27694bool ByteCodeEmitter::emitGetIntPtrUint16( const Type * A0, SourceInfo L) {
27695 return emitOp<const Type *>(OP_GetIntPtrUint16, A0, L);
27696}
27697bool ByteCodeEmitter::emitGetIntPtrSint32( const Type * A0, SourceInfo L) {
27698 return emitOp<const Type *>(OP_GetIntPtrSint32, A0, L);
27699}
27700bool ByteCodeEmitter::emitGetIntPtrUint32( const Type * A0, SourceInfo L) {
27701 return emitOp<const Type *>(OP_GetIntPtrUint32, A0, L);
27702}
27703bool ByteCodeEmitter::emitGetIntPtrSint64( const Type * A0, SourceInfo L) {
27704 return emitOp<const Type *>(OP_GetIntPtrSint64, A0, L);
27705}
27706bool ByteCodeEmitter::emitGetIntPtrUint64( const Type * A0, SourceInfo L) {
27707 return emitOp<const Type *>(OP_GetIntPtrUint64, A0, L);
27708}
27709bool ByteCodeEmitter::emitGetIntPtrIntAP( const Type * A0, SourceInfo L) {
27710 return emitOp<const Type *>(OP_GetIntPtrIntAP, A0, L);
27711}
27712bool ByteCodeEmitter::emitGetIntPtrIntAPS( const Type * A0, SourceInfo L) {
27713 return emitOp<const Type *>(OP_GetIntPtrIntAPS, A0, L);
27714}
27715bool ByteCodeEmitter::emitGetIntPtrBool( const Type * A0, SourceInfo L) {
27716 return emitOp<const Type *>(OP_GetIntPtrBool, A0, L);
27717}
27718bool ByteCodeEmitter::emitGetIntPtrFixedPoint( const Type * A0, SourceInfo L) {
27719 return emitOp<const Type *>(OP_GetIntPtrFixedPoint, A0, L);
27720}
27721#endif
27722#ifdef GET_EVAL_IMPL
27723bool EvalEmitter::emitGetIntPtrSint8( const Type * A0, SourceInfo L) {
27724 if (!isActive()) return true;
27725 CurrentSource = L;
27726 return GetIntPtr<PT_Sint8>(S, CodePtr(), A0);
27727}
27728bool EvalEmitter::emitGetIntPtrUint8( const Type * A0, SourceInfo L) {
27729 if (!isActive()) return true;
27730 CurrentSource = L;
27731 return GetIntPtr<PT_Uint8>(S, CodePtr(), A0);
27732}
27733bool EvalEmitter::emitGetIntPtrSint16( const Type * A0, SourceInfo L) {
27734 if (!isActive()) return true;
27735 CurrentSource = L;
27736 return GetIntPtr<PT_Sint16>(S, CodePtr(), A0);
27737}
27738bool EvalEmitter::emitGetIntPtrUint16( const Type * A0, SourceInfo L) {
27739 if (!isActive()) return true;
27740 CurrentSource = L;
27741 return GetIntPtr<PT_Uint16>(S, CodePtr(), A0);
27742}
27743bool EvalEmitter::emitGetIntPtrSint32( const Type * A0, SourceInfo L) {
27744 if (!isActive()) return true;
27745 CurrentSource = L;
27746 return GetIntPtr<PT_Sint32>(S, CodePtr(), A0);
27747}
27748bool EvalEmitter::emitGetIntPtrUint32( const Type * A0, SourceInfo L) {
27749 if (!isActive()) return true;
27750 CurrentSource = L;
27751 return GetIntPtr<PT_Uint32>(S, CodePtr(), A0);
27752}
27753bool EvalEmitter::emitGetIntPtrSint64( const Type * A0, SourceInfo L) {
27754 if (!isActive()) return true;
27755 CurrentSource = L;
27756 return GetIntPtr<PT_Sint64>(S, CodePtr(), A0);
27757}
27758bool EvalEmitter::emitGetIntPtrUint64( const Type * A0, SourceInfo L) {
27759 if (!isActive()) return true;
27760 CurrentSource = L;
27761 return GetIntPtr<PT_Uint64>(S, CodePtr(), A0);
27762}
27763bool EvalEmitter::emitGetIntPtrIntAP( const Type * A0, SourceInfo L) {
27764 if (!isActive()) return true;
27765 CurrentSource = L;
27766 return GetIntPtr<PT_IntAP>(S, CodePtr(), A0);
27767}
27768bool EvalEmitter::emitGetIntPtrIntAPS( const Type * A0, SourceInfo L) {
27769 if (!isActive()) return true;
27770 CurrentSource = L;
27771 return GetIntPtr<PT_IntAPS>(S, CodePtr(), A0);
27772}
27773bool EvalEmitter::emitGetIntPtrBool( const Type * A0, SourceInfo L) {
27774 if (!isActive()) return true;
27775 CurrentSource = L;
27776 return GetIntPtr<PT_Bool>(S, CodePtr(), A0);
27777}
27778bool EvalEmitter::emitGetIntPtrFixedPoint( const Type * A0, SourceInfo L) {
27779 if (!isActive()) return true;
27780 CurrentSource = L;
27781 return GetIntPtr<PT_FixedPoint>(S, CodePtr(), A0);
27782}
27783#endif
27784#ifdef GET_OPCODE_NAMES
27785OP_GetLocalSint8,
27786OP_GetLocalUint8,
27787OP_GetLocalSint16,
27788OP_GetLocalUint16,
27789OP_GetLocalSint32,
27790OP_GetLocalUint32,
27791OP_GetLocalSint64,
27792OP_GetLocalUint64,
27793OP_GetLocalIntAP,
27794OP_GetLocalIntAPS,
27795OP_GetLocalBool,
27796OP_GetLocalFixedPoint,
27797OP_GetLocalPtr,
27798OP_GetLocalMemberPtr,
27799OP_GetLocalFloat,
27800OP_GetLocalReflect,
27801#endif
27802#ifdef GET_INTERPFN_LIST
27803&Interp_GetLocalSint8,
27804&Interp_GetLocalUint8,
27805&Interp_GetLocalSint16,
27806&Interp_GetLocalUint16,
27807&Interp_GetLocalSint32,
27808&Interp_GetLocalUint32,
27809&Interp_GetLocalSint64,
27810&Interp_GetLocalUint64,
27811&Interp_GetLocalIntAP,
27812&Interp_GetLocalIntAPS,
27813&Interp_GetLocalBool,
27814&Interp_GetLocalFixedPoint,
27815&Interp_GetLocalPtr,
27816&Interp_GetLocalMemberPtr,
27817&Interp_GetLocalFloat,
27818&Interp_GetLocalReflect,
27819#endif
27820#ifdef GET_INTERPFN_DISPATCHERS
27821PRESERVE_NONE
27822static bool Interp_GetLocalSint8(InterpState &S) {
27823 {
27824 CodePtr OpPC = S.PC;
27825 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27826 if (!GetLocal<PT_Sint8>(S, OpPC, V0)) return false;
27827 }
27828#if USE_TAILCALLS
27829 MUSTTAIL return InterpNext(S);
27830#else
27831 return true;
27832#endif
27833}
27834PRESERVE_NONE
27835static bool Interp_GetLocalUint8(InterpState &S) {
27836 {
27837 CodePtr OpPC = S.PC;
27838 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27839 if (!GetLocal<PT_Uint8>(S, OpPC, V0)) return false;
27840 }
27841#if USE_TAILCALLS
27842 MUSTTAIL return InterpNext(S);
27843#else
27844 return true;
27845#endif
27846}
27847PRESERVE_NONE
27848static bool Interp_GetLocalSint16(InterpState &S) {
27849 {
27850 CodePtr OpPC = S.PC;
27851 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27852 if (!GetLocal<PT_Sint16>(S, OpPC, V0)) return false;
27853 }
27854#if USE_TAILCALLS
27855 MUSTTAIL return InterpNext(S);
27856#else
27857 return true;
27858#endif
27859}
27860PRESERVE_NONE
27861static bool Interp_GetLocalUint16(InterpState &S) {
27862 {
27863 CodePtr OpPC = S.PC;
27864 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27865 if (!GetLocal<PT_Uint16>(S, OpPC, V0)) return false;
27866 }
27867#if USE_TAILCALLS
27868 MUSTTAIL return InterpNext(S);
27869#else
27870 return true;
27871#endif
27872}
27873PRESERVE_NONE
27874static bool Interp_GetLocalSint32(InterpState &S) {
27875 {
27876 CodePtr OpPC = S.PC;
27877 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27878 if (!GetLocal<PT_Sint32>(S, OpPC, V0)) return false;
27879 }
27880#if USE_TAILCALLS
27881 MUSTTAIL return InterpNext(S);
27882#else
27883 return true;
27884#endif
27885}
27886PRESERVE_NONE
27887static bool Interp_GetLocalUint32(InterpState &S) {
27888 {
27889 CodePtr OpPC = S.PC;
27890 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27891 if (!GetLocal<PT_Uint32>(S, OpPC, V0)) return false;
27892 }
27893#if USE_TAILCALLS
27894 MUSTTAIL return InterpNext(S);
27895#else
27896 return true;
27897#endif
27898}
27899PRESERVE_NONE
27900static bool Interp_GetLocalSint64(InterpState &S) {
27901 {
27902 CodePtr OpPC = S.PC;
27903 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27904 if (!GetLocal<PT_Sint64>(S, OpPC, V0)) return false;
27905 }
27906#if USE_TAILCALLS
27907 MUSTTAIL return InterpNext(S);
27908#else
27909 return true;
27910#endif
27911}
27912PRESERVE_NONE
27913static bool Interp_GetLocalUint64(InterpState &S) {
27914 {
27915 CodePtr OpPC = S.PC;
27916 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27917 if (!GetLocal<PT_Uint64>(S, OpPC, V0)) return false;
27918 }
27919#if USE_TAILCALLS
27920 MUSTTAIL return InterpNext(S);
27921#else
27922 return true;
27923#endif
27924}
27925PRESERVE_NONE
27926static bool Interp_GetLocalIntAP(InterpState &S) {
27927 {
27928 CodePtr OpPC = S.PC;
27929 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27930 if (!GetLocal<PT_IntAP>(S, OpPC, V0)) return false;
27931 }
27932#if USE_TAILCALLS
27933 MUSTTAIL return InterpNext(S);
27934#else
27935 return true;
27936#endif
27937}
27938PRESERVE_NONE
27939static bool Interp_GetLocalIntAPS(InterpState &S) {
27940 {
27941 CodePtr OpPC = S.PC;
27942 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27943 if (!GetLocal<PT_IntAPS>(S, OpPC, V0)) return false;
27944 }
27945#if USE_TAILCALLS
27946 MUSTTAIL return InterpNext(S);
27947#else
27948 return true;
27949#endif
27950}
27951PRESERVE_NONE
27952static bool Interp_GetLocalBool(InterpState &S) {
27953 {
27954 CodePtr OpPC = S.PC;
27955 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27956 if (!GetLocal<PT_Bool>(S, OpPC, V0)) return false;
27957 }
27958#if USE_TAILCALLS
27959 MUSTTAIL return InterpNext(S);
27960#else
27961 return true;
27962#endif
27963}
27964PRESERVE_NONE
27965static bool Interp_GetLocalFixedPoint(InterpState &S) {
27966 {
27967 CodePtr OpPC = S.PC;
27968 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27969 if (!GetLocal<PT_FixedPoint>(S, OpPC, V0)) return false;
27970 }
27971#if USE_TAILCALLS
27972 MUSTTAIL return InterpNext(S);
27973#else
27974 return true;
27975#endif
27976}
27977PRESERVE_NONE
27978static bool Interp_GetLocalPtr(InterpState &S) {
27979 {
27980 CodePtr OpPC = S.PC;
27981 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27982 if (!GetLocal<PT_Ptr>(S, OpPC, V0)) return false;
27983 }
27984#if USE_TAILCALLS
27985 MUSTTAIL return InterpNext(S);
27986#else
27987 return true;
27988#endif
27989}
27990PRESERVE_NONE
27991static bool Interp_GetLocalMemberPtr(InterpState &S) {
27992 {
27993 CodePtr OpPC = S.PC;
27994 const auto V0 = ReadArg<uint32_t>(S, S.PC);
27995 if (!GetLocal<PT_MemberPtr>(S, OpPC, V0)) return false;
27996 }
27997#if USE_TAILCALLS
27998 MUSTTAIL return InterpNext(S);
27999#else
28000 return true;
28001#endif
28002}
28003PRESERVE_NONE
28004static bool Interp_GetLocalFloat(InterpState &S) {
28005 {
28006 CodePtr OpPC = S.PC;
28007 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28008 if (!GetLocal<PT_Float>(S, OpPC, V0)) return false;
28009 }
28010#if USE_TAILCALLS
28011 MUSTTAIL return InterpNext(S);
28012#else
28013 return true;
28014#endif
28015}
28016PRESERVE_NONE
28017static bool Interp_GetLocalReflect(InterpState &S) {
28018 {
28019 CodePtr OpPC = S.PC;
28020 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28021 if (!GetLocal<PT_Reflect>(S, OpPC, V0)) return false;
28022 }
28023#if USE_TAILCALLS
28024 MUSTTAIL return InterpNext(S);
28025#else
28026 return true;
28027#endif
28028}
28029#endif
28030#ifdef GET_DISASM
28031case OP_GetLocalSint8:
28032 Text.Op = PrintName("GetLocalSint8");
28033 Text.Args.push_back(printArg<uint32_t>(PC));
28034 break;
28035case OP_GetLocalUint8:
28036 Text.Op = PrintName("GetLocalUint8");
28037 Text.Args.push_back(printArg<uint32_t>(PC));
28038 break;
28039case OP_GetLocalSint16:
28040 Text.Op = PrintName("GetLocalSint16");
28041 Text.Args.push_back(printArg<uint32_t>(PC));
28042 break;
28043case OP_GetLocalUint16:
28044 Text.Op = PrintName("GetLocalUint16");
28045 Text.Args.push_back(printArg<uint32_t>(PC));
28046 break;
28047case OP_GetLocalSint32:
28048 Text.Op = PrintName("GetLocalSint32");
28049 Text.Args.push_back(printArg<uint32_t>(PC));
28050 break;
28051case OP_GetLocalUint32:
28052 Text.Op = PrintName("GetLocalUint32");
28053 Text.Args.push_back(printArg<uint32_t>(PC));
28054 break;
28055case OP_GetLocalSint64:
28056 Text.Op = PrintName("GetLocalSint64");
28057 Text.Args.push_back(printArg<uint32_t>(PC));
28058 break;
28059case OP_GetLocalUint64:
28060 Text.Op = PrintName("GetLocalUint64");
28061 Text.Args.push_back(printArg<uint32_t>(PC));
28062 break;
28063case OP_GetLocalIntAP:
28064 Text.Op = PrintName("GetLocalIntAP");
28065 Text.Args.push_back(printArg<uint32_t>(PC));
28066 break;
28067case OP_GetLocalIntAPS:
28068 Text.Op = PrintName("GetLocalIntAPS");
28069 Text.Args.push_back(printArg<uint32_t>(PC));
28070 break;
28071case OP_GetLocalBool:
28072 Text.Op = PrintName("GetLocalBool");
28073 Text.Args.push_back(printArg<uint32_t>(PC));
28074 break;
28075case OP_GetLocalFixedPoint:
28076 Text.Op = PrintName("GetLocalFixedPoint");
28077 Text.Args.push_back(printArg<uint32_t>(PC));
28078 break;
28079case OP_GetLocalPtr:
28080 Text.Op = PrintName("GetLocalPtr");
28081 Text.Args.push_back(printArg<uint32_t>(PC));
28082 break;
28083case OP_GetLocalMemberPtr:
28084 Text.Op = PrintName("GetLocalMemberPtr");
28085 Text.Args.push_back(printArg<uint32_t>(PC));
28086 break;
28087case OP_GetLocalFloat:
28088 Text.Op = PrintName("GetLocalFloat");
28089 Text.Args.push_back(printArg<uint32_t>(PC));
28090 break;
28091case OP_GetLocalReflect:
28092 Text.Op = PrintName("GetLocalReflect");
28093 Text.Args.push_back(printArg<uint32_t>(PC));
28094 break;
28095#endif
28096#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28097bool emitGetLocalSint8( uint32_t , SourceInfo);
28098bool emitGetLocalUint8( uint32_t , SourceInfo);
28099bool emitGetLocalSint16( uint32_t , SourceInfo);
28100bool emitGetLocalUint16( uint32_t , SourceInfo);
28101bool emitGetLocalSint32( uint32_t , SourceInfo);
28102bool emitGetLocalUint32( uint32_t , SourceInfo);
28103bool emitGetLocalSint64( uint32_t , SourceInfo);
28104bool emitGetLocalUint64( uint32_t , SourceInfo);
28105bool emitGetLocalIntAP( uint32_t , SourceInfo);
28106bool emitGetLocalIntAPS( uint32_t , SourceInfo);
28107bool emitGetLocalBool( uint32_t , SourceInfo);
28108bool emitGetLocalFixedPoint( uint32_t , SourceInfo);
28109bool emitGetLocalPtr( uint32_t , SourceInfo);
28110bool emitGetLocalMemberPtr( uint32_t , SourceInfo);
28111bool emitGetLocalFloat( uint32_t , SourceInfo);
28112bool emitGetLocalReflect( uint32_t , SourceInfo);
28113#if defined(GET_EVAL_PROTO)
28114template<PrimType>
28115bool emitGetLocal(uint32_t, SourceInfo);
28116#endif
28117#endif
28118#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28119[[nodiscard]] bool emitGetLocal(PrimType, uint32_t, SourceInfo I);
28120#endif
28121#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
28122bool
28123#if defined(GET_EVAL_IMPL)
28124EvalEmitter
28125#else
28126ByteCodeEmitter
28127#endif
28128::emitGetLocal(PrimType T0, uint32_t A0, SourceInfo I) {
28129 switch (T0) {
28130 case PT_Sint8:
28131#ifdef GET_LINK_IMPL
28132 return emitGetLocalSint8
28133#else
28134 return emitGetLocal<PT_Sint8>
28135#endif
28136 (A0, I);
28137 case PT_Uint8:
28138#ifdef GET_LINK_IMPL
28139 return emitGetLocalUint8
28140#else
28141 return emitGetLocal<PT_Uint8>
28142#endif
28143 (A0, I);
28144 case PT_Sint16:
28145#ifdef GET_LINK_IMPL
28146 return emitGetLocalSint16
28147#else
28148 return emitGetLocal<PT_Sint16>
28149#endif
28150 (A0, I);
28151 case PT_Uint16:
28152#ifdef GET_LINK_IMPL
28153 return emitGetLocalUint16
28154#else
28155 return emitGetLocal<PT_Uint16>
28156#endif
28157 (A0, I);
28158 case PT_Sint32:
28159#ifdef GET_LINK_IMPL
28160 return emitGetLocalSint32
28161#else
28162 return emitGetLocal<PT_Sint32>
28163#endif
28164 (A0, I);
28165 case PT_Uint32:
28166#ifdef GET_LINK_IMPL
28167 return emitGetLocalUint32
28168#else
28169 return emitGetLocal<PT_Uint32>
28170#endif
28171 (A0, I);
28172 case PT_Sint64:
28173#ifdef GET_LINK_IMPL
28174 return emitGetLocalSint64
28175#else
28176 return emitGetLocal<PT_Sint64>
28177#endif
28178 (A0, I);
28179 case PT_Uint64:
28180#ifdef GET_LINK_IMPL
28181 return emitGetLocalUint64
28182#else
28183 return emitGetLocal<PT_Uint64>
28184#endif
28185 (A0, I);
28186 case PT_IntAP:
28187#ifdef GET_LINK_IMPL
28188 return emitGetLocalIntAP
28189#else
28190 return emitGetLocal<PT_IntAP>
28191#endif
28192 (A0, I);
28193 case PT_IntAPS:
28194#ifdef GET_LINK_IMPL
28195 return emitGetLocalIntAPS
28196#else
28197 return emitGetLocal<PT_IntAPS>
28198#endif
28199 (A0, I);
28200 case PT_Bool:
28201#ifdef GET_LINK_IMPL
28202 return emitGetLocalBool
28203#else
28204 return emitGetLocal<PT_Bool>
28205#endif
28206 (A0, I);
28207 case PT_FixedPoint:
28208#ifdef GET_LINK_IMPL
28209 return emitGetLocalFixedPoint
28210#else
28211 return emitGetLocal<PT_FixedPoint>
28212#endif
28213 (A0, I);
28214 case PT_Ptr:
28215#ifdef GET_LINK_IMPL
28216 return emitGetLocalPtr
28217#else
28218 return emitGetLocal<PT_Ptr>
28219#endif
28220 (A0, I);
28221 case PT_MemberPtr:
28222#ifdef GET_LINK_IMPL
28223 return emitGetLocalMemberPtr
28224#else
28225 return emitGetLocal<PT_MemberPtr>
28226#endif
28227 (A0, I);
28228 case PT_Float:
28229#ifdef GET_LINK_IMPL
28230 return emitGetLocalFloat
28231#else
28232 return emitGetLocal<PT_Float>
28233#endif
28234 (A0, I);
28235 case PT_Reflect:
28236#ifdef GET_LINK_IMPL
28237 return emitGetLocalReflect
28238#else
28239 return emitGetLocal<PT_Reflect>
28240#endif
28241 (A0, I);
28242 }
28243 llvm_unreachable("invalid enum value");
28244}
28245#endif
28246#ifdef GET_LINK_IMPL
28247bool ByteCodeEmitter::emitGetLocalSint8( uint32_t A0, SourceInfo L) {
28248 return emitOp<uint32_t>(OP_GetLocalSint8, A0, L);
28249}
28250bool ByteCodeEmitter::emitGetLocalUint8( uint32_t A0, SourceInfo L) {
28251 return emitOp<uint32_t>(OP_GetLocalUint8, A0, L);
28252}
28253bool ByteCodeEmitter::emitGetLocalSint16( uint32_t A0, SourceInfo L) {
28254 return emitOp<uint32_t>(OP_GetLocalSint16, A0, L);
28255}
28256bool ByteCodeEmitter::emitGetLocalUint16( uint32_t A0, SourceInfo L) {
28257 return emitOp<uint32_t>(OP_GetLocalUint16, A0, L);
28258}
28259bool ByteCodeEmitter::emitGetLocalSint32( uint32_t A0, SourceInfo L) {
28260 return emitOp<uint32_t>(OP_GetLocalSint32, A0, L);
28261}
28262bool ByteCodeEmitter::emitGetLocalUint32( uint32_t A0, SourceInfo L) {
28263 return emitOp<uint32_t>(OP_GetLocalUint32, A0, L);
28264}
28265bool ByteCodeEmitter::emitGetLocalSint64( uint32_t A0, SourceInfo L) {
28266 return emitOp<uint32_t>(OP_GetLocalSint64, A0, L);
28267}
28268bool ByteCodeEmitter::emitGetLocalUint64( uint32_t A0, SourceInfo L) {
28269 return emitOp<uint32_t>(OP_GetLocalUint64, A0, L);
28270}
28271bool ByteCodeEmitter::emitGetLocalIntAP( uint32_t A0, SourceInfo L) {
28272 return emitOp<uint32_t>(OP_GetLocalIntAP, A0, L);
28273}
28274bool ByteCodeEmitter::emitGetLocalIntAPS( uint32_t A0, SourceInfo L) {
28275 return emitOp<uint32_t>(OP_GetLocalIntAPS, A0, L);
28276}
28277bool ByteCodeEmitter::emitGetLocalBool( uint32_t A0, SourceInfo L) {
28278 return emitOp<uint32_t>(OP_GetLocalBool, A0, L);
28279}
28280bool ByteCodeEmitter::emitGetLocalFixedPoint( uint32_t A0, SourceInfo L) {
28281 return emitOp<uint32_t>(OP_GetLocalFixedPoint, A0, L);
28282}
28283bool ByteCodeEmitter::emitGetLocalPtr( uint32_t A0, SourceInfo L) {
28284 return emitOp<uint32_t>(OP_GetLocalPtr, A0, L);
28285}
28286bool ByteCodeEmitter::emitGetLocalMemberPtr( uint32_t A0, SourceInfo L) {
28287 return emitOp<uint32_t>(OP_GetLocalMemberPtr, A0, L);
28288}
28289bool ByteCodeEmitter::emitGetLocalFloat( uint32_t A0, SourceInfo L) {
28290 return emitOp<uint32_t>(OP_GetLocalFloat, A0, L);
28291}
28292bool ByteCodeEmitter::emitGetLocalReflect( uint32_t A0, SourceInfo L) {
28293 return emitOp<uint32_t>(OP_GetLocalReflect, A0, L);
28294}
28295#endif
28296#ifdef GET_OPCODE_NAMES
28297OP_GetLocalEnabled,
28298#endif
28299#ifdef GET_INTERPFN_LIST
28300&Interp_GetLocalEnabled,
28301#endif
28302#ifdef GET_INTERPFN_DISPATCHERS
28303PRESERVE_NONE
28304static bool Interp_GetLocalEnabled(InterpState &S) {
28305 {
28306 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28307 GetLocalEnabled(S, V0);
28308 }
28309#if USE_TAILCALLS
28310 MUSTTAIL return InterpNext(S);
28311#else
28312 return true;
28313#endif
28314}
28315#endif
28316#ifdef GET_DISASM
28317case OP_GetLocalEnabled:
28318 Text.Op = PrintName("GetLocalEnabled");
28319 Text.Args.push_back(printArg<uint32_t>(PC));
28320 break;
28321#endif
28322#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28323bool emitGetLocalEnabled( uint32_t , SourceInfo);
28324#endif
28325#ifdef GET_LINK_IMPL
28326bool ByteCodeEmitter::emitGetLocalEnabled( uint32_t A0, SourceInfo L) {
28327 return emitOp<uint32_t>(OP_GetLocalEnabled, A0, L);
28328}
28329#endif
28330#ifdef GET_OPCODE_NAMES
28331OP_GetMemberPtr,
28332#endif
28333#ifdef GET_INTERPFN_LIST
28334&Interp_GetMemberPtr,
28335#endif
28336#ifdef GET_INTERPFN_DISPATCHERS
28337PRESERVE_NONE
28338static bool Interp_GetMemberPtr(InterpState &S) {
28339 {
28340 const auto V0 = ReadArg<const ValueDecl*>(S, S.PC);
28341 GetMemberPtr(S, V0);
28342 }
28343#if USE_TAILCALLS
28344 MUSTTAIL return InterpNext(S);
28345#else
28346 return true;
28347#endif
28348}
28349#endif
28350#ifdef GET_DISASM
28351case OP_GetMemberPtr:
28352 Text.Op = PrintName("GetMemberPtr");
28353 Text.Args.push_back(printArg<const ValueDecl*>(PC));
28354 break;
28355#endif
28356#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28357bool emitGetMemberPtr( const ValueDecl* , SourceInfo);
28358#endif
28359#ifdef GET_LINK_IMPL
28360bool ByteCodeEmitter::emitGetMemberPtr( const ValueDecl* A0, SourceInfo L) {
28361 return emitOp<const ValueDecl*>(OP_GetMemberPtr, A0, L);
28362}
28363#endif
28364#ifdef GET_EVAL_IMPL
28365bool EvalEmitter::emitGetMemberPtr( const ValueDecl* A0, SourceInfo L) {
28366 if (!isActive()) return true;
28367 CurrentSource = L;
28368 return GetMemberPtr(S, A0);
28369}
28370#endif
28371#ifdef GET_OPCODE_NAMES
28372OP_GetMemberPtrBase,
28373#endif
28374#ifdef GET_INTERPFN_LIST
28375&Interp_GetMemberPtrBase,
28376#endif
28377#ifdef GET_INTERPFN_DISPATCHERS
28378PRESERVE_NONE
28379static bool Interp_GetMemberPtrBase(InterpState &S) {
28380 if (!GetMemberPtrBase(S)) return false;
28381#if USE_TAILCALLS
28382 MUSTTAIL return InterpNext(S);
28383#else
28384 return true;
28385#endif
28386}
28387#endif
28388#ifdef GET_DISASM
28389case OP_GetMemberPtrBase:
28390 Text.Op = PrintName("GetMemberPtrBase");
28391 break;
28392#endif
28393#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28394bool emitGetMemberPtrBase(SourceInfo);
28395#endif
28396#ifdef GET_LINK_IMPL
28397bool ByteCodeEmitter::emitGetMemberPtrBase(SourceInfo L) {
28398 return emitOp<>(OP_GetMemberPtrBase, L);
28399}
28400#endif
28401#ifdef GET_EVAL_IMPL
28402bool EvalEmitter::emitGetMemberPtrBase(SourceInfo L) {
28403 if (!isActive()) return true;
28404 CurrentSource = L;
28405 return GetMemberPtrBase(S);
28406}
28407#endif
28408#ifdef GET_OPCODE_NAMES
28409OP_GetMemberPtrDecl,
28410#endif
28411#ifdef GET_INTERPFN_LIST
28412&Interp_GetMemberPtrDecl,
28413#endif
28414#ifdef GET_INTERPFN_DISPATCHERS
28415PRESERVE_NONE
28416static bool Interp_GetMemberPtrDecl(InterpState &S) {
28417 if (!GetMemberPtrDecl(S)) return false;
28418#if USE_TAILCALLS
28419 MUSTTAIL return InterpNext(S);
28420#else
28421 return true;
28422#endif
28423}
28424#endif
28425#ifdef GET_DISASM
28426case OP_GetMemberPtrDecl:
28427 Text.Op = PrintName("GetMemberPtrDecl");
28428 break;
28429#endif
28430#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28431bool emitGetMemberPtrDecl(SourceInfo);
28432#endif
28433#ifdef GET_LINK_IMPL
28434bool ByteCodeEmitter::emitGetMemberPtrDecl(SourceInfo L) {
28435 return emitOp<>(OP_GetMemberPtrDecl, L);
28436}
28437#endif
28438#ifdef GET_EVAL_IMPL
28439bool EvalEmitter::emitGetMemberPtrDecl(SourceInfo L) {
28440 if (!isActive()) return true;
28441 CurrentSource = L;
28442 return GetMemberPtrDecl(S);
28443}
28444#endif
28445#ifdef GET_OPCODE_NAMES
28446OP_GetOpaquePtr,
28447#endif
28448#ifdef GET_INTERPFN_LIST
28449&Interp_GetOpaquePtr,
28450#endif
28451#ifdef GET_INTERPFN_DISPATCHERS
28452PRESERVE_NONE
28453static bool Interp_GetOpaquePtr(InterpState &S) {
28454 {
28455 const auto V0 = ReadArg<DeclOrExpr>(S, S.PC);
28456 const auto V1 = ReadArg<bool>(S, S.PC);
28457 GetOpaquePtr(S, V0, V1);
28458 }
28459#if USE_TAILCALLS
28460 MUSTTAIL return InterpNext(S);
28461#else
28462 return true;
28463#endif
28464}
28465#endif
28466#ifdef GET_DISASM
28467case OP_GetOpaquePtr:
28468 Text.Op = PrintName("GetOpaquePtr");
28469 Text.Args.push_back(printArg<DeclOrExpr>(PC));
28470 Text.Args.push_back(printArg<bool>(PC));
28471 break;
28472#endif
28473#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28474bool emitGetOpaquePtr( DeclOrExpr , bool , SourceInfo);
28475#endif
28476#ifdef GET_LINK_IMPL
28477bool ByteCodeEmitter::emitGetOpaquePtr( DeclOrExpr A0, bool A1, SourceInfo L) {
28478 return emitOp<DeclOrExpr, bool>(OP_GetOpaquePtr, A0, A1, L);
28479}
28480#endif
28481#ifdef GET_EVAL_IMPL
28482bool EvalEmitter::emitGetOpaquePtr( DeclOrExpr A0, bool A1, SourceInfo L) {
28483 if (!isActive()) return true;
28484 CurrentSource = L;
28485 return GetOpaquePtr(S, A0, A1);
28486}
28487#endif
28488#ifdef GET_OPCODE_NAMES
28489OP_GetParamSint8,
28490OP_GetParamUint8,
28491OP_GetParamSint16,
28492OP_GetParamUint16,
28493OP_GetParamSint32,
28494OP_GetParamUint32,
28495OP_GetParamSint64,
28496OP_GetParamUint64,
28497OP_GetParamIntAP,
28498OP_GetParamIntAPS,
28499OP_GetParamBool,
28500OP_GetParamFixedPoint,
28501OP_GetParamPtr,
28502OP_GetParamMemberPtr,
28503OP_GetParamFloat,
28504OP_GetParamReflect,
28505#endif
28506#ifdef GET_INTERPFN_LIST
28507&Interp_GetParamSint8,
28508&Interp_GetParamUint8,
28509&Interp_GetParamSint16,
28510&Interp_GetParamUint16,
28511&Interp_GetParamSint32,
28512&Interp_GetParamUint32,
28513&Interp_GetParamSint64,
28514&Interp_GetParamUint64,
28515&Interp_GetParamIntAP,
28516&Interp_GetParamIntAPS,
28517&Interp_GetParamBool,
28518&Interp_GetParamFixedPoint,
28519&Interp_GetParamPtr,
28520&Interp_GetParamMemberPtr,
28521&Interp_GetParamFloat,
28522&Interp_GetParamReflect,
28523#endif
28524#ifdef GET_INTERPFN_DISPATCHERS
28525PRESERVE_NONE
28526static bool Interp_GetParamSint8(InterpState &S) {
28527 {
28528 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28529 if (!GetParam<PT_Sint8>(S, V0)) return false;
28530 }
28531#if USE_TAILCALLS
28532 MUSTTAIL return InterpNext(S);
28533#else
28534 return true;
28535#endif
28536}
28537PRESERVE_NONE
28538static bool Interp_GetParamUint8(InterpState &S) {
28539 {
28540 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28541 if (!GetParam<PT_Uint8>(S, V0)) return false;
28542 }
28543#if USE_TAILCALLS
28544 MUSTTAIL return InterpNext(S);
28545#else
28546 return true;
28547#endif
28548}
28549PRESERVE_NONE
28550static bool Interp_GetParamSint16(InterpState &S) {
28551 {
28552 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28553 if (!GetParam<PT_Sint16>(S, V0)) return false;
28554 }
28555#if USE_TAILCALLS
28556 MUSTTAIL return InterpNext(S);
28557#else
28558 return true;
28559#endif
28560}
28561PRESERVE_NONE
28562static bool Interp_GetParamUint16(InterpState &S) {
28563 {
28564 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28565 if (!GetParam<PT_Uint16>(S, V0)) return false;
28566 }
28567#if USE_TAILCALLS
28568 MUSTTAIL return InterpNext(S);
28569#else
28570 return true;
28571#endif
28572}
28573PRESERVE_NONE
28574static bool Interp_GetParamSint32(InterpState &S) {
28575 {
28576 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28577 if (!GetParam<PT_Sint32>(S, V0)) return false;
28578 }
28579#if USE_TAILCALLS
28580 MUSTTAIL return InterpNext(S);
28581#else
28582 return true;
28583#endif
28584}
28585PRESERVE_NONE
28586static bool Interp_GetParamUint32(InterpState &S) {
28587 {
28588 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28589 if (!GetParam<PT_Uint32>(S, V0)) return false;
28590 }
28591#if USE_TAILCALLS
28592 MUSTTAIL return InterpNext(S);
28593#else
28594 return true;
28595#endif
28596}
28597PRESERVE_NONE
28598static bool Interp_GetParamSint64(InterpState &S) {
28599 {
28600 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28601 if (!GetParam<PT_Sint64>(S, V0)) return false;
28602 }
28603#if USE_TAILCALLS
28604 MUSTTAIL return InterpNext(S);
28605#else
28606 return true;
28607#endif
28608}
28609PRESERVE_NONE
28610static bool Interp_GetParamUint64(InterpState &S) {
28611 {
28612 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28613 if (!GetParam<PT_Uint64>(S, V0)) return false;
28614 }
28615#if USE_TAILCALLS
28616 MUSTTAIL return InterpNext(S);
28617#else
28618 return true;
28619#endif
28620}
28621PRESERVE_NONE
28622static bool Interp_GetParamIntAP(InterpState &S) {
28623 {
28624 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28625 if (!GetParam<PT_IntAP>(S, V0)) return false;
28626 }
28627#if USE_TAILCALLS
28628 MUSTTAIL return InterpNext(S);
28629#else
28630 return true;
28631#endif
28632}
28633PRESERVE_NONE
28634static bool Interp_GetParamIntAPS(InterpState &S) {
28635 {
28636 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28637 if (!GetParam<PT_IntAPS>(S, V0)) return false;
28638 }
28639#if USE_TAILCALLS
28640 MUSTTAIL return InterpNext(S);
28641#else
28642 return true;
28643#endif
28644}
28645PRESERVE_NONE
28646static bool Interp_GetParamBool(InterpState &S) {
28647 {
28648 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28649 if (!GetParam<PT_Bool>(S, V0)) return false;
28650 }
28651#if USE_TAILCALLS
28652 MUSTTAIL return InterpNext(S);
28653#else
28654 return true;
28655#endif
28656}
28657PRESERVE_NONE
28658static bool Interp_GetParamFixedPoint(InterpState &S) {
28659 {
28660 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28661 if (!GetParam<PT_FixedPoint>(S, V0)) return false;
28662 }
28663#if USE_TAILCALLS
28664 MUSTTAIL return InterpNext(S);
28665#else
28666 return true;
28667#endif
28668}
28669PRESERVE_NONE
28670static bool Interp_GetParamPtr(InterpState &S) {
28671 {
28672 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28673 if (!GetParam<PT_Ptr>(S, V0)) return false;
28674 }
28675#if USE_TAILCALLS
28676 MUSTTAIL return InterpNext(S);
28677#else
28678 return true;
28679#endif
28680}
28681PRESERVE_NONE
28682static bool Interp_GetParamMemberPtr(InterpState &S) {
28683 {
28684 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28685 if (!GetParam<PT_MemberPtr>(S, V0)) return false;
28686 }
28687#if USE_TAILCALLS
28688 MUSTTAIL return InterpNext(S);
28689#else
28690 return true;
28691#endif
28692}
28693PRESERVE_NONE
28694static bool Interp_GetParamFloat(InterpState &S) {
28695 {
28696 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28697 if (!GetParam<PT_Float>(S, V0)) return false;
28698 }
28699#if USE_TAILCALLS
28700 MUSTTAIL return InterpNext(S);
28701#else
28702 return true;
28703#endif
28704}
28705PRESERVE_NONE
28706static bool Interp_GetParamReflect(InterpState &S) {
28707 {
28708 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28709 if (!GetParam<PT_Reflect>(S, V0)) return false;
28710 }
28711#if USE_TAILCALLS
28712 MUSTTAIL return InterpNext(S);
28713#else
28714 return true;
28715#endif
28716}
28717#endif
28718#ifdef GET_DISASM
28719case OP_GetParamSint8:
28720 Text.Op = PrintName("GetParamSint8");
28721 Text.Args.push_back(printArg<uint32_t>(PC));
28722 break;
28723case OP_GetParamUint8:
28724 Text.Op = PrintName("GetParamUint8");
28725 Text.Args.push_back(printArg<uint32_t>(PC));
28726 break;
28727case OP_GetParamSint16:
28728 Text.Op = PrintName("GetParamSint16");
28729 Text.Args.push_back(printArg<uint32_t>(PC));
28730 break;
28731case OP_GetParamUint16:
28732 Text.Op = PrintName("GetParamUint16");
28733 Text.Args.push_back(printArg<uint32_t>(PC));
28734 break;
28735case OP_GetParamSint32:
28736 Text.Op = PrintName("GetParamSint32");
28737 Text.Args.push_back(printArg<uint32_t>(PC));
28738 break;
28739case OP_GetParamUint32:
28740 Text.Op = PrintName("GetParamUint32");
28741 Text.Args.push_back(printArg<uint32_t>(PC));
28742 break;
28743case OP_GetParamSint64:
28744 Text.Op = PrintName("GetParamSint64");
28745 Text.Args.push_back(printArg<uint32_t>(PC));
28746 break;
28747case OP_GetParamUint64:
28748 Text.Op = PrintName("GetParamUint64");
28749 Text.Args.push_back(printArg<uint32_t>(PC));
28750 break;
28751case OP_GetParamIntAP:
28752 Text.Op = PrintName("GetParamIntAP");
28753 Text.Args.push_back(printArg<uint32_t>(PC));
28754 break;
28755case OP_GetParamIntAPS:
28756 Text.Op = PrintName("GetParamIntAPS");
28757 Text.Args.push_back(printArg<uint32_t>(PC));
28758 break;
28759case OP_GetParamBool:
28760 Text.Op = PrintName("GetParamBool");
28761 Text.Args.push_back(printArg<uint32_t>(PC));
28762 break;
28763case OP_GetParamFixedPoint:
28764 Text.Op = PrintName("GetParamFixedPoint");
28765 Text.Args.push_back(printArg<uint32_t>(PC));
28766 break;
28767case OP_GetParamPtr:
28768 Text.Op = PrintName("GetParamPtr");
28769 Text.Args.push_back(printArg<uint32_t>(PC));
28770 break;
28771case OP_GetParamMemberPtr:
28772 Text.Op = PrintName("GetParamMemberPtr");
28773 Text.Args.push_back(printArg<uint32_t>(PC));
28774 break;
28775case OP_GetParamFloat:
28776 Text.Op = PrintName("GetParamFloat");
28777 Text.Args.push_back(printArg<uint32_t>(PC));
28778 break;
28779case OP_GetParamReflect:
28780 Text.Op = PrintName("GetParamReflect");
28781 Text.Args.push_back(printArg<uint32_t>(PC));
28782 break;
28783#endif
28784#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28785bool emitGetParamSint8( uint32_t , SourceInfo);
28786bool emitGetParamUint8( uint32_t , SourceInfo);
28787bool emitGetParamSint16( uint32_t , SourceInfo);
28788bool emitGetParamUint16( uint32_t , SourceInfo);
28789bool emitGetParamSint32( uint32_t , SourceInfo);
28790bool emitGetParamUint32( uint32_t , SourceInfo);
28791bool emitGetParamSint64( uint32_t , SourceInfo);
28792bool emitGetParamUint64( uint32_t , SourceInfo);
28793bool emitGetParamIntAP( uint32_t , SourceInfo);
28794bool emitGetParamIntAPS( uint32_t , SourceInfo);
28795bool emitGetParamBool( uint32_t , SourceInfo);
28796bool emitGetParamFixedPoint( uint32_t , SourceInfo);
28797bool emitGetParamPtr( uint32_t , SourceInfo);
28798bool emitGetParamMemberPtr( uint32_t , SourceInfo);
28799bool emitGetParamFloat( uint32_t , SourceInfo);
28800bool emitGetParamReflect( uint32_t , SourceInfo);
28801#endif
28802#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
28803[[nodiscard]] bool emitGetParam(PrimType, uint32_t, SourceInfo I);
28804#endif
28805#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
28806bool
28807#if defined(GET_EVAL_IMPL)
28808EvalEmitter
28809#else
28810ByteCodeEmitter
28811#endif
28812::emitGetParam(PrimType T0, uint32_t A0, SourceInfo I) {
28813 switch (T0) {
28814 case PT_Sint8:
28815 return emitGetParamSint8(A0, I);
28816 case PT_Uint8:
28817 return emitGetParamUint8(A0, I);
28818 case PT_Sint16:
28819 return emitGetParamSint16(A0, I);
28820 case PT_Uint16:
28821 return emitGetParamUint16(A0, I);
28822 case PT_Sint32:
28823 return emitGetParamSint32(A0, I);
28824 case PT_Uint32:
28825 return emitGetParamUint32(A0, I);
28826 case PT_Sint64:
28827 return emitGetParamSint64(A0, I);
28828 case PT_Uint64:
28829 return emitGetParamUint64(A0, I);
28830 case PT_IntAP:
28831 return emitGetParamIntAP(A0, I);
28832 case PT_IntAPS:
28833 return emitGetParamIntAPS(A0, I);
28834 case PT_Bool:
28835 return emitGetParamBool(A0, I);
28836 case PT_FixedPoint:
28837 return emitGetParamFixedPoint(A0, I);
28838 case PT_Ptr:
28839 return emitGetParamPtr(A0, I);
28840 case PT_MemberPtr:
28841 return emitGetParamMemberPtr(A0, I);
28842 case PT_Float:
28843 return emitGetParamFloat(A0, I);
28844 case PT_Reflect:
28845 return emitGetParamReflect(A0, I);
28846 }
28847 llvm_unreachable("invalid enum value");
28848}
28849#endif
28850#ifdef GET_LINK_IMPL
28851bool ByteCodeEmitter::emitGetParamSint8( uint32_t A0, SourceInfo L) {
28852 return emitOp<uint32_t>(OP_GetParamSint8, A0, L);
28853}
28854bool ByteCodeEmitter::emitGetParamUint8( uint32_t A0, SourceInfo L) {
28855 return emitOp<uint32_t>(OP_GetParamUint8, A0, L);
28856}
28857bool ByteCodeEmitter::emitGetParamSint16( uint32_t A0, SourceInfo L) {
28858 return emitOp<uint32_t>(OP_GetParamSint16, A0, L);
28859}
28860bool ByteCodeEmitter::emitGetParamUint16( uint32_t A0, SourceInfo L) {
28861 return emitOp<uint32_t>(OP_GetParamUint16, A0, L);
28862}
28863bool ByteCodeEmitter::emitGetParamSint32( uint32_t A0, SourceInfo L) {
28864 return emitOp<uint32_t>(OP_GetParamSint32, A0, L);
28865}
28866bool ByteCodeEmitter::emitGetParamUint32( uint32_t A0, SourceInfo L) {
28867 return emitOp<uint32_t>(OP_GetParamUint32, A0, L);
28868}
28869bool ByteCodeEmitter::emitGetParamSint64( uint32_t A0, SourceInfo L) {
28870 return emitOp<uint32_t>(OP_GetParamSint64, A0, L);
28871}
28872bool ByteCodeEmitter::emitGetParamUint64( uint32_t A0, SourceInfo L) {
28873 return emitOp<uint32_t>(OP_GetParamUint64, A0, L);
28874}
28875bool ByteCodeEmitter::emitGetParamIntAP( uint32_t A0, SourceInfo L) {
28876 return emitOp<uint32_t>(OP_GetParamIntAP, A0, L);
28877}
28878bool ByteCodeEmitter::emitGetParamIntAPS( uint32_t A0, SourceInfo L) {
28879 return emitOp<uint32_t>(OP_GetParamIntAPS, A0, L);
28880}
28881bool ByteCodeEmitter::emitGetParamBool( uint32_t A0, SourceInfo L) {
28882 return emitOp<uint32_t>(OP_GetParamBool, A0, L);
28883}
28884bool ByteCodeEmitter::emitGetParamFixedPoint( uint32_t A0, SourceInfo L) {
28885 return emitOp<uint32_t>(OP_GetParamFixedPoint, A0, L);
28886}
28887bool ByteCodeEmitter::emitGetParamPtr( uint32_t A0, SourceInfo L) {
28888 return emitOp<uint32_t>(OP_GetParamPtr, A0, L);
28889}
28890bool ByteCodeEmitter::emitGetParamMemberPtr( uint32_t A0, SourceInfo L) {
28891 return emitOp<uint32_t>(OP_GetParamMemberPtr, A0, L);
28892}
28893bool ByteCodeEmitter::emitGetParamFloat( uint32_t A0, SourceInfo L) {
28894 return emitOp<uint32_t>(OP_GetParamFloat, A0, L);
28895}
28896bool ByteCodeEmitter::emitGetParamReflect( uint32_t A0, SourceInfo L) {
28897 return emitOp<uint32_t>(OP_GetParamReflect, A0, L);
28898}
28899#endif
28900#ifdef GET_EVAL_IMPL
28901bool EvalEmitter::emitGetParamSint8( uint32_t A0, SourceInfo L) {
28902 if (!isActive()) return true;
28903 CurrentSource = L;
28904 return GetParam<PT_Sint8>(S, A0);
28905}
28906bool EvalEmitter::emitGetParamUint8( uint32_t A0, SourceInfo L) {
28907 if (!isActive()) return true;
28908 CurrentSource = L;
28909 return GetParam<PT_Uint8>(S, A0);
28910}
28911bool EvalEmitter::emitGetParamSint16( uint32_t A0, SourceInfo L) {
28912 if (!isActive()) return true;
28913 CurrentSource = L;
28914 return GetParam<PT_Sint16>(S, A0);
28915}
28916bool EvalEmitter::emitGetParamUint16( uint32_t A0, SourceInfo L) {
28917 if (!isActive()) return true;
28918 CurrentSource = L;
28919 return GetParam<PT_Uint16>(S, A0);
28920}
28921bool EvalEmitter::emitGetParamSint32( uint32_t A0, SourceInfo L) {
28922 if (!isActive()) return true;
28923 CurrentSource = L;
28924 return GetParam<PT_Sint32>(S, A0);
28925}
28926bool EvalEmitter::emitGetParamUint32( uint32_t A0, SourceInfo L) {
28927 if (!isActive()) return true;
28928 CurrentSource = L;
28929 return GetParam<PT_Uint32>(S, A0);
28930}
28931bool EvalEmitter::emitGetParamSint64( uint32_t A0, SourceInfo L) {
28932 if (!isActive()) return true;
28933 CurrentSource = L;
28934 return GetParam<PT_Sint64>(S, A0);
28935}
28936bool EvalEmitter::emitGetParamUint64( uint32_t A0, SourceInfo L) {
28937 if (!isActive()) return true;
28938 CurrentSource = L;
28939 return GetParam<PT_Uint64>(S, A0);
28940}
28941bool EvalEmitter::emitGetParamIntAP( uint32_t A0, SourceInfo L) {
28942 if (!isActive()) return true;
28943 CurrentSource = L;
28944 return GetParam<PT_IntAP>(S, A0);
28945}
28946bool EvalEmitter::emitGetParamIntAPS( uint32_t A0, SourceInfo L) {
28947 if (!isActive()) return true;
28948 CurrentSource = L;
28949 return GetParam<PT_IntAPS>(S, A0);
28950}
28951bool EvalEmitter::emitGetParamBool( uint32_t A0, SourceInfo L) {
28952 if (!isActive()) return true;
28953 CurrentSource = L;
28954 return GetParam<PT_Bool>(S, A0);
28955}
28956bool EvalEmitter::emitGetParamFixedPoint( uint32_t A0, SourceInfo L) {
28957 if (!isActive()) return true;
28958 CurrentSource = L;
28959 return GetParam<PT_FixedPoint>(S, A0);
28960}
28961bool EvalEmitter::emitGetParamPtr( uint32_t A0, SourceInfo L) {
28962 if (!isActive()) return true;
28963 CurrentSource = L;
28964 return GetParam<PT_Ptr>(S, A0);
28965}
28966bool EvalEmitter::emitGetParamMemberPtr( uint32_t A0, SourceInfo L) {
28967 if (!isActive()) return true;
28968 CurrentSource = L;
28969 return GetParam<PT_MemberPtr>(S, A0);
28970}
28971bool EvalEmitter::emitGetParamFloat( uint32_t A0, SourceInfo L) {
28972 if (!isActive()) return true;
28973 CurrentSource = L;
28974 return GetParam<PT_Float>(S, A0);
28975}
28976bool EvalEmitter::emitGetParamReflect( uint32_t A0, SourceInfo L) {
28977 if (!isActive()) return true;
28978 CurrentSource = L;
28979 return GetParam<PT_Reflect>(S, A0);
28980}
28981#endif
28982#ifdef GET_OPCODE_NAMES
28983OP_GetPtrBase,
28984#endif
28985#ifdef GET_INTERPFN_LIST
28986&Interp_GetPtrBase,
28987#endif
28988#ifdef GET_INTERPFN_DISPATCHERS
28989PRESERVE_NONE
28990static bool Interp_GetPtrBase(InterpState &S) {
28991 {
28992 CodePtr OpPC = S.PC;
28993 const auto V0 = ReadArg<uint32_t>(S, S.PC);
28994 if (!GetPtrBase(S, OpPC, V0)) return false;
28995 }
28996#if USE_TAILCALLS
28997 MUSTTAIL return InterpNext(S);
28998#else
28999 return true;
29000#endif
29001}
29002#endif
29003#ifdef GET_DISASM
29004case OP_GetPtrBase:
29005 Text.Op = PrintName("GetPtrBase");
29006 Text.Args.push_back(printArg<uint32_t>(PC));
29007 break;
29008#endif
29009#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29010bool emitGetPtrBase( uint32_t , SourceInfo);
29011#endif
29012#ifdef GET_LINK_IMPL
29013bool ByteCodeEmitter::emitGetPtrBase( uint32_t A0, SourceInfo L) {
29014 return emitOp<uint32_t>(OP_GetPtrBase, A0, L);
29015}
29016#endif
29017#ifdef GET_EVAL_IMPL
29018bool EvalEmitter::emitGetPtrBase( uint32_t A0, SourceInfo L) {
29019 if (!isActive()) return true;
29020 CurrentSource = L;
29021 return GetPtrBase(S, CodePtr(), A0);
29022}
29023#endif
29024#ifdef GET_OPCODE_NAMES
29025OP_GetPtrBasePop,
29026#endif
29027#ifdef GET_INTERPFN_LIST
29028&Interp_GetPtrBasePop,
29029#endif
29030#ifdef GET_INTERPFN_DISPATCHERS
29031PRESERVE_NONE
29032static bool Interp_GetPtrBasePop(InterpState &S) {
29033 {
29034 CodePtr OpPC = S.PC;
29035 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29036 const auto V1 = ReadArg<bool>(S, S.PC);
29037 if (!GetPtrBasePop(S, OpPC, V0, V1)) return false;
29038 }
29039#if USE_TAILCALLS
29040 MUSTTAIL return InterpNext(S);
29041#else
29042 return true;
29043#endif
29044}
29045#endif
29046#ifdef GET_DISASM
29047case OP_GetPtrBasePop:
29048 Text.Op = PrintName("GetPtrBasePop");
29049 Text.Args.push_back(printArg<uint32_t>(PC));
29050 Text.Args.push_back(printArg<bool>(PC));
29051 break;
29052#endif
29053#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29054bool emitGetPtrBasePop( uint32_t , bool , SourceInfo);
29055#endif
29056#ifdef GET_LINK_IMPL
29057bool ByteCodeEmitter::emitGetPtrBasePop( uint32_t A0, bool A1, SourceInfo L) {
29058 return emitOp<uint32_t, bool>(OP_GetPtrBasePop, A0, A1, L);
29059}
29060#endif
29061#ifdef GET_EVAL_IMPL
29062bool EvalEmitter::emitGetPtrBasePop( uint32_t A0, bool A1, SourceInfo L) {
29063 if (!isActive()) return true;
29064 CurrentSource = L;
29065 return GetPtrBasePop(S, CodePtr(), A0, A1);
29066}
29067#endif
29068#ifdef GET_OPCODE_NAMES
29069OP_GetPtrDerivedPop,
29070#endif
29071#ifdef GET_INTERPFN_LIST
29072&Interp_GetPtrDerivedPop,
29073#endif
29074#ifdef GET_INTERPFN_DISPATCHERS
29075PRESERVE_NONE
29076static bool Interp_GetPtrDerivedPop(InterpState &S) {
29077 {
29078 CodePtr OpPC = S.PC;
29079 const auto V0 = ReadArg<bool>(S, S.PC);
29080 const auto V1 = ReadArg<const Type *>(S, S.PC);
29081 const auto V2 = ReadArg<const Type *>(S, S.PC);
29082 if (!GetPtrDerivedPop(S, OpPC, V0, V1, V2)) return false;
29083 }
29084#if USE_TAILCALLS
29085 MUSTTAIL return InterpNext(S);
29086#else
29087 return true;
29088#endif
29089}
29090#endif
29091#ifdef GET_DISASM
29092case OP_GetPtrDerivedPop:
29093 Text.Op = PrintName("GetPtrDerivedPop");
29094 Text.Args.push_back(printArg<bool>(PC));
29095 Text.Args.push_back(printArg<const Type *>(PC));
29096 Text.Args.push_back(printArg<const Type *>(PC));
29097 break;
29098#endif
29099#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29100bool emitGetPtrDerivedPop( bool , const Type * , const Type * , SourceInfo);
29101#endif
29102#ifdef GET_LINK_IMPL
29103bool ByteCodeEmitter::emitGetPtrDerivedPop( bool A0, const Type * A1, const Type * A2, SourceInfo L) {
29104 return emitOp<bool, const Type *, const Type *>(OP_GetPtrDerivedPop, A0, A1, A2, L);
29105}
29106#endif
29107#ifdef GET_EVAL_IMPL
29108bool EvalEmitter::emitGetPtrDerivedPop( bool A0, const Type * A1, const Type * A2, SourceInfo L) {
29109 if (!isActive()) return true;
29110 CurrentSource = L;
29111 return GetPtrDerivedPop(S, CodePtr(), A0, A1, A2);
29112}
29113#endif
29114#ifdef GET_OPCODE_NAMES
29115OP_GetPtrField,
29116#endif
29117#ifdef GET_INTERPFN_LIST
29118&Interp_GetPtrField,
29119#endif
29120#ifdef GET_INTERPFN_DISPATCHERS
29121PRESERVE_NONE
29122static bool Interp_GetPtrField(InterpState &S) {
29123 {
29124 CodePtr OpPC = S.PC;
29125 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29126 if (!GetPtrField(S, OpPC, V0)) return false;
29127 }
29128#if USE_TAILCALLS
29129 MUSTTAIL return InterpNext(S);
29130#else
29131 return true;
29132#endif
29133}
29134#endif
29135#ifdef GET_DISASM
29136case OP_GetPtrField:
29137 Text.Op = PrintName("GetPtrField");
29138 Text.Args.push_back(printArg<uint32_t>(PC));
29139 break;
29140#endif
29141#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29142bool emitGetPtrField( uint32_t , SourceInfo);
29143#endif
29144#ifdef GET_LINK_IMPL
29145bool ByteCodeEmitter::emitGetPtrField( uint32_t A0, SourceInfo L) {
29146 return emitOp<uint32_t>(OP_GetPtrField, A0, L);
29147}
29148#endif
29149#ifdef GET_EVAL_IMPL
29150bool EvalEmitter::emitGetPtrField( uint32_t A0, SourceInfo L) {
29151 if (!isActive()) return true;
29152 CurrentSource = L;
29153 return GetPtrField(S, CodePtr(), A0);
29154}
29155#endif
29156#ifdef GET_OPCODE_NAMES
29157OP_GetPtrFieldPop,
29158#endif
29159#ifdef GET_INTERPFN_LIST
29160&Interp_GetPtrFieldPop,
29161#endif
29162#ifdef GET_INTERPFN_DISPATCHERS
29163PRESERVE_NONE
29164static bool Interp_GetPtrFieldPop(InterpState &S) {
29165 {
29166 CodePtr OpPC = S.PC;
29167 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29168 if (!GetPtrFieldPop(S, OpPC, V0)) return false;
29169 }
29170#if USE_TAILCALLS
29171 MUSTTAIL return InterpNext(S);
29172#else
29173 return true;
29174#endif
29175}
29176#endif
29177#ifdef GET_DISASM
29178case OP_GetPtrFieldPop:
29179 Text.Op = PrintName("GetPtrFieldPop");
29180 Text.Args.push_back(printArg<uint32_t>(PC));
29181 break;
29182#endif
29183#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29184bool emitGetPtrFieldPop( uint32_t , SourceInfo);
29185#endif
29186#ifdef GET_LINK_IMPL
29187bool ByteCodeEmitter::emitGetPtrFieldPop( uint32_t A0, SourceInfo L) {
29188 return emitOp<uint32_t>(OP_GetPtrFieldPop, A0, L);
29189}
29190#endif
29191#ifdef GET_EVAL_IMPL
29192bool EvalEmitter::emitGetPtrFieldPop( uint32_t A0, SourceInfo L) {
29193 if (!isActive()) return true;
29194 CurrentSource = L;
29195 return GetPtrFieldPop(S, CodePtr(), A0);
29196}
29197#endif
29198#ifdef GET_OPCODE_NAMES
29199OP_GetPtrGlobal,
29200#endif
29201#ifdef GET_INTERPFN_LIST
29202&Interp_GetPtrGlobal,
29203#endif
29204#ifdef GET_INTERPFN_DISPATCHERS
29205PRESERVE_NONE
29206static bool Interp_GetPtrGlobal(InterpState &S) {
29207 {
29208 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29209 if (!GetPtrGlobal(S, V0)) return false;
29210 }
29211#if USE_TAILCALLS
29212 MUSTTAIL return InterpNext(S);
29213#else
29214 return true;
29215#endif
29216}
29217#endif
29218#ifdef GET_DISASM
29219case OP_GetPtrGlobal:
29220 Text.Op = PrintName("GetPtrGlobal");
29221 Text.Args.push_back(printArg<uint32_t>(PC));
29222 break;
29223#endif
29224#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29225bool emitGetPtrGlobal( uint32_t , SourceInfo);
29226#endif
29227#ifdef GET_LINK_IMPL
29228bool ByteCodeEmitter::emitGetPtrGlobal( uint32_t A0, SourceInfo L) {
29229 return emitOp<uint32_t>(OP_GetPtrGlobal, A0, L);
29230}
29231#endif
29232#ifdef GET_EVAL_IMPL
29233bool EvalEmitter::emitGetPtrGlobal( uint32_t A0, SourceInfo L) {
29234 if (!isActive()) return true;
29235 CurrentSource = L;
29236 return GetPtrGlobal(S, A0);
29237}
29238#endif
29239#ifdef GET_OPCODE_NAMES
29240OP_GetPtrLocal,
29241#endif
29242#ifdef GET_INTERPFN_LIST
29243&Interp_GetPtrLocal,
29244#endif
29245#ifdef GET_INTERPFN_DISPATCHERS
29246PRESERVE_NONE
29247static bool Interp_GetPtrLocal(InterpState &S) {
29248 {
29249 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29250 if (!GetPtrLocal(S, V0)) return false;
29251 }
29252#if USE_TAILCALLS
29253 MUSTTAIL return InterpNext(S);
29254#else
29255 return true;
29256#endif
29257}
29258#endif
29259#ifdef GET_DISASM
29260case OP_GetPtrLocal:
29261 Text.Op = PrintName("GetPtrLocal");
29262 Text.Args.push_back(printArg<uint32_t>(PC));
29263 break;
29264#endif
29265#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29266bool emitGetPtrLocal( uint32_t , SourceInfo);
29267#endif
29268#ifdef GET_LINK_IMPL
29269bool ByteCodeEmitter::emitGetPtrLocal( uint32_t A0, SourceInfo L) {
29270 return emitOp<uint32_t>(OP_GetPtrLocal, A0, L);
29271}
29272#endif
29273#ifdef GET_OPCODE_NAMES
29274OP_GetPtrParam,
29275#endif
29276#ifdef GET_INTERPFN_LIST
29277&Interp_GetPtrParam,
29278#endif
29279#ifdef GET_INTERPFN_DISPATCHERS
29280PRESERVE_NONE
29281static bool Interp_GetPtrParam(InterpState &S) {
29282 {
29283 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29284 if (!GetPtrParam(S, V0)) return false;
29285 }
29286#if USE_TAILCALLS
29287 MUSTTAIL return InterpNext(S);
29288#else
29289 return true;
29290#endif
29291}
29292#endif
29293#ifdef GET_DISASM
29294case OP_GetPtrParam:
29295 Text.Op = PrintName("GetPtrParam");
29296 Text.Args.push_back(printArg<uint32_t>(PC));
29297 break;
29298#endif
29299#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29300bool emitGetPtrParam( uint32_t , SourceInfo);
29301#endif
29302#ifdef GET_LINK_IMPL
29303bool ByteCodeEmitter::emitGetPtrParam( uint32_t A0, SourceInfo L) {
29304 return emitOp<uint32_t>(OP_GetPtrParam, A0, L);
29305}
29306#endif
29307#ifdef GET_EVAL_IMPL
29308bool EvalEmitter::emitGetPtrParam( uint32_t A0, SourceInfo L) {
29309 if (!isActive()) return true;
29310 CurrentSource = L;
29311 return GetPtrParam(S, A0);
29312}
29313#endif
29314#ifdef GET_OPCODE_NAMES
29315OP_GetPtrThisBase,
29316#endif
29317#ifdef GET_INTERPFN_LIST
29318&Interp_GetPtrThisBase,
29319#endif
29320#ifdef GET_INTERPFN_DISPATCHERS
29321PRESERVE_NONE
29322static bool Interp_GetPtrThisBase(InterpState &S) {
29323 {
29324 CodePtr OpPC = S.PC;
29325 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29326 if (!GetPtrThisBase(S, OpPC, V0)) return false;
29327 }
29328#if USE_TAILCALLS
29329 MUSTTAIL return InterpNext(S);
29330#else
29331 return true;
29332#endif
29333}
29334#endif
29335#ifdef GET_DISASM
29336case OP_GetPtrThisBase:
29337 Text.Op = PrintName("GetPtrThisBase");
29338 Text.Args.push_back(printArg<uint32_t>(PC));
29339 break;
29340#endif
29341#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29342bool emitGetPtrThisBase( uint32_t , SourceInfo);
29343#endif
29344#ifdef GET_LINK_IMPL
29345bool ByteCodeEmitter::emitGetPtrThisBase( uint32_t A0, SourceInfo L) {
29346 return emitOp<uint32_t>(OP_GetPtrThisBase, A0, L);
29347}
29348#endif
29349#ifdef GET_EVAL_IMPL
29350bool EvalEmitter::emitGetPtrThisBase( uint32_t A0, SourceInfo L) {
29351 if (!isActive()) return true;
29352 CurrentSource = L;
29353 return GetPtrThisBase(S, CodePtr(), A0);
29354}
29355#endif
29356#ifdef GET_OPCODE_NAMES
29357OP_GetPtrThisField,
29358#endif
29359#ifdef GET_INTERPFN_LIST
29360&Interp_GetPtrThisField,
29361#endif
29362#ifdef GET_INTERPFN_DISPATCHERS
29363PRESERVE_NONE
29364static bool Interp_GetPtrThisField(InterpState &S) {
29365 {
29366 CodePtr OpPC = S.PC;
29367 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29368 if (!GetPtrThisField(S, OpPC, V0)) return false;
29369 }
29370#if USE_TAILCALLS
29371 MUSTTAIL return InterpNext(S);
29372#else
29373 return true;
29374#endif
29375}
29376#endif
29377#ifdef GET_DISASM
29378case OP_GetPtrThisField:
29379 Text.Op = PrintName("GetPtrThisField");
29380 Text.Args.push_back(printArg<uint32_t>(PC));
29381 break;
29382#endif
29383#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29384bool emitGetPtrThisField( uint32_t , SourceInfo);
29385#endif
29386#ifdef GET_LINK_IMPL
29387bool ByteCodeEmitter::emitGetPtrThisField( uint32_t A0, SourceInfo L) {
29388 return emitOp<uint32_t>(OP_GetPtrThisField, A0, L);
29389}
29390#endif
29391#ifdef GET_EVAL_IMPL
29392bool EvalEmitter::emitGetPtrThisField( uint32_t A0, SourceInfo L) {
29393 if (!isActive()) return true;
29394 CurrentSource = L;
29395 return GetPtrThisField(S, CodePtr(), A0);
29396}
29397#endif
29398#ifdef GET_OPCODE_NAMES
29399OP_GetPtrThisVirtBase,
29400#endif
29401#ifdef GET_INTERPFN_LIST
29402&Interp_GetPtrThisVirtBase,
29403#endif
29404#ifdef GET_INTERPFN_DISPATCHERS
29405PRESERVE_NONE
29406static bool Interp_GetPtrThisVirtBase(InterpState &S) {
29407 {
29408 CodePtr OpPC = S.PC;
29409 const auto V0 = ReadArg<const CXXRecordDecl *>(S, S.PC);
29410 if (!GetPtrThisVirtBase(S, OpPC, V0)) return false;
29411 }
29412#if USE_TAILCALLS
29413 MUSTTAIL return InterpNext(S);
29414#else
29415 return true;
29416#endif
29417}
29418#endif
29419#ifdef GET_DISASM
29420case OP_GetPtrThisVirtBase:
29421 Text.Op = PrintName("GetPtrThisVirtBase");
29422 Text.Args.push_back(printArg<const CXXRecordDecl *>(PC));
29423 break;
29424#endif
29425#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29426bool emitGetPtrThisVirtBase( const CXXRecordDecl * , SourceInfo);
29427#endif
29428#ifdef GET_LINK_IMPL
29429bool ByteCodeEmitter::emitGetPtrThisVirtBase( const CXXRecordDecl * A0, SourceInfo L) {
29430 return emitOp<const CXXRecordDecl *>(OP_GetPtrThisVirtBase, A0, L);
29431}
29432#endif
29433#ifdef GET_EVAL_IMPL
29434bool EvalEmitter::emitGetPtrThisVirtBase( const CXXRecordDecl * A0, SourceInfo L) {
29435 if (!isActive()) return true;
29436 CurrentSource = L;
29437 return GetPtrThisVirtBase(S, CodePtr(), A0);
29438}
29439#endif
29440#ifdef GET_OPCODE_NAMES
29441OP_GetPtrVirtBase,
29442#endif
29443#ifdef GET_INTERPFN_LIST
29444&Interp_GetPtrVirtBase,
29445#endif
29446#ifdef GET_INTERPFN_DISPATCHERS
29447PRESERVE_NONE
29448static bool Interp_GetPtrVirtBase(InterpState &S) {
29449 {
29450 CodePtr OpPC = S.PC;
29451 const auto V0 = ReadArg<const CXXRecordDecl *>(S, S.PC);
29452 if (!GetPtrVirtBase(S, OpPC, V0)) return false;
29453 }
29454#if USE_TAILCALLS
29455 MUSTTAIL return InterpNext(S);
29456#else
29457 return true;
29458#endif
29459}
29460#endif
29461#ifdef GET_DISASM
29462case OP_GetPtrVirtBase:
29463 Text.Op = PrintName("GetPtrVirtBase");
29464 Text.Args.push_back(printArg<const CXXRecordDecl *>(PC));
29465 break;
29466#endif
29467#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29468bool emitGetPtrVirtBase( const CXXRecordDecl * , SourceInfo);
29469#endif
29470#ifdef GET_LINK_IMPL
29471bool ByteCodeEmitter::emitGetPtrVirtBase( const CXXRecordDecl * A0, SourceInfo L) {
29472 return emitOp<const CXXRecordDecl *>(OP_GetPtrVirtBase, A0, L);
29473}
29474#endif
29475#ifdef GET_EVAL_IMPL
29476bool EvalEmitter::emitGetPtrVirtBase( const CXXRecordDecl * A0, SourceInfo L) {
29477 if (!isActive()) return true;
29478 CurrentSource = L;
29479 return GetPtrVirtBase(S, CodePtr(), A0);
29480}
29481#endif
29482#ifdef GET_OPCODE_NAMES
29483OP_GetPtrVirtBasePop,
29484#endif
29485#ifdef GET_INTERPFN_LIST
29486&Interp_GetPtrVirtBasePop,
29487#endif
29488#ifdef GET_INTERPFN_DISPATCHERS
29489PRESERVE_NONE
29490static bool Interp_GetPtrVirtBasePop(InterpState &S) {
29491 {
29492 CodePtr OpPC = S.PC;
29493 const auto V0 = ReadArg<const CXXRecordDecl *>(S, S.PC);
29494 if (!GetPtrVirtBasePop(S, OpPC, V0)) return false;
29495 }
29496#if USE_TAILCALLS
29497 MUSTTAIL return InterpNext(S);
29498#else
29499 return true;
29500#endif
29501}
29502#endif
29503#ifdef GET_DISASM
29504case OP_GetPtrVirtBasePop:
29505 Text.Op = PrintName("GetPtrVirtBasePop");
29506 Text.Args.push_back(printArg<const CXXRecordDecl *>(PC));
29507 break;
29508#endif
29509#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29510bool emitGetPtrVirtBasePop( const CXXRecordDecl * , SourceInfo);
29511#endif
29512#ifdef GET_LINK_IMPL
29513bool ByteCodeEmitter::emitGetPtrVirtBasePop( const CXXRecordDecl * A0, SourceInfo L) {
29514 return emitOp<const CXXRecordDecl *>(OP_GetPtrVirtBasePop, A0, L);
29515}
29516#endif
29517#ifdef GET_EVAL_IMPL
29518bool EvalEmitter::emitGetPtrVirtBasePop( const CXXRecordDecl * A0, SourceInfo L) {
29519 if (!isActive()) return true;
29520 CurrentSource = L;
29521 return GetPtrVirtBasePop(S, CodePtr(), A0);
29522}
29523#endif
29524#ifdef GET_OPCODE_NAMES
29525OP_GetRefGlobal,
29526#endif
29527#ifdef GET_INTERPFN_LIST
29528&Interp_GetRefGlobal,
29529#endif
29530#ifdef GET_INTERPFN_DISPATCHERS
29531PRESERVE_NONE
29532static bool Interp_GetRefGlobal(InterpState &S) {
29533 {
29534 CodePtr OpPC = S.PC;
29535 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29536 if (!GetRefGlobal(S, OpPC, V0)) return false;
29537 }
29538#if USE_TAILCALLS
29539 MUSTTAIL return InterpNext(S);
29540#else
29541 return true;
29542#endif
29543}
29544#endif
29545#ifdef GET_DISASM
29546case OP_GetRefGlobal:
29547 Text.Op = PrintName("GetRefGlobal");
29548 Text.Args.push_back(printArg<uint32_t>(PC));
29549 break;
29550#endif
29551#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29552bool emitGetRefGlobal( uint32_t , SourceInfo);
29553#endif
29554#ifdef GET_LINK_IMPL
29555bool ByteCodeEmitter::emitGetRefGlobal( uint32_t A0, SourceInfo L) {
29556 return emitOp<uint32_t>(OP_GetRefGlobal, A0, L);
29557}
29558#endif
29559#ifdef GET_EVAL_IMPL
29560bool EvalEmitter::emitGetRefGlobal( uint32_t A0, SourceInfo L) {
29561 if (!isActive()) return true;
29562 CurrentSource = L;
29563 return GetRefGlobal(S, CodePtr(), A0);
29564}
29565#endif
29566#ifdef GET_OPCODE_NAMES
29567OP_GetRefLocal,
29568#endif
29569#ifdef GET_INTERPFN_LIST
29570&Interp_GetRefLocal,
29571#endif
29572#ifdef GET_INTERPFN_DISPATCHERS
29573PRESERVE_NONE
29574static bool Interp_GetRefLocal(InterpState &S) {
29575 {
29576 CodePtr OpPC = S.PC;
29577 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29578 if (!GetRefLocal(S, OpPC, V0)) return false;
29579 }
29580#if USE_TAILCALLS
29581 MUSTTAIL return InterpNext(S);
29582#else
29583 return true;
29584#endif
29585}
29586#endif
29587#ifdef GET_DISASM
29588case OP_GetRefLocal:
29589 Text.Op = PrintName("GetRefLocal");
29590 Text.Args.push_back(printArg<uint32_t>(PC));
29591 break;
29592#endif
29593#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29594bool emitGetRefLocal( uint32_t , SourceInfo);
29595#endif
29596#ifdef GET_LINK_IMPL
29597bool ByteCodeEmitter::emitGetRefLocal( uint32_t A0, SourceInfo L) {
29598 return emitOp<uint32_t>(OP_GetRefLocal, A0, L);
29599}
29600#endif
29601#ifdef GET_OPCODE_NAMES
29602OP_GetStringPtr,
29603#endif
29604#ifdef GET_INTERPFN_LIST
29605&Interp_GetStringPtr,
29606#endif
29607#ifdef GET_INTERPFN_DISPATCHERS
29608PRESERVE_NONE
29609static bool Interp_GetStringPtr(InterpState &S) {
29610 {
29611 const auto V0 = ReadArg<const Expr *>(S, S.PC);
29612 GetStringPtr(S, V0);
29613 }
29614#if USE_TAILCALLS
29615 MUSTTAIL return InterpNext(S);
29616#else
29617 return true;
29618#endif
29619}
29620#endif
29621#ifdef GET_DISASM
29622case OP_GetStringPtr:
29623 Text.Op = PrintName("GetStringPtr");
29624 Text.Args.push_back(printArg<const Expr *>(PC));
29625 break;
29626#endif
29627#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29628bool emitGetStringPtr( const Expr * , SourceInfo);
29629#endif
29630#ifdef GET_LINK_IMPL
29631bool ByteCodeEmitter::emitGetStringPtr( const Expr * A0, SourceInfo L) {
29632 return emitOp<const Expr *>(OP_GetStringPtr, A0, L);
29633}
29634#endif
29635#ifdef GET_EVAL_IMPL
29636bool EvalEmitter::emitGetStringPtr( const Expr * A0, SourceInfo L) {
29637 if (!isActive()) return true;
29638 CurrentSource = L;
29639 return GetStringPtr(S, A0);
29640}
29641#endif
29642#ifdef GET_OPCODE_NAMES
29643OP_GetThisFieldSint8,
29644OP_GetThisFieldUint8,
29645OP_GetThisFieldSint16,
29646OP_GetThisFieldUint16,
29647OP_GetThisFieldSint32,
29648OP_GetThisFieldUint32,
29649OP_GetThisFieldSint64,
29650OP_GetThisFieldUint64,
29651OP_GetThisFieldIntAP,
29652OP_GetThisFieldIntAPS,
29653OP_GetThisFieldBool,
29654OP_GetThisFieldFixedPoint,
29655OP_GetThisFieldPtr,
29656OP_GetThisFieldMemberPtr,
29657OP_GetThisFieldFloat,
29658OP_GetThisFieldReflect,
29659#endif
29660#ifdef GET_INTERPFN_LIST
29661&Interp_GetThisFieldSint8,
29662&Interp_GetThisFieldUint8,
29663&Interp_GetThisFieldSint16,
29664&Interp_GetThisFieldUint16,
29665&Interp_GetThisFieldSint32,
29666&Interp_GetThisFieldUint32,
29667&Interp_GetThisFieldSint64,
29668&Interp_GetThisFieldUint64,
29669&Interp_GetThisFieldIntAP,
29670&Interp_GetThisFieldIntAPS,
29671&Interp_GetThisFieldBool,
29672&Interp_GetThisFieldFixedPoint,
29673&Interp_GetThisFieldPtr,
29674&Interp_GetThisFieldMemberPtr,
29675&Interp_GetThisFieldFloat,
29676&Interp_GetThisFieldReflect,
29677#endif
29678#ifdef GET_INTERPFN_DISPATCHERS
29679PRESERVE_NONE
29680static bool Interp_GetThisFieldSint8(InterpState &S) {
29681 {
29682 CodePtr OpPC = S.PC;
29683 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29684 if (!GetThisField<PT_Sint8>(S, OpPC, V0)) return false;
29685 }
29686#if USE_TAILCALLS
29687 MUSTTAIL return InterpNext(S);
29688#else
29689 return true;
29690#endif
29691}
29692PRESERVE_NONE
29693static bool Interp_GetThisFieldUint8(InterpState &S) {
29694 {
29695 CodePtr OpPC = S.PC;
29696 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29697 if (!GetThisField<PT_Uint8>(S, OpPC, V0)) return false;
29698 }
29699#if USE_TAILCALLS
29700 MUSTTAIL return InterpNext(S);
29701#else
29702 return true;
29703#endif
29704}
29705PRESERVE_NONE
29706static bool Interp_GetThisFieldSint16(InterpState &S) {
29707 {
29708 CodePtr OpPC = S.PC;
29709 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29710 if (!GetThisField<PT_Sint16>(S, OpPC, V0)) return false;
29711 }
29712#if USE_TAILCALLS
29713 MUSTTAIL return InterpNext(S);
29714#else
29715 return true;
29716#endif
29717}
29718PRESERVE_NONE
29719static bool Interp_GetThisFieldUint16(InterpState &S) {
29720 {
29721 CodePtr OpPC = S.PC;
29722 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29723 if (!GetThisField<PT_Uint16>(S, OpPC, V0)) return false;
29724 }
29725#if USE_TAILCALLS
29726 MUSTTAIL return InterpNext(S);
29727#else
29728 return true;
29729#endif
29730}
29731PRESERVE_NONE
29732static bool Interp_GetThisFieldSint32(InterpState &S) {
29733 {
29734 CodePtr OpPC = S.PC;
29735 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29736 if (!GetThisField<PT_Sint32>(S, OpPC, V0)) return false;
29737 }
29738#if USE_TAILCALLS
29739 MUSTTAIL return InterpNext(S);
29740#else
29741 return true;
29742#endif
29743}
29744PRESERVE_NONE
29745static bool Interp_GetThisFieldUint32(InterpState &S) {
29746 {
29747 CodePtr OpPC = S.PC;
29748 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29749 if (!GetThisField<PT_Uint32>(S, OpPC, V0)) return false;
29750 }
29751#if USE_TAILCALLS
29752 MUSTTAIL return InterpNext(S);
29753#else
29754 return true;
29755#endif
29756}
29757PRESERVE_NONE
29758static bool Interp_GetThisFieldSint64(InterpState &S) {
29759 {
29760 CodePtr OpPC = S.PC;
29761 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29762 if (!GetThisField<PT_Sint64>(S, OpPC, V0)) return false;
29763 }
29764#if USE_TAILCALLS
29765 MUSTTAIL return InterpNext(S);
29766#else
29767 return true;
29768#endif
29769}
29770PRESERVE_NONE
29771static bool Interp_GetThisFieldUint64(InterpState &S) {
29772 {
29773 CodePtr OpPC = S.PC;
29774 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29775 if (!GetThisField<PT_Uint64>(S, OpPC, V0)) return false;
29776 }
29777#if USE_TAILCALLS
29778 MUSTTAIL return InterpNext(S);
29779#else
29780 return true;
29781#endif
29782}
29783PRESERVE_NONE
29784static bool Interp_GetThisFieldIntAP(InterpState &S) {
29785 {
29786 CodePtr OpPC = S.PC;
29787 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29788 if (!GetThisField<PT_IntAP>(S, OpPC, V0)) return false;
29789 }
29790#if USE_TAILCALLS
29791 MUSTTAIL return InterpNext(S);
29792#else
29793 return true;
29794#endif
29795}
29796PRESERVE_NONE
29797static bool Interp_GetThisFieldIntAPS(InterpState &S) {
29798 {
29799 CodePtr OpPC = S.PC;
29800 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29801 if (!GetThisField<PT_IntAPS>(S, OpPC, V0)) return false;
29802 }
29803#if USE_TAILCALLS
29804 MUSTTAIL return InterpNext(S);
29805#else
29806 return true;
29807#endif
29808}
29809PRESERVE_NONE
29810static bool Interp_GetThisFieldBool(InterpState &S) {
29811 {
29812 CodePtr OpPC = S.PC;
29813 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29814 if (!GetThisField<PT_Bool>(S, OpPC, V0)) return false;
29815 }
29816#if USE_TAILCALLS
29817 MUSTTAIL return InterpNext(S);
29818#else
29819 return true;
29820#endif
29821}
29822PRESERVE_NONE
29823static bool Interp_GetThisFieldFixedPoint(InterpState &S) {
29824 {
29825 CodePtr OpPC = S.PC;
29826 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29827 if (!GetThisField<PT_FixedPoint>(S, OpPC, V0)) return false;
29828 }
29829#if USE_TAILCALLS
29830 MUSTTAIL return InterpNext(S);
29831#else
29832 return true;
29833#endif
29834}
29835PRESERVE_NONE
29836static bool Interp_GetThisFieldPtr(InterpState &S) {
29837 {
29838 CodePtr OpPC = S.PC;
29839 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29840 if (!GetThisField<PT_Ptr>(S, OpPC, V0)) return false;
29841 }
29842#if USE_TAILCALLS
29843 MUSTTAIL return InterpNext(S);
29844#else
29845 return true;
29846#endif
29847}
29848PRESERVE_NONE
29849static bool Interp_GetThisFieldMemberPtr(InterpState &S) {
29850 {
29851 CodePtr OpPC = S.PC;
29852 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29853 if (!GetThisField<PT_MemberPtr>(S, OpPC, V0)) return false;
29854 }
29855#if USE_TAILCALLS
29856 MUSTTAIL return InterpNext(S);
29857#else
29858 return true;
29859#endif
29860}
29861PRESERVE_NONE
29862static bool Interp_GetThisFieldFloat(InterpState &S) {
29863 {
29864 CodePtr OpPC = S.PC;
29865 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29866 if (!GetThisField<PT_Float>(S, OpPC, V0)) return false;
29867 }
29868#if USE_TAILCALLS
29869 MUSTTAIL return InterpNext(S);
29870#else
29871 return true;
29872#endif
29873}
29874PRESERVE_NONE
29875static bool Interp_GetThisFieldReflect(InterpState &S) {
29876 {
29877 CodePtr OpPC = S.PC;
29878 const auto V0 = ReadArg<uint32_t>(S, S.PC);
29879 if (!GetThisField<PT_Reflect>(S, OpPC, V0)) return false;
29880 }
29881#if USE_TAILCALLS
29882 MUSTTAIL return InterpNext(S);
29883#else
29884 return true;
29885#endif
29886}
29887#endif
29888#ifdef GET_DISASM
29889case OP_GetThisFieldSint8:
29890 Text.Op = PrintName("GetThisFieldSint8");
29891 Text.Args.push_back(printArg<uint32_t>(PC));
29892 break;
29893case OP_GetThisFieldUint8:
29894 Text.Op = PrintName("GetThisFieldUint8");
29895 Text.Args.push_back(printArg<uint32_t>(PC));
29896 break;
29897case OP_GetThisFieldSint16:
29898 Text.Op = PrintName("GetThisFieldSint16");
29899 Text.Args.push_back(printArg<uint32_t>(PC));
29900 break;
29901case OP_GetThisFieldUint16:
29902 Text.Op = PrintName("GetThisFieldUint16");
29903 Text.Args.push_back(printArg<uint32_t>(PC));
29904 break;
29905case OP_GetThisFieldSint32:
29906 Text.Op = PrintName("GetThisFieldSint32");
29907 Text.Args.push_back(printArg<uint32_t>(PC));
29908 break;
29909case OP_GetThisFieldUint32:
29910 Text.Op = PrintName("GetThisFieldUint32");
29911 Text.Args.push_back(printArg<uint32_t>(PC));
29912 break;
29913case OP_GetThisFieldSint64:
29914 Text.Op = PrintName("GetThisFieldSint64");
29915 Text.Args.push_back(printArg<uint32_t>(PC));
29916 break;
29917case OP_GetThisFieldUint64:
29918 Text.Op = PrintName("GetThisFieldUint64");
29919 Text.Args.push_back(printArg<uint32_t>(PC));
29920 break;
29921case OP_GetThisFieldIntAP:
29922 Text.Op = PrintName("GetThisFieldIntAP");
29923 Text.Args.push_back(printArg<uint32_t>(PC));
29924 break;
29925case OP_GetThisFieldIntAPS:
29926 Text.Op = PrintName("GetThisFieldIntAPS");
29927 Text.Args.push_back(printArg<uint32_t>(PC));
29928 break;
29929case OP_GetThisFieldBool:
29930 Text.Op = PrintName("GetThisFieldBool");
29931 Text.Args.push_back(printArg<uint32_t>(PC));
29932 break;
29933case OP_GetThisFieldFixedPoint:
29934 Text.Op = PrintName("GetThisFieldFixedPoint");
29935 Text.Args.push_back(printArg<uint32_t>(PC));
29936 break;
29937case OP_GetThisFieldPtr:
29938 Text.Op = PrintName("GetThisFieldPtr");
29939 Text.Args.push_back(printArg<uint32_t>(PC));
29940 break;
29941case OP_GetThisFieldMemberPtr:
29942 Text.Op = PrintName("GetThisFieldMemberPtr");
29943 Text.Args.push_back(printArg<uint32_t>(PC));
29944 break;
29945case OP_GetThisFieldFloat:
29946 Text.Op = PrintName("GetThisFieldFloat");
29947 Text.Args.push_back(printArg<uint32_t>(PC));
29948 break;
29949case OP_GetThisFieldReflect:
29950 Text.Op = PrintName("GetThisFieldReflect");
29951 Text.Args.push_back(printArg<uint32_t>(PC));
29952 break;
29953#endif
29954#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29955bool emitGetThisFieldSint8( uint32_t , SourceInfo);
29956bool emitGetThisFieldUint8( uint32_t , SourceInfo);
29957bool emitGetThisFieldSint16( uint32_t , SourceInfo);
29958bool emitGetThisFieldUint16( uint32_t , SourceInfo);
29959bool emitGetThisFieldSint32( uint32_t , SourceInfo);
29960bool emitGetThisFieldUint32( uint32_t , SourceInfo);
29961bool emitGetThisFieldSint64( uint32_t , SourceInfo);
29962bool emitGetThisFieldUint64( uint32_t , SourceInfo);
29963bool emitGetThisFieldIntAP( uint32_t , SourceInfo);
29964bool emitGetThisFieldIntAPS( uint32_t , SourceInfo);
29965bool emitGetThisFieldBool( uint32_t , SourceInfo);
29966bool emitGetThisFieldFixedPoint( uint32_t , SourceInfo);
29967bool emitGetThisFieldPtr( uint32_t , SourceInfo);
29968bool emitGetThisFieldMemberPtr( uint32_t , SourceInfo);
29969bool emitGetThisFieldFloat( uint32_t , SourceInfo);
29970bool emitGetThisFieldReflect( uint32_t , SourceInfo);
29971#endif
29972#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
29973[[nodiscard]] bool emitGetThisField(PrimType, uint32_t, SourceInfo I);
29974#endif
29975#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
29976bool
29977#if defined(GET_EVAL_IMPL)
29978EvalEmitter
29979#else
29980ByteCodeEmitter
29981#endif
29982::emitGetThisField(PrimType T0, uint32_t A0, SourceInfo I) {
29983 switch (T0) {
29984 case PT_Sint8:
29985 return emitGetThisFieldSint8(A0, I);
29986 case PT_Uint8:
29987 return emitGetThisFieldUint8(A0, I);
29988 case PT_Sint16:
29989 return emitGetThisFieldSint16(A0, I);
29990 case PT_Uint16:
29991 return emitGetThisFieldUint16(A0, I);
29992 case PT_Sint32:
29993 return emitGetThisFieldSint32(A0, I);
29994 case PT_Uint32:
29995 return emitGetThisFieldUint32(A0, I);
29996 case PT_Sint64:
29997 return emitGetThisFieldSint64(A0, I);
29998 case PT_Uint64:
29999 return emitGetThisFieldUint64(A0, I);
30000 case PT_IntAP:
30001 return emitGetThisFieldIntAP(A0, I);
30002 case PT_IntAPS:
30003 return emitGetThisFieldIntAPS(A0, I);
30004 case PT_Bool:
30005 return emitGetThisFieldBool(A0, I);
30006 case PT_FixedPoint:
30007 return emitGetThisFieldFixedPoint(A0, I);
30008 case PT_Ptr:
30009 return emitGetThisFieldPtr(A0, I);
30010 case PT_MemberPtr:
30011 return emitGetThisFieldMemberPtr(A0, I);
30012 case PT_Float:
30013 return emitGetThisFieldFloat(A0, I);
30014 case PT_Reflect:
30015 return emitGetThisFieldReflect(A0, I);
30016 }
30017 llvm_unreachable("invalid enum value");
30018}
30019#endif
30020#ifdef GET_LINK_IMPL
30021bool ByteCodeEmitter::emitGetThisFieldSint8( uint32_t A0, SourceInfo L) {
30022 return emitOp<uint32_t>(OP_GetThisFieldSint8, A0, L);
30023}
30024bool ByteCodeEmitter::emitGetThisFieldUint8( uint32_t A0, SourceInfo L) {
30025 return emitOp<uint32_t>(OP_GetThisFieldUint8, A0, L);
30026}
30027bool ByteCodeEmitter::emitGetThisFieldSint16( uint32_t A0, SourceInfo L) {
30028 return emitOp<uint32_t>(OP_GetThisFieldSint16, A0, L);
30029}
30030bool ByteCodeEmitter::emitGetThisFieldUint16( uint32_t A0, SourceInfo L) {
30031 return emitOp<uint32_t>(OP_GetThisFieldUint16, A0, L);
30032}
30033bool ByteCodeEmitter::emitGetThisFieldSint32( uint32_t A0, SourceInfo L) {
30034 return emitOp<uint32_t>(OP_GetThisFieldSint32, A0, L);
30035}
30036bool ByteCodeEmitter::emitGetThisFieldUint32( uint32_t A0, SourceInfo L) {
30037 return emitOp<uint32_t>(OP_GetThisFieldUint32, A0, L);
30038}
30039bool ByteCodeEmitter::emitGetThisFieldSint64( uint32_t A0, SourceInfo L) {
30040 return emitOp<uint32_t>(OP_GetThisFieldSint64, A0, L);
30041}
30042bool ByteCodeEmitter::emitGetThisFieldUint64( uint32_t A0, SourceInfo L) {
30043 return emitOp<uint32_t>(OP_GetThisFieldUint64, A0, L);
30044}
30045bool ByteCodeEmitter::emitGetThisFieldIntAP( uint32_t A0, SourceInfo L) {
30046 return emitOp<uint32_t>(OP_GetThisFieldIntAP, A0, L);
30047}
30048bool ByteCodeEmitter::emitGetThisFieldIntAPS( uint32_t A0, SourceInfo L) {
30049 return emitOp<uint32_t>(OP_GetThisFieldIntAPS, A0, L);
30050}
30051bool ByteCodeEmitter::emitGetThisFieldBool( uint32_t A0, SourceInfo L) {
30052 return emitOp<uint32_t>(OP_GetThisFieldBool, A0, L);
30053}
30054bool ByteCodeEmitter::emitGetThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
30055 return emitOp<uint32_t>(OP_GetThisFieldFixedPoint, A0, L);
30056}
30057bool ByteCodeEmitter::emitGetThisFieldPtr( uint32_t A0, SourceInfo L) {
30058 return emitOp<uint32_t>(OP_GetThisFieldPtr, A0, L);
30059}
30060bool ByteCodeEmitter::emitGetThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
30061 return emitOp<uint32_t>(OP_GetThisFieldMemberPtr, A0, L);
30062}
30063bool ByteCodeEmitter::emitGetThisFieldFloat( uint32_t A0, SourceInfo L) {
30064 return emitOp<uint32_t>(OP_GetThisFieldFloat, A0, L);
30065}
30066bool ByteCodeEmitter::emitGetThisFieldReflect( uint32_t A0, SourceInfo L) {
30067 return emitOp<uint32_t>(OP_GetThisFieldReflect, A0, L);
30068}
30069#endif
30070#ifdef GET_EVAL_IMPL
30071bool EvalEmitter::emitGetThisFieldSint8( uint32_t A0, SourceInfo L) {
30072 if (!isActive()) return true;
30073 CurrentSource = L;
30074 return GetThisField<PT_Sint8>(S, CodePtr(), A0);
30075}
30076bool EvalEmitter::emitGetThisFieldUint8( uint32_t A0, SourceInfo L) {
30077 if (!isActive()) return true;
30078 CurrentSource = L;
30079 return GetThisField<PT_Uint8>(S, CodePtr(), A0);
30080}
30081bool EvalEmitter::emitGetThisFieldSint16( uint32_t A0, SourceInfo L) {
30082 if (!isActive()) return true;
30083 CurrentSource = L;
30084 return GetThisField<PT_Sint16>(S, CodePtr(), A0);
30085}
30086bool EvalEmitter::emitGetThisFieldUint16( uint32_t A0, SourceInfo L) {
30087 if (!isActive()) return true;
30088 CurrentSource = L;
30089 return GetThisField<PT_Uint16>(S, CodePtr(), A0);
30090}
30091bool EvalEmitter::emitGetThisFieldSint32( uint32_t A0, SourceInfo L) {
30092 if (!isActive()) return true;
30093 CurrentSource = L;
30094 return GetThisField<PT_Sint32>(S, CodePtr(), A0);
30095}
30096bool EvalEmitter::emitGetThisFieldUint32( uint32_t A0, SourceInfo L) {
30097 if (!isActive()) return true;
30098 CurrentSource = L;
30099 return GetThisField<PT_Uint32>(S, CodePtr(), A0);
30100}
30101bool EvalEmitter::emitGetThisFieldSint64( uint32_t A0, SourceInfo L) {
30102 if (!isActive()) return true;
30103 CurrentSource = L;
30104 return GetThisField<PT_Sint64>(S, CodePtr(), A0);
30105}
30106bool EvalEmitter::emitGetThisFieldUint64( uint32_t A0, SourceInfo L) {
30107 if (!isActive()) return true;
30108 CurrentSource = L;
30109 return GetThisField<PT_Uint64>(S, CodePtr(), A0);
30110}
30111bool EvalEmitter::emitGetThisFieldIntAP( uint32_t A0, SourceInfo L) {
30112 if (!isActive()) return true;
30113 CurrentSource = L;
30114 return GetThisField<PT_IntAP>(S, CodePtr(), A0);
30115}
30116bool EvalEmitter::emitGetThisFieldIntAPS( uint32_t A0, SourceInfo L) {
30117 if (!isActive()) return true;
30118 CurrentSource = L;
30119 return GetThisField<PT_IntAPS>(S, CodePtr(), A0);
30120}
30121bool EvalEmitter::emitGetThisFieldBool( uint32_t A0, SourceInfo L) {
30122 if (!isActive()) return true;
30123 CurrentSource = L;
30124 return GetThisField<PT_Bool>(S, CodePtr(), A0);
30125}
30126bool EvalEmitter::emitGetThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
30127 if (!isActive()) return true;
30128 CurrentSource = L;
30129 return GetThisField<PT_FixedPoint>(S, CodePtr(), A0);
30130}
30131bool EvalEmitter::emitGetThisFieldPtr( uint32_t A0, SourceInfo L) {
30132 if (!isActive()) return true;
30133 CurrentSource = L;
30134 return GetThisField<PT_Ptr>(S, CodePtr(), A0);
30135}
30136bool EvalEmitter::emitGetThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
30137 if (!isActive()) return true;
30138 CurrentSource = L;
30139 return GetThisField<PT_MemberPtr>(S, CodePtr(), A0);
30140}
30141bool EvalEmitter::emitGetThisFieldFloat( uint32_t A0, SourceInfo L) {
30142 if (!isActive()) return true;
30143 CurrentSource = L;
30144 return GetThisField<PT_Float>(S, CodePtr(), A0);
30145}
30146bool EvalEmitter::emitGetThisFieldReflect( uint32_t A0, SourceInfo L) {
30147 if (!isActive()) return true;
30148 CurrentSource = L;
30149 return GetThisField<PT_Reflect>(S, CodePtr(), A0);
30150}
30151#endif
30152#ifdef GET_OPCODE_NAMES
30153OP_GetTypeid,
30154#endif
30155#ifdef GET_INTERPFN_LIST
30156&Interp_GetTypeid,
30157#endif
30158#ifdef GET_INTERPFN_DISPATCHERS
30159PRESERVE_NONE
30160static bool Interp_GetTypeid(InterpState &S) {
30161 {
30162 const auto V0 = ReadArg<const Type *>(S, S.PC);
30163 const auto V1 = ReadArg<const Type *>(S, S.PC);
30164 GetTypeid(S, V0, V1);
30165 }
30166#if USE_TAILCALLS
30167 MUSTTAIL return InterpNext(S);
30168#else
30169 return true;
30170#endif
30171}
30172#endif
30173#ifdef GET_DISASM
30174case OP_GetTypeid:
30175 Text.Op = PrintName("GetTypeid");
30176 Text.Args.push_back(printArg<const Type *>(PC));
30177 Text.Args.push_back(printArg<const Type *>(PC));
30178 break;
30179#endif
30180#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
30181bool emitGetTypeid( const Type * , const Type * , SourceInfo);
30182#endif
30183#ifdef GET_LINK_IMPL
30184bool ByteCodeEmitter::emitGetTypeid( const Type * A0, const Type * A1, SourceInfo L) {
30185 return emitOp<const Type *, const Type *>(OP_GetTypeid, A0, A1, L);
30186}
30187#endif
30188#ifdef GET_EVAL_IMPL
30189bool EvalEmitter::emitGetTypeid( const Type * A0, const Type * A1, SourceInfo L) {
30190 if (!isActive()) return true;
30191 CurrentSource = L;
30192 return GetTypeid(S, A0, A1);
30193}
30194#endif
30195#ifdef GET_OPCODE_NAMES
30196OP_GetTypeidPtr,
30197#endif
30198#ifdef GET_INTERPFN_LIST
30199&Interp_GetTypeidPtr,
30200#endif
30201#ifdef GET_INTERPFN_DISPATCHERS
30202PRESERVE_NONE
30203static bool Interp_GetTypeidPtr(InterpState &S) {
30204 {
30205 CodePtr OpPC = S.PC;
30206 const auto V0 = ReadArg<const Type *>(S, S.PC);
30207 if (!GetTypeidPtr(S, OpPC, V0)) return false;
30208 }
30209#if USE_TAILCALLS
30210 MUSTTAIL return InterpNext(S);
30211#else
30212 return true;
30213#endif
30214}
30215#endif
30216#ifdef GET_DISASM
30217case OP_GetTypeidPtr:
30218 Text.Op = PrintName("GetTypeidPtr");
30219 Text.Args.push_back(printArg<const Type *>(PC));
30220 break;
30221#endif
30222#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
30223bool emitGetTypeidPtr( const Type * , SourceInfo);
30224#endif
30225#ifdef GET_LINK_IMPL
30226bool ByteCodeEmitter::emitGetTypeidPtr( const Type * A0, SourceInfo L) {
30227 return emitOp<const Type *>(OP_GetTypeidPtr, A0, L);
30228}
30229#endif
30230#ifdef GET_EVAL_IMPL
30231bool EvalEmitter::emitGetTypeidPtr( const Type * A0, SourceInfo L) {
30232 if (!isActive()) return true;
30233 CurrentSource = L;
30234 return GetTypeidPtr(S, CodePtr(), A0);
30235}
30236#endif
30237#ifdef GET_OPCODE_NAMES
30238OP_IncSint8,
30239OP_IncUint8,
30240OP_IncSint16,
30241OP_IncUint16,
30242OP_IncSint32,
30243OP_IncUint32,
30244OP_IncSint64,
30245OP_IncUint64,
30246OP_IncIntAP,
30247OP_IncIntAPS,
30248OP_IncBool,
30249OP_IncFixedPoint,
30250#endif
30251#ifdef GET_INTERPFN_LIST
30252&Interp_IncSint8,
30253&Interp_IncUint8,
30254&Interp_IncSint16,
30255&Interp_IncUint16,
30256&Interp_IncSint32,
30257&Interp_IncUint32,
30258&Interp_IncSint64,
30259&Interp_IncUint64,
30260&Interp_IncIntAP,
30261&Interp_IncIntAPS,
30262&Interp_IncBool,
30263&Interp_IncFixedPoint,
30264#endif
30265#ifdef GET_INTERPFN_DISPATCHERS
30266PRESERVE_NONE
30267static bool Interp_IncSint8(InterpState &S) {
30268 {
30269 CodePtr OpPC = S.PC;
30270 const auto V0 = ReadArg<bool>(S, S.PC);
30271 if (!Inc<PT_Sint8>(S, OpPC, V0)) return false;
30272 }
30273#if USE_TAILCALLS
30274 MUSTTAIL return InterpNext(S);
30275#else
30276 return true;
30277#endif
30278}
30279PRESERVE_NONE
30280static bool Interp_IncUint8(InterpState &S) {
30281 {
30282 CodePtr OpPC = S.PC;
30283 const auto V0 = ReadArg<bool>(S, S.PC);
30284 if (!Inc<PT_Uint8>(S, OpPC, V0)) return false;
30285 }
30286#if USE_TAILCALLS
30287 MUSTTAIL return InterpNext(S);
30288#else
30289 return true;
30290#endif
30291}
30292PRESERVE_NONE
30293static bool Interp_IncSint16(InterpState &S) {
30294 {
30295 CodePtr OpPC = S.PC;
30296 const auto V0 = ReadArg<bool>(S, S.PC);
30297 if (!Inc<PT_Sint16>(S, OpPC, V0)) return false;
30298 }
30299#if USE_TAILCALLS
30300 MUSTTAIL return InterpNext(S);
30301#else
30302 return true;
30303#endif
30304}
30305PRESERVE_NONE
30306static bool Interp_IncUint16(InterpState &S) {
30307 {
30308 CodePtr OpPC = S.PC;
30309 const auto V0 = ReadArg<bool>(S, S.PC);
30310 if (!Inc<PT_Uint16>(S, OpPC, V0)) return false;
30311 }
30312#if USE_TAILCALLS
30313 MUSTTAIL return InterpNext(S);
30314#else
30315 return true;
30316#endif
30317}
30318PRESERVE_NONE
30319static bool Interp_IncSint32(InterpState &S) {
30320 {
30321 CodePtr OpPC = S.PC;
30322 const auto V0 = ReadArg<bool>(S, S.PC);
30323 if (!Inc<PT_Sint32>(S, OpPC, V0)) return false;
30324 }
30325#if USE_TAILCALLS
30326 MUSTTAIL return InterpNext(S);
30327#else
30328 return true;
30329#endif
30330}
30331PRESERVE_NONE
30332static bool Interp_IncUint32(InterpState &S) {
30333 {
30334 CodePtr OpPC = S.PC;
30335 const auto V0 = ReadArg<bool>(S, S.PC);
30336 if (!Inc<PT_Uint32>(S, OpPC, V0)) return false;
30337 }
30338#if USE_TAILCALLS
30339 MUSTTAIL return InterpNext(S);
30340#else
30341 return true;
30342#endif
30343}
30344PRESERVE_NONE
30345static bool Interp_IncSint64(InterpState &S) {
30346 {
30347 CodePtr OpPC = S.PC;
30348 const auto V0 = ReadArg<bool>(S, S.PC);
30349 if (!Inc<PT_Sint64>(S, OpPC, V0)) return false;
30350 }
30351#if USE_TAILCALLS
30352 MUSTTAIL return InterpNext(S);
30353#else
30354 return true;
30355#endif
30356}
30357PRESERVE_NONE
30358static bool Interp_IncUint64(InterpState &S) {
30359 {
30360 CodePtr OpPC = S.PC;
30361 const auto V0 = ReadArg<bool>(S, S.PC);
30362 if (!Inc<PT_Uint64>(S, OpPC, V0)) return false;
30363 }
30364#if USE_TAILCALLS
30365 MUSTTAIL return InterpNext(S);
30366#else
30367 return true;
30368#endif
30369}
30370PRESERVE_NONE
30371static bool Interp_IncIntAP(InterpState &S) {
30372 {
30373 CodePtr OpPC = S.PC;
30374 const auto V0 = ReadArg<bool>(S, S.PC);
30375 if (!Inc<PT_IntAP>(S, OpPC, V0)) return false;
30376 }
30377#if USE_TAILCALLS
30378 MUSTTAIL return InterpNext(S);
30379#else
30380 return true;
30381#endif
30382}
30383PRESERVE_NONE
30384static bool Interp_IncIntAPS(InterpState &S) {
30385 {
30386 CodePtr OpPC = S.PC;
30387 const auto V0 = ReadArg<bool>(S, S.PC);
30388 if (!Inc<PT_IntAPS>(S, OpPC, V0)) return false;
30389 }
30390#if USE_TAILCALLS
30391 MUSTTAIL return InterpNext(S);
30392#else
30393 return true;
30394#endif
30395}
30396PRESERVE_NONE
30397static bool Interp_IncBool(InterpState &S) {
30398 {
30399 CodePtr OpPC = S.PC;
30400 const auto V0 = ReadArg<bool>(S, S.PC);
30401 if (!Inc<PT_Bool>(S, OpPC, V0)) return false;
30402 }
30403#if USE_TAILCALLS
30404 MUSTTAIL return InterpNext(S);
30405#else
30406 return true;
30407#endif
30408}
30409PRESERVE_NONE
30410static bool Interp_IncFixedPoint(InterpState &S) {
30411 {
30412 CodePtr OpPC = S.PC;
30413 const auto V0 = ReadArg<bool>(S, S.PC);
30414 if (!Inc<PT_FixedPoint>(S, OpPC, V0)) return false;
30415 }
30416#if USE_TAILCALLS
30417 MUSTTAIL return InterpNext(S);
30418#else
30419 return true;
30420#endif
30421}
30422#endif
30423#ifdef GET_DISASM
30424case OP_IncSint8:
30425 Text.Op = PrintName("IncSint8");
30426 Text.Args.push_back(printArg<bool>(PC));
30427 break;
30428case OP_IncUint8:
30429 Text.Op = PrintName("IncUint8");
30430 Text.Args.push_back(printArg<bool>(PC));
30431 break;
30432case OP_IncSint16:
30433 Text.Op = PrintName("IncSint16");
30434 Text.Args.push_back(printArg<bool>(PC));
30435 break;
30436case OP_IncUint16:
30437 Text.Op = PrintName("IncUint16");
30438 Text.Args.push_back(printArg<bool>(PC));
30439 break;
30440case OP_IncSint32:
30441 Text.Op = PrintName("IncSint32");
30442 Text.Args.push_back(printArg<bool>(PC));
30443 break;
30444case OP_IncUint32:
30445 Text.Op = PrintName("IncUint32");
30446 Text.Args.push_back(printArg<bool>(PC));
30447 break;
30448case OP_IncSint64:
30449 Text.Op = PrintName("IncSint64");
30450 Text.Args.push_back(printArg<bool>(PC));
30451 break;
30452case OP_IncUint64:
30453 Text.Op = PrintName("IncUint64");
30454 Text.Args.push_back(printArg<bool>(PC));
30455 break;
30456case OP_IncIntAP:
30457 Text.Op = PrintName("IncIntAP");
30458 Text.Args.push_back(printArg<bool>(PC));
30459 break;
30460case OP_IncIntAPS:
30461 Text.Op = PrintName("IncIntAPS");
30462 Text.Args.push_back(printArg<bool>(PC));
30463 break;
30464case OP_IncBool:
30465 Text.Op = PrintName("IncBool");
30466 Text.Args.push_back(printArg<bool>(PC));
30467 break;
30468case OP_IncFixedPoint:
30469 Text.Op = PrintName("IncFixedPoint");
30470 Text.Args.push_back(printArg<bool>(PC));
30471 break;
30472#endif
30473#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
30474bool emitIncSint8( bool , SourceInfo);
30475bool emitIncUint8( bool , SourceInfo);
30476bool emitIncSint16( bool , SourceInfo);
30477bool emitIncUint16( bool , SourceInfo);
30478bool emitIncSint32( bool , SourceInfo);
30479bool emitIncUint32( bool , SourceInfo);
30480bool emitIncSint64( bool , SourceInfo);
30481bool emitIncUint64( bool , SourceInfo);
30482bool emitIncIntAP( bool , SourceInfo);
30483bool emitIncIntAPS( bool , SourceInfo);
30484bool emitIncBool( bool , SourceInfo);
30485bool emitIncFixedPoint( bool , SourceInfo);
30486#endif
30487#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
30488[[nodiscard]] bool emitInc(PrimType, bool, SourceInfo I);
30489#endif
30490#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
30491bool
30492#if defined(GET_EVAL_IMPL)
30493EvalEmitter
30494#else
30495ByteCodeEmitter
30496#endif
30497::emitInc(PrimType T0, bool A0, SourceInfo I) {
30498 switch (T0) {
30499 case PT_Sint8:
30500 return emitIncSint8(A0, I);
30501 case PT_Uint8:
30502 return emitIncUint8(A0, I);
30503 case PT_Sint16:
30504 return emitIncSint16(A0, I);
30505 case PT_Uint16:
30506 return emitIncUint16(A0, I);
30507 case PT_Sint32:
30508 return emitIncSint32(A0, I);
30509 case PT_Uint32:
30510 return emitIncUint32(A0, I);
30511 case PT_Sint64:
30512 return emitIncSint64(A0, I);
30513 case PT_Uint64:
30514 return emitIncUint64(A0, I);
30515 case PT_IntAP:
30516 return emitIncIntAP(A0, I);
30517 case PT_IntAPS:
30518 return emitIncIntAPS(A0, I);
30519 case PT_Bool:
30520 return emitIncBool(A0, I);
30521 case PT_FixedPoint:
30522 return emitIncFixedPoint(A0, I);
30523 default: llvm_unreachable("invalid type: emitInc");
30524 }
30525 llvm_unreachable("invalid enum value");
30526}
30527#endif
30528#ifdef GET_LINK_IMPL
30529bool ByteCodeEmitter::emitIncSint8( bool A0, SourceInfo L) {
30530 return emitOp<bool>(OP_IncSint8, A0, L);
30531}
30532bool ByteCodeEmitter::emitIncUint8( bool A0, SourceInfo L) {
30533 return emitOp<bool>(OP_IncUint8, A0, L);
30534}
30535bool ByteCodeEmitter::emitIncSint16( bool A0, SourceInfo L) {
30536 return emitOp<bool>(OP_IncSint16, A0, L);
30537}
30538bool ByteCodeEmitter::emitIncUint16( bool A0, SourceInfo L) {
30539 return emitOp<bool>(OP_IncUint16, A0, L);
30540}
30541bool ByteCodeEmitter::emitIncSint32( bool A0, SourceInfo L) {
30542 return emitOp<bool>(OP_IncSint32, A0, L);
30543}
30544bool ByteCodeEmitter::emitIncUint32( bool A0, SourceInfo L) {
30545 return emitOp<bool>(OP_IncUint32, A0, L);
30546}
30547bool ByteCodeEmitter::emitIncSint64( bool A0, SourceInfo L) {
30548 return emitOp<bool>(OP_IncSint64, A0, L);
30549}
30550bool ByteCodeEmitter::emitIncUint64( bool A0, SourceInfo L) {
30551 return emitOp<bool>(OP_IncUint64, A0, L);
30552}
30553bool ByteCodeEmitter::emitIncIntAP( bool A0, SourceInfo L) {
30554 return emitOp<bool>(OP_IncIntAP, A0, L);
30555}
30556bool ByteCodeEmitter::emitIncIntAPS( bool A0, SourceInfo L) {
30557 return emitOp<bool>(OP_IncIntAPS, A0, L);
30558}
30559bool ByteCodeEmitter::emitIncBool( bool A0, SourceInfo L) {
30560 return emitOp<bool>(OP_IncBool, A0, L);
30561}
30562bool ByteCodeEmitter::emitIncFixedPoint( bool A0, SourceInfo L) {
30563 return emitOp<bool>(OP_IncFixedPoint, A0, L);
30564}
30565#endif
30566#ifdef GET_EVAL_IMPL
30567bool EvalEmitter::emitIncSint8( bool A0, SourceInfo L) {
30568 if (!isActive()) return true;
30569 CurrentSource = L;
30570 return Inc<PT_Sint8>(S, CodePtr(), A0);
30571}
30572bool EvalEmitter::emitIncUint8( bool A0, SourceInfo L) {
30573 if (!isActive()) return true;
30574 CurrentSource = L;
30575 return Inc<PT_Uint8>(S, CodePtr(), A0);
30576}
30577bool EvalEmitter::emitIncSint16( bool A0, SourceInfo L) {
30578 if (!isActive()) return true;
30579 CurrentSource = L;
30580 return Inc<PT_Sint16>(S, CodePtr(), A0);
30581}
30582bool EvalEmitter::emitIncUint16( bool A0, SourceInfo L) {
30583 if (!isActive()) return true;
30584 CurrentSource = L;
30585 return Inc<PT_Uint16>(S, CodePtr(), A0);
30586}
30587bool EvalEmitter::emitIncSint32( bool A0, SourceInfo L) {
30588 if (!isActive()) return true;
30589 CurrentSource = L;
30590 return Inc<PT_Sint32>(S, CodePtr(), A0);
30591}
30592bool EvalEmitter::emitIncUint32( bool A0, SourceInfo L) {
30593 if (!isActive()) return true;
30594 CurrentSource = L;
30595 return Inc<PT_Uint32>(S, CodePtr(), A0);
30596}
30597bool EvalEmitter::emitIncSint64( bool A0, SourceInfo L) {
30598 if (!isActive()) return true;
30599 CurrentSource = L;
30600 return Inc<PT_Sint64>(S, CodePtr(), A0);
30601}
30602bool EvalEmitter::emitIncUint64( bool A0, SourceInfo L) {
30603 if (!isActive()) return true;
30604 CurrentSource = L;
30605 return Inc<PT_Uint64>(S, CodePtr(), A0);
30606}
30607bool EvalEmitter::emitIncIntAP( bool A0, SourceInfo L) {
30608 if (!isActive()) return true;
30609 CurrentSource = L;
30610 return Inc<PT_IntAP>(S, CodePtr(), A0);
30611}
30612bool EvalEmitter::emitIncIntAPS( bool A0, SourceInfo L) {
30613 if (!isActive()) return true;
30614 CurrentSource = L;
30615 return Inc<PT_IntAPS>(S, CodePtr(), A0);
30616}
30617bool EvalEmitter::emitIncBool( bool A0, SourceInfo L) {
30618 if (!isActive()) return true;
30619 CurrentSource = L;
30620 return Inc<PT_Bool>(S, CodePtr(), A0);
30621}
30622bool EvalEmitter::emitIncFixedPoint( bool A0, SourceInfo L) {
30623 if (!isActive()) return true;
30624 CurrentSource = L;
30625 return Inc<PT_FixedPoint>(S, CodePtr(), A0);
30626}
30627#endif
30628#ifdef GET_OPCODE_NAMES
30629OP_IncBitfieldSint8,
30630OP_IncBitfieldUint8,
30631OP_IncBitfieldSint16,
30632OP_IncBitfieldUint16,
30633OP_IncBitfieldSint32,
30634OP_IncBitfieldUint32,
30635OP_IncBitfieldSint64,
30636OP_IncBitfieldUint64,
30637OP_IncBitfieldIntAP,
30638OP_IncBitfieldIntAPS,
30639OP_IncBitfieldBool,
30640OP_IncBitfieldFixedPoint,
30641#endif
30642#ifdef GET_INTERPFN_LIST
30643&Interp_IncBitfieldSint8,
30644&Interp_IncBitfieldUint8,
30645&Interp_IncBitfieldSint16,
30646&Interp_IncBitfieldUint16,
30647&Interp_IncBitfieldSint32,
30648&Interp_IncBitfieldUint32,
30649&Interp_IncBitfieldSint64,
30650&Interp_IncBitfieldUint64,
30651&Interp_IncBitfieldIntAP,
30652&Interp_IncBitfieldIntAPS,
30653&Interp_IncBitfieldBool,
30654&Interp_IncBitfieldFixedPoint,
30655#endif
30656#ifdef GET_INTERPFN_DISPATCHERS
30657PRESERVE_NONE
30658static bool Interp_IncBitfieldSint8(InterpState &S) {
30659 {
30660 CodePtr OpPC = S.PC;
30661 const auto V0 = ReadArg<bool>(S, S.PC);
30662 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30663 if (!IncBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
30664 }
30665#if USE_TAILCALLS
30666 MUSTTAIL return InterpNext(S);
30667#else
30668 return true;
30669#endif
30670}
30671PRESERVE_NONE
30672static bool Interp_IncBitfieldUint8(InterpState &S) {
30673 {
30674 CodePtr OpPC = S.PC;
30675 const auto V0 = ReadArg<bool>(S, S.PC);
30676 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30677 if (!IncBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
30678 }
30679#if USE_TAILCALLS
30680 MUSTTAIL return InterpNext(S);
30681#else
30682 return true;
30683#endif
30684}
30685PRESERVE_NONE
30686static bool Interp_IncBitfieldSint16(InterpState &S) {
30687 {
30688 CodePtr OpPC = S.PC;
30689 const auto V0 = ReadArg<bool>(S, S.PC);
30690 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30691 if (!IncBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
30692 }
30693#if USE_TAILCALLS
30694 MUSTTAIL return InterpNext(S);
30695#else
30696 return true;
30697#endif
30698}
30699PRESERVE_NONE
30700static bool Interp_IncBitfieldUint16(InterpState &S) {
30701 {
30702 CodePtr OpPC = S.PC;
30703 const auto V0 = ReadArg<bool>(S, S.PC);
30704 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30705 if (!IncBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
30706 }
30707#if USE_TAILCALLS
30708 MUSTTAIL return InterpNext(S);
30709#else
30710 return true;
30711#endif
30712}
30713PRESERVE_NONE
30714static bool Interp_IncBitfieldSint32(InterpState &S) {
30715 {
30716 CodePtr OpPC = S.PC;
30717 const auto V0 = ReadArg<bool>(S, S.PC);
30718 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30719 if (!IncBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
30720 }
30721#if USE_TAILCALLS
30722 MUSTTAIL return InterpNext(S);
30723#else
30724 return true;
30725#endif
30726}
30727PRESERVE_NONE
30728static bool Interp_IncBitfieldUint32(InterpState &S) {
30729 {
30730 CodePtr OpPC = S.PC;
30731 const auto V0 = ReadArg<bool>(S, S.PC);
30732 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30733 if (!IncBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
30734 }
30735#if USE_TAILCALLS
30736 MUSTTAIL return InterpNext(S);
30737#else
30738 return true;
30739#endif
30740}
30741PRESERVE_NONE
30742static bool Interp_IncBitfieldSint64(InterpState &S) {
30743 {
30744 CodePtr OpPC = S.PC;
30745 const auto V0 = ReadArg<bool>(S, S.PC);
30746 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30747 if (!IncBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
30748 }
30749#if USE_TAILCALLS
30750 MUSTTAIL return InterpNext(S);
30751#else
30752 return true;
30753#endif
30754}
30755PRESERVE_NONE
30756static bool Interp_IncBitfieldUint64(InterpState &S) {
30757 {
30758 CodePtr OpPC = S.PC;
30759 const auto V0 = ReadArg<bool>(S, S.PC);
30760 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30761 if (!IncBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
30762 }
30763#if USE_TAILCALLS
30764 MUSTTAIL return InterpNext(S);
30765#else
30766 return true;
30767#endif
30768}
30769PRESERVE_NONE
30770static bool Interp_IncBitfieldIntAP(InterpState &S) {
30771 {
30772 CodePtr OpPC = S.PC;
30773 const auto V0 = ReadArg<bool>(S, S.PC);
30774 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30775 if (!IncBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
30776 }
30777#if USE_TAILCALLS
30778 MUSTTAIL return InterpNext(S);
30779#else
30780 return true;
30781#endif
30782}
30783PRESERVE_NONE
30784static bool Interp_IncBitfieldIntAPS(InterpState &S) {
30785 {
30786 CodePtr OpPC = S.PC;
30787 const auto V0 = ReadArg<bool>(S, S.PC);
30788 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30789 if (!IncBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
30790 }
30791#if USE_TAILCALLS
30792 MUSTTAIL return InterpNext(S);
30793#else
30794 return true;
30795#endif
30796}
30797PRESERVE_NONE
30798static bool Interp_IncBitfieldBool(InterpState &S) {
30799 {
30800 CodePtr OpPC = S.PC;
30801 const auto V0 = ReadArg<bool>(S, S.PC);
30802 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30803 if (!IncBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
30804 }
30805#if USE_TAILCALLS
30806 MUSTTAIL return InterpNext(S);
30807#else
30808 return true;
30809#endif
30810}
30811PRESERVE_NONE
30812static bool Interp_IncBitfieldFixedPoint(InterpState &S) {
30813 {
30814 CodePtr OpPC = S.PC;
30815 const auto V0 = ReadArg<bool>(S, S.PC);
30816 const auto V1 = ReadArg<uint32_t>(S, S.PC);
30817 if (!IncBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
30818 }
30819#if USE_TAILCALLS
30820 MUSTTAIL return InterpNext(S);
30821#else
30822 return true;
30823#endif
30824}
30825#endif
30826#ifdef GET_DISASM
30827case OP_IncBitfieldSint8:
30828 Text.Op = PrintName("IncBitfieldSint8");
30829 Text.Args.push_back(printArg<bool>(PC));
30830 Text.Args.push_back(printArg<uint32_t>(PC));
30831 break;
30832case OP_IncBitfieldUint8:
30833 Text.Op = PrintName("IncBitfieldUint8");
30834 Text.Args.push_back(printArg<bool>(PC));
30835 Text.Args.push_back(printArg<uint32_t>(PC));
30836 break;
30837case OP_IncBitfieldSint16:
30838 Text.Op = PrintName("IncBitfieldSint16");
30839 Text.Args.push_back(printArg<bool>(PC));
30840 Text.Args.push_back(printArg<uint32_t>(PC));
30841 break;
30842case OP_IncBitfieldUint16:
30843 Text.Op = PrintName("IncBitfieldUint16");
30844 Text.Args.push_back(printArg<bool>(PC));
30845 Text.Args.push_back(printArg<uint32_t>(PC));
30846 break;
30847case OP_IncBitfieldSint32:
30848 Text.Op = PrintName("IncBitfieldSint32");
30849 Text.Args.push_back(printArg<bool>(PC));
30850 Text.Args.push_back(printArg<uint32_t>(PC));
30851 break;
30852case OP_IncBitfieldUint32:
30853 Text.Op = PrintName("IncBitfieldUint32");
30854 Text.Args.push_back(printArg<bool>(PC));
30855 Text.Args.push_back(printArg<uint32_t>(PC));
30856 break;
30857case OP_IncBitfieldSint64:
30858 Text.Op = PrintName("IncBitfieldSint64");
30859 Text.Args.push_back(printArg<bool>(PC));
30860 Text.Args.push_back(printArg<uint32_t>(PC));
30861 break;
30862case OP_IncBitfieldUint64:
30863 Text.Op = PrintName("IncBitfieldUint64");
30864 Text.Args.push_back(printArg<bool>(PC));
30865 Text.Args.push_back(printArg<uint32_t>(PC));
30866 break;
30867case OP_IncBitfieldIntAP:
30868 Text.Op = PrintName("IncBitfieldIntAP");
30869 Text.Args.push_back(printArg<bool>(PC));
30870 Text.Args.push_back(printArg<uint32_t>(PC));
30871 break;
30872case OP_IncBitfieldIntAPS:
30873 Text.Op = PrintName("IncBitfieldIntAPS");
30874 Text.Args.push_back(printArg<bool>(PC));
30875 Text.Args.push_back(printArg<uint32_t>(PC));
30876 break;
30877case OP_IncBitfieldBool:
30878 Text.Op = PrintName("IncBitfieldBool");
30879 Text.Args.push_back(printArg<bool>(PC));
30880 Text.Args.push_back(printArg<uint32_t>(PC));
30881 break;
30882case OP_IncBitfieldFixedPoint:
30883 Text.Op = PrintName("IncBitfieldFixedPoint");
30884 Text.Args.push_back(printArg<bool>(PC));
30885 Text.Args.push_back(printArg<uint32_t>(PC));
30886 break;
30887#endif
30888#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
30889bool emitIncBitfieldSint8( bool , uint32_t , SourceInfo);
30890bool emitIncBitfieldUint8( bool , uint32_t , SourceInfo);
30891bool emitIncBitfieldSint16( bool , uint32_t , SourceInfo);
30892bool emitIncBitfieldUint16( bool , uint32_t , SourceInfo);
30893bool emitIncBitfieldSint32( bool , uint32_t , SourceInfo);
30894bool emitIncBitfieldUint32( bool , uint32_t , SourceInfo);
30895bool emitIncBitfieldSint64( bool , uint32_t , SourceInfo);
30896bool emitIncBitfieldUint64( bool , uint32_t , SourceInfo);
30897bool emitIncBitfieldIntAP( bool , uint32_t , SourceInfo);
30898bool emitIncBitfieldIntAPS( bool , uint32_t , SourceInfo);
30899bool emitIncBitfieldBool( bool , uint32_t , SourceInfo);
30900bool emitIncBitfieldFixedPoint( bool , uint32_t , SourceInfo);
30901#endif
30902#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
30903[[nodiscard]] bool emitIncBitfield(PrimType, bool, uint32_t, SourceInfo I);
30904#endif
30905#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
30906bool
30907#if defined(GET_EVAL_IMPL)
30908EvalEmitter
30909#else
30910ByteCodeEmitter
30911#endif
30912::emitIncBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
30913 switch (T0) {
30914 case PT_Sint8:
30915 return emitIncBitfieldSint8(A0, A1, I);
30916 case PT_Uint8:
30917 return emitIncBitfieldUint8(A0, A1, I);
30918 case PT_Sint16:
30919 return emitIncBitfieldSint16(A0, A1, I);
30920 case PT_Uint16:
30921 return emitIncBitfieldUint16(A0, A1, I);
30922 case PT_Sint32:
30923 return emitIncBitfieldSint32(A0, A1, I);
30924 case PT_Uint32:
30925 return emitIncBitfieldUint32(A0, A1, I);
30926 case PT_Sint64:
30927 return emitIncBitfieldSint64(A0, A1, I);
30928 case PT_Uint64:
30929 return emitIncBitfieldUint64(A0, A1, I);
30930 case PT_IntAP:
30931 return emitIncBitfieldIntAP(A0, A1, I);
30932 case PT_IntAPS:
30933 return emitIncBitfieldIntAPS(A0, A1, I);
30934 case PT_Bool:
30935 return emitIncBitfieldBool(A0, A1, I);
30936 case PT_FixedPoint:
30937 return emitIncBitfieldFixedPoint(A0, A1, I);
30938 default: llvm_unreachable("invalid type: emitIncBitfield");
30939 }
30940 llvm_unreachable("invalid enum value");
30941}
30942#endif
30943#ifdef GET_LINK_IMPL
30944bool ByteCodeEmitter::emitIncBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
30945 return emitOp<bool, uint32_t>(OP_IncBitfieldSint8, A0, A1, L);
30946}
30947bool ByteCodeEmitter::emitIncBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
30948 return emitOp<bool, uint32_t>(OP_IncBitfieldUint8, A0, A1, L);
30949}
30950bool ByteCodeEmitter::emitIncBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
30951 return emitOp<bool, uint32_t>(OP_IncBitfieldSint16, A0, A1, L);
30952}
30953bool ByteCodeEmitter::emitIncBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
30954 return emitOp<bool, uint32_t>(OP_IncBitfieldUint16, A0, A1, L);
30955}
30956bool ByteCodeEmitter::emitIncBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
30957 return emitOp<bool, uint32_t>(OP_IncBitfieldSint32, A0, A1, L);
30958}
30959bool ByteCodeEmitter::emitIncBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
30960 return emitOp<bool, uint32_t>(OP_IncBitfieldUint32, A0, A1, L);
30961}
30962bool ByteCodeEmitter::emitIncBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
30963 return emitOp<bool, uint32_t>(OP_IncBitfieldSint64, A0, A1, L);
30964}
30965bool ByteCodeEmitter::emitIncBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
30966 return emitOp<bool, uint32_t>(OP_IncBitfieldUint64, A0, A1, L);
30967}
30968bool ByteCodeEmitter::emitIncBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
30969 return emitOp<bool, uint32_t>(OP_IncBitfieldIntAP, A0, A1, L);
30970}
30971bool ByteCodeEmitter::emitIncBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
30972 return emitOp<bool, uint32_t>(OP_IncBitfieldIntAPS, A0, A1, L);
30973}
30974bool ByteCodeEmitter::emitIncBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
30975 return emitOp<bool, uint32_t>(OP_IncBitfieldBool, A0, A1, L);
30976}
30977bool ByteCodeEmitter::emitIncBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
30978 return emitOp<bool, uint32_t>(OP_IncBitfieldFixedPoint, A0, A1, L);
30979}
30980#endif
30981#ifdef GET_EVAL_IMPL
30982bool EvalEmitter::emitIncBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
30983 if (!isActive()) return true;
30984 CurrentSource = L;
30985 return IncBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
30986}
30987bool EvalEmitter::emitIncBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
30988 if (!isActive()) return true;
30989 CurrentSource = L;
30990 return IncBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
30991}
30992bool EvalEmitter::emitIncBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
30993 if (!isActive()) return true;
30994 CurrentSource = L;
30995 return IncBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
30996}
30997bool EvalEmitter::emitIncBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
30998 if (!isActive()) return true;
30999 CurrentSource = L;
31000 return IncBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
31001}
31002bool EvalEmitter::emitIncBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
31003 if (!isActive()) return true;
31004 CurrentSource = L;
31005 return IncBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
31006}
31007bool EvalEmitter::emitIncBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
31008 if (!isActive()) return true;
31009 CurrentSource = L;
31010 return IncBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
31011}
31012bool EvalEmitter::emitIncBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
31013 if (!isActive()) return true;
31014 CurrentSource = L;
31015 return IncBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
31016}
31017bool EvalEmitter::emitIncBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
31018 if (!isActive()) return true;
31019 CurrentSource = L;
31020 return IncBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
31021}
31022bool EvalEmitter::emitIncBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
31023 if (!isActive()) return true;
31024 CurrentSource = L;
31025 return IncBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
31026}
31027bool EvalEmitter::emitIncBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
31028 if (!isActive()) return true;
31029 CurrentSource = L;
31030 return IncBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
31031}
31032bool EvalEmitter::emitIncBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
31033 if (!isActive()) return true;
31034 CurrentSource = L;
31035 return IncBitfield<PT_Bool>(S, CodePtr(), A0, A1);
31036}
31037bool EvalEmitter::emitIncBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
31038 if (!isActive()) return true;
31039 CurrentSource = L;
31040 return IncBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
31041}
31042#endif
31043#ifdef GET_OPCODE_NAMES
31044OP_IncPopSint8,
31045OP_IncPopUint8,
31046OP_IncPopSint16,
31047OP_IncPopUint16,
31048OP_IncPopSint32,
31049OP_IncPopUint32,
31050OP_IncPopSint64,
31051OP_IncPopUint64,
31052OP_IncPopIntAP,
31053OP_IncPopIntAPS,
31054OP_IncPopBool,
31055OP_IncPopFixedPoint,
31056#endif
31057#ifdef GET_INTERPFN_LIST
31058&Interp_IncPopSint8,
31059&Interp_IncPopUint8,
31060&Interp_IncPopSint16,
31061&Interp_IncPopUint16,
31062&Interp_IncPopSint32,
31063&Interp_IncPopUint32,
31064&Interp_IncPopSint64,
31065&Interp_IncPopUint64,
31066&Interp_IncPopIntAP,
31067&Interp_IncPopIntAPS,
31068&Interp_IncPopBool,
31069&Interp_IncPopFixedPoint,
31070#endif
31071#ifdef GET_INTERPFN_DISPATCHERS
31072PRESERVE_NONE
31073static bool Interp_IncPopSint8(InterpState &S) {
31074 {
31075 CodePtr OpPC = S.PC;
31076 const auto V0 = ReadArg<bool>(S, S.PC);
31077 if (!IncPop<PT_Sint8>(S, OpPC, V0)) return false;
31078 }
31079#if USE_TAILCALLS
31080 MUSTTAIL return InterpNext(S);
31081#else
31082 return true;
31083#endif
31084}
31085PRESERVE_NONE
31086static bool Interp_IncPopUint8(InterpState &S) {
31087 {
31088 CodePtr OpPC = S.PC;
31089 const auto V0 = ReadArg<bool>(S, S.PC);
31090 if (!IncPop<PT_Uint8>(S, OpPC, V0)) return false;
31091 }
31092#if USE_TAILCALLS
31093 MUSTTAIL return InterpNext(S);
31094#else
31095 return true;
31096#endif
31097}
31098PRESERVE_NONE
31099static bool Interp_IncPopSint16(InterpState &S) {
31100 {
31101 CodePtr OpPC = S.PC;
31102 const auto V0 = ReadArg<bool>(S, S.PC);
31103 if (!IncPop<PT_Sint16>(S, OpPC, V0)) return false;
31104 }
31105#if USE_TAILCALLS
31106 MUSTTAIL return InterpNext(S);
31107#else
31108 return true;
31109#endif
31110}
31111PRESERVE_NONE
31112static bool Interp_IncPopUint16(InterpState &S) {
31113 {
31114 CodePtr OpPC = S.PC;
31115 const auto V0 = ReadArg<bool>(S, S.PC);
31116 if (!IncPop<PT_Uint16>(S, OpPC, V0)) return false;
31117 }
31118#if USE_TAILCALLS
31119 MUSTTAIL return InterpNext(S);
31120#else
31121 return true;
31122#endif
31123}
31124PRESERVE_NONE
31125static bool Interp_IncPopSint32(InterpState &S) {
31126 {
31127 CodePtr OpPC = S.PC;
31128 const auto V0 = ReadArg<bool>(S, S.PC);
31129 if (!IncPop<PT_Sint32>(S, OpPC, V0)) return false;
31130 }
31131#if USE_TAILCALLS
31132 MUSTTAIL return InterpNext(S);
31133#else
31134 return true;
31135#endif
31136}
31137PRESERVE_NONE
31138static bool Interp_IncPopUint32(InterpState &S) {
31139 {
31140 CodePtr OpPC = S.PC;
31141 const auto V0 = ReadArg<bool>(S, S.PC);
31142 if (!IncPop<PT_Uint32>(S, OpPC, V0)) return false;
31143 }
31144#if USE_TAILCALLS
31145 MUSTTAIL return InterpNext(S);
31146#else
31147 return true;
31148#endif
31149}
31150PRESERVE_NONE
31151static bool Interp_IncPopSint64(InterpState &S) {
31152 {
31153 CodePtr OpPC = S.PC;
31154 const auto V0 = ReadArg<bool>(S, S.PC);
31155 if (!IncPop<PT_Sint64>(S, OpPC, V0)) return false;
31156 }
31157#if USE_TAILCALLS
31158 MUSTTAIL return InterpNext(S);
31159#else
31160 return true;
31161#endif
31162}
31163PRESERVE_NONE
31164static bool Interp_IncPopUint64(InterpState &S) {
31165 {
31166 CodePtr OpPC = S.PC;
31167 const auto V0 = ReadArg<bool>(S, S.PC);
31168 if (!IncPop<PT_Uint64>(S, OpPC, V0)) return false;
31169 }
31170#if USE_TAILCALLS
31171 MUSTTAIL return InterpNext(S);
31172#else
31173 return true;
31174#endif
31175}
31176PRESERVE_NONE
31177static bool Interp_IncPopIntAP(InterpState &S) {
31178 {
31179 CodePtr OpPC = S.PC;
31180 const auto V0 = ReadArg<bool>(S, S.PC);
31181 if (!IncPop<PT_IntAP>(S, OpPC, V0)) return false;
31182 }
31183#if USE_TAILCALLS
31184 MUSTTAIL return InterpNext(S);
31185#else
31186 return true;
31187#endif
31188}
31189PRESERVE_NONE
31190static bool Interp_IncPopIntAPS(InterpState &S) {
31191 {
31192 CodePtr OpPC = S.PC;
31193 const auto V0 = ReadArg<bool>(S, S.PC);
31194 if (!IncPop<PT_IntAPS>(S, OpPC, V0)) return false;
31195 }
31196#if USE_TAILCALLS
31197 MUSTTAIL return InterpNext(S);
31198#else
31199 return true;
31200#endif
31201}
31202PRESERVE_NONE
31203static bool Interp_IncPopBool(InterpState &S) {
31204 {
31205 CodePtr OpPC = S.PC;
31206 const auto V0 = ReadArg<bool>(S, S.PC);
31207 if (!IncPop<PT_Bool>(S, OpPC, V0)) return false;
31208 }
31209#if USE_TAILCALLS
31210 MUSTTAIL return InterpNext(S);
31211#else
31212 return true;
31213#endif
31214}
31215PRESERVE_NONE
31216static bool Interp_IncPopFixedPoint(InterpState &S) {
31217 {
31218 CodePtr OpPC = S.PC;
31219 const auto V0 = ReadArg<bool>(S, S.PC);
31220 if (!IncPop<PT_FixedPoint>(S, OpPC, V0)) return false;
31221 }
31222#if USE_TAILCALLS
31223 MUSTTAIL return InterpNext(S);
31224#else
31225 return true;
31226#endif
31227}
31228#endif
31229#ifdef GET_DISASM
31230case OP_IncPopSint8:
31231 Text.Op = PrintName("IncPopSint8");
31232 Text.Args.push_back(printArg<bool>(PC));
31233 break;
31234case OP_IncPopUint8:
31235 Text.Op = PrintName("IncPopUint8");
31236 Text.Args.push_back(printArg<bool>(PC));
31237 break;
31238case OP_IncPopSint16:
31239 Text.Op = PrintName("IncPopSint16");
31240 Text.Args.push_back(printArg<bool>(PC));
31241 break;
31242case OP_IncPopUint16:
31243 Text.Op = PrintName("IncPopUint16");
31244 Text.Args.push_back(printArg<bool>(PC));
31245 break;
31246case OP_IncPopSint32:
31247 Text.Op = PrintName("IncPopSint32");
31248 Text.Args.push_back(printArg<bool>(PC));
31249 break;
31250case OP_IncPopUint32:
31251 Text.Op = PrintName("IncPopUint32");
31252 Text.Args.push_back(printArg<bool>(PC));
31253 break;
31254case OP_IncPopSint64:
31255 Text.Op = PrintName("IncPopSint64");
31256 Text.Args.push_back(printArg<bool>(PC));
31257 break;
31258case OP_IncPopUint64:
31259 Text.Op = PrintName("IncPopUint64");
31260 Text.Args.push_back(printArg<bool>(PC));
31261 break;
31262case OP_IncPopIntAP:
31263 Text.Op = PrintName("IncPopIntAP");
31264 Text.Args.push_back(printArg<bool>(PC));
31265 break;
31266case OP_IncPopIntAPS:
31267 Text.Op = PrintName("IncPopIntAPS");
31268 Text.Args.push_back(printArg<bool>(PC));
31269 break;
31270case OP_IncPopBool:
31271 Text.Op = PrintName("IncPopBool");
31272 Text.Args.push_back(printArg<bool>(PC));
31273 break;
31274case OP_IncPopFixedPoint:
31275 Text.Op = PrintName("IncPopFixedPoint");
31276 Text.Args.push_back(printArg<bool>(PC));
31277 break;
31278#endif
31279#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
31280bool emitIncPopSint8( bool , SourceInfo);
31281bool emitIncPopUint8( bool , SourceInfo);
31282bool emitIncPopSint16( bool , SourceInfo);
31283bool emitIncPopUint16( bool , SourceInfo);
31284bool emitIncPopSint32( bool , SourceInfo);
31285bool emitIncPopUint32( bool , SourceInfo);
31286bool emitIncPopSint64( bool , SourceInfo);
31287bool emitIncPopUint64( bool , SourceInfo);
31288bool emitIncPopIntAP( bool , SourceInfo);
31289bool emitIncPopIntAPS( bool , SourceInfo);
31290bool emitIncPopBool( bool , SourceInfo);
31291bool emitIncPopFixedPoint( bool , SourceInfo);
31292#endif
31293#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
31294[[nodiscard]] bool emitIncPop(PrimType, bool, SourceInfo I);
31295#endif
31296#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
31297bool
31298#if defined(GET_EVAL_IMPL)
31299EvalEmitter
31300#else
31301ByteCodeEmitter
31302#endif
31303::emitIncPop(PrimType T0, bool A0, SourceInfo I) {
31304 switch (T0) {
31305 case PT_Sint8:
31306 return emitIncPopSint8(A0, I);
31307 case PT_Uint8:
31308 return emitIncPopUint8(A0, I);
31309 case PT_Sint16:
31310 return emitIncPopSint16(A0, I);
31311 case PT_Uint16:
31312 return emitIncPopUint16(A0, I);
31313 case PT_Sint32:
31314 return emitIncPopSint32(A0, I);
31315 case PT_Uint32:
31316 return emitIncPopUint32(A0, I);
31317 case PT_Sint64:
31318 return emitIncPopSint64(A0, I);
31319 case PT_Uint64:
31320 return emitIncPopUint64(A0, I);
31321 case PT_IntAP:
31322 return emitIncPopIntAP(A0, I);
31323 case PT_IntAPS:
31324 return emitIncPopIntAPS(A0, I);
31325 case PT_Bool:
31326 return emitIncPopBool(A0, I);
31327 case PT_FixedPoint:
31328 return emitIncPopFixedPoint(A0, I);
31329 default: llvm_unreachable("invalid type: emitIncPop");
31330 }
31331 llvm_unreachable("invalid enum value");
31332}
31333#endif
31334#ifdef GET_LINK_IMPL
31335bool ByteCodeEmitter::emitIncPopSint8( bool A0, SourceInfo L) {
31336 return emitOp<bool>(OP_IncPopSint8, A0, L);
31337}
31338bool ByteCodeEmitter::emitIncPopUint8( bool A0, SourceInfo L) {
31339 return emitOp<bool>(OP_IncPopUint8, A0, L);
31340}
31341bool ByteCodeEmitter::emitIncPopSint16( bool A0, SourceInfo L) {
31342 return emitOp<bool>(OP_IncPopSint16, A0, L);
31343}
31344bool ByteCodeEmitter::emitIncPopUint16( bool A0, SourceInfo L) {
31345 return emitOp<bool>(OP_IncPopUint16, A0, L);
31346}
31347bool ByteCodeEmitter::emitIncPopSint32( bool A0, SourceInfo L) {
31348 return emitOp<bool>(OP_IncPopSint32, A0, L);
31349}
31350bool ByteCodeEmitter::emitIncPopUint32( bool A0, SourceInfo L) {
31351 return emitOp<bool>(OP_IncPopUint32, A0, L);
31352}
31353bool ByteCodeEmitter::emitIncPopSint64( bool A0, SourceInfo L) {
31354 return emitOp<bool>(OP_IncPopSint64, A0, L);
31355}
31356bool ByteCodeEmitter::emitIncPopUint64( bool A0, SourceInfo L) {
31357 return emitOp<bool>(OP_IncPopUint64, A0, L);
31358}
31359bool ByteCodeEmitter::emitIncPopIntAP( bool A0, SourceInfo L) {
31360 return emitOp<bool>(OP_IncPopIntAP, A0, L);
31361}
31362bool ByteCodeEmitter::emitIncPopIntAPS( bool A0, SourceInfo L) {
31363 return emitOp<bool>(OP_IncPopIntAPS, A0, L);
31364}
31365bool ByteCodeEmitter::emitIncPopBool( bool A0, SourceInfo L) {
31366 return emitOp<bool>(OP_IncPopBool, A0, L);
31367}
31368bool ByteCodeEmitter::emitIncPopFixedPoint( bool A0, SourceInfo L) {
31369 return emitOp<bool>(OP_IncPopFixedPoint, A0, L);
31370}
31371#endif
31372#ifdef GET_EVAL_IMPL
31373bool EvalEmitter::emitIncPopSint8( bool A0, SourceInfo L) {
31374 if (!isActive()) return true;
31375 CurrentSource = L;
31376 return IncPop<PT_Sint8>(S, CodePtr(), A0);
31377}
31378bool EvalEmitter::emitIncPopUint8( bool A0, SourceInfo L) {
31379 if (!isActive()) return true;
31380 CurrentSource = L;
31381 return IncPop<PT_Uint8>(S, CodePtr(), A0);
31382}
31383bool EvalEmitter::emitIncPopSint16( bool A0, SourceInfo L) {
31384 if (!isActive()) return true;
31385 CurrentSource = L;
31386 return IncPop<PT_Sint16>(S, CodePtr(), A0);
31387}
31388bool EvalEmitter::emitIncPopUint16( bool A0, SourceInfo L) {
31389 if (!isActive()) return true;
31390 CurrentSource = L;
31391 return IncPop<PT_Uint16>(S, CodePtr(), A0);
31392}
31393bool EvalEmitter::emitIncPopSint32( bool A0, SourceInfo L) {
31394 if (!isActive()) return true;
31395 CurrentSource = L;
31396 return IncPop<PT_Sint32>(S, CodePtr(), A0);
31397}
31398bool EvalEmitter::emitIncPopUint32( bool A0, SourceInfo L) {
31399 if (!isActive()) return true;
31400 CurrentSource = L;
31401 return IncPop<PT_Uint32>(S, CodePtr(), A0);
31402}
31403bool EvalEmitter::emitIncPopSint64( bool A0, SourceInfo L) {
31404 if (!isActive()) return true;
31405 CurrentSource = L;
31406 return IncPop<PT_Sint64>(S, CodePtr(), A0);
31407}
31408bool EvalEmitter::emitIncPopUint64( bool A0, SourceInfo L) {
31409 if (!isActive()) return true;
31410 CurrentSource = L;
31411 return IncPop<PT_Uint64>(S, CodePtr(), A0);
31412}
31413bool EvalEmitter::emitIncPopIntAP( bool A0, SourceInfo L) {
31414 if (!isActive()) return true;
31415 CurrentSource = L;
31416 return IncPop<PT_IntAP>(S, CodePtr(), A0);
31417}
31418bool EvalEmitter::emitIncPopIntAPS( bool A0, SourceInfo L) {
31419 if (!isActive()) return true;
31420 CurrentSource = L;
31421 return IncPop<PT_IntAPS>(S, CodePtr(), A0);
31422}
31423bool EvalEmitter::emitIncPopBool( bool A0, SourceInfo L) {
31424 if (!isActive()) return true;
31425 CurrentSource = L;
31426 return IncPop<PT_Bool>(S, CodePtr(), A0);
31427}
31428bool EvalEmitter::emitIncPopFixedPoint( bool A0, SourceInfo L) {
31429 if (!isActive()) return true;
31430 CurrentSource = L;
31431 return IncPop<PT_FixedPoint>(S, CodePtr(), A0);
31432}
31433#endif
31434#ifdef GET_OPCODE_NAMES
31435OP_IncPopBitfieldSint8,
31436OP_IncPopBitfieldUint8,
31437OP_IncPopBitfieldSint16,
31438OP_IncPopBitfieldUint16,
31439OP_IncPopBitfieldSint32,
31440OP_IncPopBitfieldUint32,
31441OP_IncPopBitfieldSint64,
31442OP_IncPopBitfieldUint64,
31443OP_IncPopBitfieldIntAP,
31444OP_IncPopBitfieldIntAPS,
31445OP_IncPopBitfieldBool,
31446OP_IncPopBitfieldFixedPoint,
31447#endif
31448#ifdef GET_INTERPFN_LIST
31449&Interp_IncPopBitfieldSint8,
31450&Interp_IncPopBitfieldUint8,
31451&Interp_IncPopBitfieldSint16,
31452&Interp_IncPopBitfieldUint16,
31453&Interp_IncPopBitfieldSint32,
31454&Interp_IncPopBitfieldUint32,
31455&Interp_IncPopBitfieldSint64,
31456&Interp_IncPopBitfieldUint64,
31457&Interp_IncPopBitfieldIntAP,
31458&Interp_IncPopBitfieldIntAPS,
31459&Interp_IncPopBitfieldBool,
31460&Interp_IncPopBitfieldFixedPoint,
31461#endif
31462#ifdef GET_INTERPFN_DISPATCHERS
31463PRESERVE_NONE
31464static bool Interp_IncPopBitfieldSint8(InterpState &S) {
31465 {
31466 CodePtr OpPC = S.PC;
31467 const auto V0 = ReadArg<bool>(S, S.PC);
31468 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31469 if (!IncPopBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
31470 }
31471#if USE_TAILCALLS
31472 MUSTTAIL return InterpNext(S);
31473#else
31474 return true;
31475#endif
31476}
31477PRESERVE_NONE
31478static bool Interp_IncPopBitfieldUint8(InterpState &S) {
31479 {
31480 CodePtr OpPC = S.PC;
31481 const auto V0 = ReadArg<bool>(S, S.PC);
31482 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31483 if (!IncPopBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
31484 }
31485#if USE_TAILCALLS
31486 MUSTTAIL return InterpNext(S);
31487#else
31488 return true;
31489#endif
31490}
31491PRESERVE_NONE
31492static bool Interp_IncPopBitfieldSint16(InterpState &S) {
31493 {
31494 CodePtr OpPC = S.PC;
31495 const auto V0 = ReadArg<bool>(S, S.PC);
31496 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31497 if (!IncPopBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
31498 }
31499#if USE_TAILCALLS
31500 MUSTTAIL return InterpNext(S);
31501#else
31502 return true;
31503#endif
31504}
31505PRESERVE_NONE
31506static bool Interp_IncPopBitfieldUint16(InterpState &S) {
31507 {
31508 CodePtr OpPC = S.PC;
31509 const auto V0 = ReadArg<bool>(S, S.PC);
31510 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31511 if (!IncPopBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
31512 }
31513#if USE_TAILCALLS
31514 MUSTTAIL return InterpNext(S);
31515#else
31516 return true;
31517#endif
31518}
31519PRESERVE_NONE
31520static bool Interp_IncPopBitfieldSint32(InterpState &S) {
31521 {
31522 CodePtr OpPC = S.PC;
31523 const auto V0 = ReadArg<bool>(S, S.PC);
31524 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31525 if (!IncPopBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
31526 }
31527#if USE_TAILCALLS
31528 MUSTTAIL return InterpNext(S);
31529#else
31530 return true;
31531#endif
31532}
31533PRESERVE_NONE
31534static bool Interp_IncPopBitfieldUint32(InterpState &S) {
31535 {
31536 CodePtr OpPC = S.PC;
31537 const auto V0 = ReadArg<bool>(S, S.PC);
31538 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31539 if (!IncPopBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
31540 }
31541#if USE_TAILCALLS
31542 MUSTTAIL return InterpNext(S);
31543#else
31544 return true;
31545#endif
31546}
31547PRESERVE_NONE
31548static bool Interp_IncPopBitfieldSint64(InterpState &S) {
31549 {
31550 CodePtr OpPC = S.PC;
31551 const auto V0 = ReadArg<bool>(S, S.PC);
31552 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31553 if (!IncPopBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
31554 }
31555#if USE_TAILCALLS
31556 MUSTTAIL return InterpNext(S);
31557#else
31558 return true;
31559#endif
31560}
31561PRESERVE_NONE
31562static bool Interp_IncPopBitfieldUint64(InterpState &S) {
31563 {
31564 CodePtr OpPC = S.PC;
31565 const auto V0 = ReadArg<bool>(S, S.PC);
31566 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31567 if (!IncPopBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
31568 }
31569#if USE_TAILCALLS
31570 MUSTTAIL return InterpNext(S);
31571#else
31572 return true;
31573#endif
31574}
31575PRESERVE_NONE
31576static bool Interp_IncPopBitfieldIntAP(InterpState &S) {
31577 {
31578 CodePtr OpPC = S.PC;
31579 const auto V0 = ReadArg<bool>(S, S.PC);
31580 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31581 if (!IncPopBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
31582 }
31583#if USE_TAILCALLS
31584 MUSTTAIL return InterpNext(S);
31585#else
31586 return true;
31587#endif
31588}
31589PRESERVE_NONE
31590static bool Interp_IncPopBitfieldIntAPS(InterpState &S) {
31591 {
31592 CodePtr OpPC = S.PC;
31593 const auto V0 = ReadArg<bool>(S, S.PC);
31594 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31595 if (!IncPopBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
31596 }
31597#if USE_TAILCALLS
31598 MUSTTAIL return InterpNext(S);
31599#else
31600 return true;
31601#endif
31602}
31603PRESERVE_NONE
31604static bool Interp_IncPopBitfieldBool(InterpState &S) {
31605 {
31606 CodePtr OpPC = S.PC;
31607 const auto V0 = ReadArg<bool>(S, S.PC);
31608 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31609 if (!IncPopBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
31610 }
31611#if USE_TAILCALLS
31612 MUSTTAIL return InterpNext(S);
31613#else
31614 return true;
31615#endif
31616}
31617PRESERVE_NONE
31618static bool Interp_IncPopBitfieldFixedPoint(InterpState &S) {
31619 {
31620 CodePtr OpPC = S.PC;
31621 const auto V0 = ReadArg<bool>(S, S.PC);
31622 const auto V1 = ReadArg<uint32_t>(S, S.PC);
31623 if (!IncPopBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
31624 }
31625#if USE_TAILCALLS
31626 MUSTTAIL return InterpNext(S);
31627#else
31628 return true;
31629#endif
31630}
31631#endif
31632#ifdef GET_DISASM
31633case OP_IncPopBitfieldSint8:
31634 Text.Op = PrintName("IncPopBitfieldSint8");
31635 Text.Args.push_back(printArg<bool>(PC));
31636 Text.Args.push_back(printArg<uint32_t>(PC));
31637 break;
31638case OP_IncPopBitfieldUint8:
31639 Text.Op = PrintName("IncPopBitfieldUint8");
31640 Text.Args.push_back(printArg<bool>(PC));
31641 Text.Args.push_back(printArg<uint32_t>(PC));
31642 break;
31643case OP_IncPopBitfieldSint16:
31644 Text.Op = PrintName("IncPopBitfieldSint16");
31645 Text.Args.push_back(printArg<bool>(PC));
31646 Text.Args.push_back(printArg<uint32_t>(PC));
31647 break;
31648case OP_IncPopBitfieldUint16:
31649 Text.Op = PrintName("IncPopBitfieldUint16");
31650 Text.Args.push_back(printArg<bool>(PC));
31651 Text.Args.push_back(printArg<uint32_t>(PC));
31652 break;
31653case OP_IncPopBitfieldSint32:
31654 Text.Op = PrintName("IncPopBitfieldSint32");
31655 Text.Args.push_back(printArg<bool>(PC));
31656 Text.Args.push_back(printArg<uint32_t>(PC));
31657 break;
31658case OP_IncPopBitfieldUint32:
31659 Text.Op = PrintName("IncPopBitfieldUint32");
31660 Text.Args.push_back(printArg<bool>(PC));
31661 Text.Args.push_back(printArg<uint32_t>(PC));
31662 break;
31663case OP_IncPopBitfieldSint64:
31664 Text.Op = PrintName("IncPopBitfieldSint64");
31665 Text.Args.push_back(printArg<bool>(PC));
31666 Text.Args.push_back(printArg<uint32_t>(PC));
31667 break;
31668case OP_IncPopBitfieldUint64:
31669 Text.Op = PrintName("IncPopBitfieldUint64");
31670 Text.Args.push_back(printArg<bool>(PC));
31671 Text.Args.push_back(printArg<uint32_t>(PC));
31672 break;
31673case OP_IncPopBitfieldIntAP:
31674 Text.Op = PrintName("IncPopBitfieldIntAP");
31675 Text.Args.push_back(printArg<bool>(PC));
31676 Text.Args.push_back(printArg<uint32_t>(PC));
31677 break;
31678case OP_IncPopBitfieldIntAPS:
31679 Text.Op = PrintName("IncPopBitfieldIntAPS");
31680 Text.Args.push_back(printArg<bool>(PC));
31681 Text.Args.push_back(printArg<uint32_t>(PC));
31682 break;
31683case OP_IncPopBitfieldBool:
31684 Text.Op = PrintName("IncPopBitfieldBool");
31685 Text.Args.push_back(printArg<bool>(PC));
31686 Text.Args.push_back(printArg<uint32_t>(PC));
31687 break;
31688case OP_IncPopBitfieldFixedPoint:
31689 Text.Op = PrintName("IncPopBitfieldFixedPoint");
31690 Text.Args.push_back(printArg<bool>(PC));
31691 Text.Args.push_back(printArg<uint32_t>(PC));
31692 break;
31693#endif
31694#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
31695bool emitIncPopBitfieldSint8( bool , uint32_t , SourceInfo);
31696bool emitIncPopBitfieldUint8( bool , uint32_t , SourceInfo);
31697bool emitIncPopBitfieldSint16( bool , uint32_t , SourceInfo);
31698bool emitIncPopBitfieldUint16( bool , uint32_t , SourceInfo);
31699bool emitIncPopBitfieldSint32( bool , uint32_t , SourceInfo);
31700bool emitIncPopBitfieldUint32( bool , uint32_t , SourceInfo);
31701bool emitIncPopBitfieldSint64( bool , uint32_t , SourceInfo);
31702bool emitIncPopBitfieldUint64( bool , uint32_t , SourceInfo);
31703bool emitIncPopBitfieldIntAP( bool , uint32_t , SourceInfo);
31704bool emitIncPopBitfieldIntAPS( bool , uint32_t , SourceInfo);
31705bool emitIncPopBitfieldBool( bool , uint32_t , SourceInfo);
31706bool emitIncPopBitfieldFixedPoint( bool , uint32_t , SourceInfo);
31707#endif
31708#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
31709[[nodiscard]] bool emitIncPopBitfield(PrimType, bool, uint32_t, SourceInfo I);
31710#endif
31711#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
31712bool
31713#if defined(GET_EVAL_IMPL)
31714EvalEmitter
31715#else
31716ByteCodeEmitter
31717#endif
31718::emitIncPopBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
31719 switch (T0) {
31720 case PT_Sint8:
31721 return emitIncPopBitfieldSint8(A0, A1, I);
31722 case PT_Uint8:
31723 return emitIncPopBitfieldUint8(A0, A1, I);
31724 case PT_Sint16:
31725 return emitIncPopBitfieldSint16(A0, A1, I);
31726 case PT_Uint16:
31727 return emitIncPopBitfieldUint16(A0, A1, I);
31728 case PT_Sint32:
31729 return emitIncPopBitfieldSint32(A0, A1, I);
31730 case PT_Uint32:
31731 return emitIncPopBitfieldUint32(A0, A1, I);
31732 case PT_Sint64:
31733 return emitIncPopBitfieldSint64(A0, A1, I);
31734 case PT_Uint64:
31735 return emitIncPopBitfieldUint64(A0, A1, I);
31736 case PT_IntAP:
31737 return emitIncPopBitfieldIntAP(A0, A1, I);
31738 case PT_IntAPS:
31739 return emitIncPopBitfieldIntAPS(A0, A1, I);
31740 case PT_Bool:
31741 return emitIncPopBitfieldBool(A0, A1, I);
31742 case PT_FixedPoint:
31743 return emitIncPopBitfieldFixedPoint(A0, A1, I);
31744 default: llvm_unreachable("invalid type: emitIncPopBitfield");
31745 }
31746 llvm_unreachable("invalid enum value");
31747}
31748#endif
31749#ifdef GET_LINK_IMPL
31750bool ByteCodeEmitter::emitIncPopBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
31751 return emitOp<bool, uint32_t>(OP_IncPopBitfieldSint8, A0, A1, L);
31752}
31753bool ByteCodeEmitter::emitIncPopBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
31754 return emitOp<bool, uint32_t>(OP_IncPopBitfieldUint8, A0, A1, L);
31755}
31756bool ByteCodeEmitter::emitIncPopBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
31757 return emitOp<bool, uint32_t>(OP_IncPopBitfieldSint16, A0, A1, L);
31758}
31759bool ByteCodeEmitter::emitIncPopBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
31760 return emitOp<bool, uint32_t>(OP_IncPopBitfieldUint16, A0, A1, L);
31761}
31762bool ByteCodeEmitter::emitIncPopBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
31763 return emitOp<bool, uint32_t>(OP_IncPopBitfieldSint32, A0, A1, L);
31764}
31765bool ByteCodeEmitter::emitIncPopBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
31766 return emitOp<bool, uint32_t>(OP_IncPopBitfieldUint32, A0, A1, L);
31767}
31768bool ByteCodeEmitter::emitIncPopBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
31769 return emitOp<bool, uint32_t>(OP_IncPopBitfieldSint64, A0, A1, L);
31770}
31771bool ByteCodeEmitter::emitIncPopBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
31772 return emitOp<bool, uint32_t>(OP_IncPopBitfieldUint64, A0, A1, L);
31773}
31774bool ByteCodeEmitter::emitIncPopBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
31775 return emitOp<bool, uint32_t>(OP_IncPopBitfieldIntAP, A0, A1, L);
31776}
31777bool ByteCodeEmitter::emitIncPopBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
31778 return emitOp<bool, uint32_t>(OP_IncPopBitfieldIntAPS, A0, A1, L);
31779}
31780bool ByteCodeEmitter::emitIncPopBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
31781 return emitOp<bool, uint32_t>(OP_IncPopBitfieldBool, A0, A1, L);
31782}
31783bool ByteCodeEmitter::emitIncPopBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
31784 return emitOp<bool, uint32_t>(OP_IncPopBitfieldFixedPoint, A0, A1, L);
31785}
31786#endif
31787#ifdef GET_EVAL_IMPL
31788bool EvalEmitter::emitIncPopBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
31789 if (!isActive()) return true;
31790 CurrentSource = L;
31791 return IncPopBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
31792}
31793bool EvalEmitter::emitIncPopBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
31794 if (!isActive()) return true;
31795 CurrentSource = L;
31796 return IncPopBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
31797}
31798bool EvalEmitter::emitIncPopBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
31799 if (!isActive()) return true;
31800 CurrentSource = L;
31801 return IncPopBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
31802}
31803bool EvalEmitter::emitIncPopBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
31804 if (!isActive()) return true;
31805 CurrentSource = L;
31806 return IncPopBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
31807}
31808bool EvalEmitter::emitIncPopBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
31809 if (!isActive()) return true;
31810 CurrentSource = L;
31811 return IncPopBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
31812}
31813bool EvalEmitter::emitIncPopBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
31814 if (!isActive()) return true;
31815 CurrentSource = L;
31816 return IncPopBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
31817}
31818bool EvalEmitter::emitIncPopBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
31819 if (!isActive()) return true;
31820 CurrentSource = L;
31821 return IncPopBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
31822}
31823bool EvalEmitter::emitIncPopBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
31824 if (!isActive()) return true;
31825 CurrentSource = L;
31826 return IncPopBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
31827}
31828bool EvalEmitter::emitIncPopBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
31829 if (!isActive()) return true;
31830 CurrentSource = L;
31831 return IncPopBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
31832}
31833bool EvalEmitter::emitIncPopBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
31834 if (!isActive()) return true;
31835 CurrentSource = L;
31836 return IncPopBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
31837}
31838bool EvalEmitter::emitIncPopBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
31839 if (!isActive()) return true;
31840 CurrentSource = L;
31841 return IncPopBitfield<PT_Bool>(S, CodePtr(), A0, A1);
31842}
31843bool EvalEmitter::emitIncPopBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
31844 if (!isActive()) return true;
31845 CurrentSource = L;
31846 return IncPopBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
31847}
31848#endif
31849#ifdef GET_OPCODE_NAMES
31850OP_IncPtr,
31851#endif
31852#ifdef GET_INTERPFN_LIST
31853&Interp_IncPtr,
31854#endif
31855#ifdef GET_INTERPFN_DISPATCHERS
31856PRESERVE_NONE
31857static bool Interp_IncPtr(InterpState &S) {
31858 if (!IncPtr(S, S.PC)) return false;
31859#if USE_TAILCALLS
31860 MUSTTAIL return InterpNext(S);
31861#else
31862 return true;
31863#endif
31864}
31865#endif
31866#ifdef GET_DISASM
31867case OP_IncPtr:
31868 Text.Op = PrintName("IncPtr");
31869 break;
31870#endif
31871#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
31872bool emitIncPtr(SourceInfo);
31873#endif
31874#ifdef GET_LINK_IMPL
31875bool ByteCodeEmitter::emitIncPtr(SourceInfo L) {
31876 return emitOp<>(OP_IncPtr, L);
31877}
31878#endif
31879#ifdef GET_EVAL_IMPL
31880bool EvalEmitter::emitIncPtr(SourceInfo L) {
31881 if (!isActive()) return true;
31882 CurrentSource = L;
31883 return IncPtr(S, CodePtr());
31884}
31885#endif
31886#ifdef GET_OPCODE_NAMES
31887OP_Incf,
31888#endif
31889#ifdef GET_INTERPFN_LIST
31890&Interp_Incf,
31891#endif
31892#ifdef GET_INTERPFN_DISPATCHERS
31893PRESERVE_NONE
31894static bool Interp_Incf(InterpState &S) {
31895 {
31896 CodePtr OpPC = S.PC;
31897 const auto V0 = ReadArg<uint32_t>(S, S.PC);
31898 if (!Incf(S, OpPC, V0)) return false;
31899 }
31900#if USE_TAILCALLS
31901 MUSTTAIL return InterpNext(S);
31902#else
31903 return true;
31904#endif
31905}
31906#endif
31907#ifdef GET_DISASM
31908case OP_Incf:
31909 Text.Op = PrintName("Incf");
31910 Text.Args.push_back(printArg<uint32_t>(PC));
31911 break;
31912#endif
31913#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
31914bool emitIncf( uint32_t , SourceInfo);
31915#endif
31916#ifdef GET_LINK_IMPL
31917bool ByteCodeEmitter::emitIncf( uint32_t A0, SourceInfo L) {
31918 return emitOp<uint32_t>(OP_Incf, A0, L);
31919}
31920#endif
31921#ifdef GET_EVAL_IMPL
31922bool EvalEmitter::emitIncf( uint32_t A0, SourceInfo L) {
31923 if (!isActive()) return true;
31924 CurrentSource = L;
31925 return Incf(S, CodePtr(), A0);
31926}
31927#endif
31928#ifdef GET_OPCODE_NAMES
31929OP_IncfPop,
31930#endif
31931#ifdef GET_INTERPFN_LIST
31932&Interp_IncfPop,
31933#endif
31934#ifdef GET_INTERPFN_DISPATCHERS
31935PRESERVE_NONE
31936static bool Interp_IncfPop(InterpState &S) {
31937 {
31938 CodePtr OpPC = S.PC;
31939 const auto V0 = ReadArg<uint32_t>(S, S.PC);
31940 if (!IncfPop(S, OpPC, V0)) return false;
31941 }
31942#if USE_TAILCALLS
31943 MUSTTAIL return InterpNext(S);
31944#else
31945 return true;
31946#endif
31947}
31948#endif
31949#ifdef GET_DISASM
31950case OP_IncfPop:
31951 Text.Op = PrintName("IncfPop");
31952 Text.Args.push_back(printArg<uint32_t>(PC));
31953 break;
31954#endif
31955#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
31956bool emitIncfPop( uint32_t , SourceInfo);
31957#endif
31958#ifdef GET_LINK_IMPL
31959bool ByteCodeEmitter::emitIncfPop( uint32_t A0, SourceInfo L) {
31960 return emitOp<uint32_t>(OP_IncfPop, A0, L);
31961}
31962#endif
31963#ifdef GET_EVAL_IMPL
31964bool EvalEmitter::emitIncfPop( uint32_t A0, SourceInfo L) {
31965 if (!isActive()) return true;
31966 CurrentSource = L;
31967 return IncfPop(S, CodePtr(), A0);
31968}
31969#endif
31970#ifdef GET_OPCODE_NAMES
31971OP_InitSint8,
31972OP_InitUint8,
31973OP_InitSint16,
31974OP_InitUint16,
31975OP_InitSint32,
31976OP_InitUint32,
31977OP_InitSint64,
31978OP_InitUint64,
31979OP_InitIntAP,
31980OP_InitIntAPS,
31981OP_InitBool,
31982OP_InitFixedPoint,
31983OP_InitPtr,
31984OP_InitMemberPtr,
31985OP_InitFloat,
31986OP_InitReflect,
31987#endif
31988#ifdef GET_INTERPFN_LIST
31989&Interp_InitSint8,
31990&Interp_InitUint8,
31991&Interp_InitSint16,
31992&Interp_InitUint16,
31993&Interp_InitSint32,
31994&Interp_InitUint32,
31995&Interp_InitSint64,
31996&Interp_InitUint64,
31997&Interp_InitIntAP,
31998&Interp_InitIntAPS,
31999&Interp_InitBool,
32000&Interp_InitFixedPoint,
32001&Interp_InitPtr,
32002&Interp_InitMemberPtr,
32003&Interp_InitFloat,
32004&Interp_InitReflect,
32005#endif
32006#ifdef GET_INTERPFN_DISPATCHERS
32007PRESERVE_NONE
32008static bool Interp_InitSint8(InterpState &S) {
32009 if (!Init<PT_Sint8>(S, S.PC)) return false;
32010#if USE_TAILCALLS
32011 MUSTTAIL return InterpNext(S);
32012#else
32013 return true;
32014#endif
32015}
32016PRESERVE_NONE
32017static bool Interp_InitUint8(InterpState &S) {
32018 if (!Init<PT_Uint8>(S, S.PC)) return false;
32019#if USE_TAILCALLS
32020 MUSTTAIL return InterpNext(S);
32021#else
32022 return true;
32023#endif
32024}
32025PRESERVE_NONE
32026static bool Interp_InitSint16(InterpState &S) {
32027 if (!Init<PT_Sint16>(S, S.PC)) return false;
32028#if USE_TAILCALLS
32029 MUSTTAIL return InterpNext(S);
32030#else
32031 return true;
32032#endif
32033}
32034PRESERVE_NONE
32035static bool Interp_InitUint16(InterpState &S) {
32036 if (!Init<PT_Uint16>(S, S.PC)) return false;
32037#if USE_TAILCALLS
32038 MUSTTAIL return InterpNext(S);
32039#else
32040 return true;
32041#endif
32042}
32043PRESERVE_NONE
32044static bool Interp_InitSint32(InterpState &S) {
32045 if (!Init<PT_Sint32>(S, S.PC)) return false;
32046#if USE_TAILCALLS
32047 MUSTTAIL return InterpNext(S);
32048#else
32049 return true;
32050#endif
32051}
32052PRESERVE_NONE
32053static bool Interp_InitUint32(InterpState &S) {
32054 if (!Init<PT_Uint32>(S, S.PC)) return false;
32055#if USE_TAILCALLS
32056 MUSTTAIL return InterpNext(S);
32057#else
32058 return true;
32059#endif
32060}
32061PRESERVE_NONE
32062static bool Interp_InitSint64(InterpState &S) {
32063 if (!Init<PT_Sint64>(S, S.PC)) return false;
32064#if USE_TAILCALLS
32065 MUSTTAIL return InterpNext(S);
32066#else
32067 return true;
32068#endif
32069}
32070PRESERVE_NONE
32071static bool Interp_InitUint64(InterpState &S) {
32072 if (!Init<PT_Uint64>(S, S.PC)) return false;
32073#if USE_TAILCALLS
32074 MUSTTAIL return InterpNext(S);
32075#else
32076 return true;
32077#endif
32078}
32079PRESERVE_NONE
32080static bool Interp_InitIntAP(InterpState &S) {
32081 if (!Init<PT_IntAP>(S, S.PC)) return false;
32082#if USE_TAILCALLS
32083 MUSTTAIL return InterpNext(S);
32084#else
32085 return true;
32086#endif
32087}
32088PRESERVE_NONE
32089static bool Interp_InitIntAPS(InterpState &S) {
32090 if (!Init<PT_IntAPS>(S, S.PC)) return false;
32091#if USE_TAILCALLS
32092 MUSTTAIL return InterpNext(S);
32093#else
32094 return true;
32095#endif
32096}
32097PRESERVE_NONE
32098static bool Interp_InitBool(InterpState &S) {
32099 if (!Init<PT_Bool>(S, S.PC)) return false;
32100#if USE_TAILCALLS
32101 MUSTTAIL return InterpNext(S);
32102#else
32103 return true;
32104#endif
32105}
32106PRESERVE_NONE
32107static bool Interp_InitFixedPoint(InterpState &S) {
32108 if (!Init<PT_FixedPoint>(S, S.PC)) return false;
32109#if USE_TAILCALLS
32110 MUSTTAIL return InterpNext(S);
32111#else
32112 return true;
32113#endif
32114}
32115PRESERVE_NONE
32116static bool Interp_InitPtr(InterpState &S) {
32117 if (!Init<PT_Ptr>(S, S.PC)) return false;
32118#if USE_TAILCALLS
32119 MUSTTAIL return InterpNext(S);
32120#else
32121 return true;
32122#endif
32123}
32124PRESERVE_NONE
32125static bool Interp_InitMemberPtr(InterpState &S) {
32126 if (!Init<PT_MemberPtr>(S, S.PC)) return false;
32127#if USE_TAILCALLS
32128 MUSTTAIL return InterpNext(S);
32129#else
32130 return true;
32131#endif
32132}
32133PRESERVE_NONE
32134static bool Interp_InitFloat(InterpState &S) {
32135 if (!Init<PT_Float>(S, S.PC)) return false;
32136#if USE_TAILCALLS
32137 MUSTTAIL return InterpNext(S);
32138#else
32139 return true;
32140#endif
32141}
32142PRESERVE_NONE
32143static bool Interp_InitReflect(InterpState &S) {
32144 if (!Init<PT_Reflect>(S, S.PC)) return false;
32145#if USE_TAILCALLS
32146 MUSTTAIL return InterpNext(S);
32147#else
32148 return true;
32149#endif
32150}
32151#endif
32152#ifdef GET_DISASM
32153case OP_InitSint8:
32154 Text.Op = PrintName("InitSint8");
32155 break;
32156case OP_InitUint8:
32157 Text.Op = PrintName("InitUint8");
32158 break;
32159case OP_InitSint16:
32160 Text.Op = PrintName("InitSint16");
32161 break;
32162case OP_InitUint16:
32163 Text.Op = PrintName("InitUint16");
32164 break;
32165case OP_InitSint32:
32166 Text.Op = PrintName("InitSint32");
32167 break;
32168case OP_InitUint32:
32169 Text.Op = PrintName("InitUint32");
32170 break;
32171case OP_InitSint64:
32172 Text.Op = PrintName("InitSint64");
32173 break;
32174case OP_InitUint64:
32175 Text.Op = PrintName("InitUint64");
32176 break;
32177case OP_InitIntAP:
32178 Text.Op = PrintName("InitIntAP");
32179 break;
32180case OP_InitIntAPS:
32181 Text.Op = PrintName("InitIntAPS");
32182 break;
32183case OP_InitBool:
32184 Text.Op = PrintName("InitBool");
32185 break;
32186case OP_InitFixedPoint:
32187 Text.Op = PrintName("InitFixedPoint");
32188 break;
32189case OP_InitPtr:
32190 Text.Op = PrintName("InitPtr");
32191 break;
32192case OP_InitMemberPtr:
32193 Text.Op = PrintName("InitMemberPtr");
32194 break;
32195case OP_InitFloat:
32196 Text.Op = PrintName("InitFloat");
32197 break;
32198case OP_InitReflect:
32199 Text.Op = PrintName("InitReflect");
32200 break;
32201#endif
32202#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
32203bool emitInitSint8(SourceInfo);
32204bool emitInitUint8(SourceInfo);
32205bool emitInitSint16(SourceInfo);
32206bool emitInitUint16(SourceInfo);
32207bool emitInitSint32(SourceInfo);
32208bool emitInitUint32(SourceInfo);
32209bool emitInitSint64(SourceInfo);
32210bool emitInitUint64(SourceInfo);
32211bool emitInitIntAP(SourceInfo);
32212bool emitInitIntAPS(SourceInfo);
32213bool emitInitBool(SourceInfo);
32214bool emitInitFixedPoint(SourceInfo);
32215bool emitInitPtr(SourceInfo);
32216bool emitInitMemberPtr(SourceInfo);
32217bool emitInitFloat(SourceInfo);
32218bool emitInitReflect(SourceInfo);
32219#endif
32220#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
32221[[nodiscard]] bool emitInit(PrimType, SourceInfo I);
32222#endif
32223#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
32224bool
32225#if defined(GET_EVAL_IMPL)
32226EvalEmitter
32227#else
32228ByteCodeEmitter
32229#endif
32230::emitInit(PrimType T0, SourceInfo I) {
32231 switch (T0) {
32232 case PT_Sint8:
32233 return emitInitSint8(I);
32234 case PT_Uint8:
32235 return emitInitUint8(I);
32236 case PT_Sint16:
32237 return emitInitSint16(I);
32238 case PT_Uint16:
32239 return emitInitUint16(I);
32240 case PT_Sint32:
32241 return emitInitSint32(I);
32242 case PT_Uint32:
32243 return emitInitUint32(I);
32244 case PT_Sint64:
32245 return emitInitSint64(I);
32246 case PT_Uint64:
32247 return emitInitUint64(I);
32248 case PT_IntAP:
32249 return emitInitIntAP(I);
32250 case PT_IntAPS:
32251 return emitInitIntAPS(I);
32252 case PT_Bool:
32253 return emitInitBool(I);
32254 case PT_FixedPoint:
32255 return emitInitFixedPoint(I);
32256 case PT_Ptr:
32257 return emitInitPtr(I);
32258 case PT_MemberPtr:
32259 return emitInitMemberPtr(I);
32260 case PT_Float:
32261 return emitInitFloat(I);
32262 case PT_Reflect:
32263 return emitInitReflect(I);
32264 }
32265 llvm_unreachable("invalid enum value");
32266}
32267#endif
32268#ifdef GET_LINK_IMPL
32269bool ByteCodeEmitter::emitInitSint8(SourceInfo L) {
32270 return emitOp<>(OP_InitSint8, L);
32271}
32272bool ByteCodeEmitter::emitInitUint8(SourceInfo L) {
32273 return emitOp<>(OP_InitUint8, L);
32274}
32275bool ByteCodeEmitter::emitInitSint16(SourceInfo L) {
32276 return emitOp<>(OP_InitSint16, L);
32277}
32278bool ByteCodeEmitter::emitInitUint16(SourceInfo L) {
32279 return emitOp<>(OP_InitUint16, L);
32280}
32281bool ByteCodeEmitter::emitInitSint32(SourceInfo L) {
32282 return emitOp<>(OP_InitSint32, L);
32283}
32284bool ByteCodeEmitter::emitInitUint32(SourceInfo L) {
32285 return emitOp<>(OP_InitUint32, L);
32286}
32287bool ByteCodeEmitter::emitInitSint64(SourceInfo L) {
32288 return emitOp<>(OP_InitSint64, L);
32289}
32290bool ByteCodeEmitter::emitInitUint64(SourceInfo L) {
32291 return emitOp<>(OP_InitUint64, L);
32292}
32293bool ByteCodeEmitter::emitInitIntAP(SourceInfo L) {
32294 return emitOp<>(OP_InitIntAP, L);
32295}
32296bool ByteCodeEmitter::emitInitIntAPS(SourceInfo L) {
32297 return emitOp<>(OP_InitIntAPS, L);
32298}
32299bool ByteCodeEmitter::emitInitBool(SourceInfo L) {
32300 return emitOp<>(OP_InitBool, L);
32301}
32302bool ByteCodeEmitter::emitInitFixedPoint(SourceInfo L) {
32303 return emitOp<>(OP_InitFixedPoint, L);
32304}
32305bool ByteCodeEmitter::emitInitPtr(SourceInfo L) {
32306 return emitOp<>(OP_InitPtr, L);
32307}
32308bool ByteCodeEmitter::emitInitMemberPtr(SourceInfo L) {
32309 return emitOp<>(OP_InitMemberPtr, L);
32310}
32311bool ByteCodeEmitter::emitInitFloat(SourceInfo L) {
32312 return emitOp<>(OP_InitFloat, L);
32313}
32314bool ByteCodeEmitter::emitInitReflect(SourceInfo L) {
32315 return emitOp<>(OP_InitReflect, L);
32316}
32317#endif
32318#ifdef GET_EVAL_IMPL
32319bool EvalEmitter::emitInitSint8(SourceInfo L) {
32320 if (!isActive()) return true;
32321 CurrentSource = L;
32322 return Init<PT_Sint8>(S, CodePtr());
32323}
32324bool EvalEmitter::emitInitUint8(SourceInfo L) {
32325 if (!isActive()) return true;
32326 CurrentSource = L;
32327 return Init<PT_Uint8>(S, CodePtr());
32328}
32329bool EvalEmitter::emitInitSint16(SourceInfo L) {
32330 if (!isActive()) return true;
32331 CurrentSource = L;
32332 return Init<PT_Sint16>(S, CodePtr());
32333}
32334bool EvalEmitter::emitInitUint16(SourceInfo L) {
32335 if (!isActive()) return true;
32336 CurrentSource = L;
32337 return Init<PT_Uint16>(S, CodePtr());
32338}
32339bool EvalEmitter::emitInitSint32(SourceInfo L) {
32340 if (!isActive()) return true;
32341 CurrentSource = L;
32342 return Init<PT_Sint32>(S, CodePtr());
32343}
32344bool EvalEmitter::emitInitUint32(SourceInfo L) {
32345 if (!isActive()) return true;
32346 CurrentSource = L;
32347 return Init<PT_Uint32>(S, CodePtr());
32348}
32349bool EvalEmitter::emitInitSint64(SourceInfo L) {
32350 if (!isActive()) return true;
32351 CurrentSource = L;
32352 return Init<PT_Sint64>(S, CodePtr());
32353}
32354bool EvalEmitter::emitInitUint64(SourceInfo L) {
32355 if (!isActive()) return true;
32356 CurrentSource = L;
32357 return Init<PT_Uint64>(S, CodePtr());
32358}
32359bool EvalEmitter::emitInitIntAP(SourceInfo L) {
32360 if (!isActive()) return true;
32361 CurrentSource = L;
32362 return Init<PT_IntAP>(S, CodePtr());
32363}
32364bool EvalEmitter::emitInitIntAPS(SourceInfo L) {
32365 if (!isActive()) return true;
32366 CurrentSource = L;
32367 return Init<PT_IntAPS>(S, CodePtr());
32368}
32369bool EvalEmitter::emitInitBool(SourceInfo L) {
32370 if (!isActive()) return true;
32371 CurrentSource = L;
32372 return Init<PT_Bool>(S, CodePtr());
32373}
32374bool EvalEmitter::emitInitFixedPoint(SourceInfo L) {
32375 if (!isActive()) return true;
32376 CurrentSource = L;
32377 return Init<PT_FixedPoint>(S, CodePtr());
32378}
32379bool EvalEmitter::emitInitPtr(SourceInfo L) {
32380 if (!isActive()) return true;
32381 CurrentSource = L;
32382 return Init<PT_Ptr>(S, CodePtr());
32383}
32384bool EvalEmitter::emitInitMemberPtr(SourceInfo L) {
32385 if (!isActive()) return true;
32386 CurrentSource = L;
32387 return Init<PT_MemberPtr>(S, CodePtr());
32388}
32389bool EvalEmitter::emitInitFloat(SourceInfo L) {
32390 if (!isActive()) return true;
32391 CurrentSource = L;
32392 return Init<PT_Float>(S, CodePtr());
32393}
32394bool EvalEmitter::emitInitReflect(SourceInfo L) {
32395 if (!isActive()) return true;
32396 CurrentSource = L;
32397 return Init<PT_Reflect>(S, CodePtr());
32398}
32399#endif
32400#ifdef GET_OPCODE_NAMES
32401OP_InitBitFieldSint8,
32402OP_InitBitFieldUint8,
32403OP_InitBitFieldSint16,
32404OP_InitBitFieldUint16,
32405OP_InitBitFieldSint32,
32406OP_InitBitFieldUint32,
32407OP_InitBitFieldSint64,
32408OP_InitBitFieldUint64,
32409OP_InitBitFieldIntAP,
32410OP_InitBitFieldIntAPS,
32411OP_InitBitFieldBool,
32412#endif
32413#ifdef GET_INTERPFN_LIST
32414&Interp_InitBitFieldSint8,
32415&Interp_InitBitFieldUint8,
32416&Interp_InitBitFieldSint16,
32417&Interp_InitBitFieldUint16,
32418&Interp_InitBitFieldSint32,
32419&Interp_InitBitFieldUint32,
32420&Interp_InitBitFieldSint64,
32421&Interp_InitBitFieldUint64,
32422&Interp_InitBitFieldIntAP,
32423&Interp_InitBitFieldIntAPS,
32424&Interp_InitBitFieldBool,
32425#endif
32426#ifdef GET_INTERPFN_DISPATCHERS
32427PRESERVE_NONE
32428static bool Interp_InitBitFieldSint8(InterpState &S) {
32429 {
32430 CodePtr OpPC = S.PC;
32431 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32432 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32433 if (!InitBitField<PT_Sint8>(S, OpPC, V0, V1)) return false;
32434 }
32435#if USE_TAILCALLS
32436 MUSTTAIL return InterpNext(S);
32437#else
32438 return true;
32439#endif
32440}
32441PRESERVE_NONE
32442static bool Interp_InitBitFieldUint8(InterpState &S) {
32443 {
32444 CodePtr OpPC = S.PC;
32445 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32446 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32447 if (!InitBitField<PT_Uint8>(S, OpPC, V0, V1)) return false;
32448 }
32449#if USE_TAILCALLS
32450 MUSTTAIL return InterpNext(S);
32451#else
32452 return true;
32453#endif
32454}
32455PRESERVE_NONE
32456static bool Interp_InitBitFieldSint16(InterpState &S) {
32457 {
32458 CodePtr OpPC = S.PC;
32459 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32460 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32461 if (!InitBitField<PT_Sint16>(S, OpPC, V0, V1)) return false;
32462 }
32463#if USE_TAILCALLS
32464 MUSTTAIL return InterpNext(S);
32465#else
32466 return true;
32467#endif
32468}
32469PRESERVE_NONE
32470static bool Interp_InitBitFieldUint16(InterpState &S) {
32471 {
32472 CodePtr OpPC = S.PC;
32473 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32474 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32475 if (!InitBitField<PT_Uint16>(S, OpPC, V0, V1)) return false;
32476 }
32477#if USE_TAILCALLS
32478 MUSTTAIL return InterpNext(S);
32479#else
32480 return true;
32481#endif
32482}
32483PRESERVE_NONE
32484static bool Interp_InitBitFieldSint32(InterpState &S) {
32485 {
32486 CodePtr OpPC = S.PC;
32487 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32488 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32489 if (!InitBitField<PT_Sint32>(S, OpPC, V0, V1)) return false;
32490 }
32491#if USE_TAILCALLS
32492 MUSTTAIL return InterpNext(S);
32493#else
32494 return true;
32495#endif
32496}
32497PRESERVE_NONE
32498static bool Interp_InitBitFieldUint32(InterpState &S) {
32499 {
32500 CodePtr OpPC = S.PC;
32501 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32502 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32503 if (!InitBitField<PT_Uint32>(S, OpPC, V0, V1)) return false;
32504 }
32505#if USE_TAILCALLS
32506 MUSTTAIL return InterpNext(S);
32507#else
32508 return true;
32509#endif
32510}
32511PRESERVE_NONE
32512static bool Interp_InitBitFieldSint64(InterpState &S) {
32513 {
32514 CodePtr OpPC = S.PC;
32515 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32516 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32517 if (!InitBitField<PT_Sint64>(S, OpPC, V0, V1)) return false;
32518 }
32519#if USE_TAILCALLS
32520 MUSTTAIL return InterpNext(S);
32521#else
32522 return true;
32523#endif
32524}
32525PRESERVE_NONE
32526static bool Interp_InitBitFieldUint64(InterpState &S) {
32527 {
32528 CodePtr OpPC = S.PC;
32529 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32530 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32531 if (!InitBitField<PT_Uint64>(S, OpPC, V0, V1)) return false;
32532 }
32533#if USE_TAILCALLS
32534 MUSTTAIL return InterpNext(S);
32535#else
32536 return true;
32537#endif
32538}
32539PRESERVE_NONE
32540static bool Interp_InitBitFieldIntAP(InterpState &S) {
32541 {
32542 CodePtr OpPC = S.PC;
32543 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32544 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32545 if (!InitBitField<PT_IntAP>(S, OpPC, V0, V1)) return false;
32546 }
32547#if USE_TAILCALLS
32548 MUSTTAIL return InterpNext(S);
32549#else
32550 return true;
32551#endif
32552}
32553PRESERVE_NONE
32554static bool Interp_InitBitFieldIntAPS(InterpState &S) {
32555 {
32556 CodePtr OpPC = S.PC;
32557 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32558 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32559 if (!InitBitField<PT_IntAPS>(S, OpPC, V0, V1)) return false;
32560 }
32561#if USE_TAILCALLS
32562 MUSTTAIL return InterpNext(S);
32563#else
32564 return true;
32565#endif
32566}
32567PRESERVE_NONE
32568static bool Interp_InitBitFieldBool(InterpState &S) {
32569 {
32570 CodePtr OpPC = S.PC;
32571 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32572 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32573 if (!InitBitField<PT_Bool>(S, OpPC, V0, V1)) return false;
32574 }
32575#if USE_TAILCALLS
32576 MUSTTAIL return InterpNext(S);
32577#else
32578 return true;
32579#endif
32580}
32581#endif
32582#ifdef GET_DISASM
32583case OP_InitBitFieldSint8:
32584 Text.Op = PrintName("InitBitFieldSint8");
32585 Text.Args.push_back(printArg<uint32_t>(PC));
32586 Text.Args.push_back(printArg<uint32_t>(PC));
32587 break;
32588case OP_InitBitFieldUint8:
32589 Text.Op = PrintName("InitBitFieldUint8");
32590 Text.Args.push_back(printArg<uint32_t>(PC));
32591 Text.Args.push_back(printArg<uint32_t>(PC));
32592 break;
32593case OP_InitBitFieldSint16:
32594 Text.Op = PrintName("InitBitFieldSint16");
32595 Text.Args.push_back(printArg<uint32_t>(PC));
32596 Text.Args.push_back(printArg<uint32_t>(PC));
32597 break;
32598case OP_InitBitFieldUint16:
32599 Text.Op = PrintName("InitBitFieldUint16");
32600 Text.Args.push_back(printArg<uint32_t>(PC));
32601 Text.Args.push_back(printArg<uint32_t>(PC));
32602 break;
32603case OP_InitBitFieldSint32:
32604 Text.Op = PrintName("InitBitFieldSint32");
32605 Text.Args.push_back(printArg<uint32_t>(PC));
32606 Text.Args.push_back(printArg<uint32_t>(PC));
32607 break;
32608case OP_InitBitFieldUint32:
32609 Text.Op = PrintName("InitBitFieldUint32");
32610 Text.Args.push_back(printArg<uint32_t>(PC));
32611 Text.Args.push_back(printArg<uint32_t>(PC));
32612 break;
32613case OP_InitBitFieldSint64:
32614 Text.Op = PrintName("InitBitFieldSint64");
32615 Text.Args.push_back(printArg<uint32_t>(PC));
32616 Text.Args.push_back(printArg<uint32_t>(PC));
32617 break;
32618case OP_InitBitFieldUint64:
32619 Text.Op = PrintName("InitBitFieldUint64");
32620 Text.Args.push_back(printArg<uint32_t>(PC));
32621 Text.Args.push_back(printArg<uint32_t>(PC));
32622 break;
32623case OP_InitBitFieldIntAP:
32624 Text.Op = PrintName("InitBitFieldIntAP");
32625 Text.Args.push_back(printArg<uint32_t>(PC));
32626 Text.Args.push_back(printArg<uint32_t>(PC));
32627 break;
32628case OP_InitBitFieldIntAPS:
32629 Text.Op = PrintName("InitBitFieldIntAPS");
32630 Text.Args.push_back(printArg<uint32_t>(PC));
32631 Text.Args.push_back(printArg<uint32_t>(PC));
32632 break;
32633case OP_InitBitFieldBool:
32634 Text.Op = PrintName("InitBitFieldBool");
32635 Text.Args.push_back(printArg<uint32_t>(PC));
32636 Text.Args.push_back(printArg<uint32_t>(PC));
32637 break;
32638#endif
32639#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
32640bool emitInitBitFieldSint8( uint32_t , uint32_t , SourceInfo);
32641bool emitInitBitFieldUint8( uint32_t , uint32_t , SourceInfo);
32642bool emitInitBitFieldSint16( uint32_t , uint32_t , SourceInfo);
32643bool emitInitBitFieldUint16( uint32_t , uint32_t , SourceInfo);
32644bool emitInitBitFieldSint32( uint32_t , uint32_t , SourceInfo);
32645bool emitInitBitFieldUint32( uint32_t , uint32_t , SourceInfo);
32646bool emitInitBitFieldSint64( uint32_t , uint32_t , SourceInfo);
32647bool emitInitBitFieldUint64( uint32_t , uint32_t , SourceInfo);
32648bool emitInitBitFieldIntAP( uint32_t , uint32_t , SourceInfo);
32649bool emitInitBitFieldIntAPS( uint32_t , uint32_t , SourceInfo);
32650bool emitInitBitFieldBool( uint32_t , uint32_t , SourceInfo);
32651#endif
32652#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
32653[[nodiscard]] bool emitInitBitField(PrimType, uint32_t, uint32_t, SourceInfo I);
32654#endif
32655#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
32656bool
32657#if defined(GET_EVAL_IMPL)
32658EvalEmitter
32659#else
32660ByteCodeEmitter
32661#endif
32662::emitInitBitField(PrimType T0, uint32_t A0, uint32_t A1, SourceInfo I) {
32663 switch (T0) {
32664 case PT_Sint8:
32665 return emitInitBitFieldSint8(A0, A1, I);
32666 case PT_Uint8:
32667 return emitInitBitFieldUint8(A0, A1, I);
32668 case PT_Sint16:
32669 return emitInitBitFieldSint16(A0, A1, I);
32670 case PT_Uint16:
32671 return emitInitBitFieldUint16(A0, A1, I);
32672 case PT_Sint32:
32673 return emitInitBitFieldSint32(A0, A1, I);
32674 case PT_Uint32:
32675 return emitInitBitFieldUint32(A0, A1, I);
32676 case PT_Sint64:
32677 return emitInitBitFieldSint64(A0, A1, I);
32678 case PT_Uint64:
32679 return emitInitBitFieldUint64(A0, A1, I);
32680 case PT_IntAP:
32681 return emitInitBitFieldIntAP(A0, A1, I);
32682 case PT_IntAPS:
32683 return emitInitBitFieldIntAPS(A0, A1, I);
32684 case PT_Bool:
32685 return emitInitBitFieldBool(A0, A1, I);
32686 default: llvm_unreachable("invalid type: emitInitBitField");
32687 }
32688 llvm_unreachable("invalid enum value");
32689}
32690#endif
32691#ifdef GET_LINK_IMPL
32692bool ByteCodeEmitter::emitInitBitFieldSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
32693 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldSint8, A0, A1, L);
32694}
32695bool ByteCodeEmitter::emitInitBitFieldUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
32696 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldUint8, A0, A1, L);
32697}
32698bool ByteCodeEmitter::emitInitBitFieldSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
32699 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldSint16, A0, A1, L);
32700}
32701bool ByteCodeEmitter::emitInitBitFieldUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
32702 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldUint16, A0, A1, L);
32703}
32704bool ByteCodeEmitter::emitInitBitFieldSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
32705 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldSint32, A0, A1, L);
32706}
32707bool ByteCodeEmitter::emitInitBitFieldUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
32708 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldUint32, A0, A1, L);
32709}
32710bool ByteCodeEmitter::emitInitBitFieldSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
32711 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldSint64, A0, A1, L);
32712}
32713bool ByteCodeEmitter::emitInitBitFieldUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
32714 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldUint64, A0, A1, L);
32715}
32716bool ByteCodeEmitter::emitInitBitFieldIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
32717 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldIntAP, A0, A1, L);
32718}
32719bool ByteCodeEmitter::emitInitBitFieldIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
32720 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldIntAPS, A0, A1, L);
32721}
32722bool ByteCodeEmitter::emitInitBitFieldBool( uint32_t A0, uint32_t A1, SourceInfo L) {
32723 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldBool, A0, A1, L);
32724}
32725#endif
32726#ifdef GET_EVAL_IMPL
32727bool EvalEmitter::emitInitBitFieldSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
32728 if (!isActive()) return true;
32729 CurrentSource = L;
32730 return InitBitField<PT_Sint8>(S, CodePtr(), A0, A1);
32731}
32732bool EvalEmitter::emitInitBitFieldUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
32733 if (!isActive()) return true;
32734 CurrentSource = L;
32735 return InitBitField<PT_Uint8>(S, CodePtr(), A0, A1);
32736}
32737bool EvalEmitter::emitInitBitFieldSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
32738 if (!isActive()) return true;
32739 CurrentSource = L;
32740 return InitBitField<PT_Sint16>(S, CodePtr(), A0, A1);
32741}
32742bool EvalEmitter::emitInitBitFieldUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
32743 if (!isActive()) return true;
32744 CurrentSource = L;
32745 return InitBitField<PT_Uint16>(S, CodePtr(), A0, A1);
32746}
32747bool EvalEmitter::emitInitBitFieldSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
32748 if (!isActive()) return true;
32749 CurrentSource = L;
32750 return InitBitField<PT_Sint32>(S, CodePtr(), A0, A1);
32751}
32752bool EvalEmitter::emitInitBitFieldUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
32753 if (!isActive()) return true;
32754 CurrentSource = L;
32755 return InitBitField<PT_Uint32>(S, CodePtr(), A0, A1);
32756}
32757bool EvalEmitter::emitInitBitFieldSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
32758 if (!isActive()) return true;
32759 CurrentSource = L;
32760 return InitBitField<PT_Sint64>(S, CodePtr(), A0, A1);
32761}
32762bool EvalEmitter::emitInitBitFieldUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
32763 if (!isActive()) return true;
32764 CurrentSource = L;
32765 return InitBitField<PT_Uint64>(S, CodePtr(), A0, A1);
32766}
32767bool EvalEmitter::emitInitBitFieldIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
32768 if (!isActive()) return true;
32769 CurrentSource = L;
32770 return InitBitField<PT_IntAP>(S, CodePtr(), A0, A1);
32771}
32772bool EvalEmitter::emitInitBitFieldIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
32773 if (!isActive()) return true;
32774 CurrentSource = L;
32775 return InitBitField<PT_IntAPS>(S, CodePtr(), A0, A1);
32776}
32777bool EvalEmitter::emitInitBitFieldBool( uint32_t A0, uint32_t A1, SourceInfo L) {
32778 if (!isActive()) return true;
32779 CurrentSource = L;
32780 return InitBitField<PT_Bool>(S, CodePtr(), A0, A1);
32781}
32782#endif
32783#ifdef GET_OPCODE_NAMES
32784OP_InitBitFieldActivateSint8,
32785OP_InitBitFieldActivateUint8,
32786OP_InitBitFieldActivateSint16,
32787OP_InitBitFieldActivateUint16,
32788OP_InitBitFieldActivateSint32,
32789OP_InitBitFieldActivateUint32,
32790OP_InitBitFieldActivateSint64,
32791OP_InitBitFieldActivateUint64,
32792OP_InitBitFieldActivateIntAP,
32793OP_InitBitFieldActivateIntAPS,
32794OP_InitBitFieldActivateBool,
32795#endif
32796#ifdef GET_INTERPFN_LIST
32797&Interp_InitBitFieldActivateSint8,
32798&Interp_InitBitFieldActivateUint8,
32799&Interp_InitBitFieldActivateSint16,
32800&Interp_InitBitFieldActivateUint16,
32801&Interp_InitBitFieldActivateSint32,
32802&Interp_InitBitFieldActivateUint32,
32803&Interp_InitBitFieldActivateSint64,
32804&Interp_InitBitFieldActivateUint64,
32805&Interp_InitBitFieldActivateIntAP,
32806&Interp_InitBitFieldActivateIntAPS,
32807&Interp_InitBitFieldActivateBool,
32808#endif
32809#ifdef GET_INTERPFN_DISPATCHERS
32810PRESERVE_NONE
32811static bool Interp_InitBitFieldActivateSint8(InterpState &S) {
32812 {
32813 CodePtr OpPC = S.PC;
32814 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32815 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32816 if (!InitBitFieldActivate<PT_Sint8>(S, OpPC, V0, V1)) return false;
32817 }
32818#if USE_TAILCALLS
32819 MUSTTAIL return InterpNext(S);
32820#else
32821 return true;
32822#endif
32823}
32824PRESERVE_NONE
32825static bool Interp_InitBitFieldActivateUint8(InterpState &S) {
32826 {
32827 CodePtr OpPC = S.PC;
32828 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32829 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32830 if (!InitBitFieldActivate<PT_Uint8>(S, OpPC, V0, V1)) return false;
32831 }
32832#if USE_TAILCALLS
32833 MUSTTAIL return InterpNext(S);
32834#else
32835 return true;
32836#endif
32837}
32838PRESERVE_NONE
32839static bool Interp_InitBitFieldActivateSint16(InterpState &S) {
32840 {
32841 CodePtr OpPC = S.PC;
32842 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32843 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32844 if (!InitBitFieldActivate<PT_Sint16>(S, OpPC, V0, V1)) return false;
32845 }
32846#if USE_TAILCALLS
32847 MUSTTAIL return InterpNext(S);
32848#else
32849 return true;
32850#endif
32851}
32852PRESERVE_NONE
32853static bool Interp_InitBitFieldActivateUint16(InterpState &S) {
32854 {
32855 CodePtr OpPC = S.PC;
32856 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32857 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32858 if (!InitBitFieldActivate<PT_Uint16>(S, OpPC, V0, V1)) return false;
32859 }
32860#if USE_TAILCALLS
32861 MUSTTAIL return InterpNext(S);
32862#else
32863 return true;
32864#endif
32865}
32866PRESERVE_NONE
32867static bool Interp_InitBitFieldActivateSint32(InterpState &S) {
32868 {
32869 CodePtr OpPC = S.PC;
32870 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32871 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32872 if (!InitBitFieldActivate<PT_Sint32>(S, OpPC, V0, V1)) return false;
32873 }
32874#if USE_TAILCALLS
32875 MUSTTAIL return InterpNext(S);
32876#else
32877 return true;
32878#endif
32879}
32880PRESERVE_NONE
32881static bool Interp_InitBitFieldActivateUint32(InterpState &S) {
32882 {
32883 CodePtr OpPC = S.PC;
32884 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32885 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32886 if (!InitBitFieldActivate<PT_Uint32>(S, OpPC, V0, V1)) return false;
32887 }
32888#if USE_TAILCALLS
32889 MUSTTAIL return InterpNext(S);
32890#else
32891 return true;
32892#endif
32893}
32894PRESERVE_NONE
32895static bool Interp_InitBitFieldActivateSint64(InterpState &S) {
32896 {
32897 CodePtr OpPC = S.PC;
32898 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32899 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32900 if (!InitBitFieldActivate<PT_Sint64>(S, OpPC, V0, V1)) return false;
32901 }
32902#if USE_TAILCALLS
32903 MUSTTAIL return InterpNext(S);
32904#else
32905 return true;
32906#endif
32907}
32908PRESERVE_NONE
32909static bool Interp_InitBitFieldActivateUint64(InterpState &S) {
32910 {
32911 CodePtr OpPC = S.PC;
32912 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32913 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32914 if (!InitBitFieldActivate<PT_Uint64>(S, OpPC, V0, V1)) return false;
32915 }
32916#if USE_TAILCALLS
32917 MUSTTAIL return InterpNext(S);
32918#else
32919 return true;
32920#endif
32921}
32922PRESERVE_NONE
32923static bool Interp_InitBitFieldActivateIntAP(InterpState &S) {
32924 {
32925 CodePtr OpPC = S.PC;
32926 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32927 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32928 if (!InitBitFieldActivate<PT_IntAP>(S, OpPC, V0, V1)) return false;
32929 }
32930#if USE_TAILCALLS
32931 MUSTTAIL return InterpNext(S);
32932#else
32933 return true;
32934#endif
32935}
32936PRESERVE_NONE
32937static bool Interp_InitBitFieldActivateIntAPS(InterpState &S) {
32938 {
32939 CodePtr OpPC = S.PC;
32940 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32941 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32942 if (!InitBitFieldActivate<PT_IntAPS>(S, OpPC, V0, V1)) return false;
32943 }
32944#if USE_TAILCALLS
32945 MUSTTAIL return InterpNext(S);
32946#else
32947 return true;
32948#endif
32949}
32950PRESERVE_NONE
32951static bool Interp_InitBitFieldActivateBool(InterpState &S) {
32952 {
32953 CodePtr OpPC = S.PC;
32954 const auto V0 = ReadArg<uint32_t>(S, S.PC);
32955 const auto V1 = ReadArg<uint32_t>(S, S.PC);
32956 if (!InitBitFieldActivate<PT_Bool>(S, OpPC, V0, V1)) return false;
32957 }
32958#if USE_TAILCALLS
32959 MUSTTAIL return InterpNext(S);
32960#else
32961 return true;
32962#endif
32963}
32964#endif
32965#ifdef GET_DISASM
32966case OP_InitBitFieldActivateSint8:
32967 Text.Op = PrintName("InitBitFieldActivateSint8");
32968 Text.Args.push_back(printArg<uint32_t>(PC));
32969 Text.Args.push_back(printArg<uint32_t>(PC));
32970 break;
32971case OP_InitBitFieldActivateUint8:
32972 Text.Op = PrintName("InitBitFieldActivateUint8");
32973 Text.Args.push_back(printArg<uint32_t>(PC));
32974 Text.Args.push_back(printArg<uint32_t>(PC));
32975 break;
32976case OP_InitBitFieldActivateSint16:
32977 Text.Op = PrintName("InitBitFieldActivateSint16");
32978 Text.Args.push_back(printArg<uint32_t>(PC));
32979 Text.Args.push_back(printArg<uint32_t>(PC));
32980 break;
32981case OP_InitBitFieldActivateUint16:
32982 Text.Op = PrintName("InitBitFieldActivateUint16");
32983 Text.Args.push_back(printArg<uint32_t>(PC));
32984 Text.Args.push_back(printArg<uint32_t>(PC));
32985 break;
32986case OP_InitBitFieldActivateSint32:
32987 Text.Op = PrintName("InitBitFieldActivateSint32");
32988 Text.Args.push_back(printArg<uint32_t>(PC));
32989 Text.Args.push_back(printArg<uint32_t>(PC));
32990 break;
32991case OP_InitBitFieldActivateUint32:
32992 Text.Op = PrintName("InitBitFieldActivateUint32");
32993 Text.Args.push_back(printArg<uint32_t>(PC));
32994 Text.Args.push_back(printArg<uint32_t>(PC));
32995 break;
32996case OP_InitBitFieldActivateSint64:
32997 Text.Op = PrintName("InitBitFieldActivateSint64");
32998 Text.Args.push_back(printArg<uint32_t>(PC));
32999 Text.Args.push_back(printArg<uint32_t>(PC));
33000 break;
33001case OP_InitBitFieldActivateUint64:
33002 Text.Op = PrintName("InitBitFieldActivateUint64");
33003 Text.Args.push_back(printArg<uint32_t>(PC));
33004 Text.Args.push_back(printArg<uint32_t>(PC));
33005 break;
33006case OP_InitBitFieldActivateIntAP:
33007 Text.Op = PrintName("InitBitFieldActivateIntAP");
33008 Text.Args.push_back(printArg<uint32_t>(PC));
33009 Text.Args.push_back(printArg<uint32_t>(PC));
33010 break;
33011case OP_InitBitFieldActivateIntAPS:
33012 Text.Op = PrintName("InitBitFieldActivateIntAPS");
33013 Text.Args.push_back(printArg<uint32_t>(PC));
33014 Text.Args.push_back(printArg<uint32_t>(PC));
33015 break;
33016case OP_InitBitFieldActivateBool:
33017 Text.Op = PrintName("InitBitFieldActivateBool");
33018 Text.Args.push_back(printArg<uint32_t>(PC));
33019 Text.Args.push_back(printArg<uint32_t>(PC));
33020 break;
33021#endif
33022#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
33023bool emitInitBitFieldActivateSint8( uint32_t , uint32_t , SourceInfo);
33024bool emitInitBitFieldActivateUint8( uint32_t , uint32_t , SourceInfo);
33025bool emitInitBitFieldActivateSint16( uint32_t , uint32_t , SourceInfo);
33026bool emitInitBitFieldActivateUint16( uint32_t , uint32_t , SourceInfo);
33027bool emitInitBitFieldActivateSint32( uint32_t , uint32_t , SourceInfo);
33028bool emitInitBitFieldActivateUint32( uint32_t , uint32_t , SourceInfo);
33029bool emitInitBitFieldActivateSint64( uint32_t , uint32_t , SourceInfo);
33030bool emitInitBitFieldActivateUint64( uint32_t , uint32_t , SourceInfo);
33031bool emitInitBitFieldActivateIntAP( uint32_t , uint32_t , SourceInfo);
33032bool emitInitBitFieldActivateIntAPS( uint32_t , uint32_t , SourceInfo);
33033bool emitInitBitFieldActivateBool( uint32_t , uint32_t , SourceInfo);
33034#endif
33035#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
33036[[nodiscard]] bool emitInitBitFieldActivate(PrimType, uint32_t, uint32_t, SourceInfo I);
33037#endif
33038#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
33039bool
33040#if defined(GET_EVAL_IMPL)
33041EvalEmitter
33042#else
33043ByteCodeEmitter
33044#endif
33045::emitInitBitFieldActivate(PrimType T0, uint32_t A0, uint32_t A1, SourceInfo I) {
33046 switch (T0) {
33047 case PT_Sint8:
33048 return emitInitBitFieldActivateSint8(A0, A1, I);
33049 case PT_Uint8:
33050 return emitInitBitFieldActivateUint8(A0, A1, I);
33051 case PT_Sint16:
33052 return emitInitBitFieldActivateSint16(A0, A1, I);
33053 case PT_Uint16:
33054 return emitInitBitFieldActivateUint16(A0, A1, I);
33055 case PT_Sint32:
33056 return emitInitBitFieldActivateSint32(A0, A1, I);
33057 case PT_Uint32:
33058 return emitInitBitFieldActivateUint32(A0, A1, I);
33059 case PT_Sint64:
33060 return emitInitBitFieldActivateSint64(A0, A1, I);
33061 case PT_Uint64:
33062 return emitInitBitFieldActivateUint64(A0, A1, I);
33063 case PT_IntAP:
33064 return emitInitBitFieldActivateIntAP(A0, A1, I);
33065 case PT_IntAPS:
33066 return emitInitBitFieldActivateIntAPS(A0, A1, I);
33067 case PT_Bool:
33068 return emitInitBitFieldActivateBool(A0, A1, I);
33069 default: llvm_unreachable("invalid type: emitInitBitFieldActivate");
33070 }
33071 llvm_unreachable("invalid enum value");
33072}
33073#endif
33074#ifdef GET_LINK_IMPL
33075bool ByteCodeEmitter::emitInitBitFieldActivateSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
33076 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateSint8, A0, A1, L);
33077}
33078bool ByteCodeEmitter::emitInitBitFieldActivateUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
33079 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateUint8, A0, A1, L);
33080}
33081bool ByteCodeEmitter::emitInitBitFieldActivateSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
33082 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateSint16, A0, A1, L);
33083}
33084bool ByteCodeEmitter::emitInitBitFieldActivateUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
33085 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateUint16, A0, A1, L);
33086}
33087bool ByteCodeEmitter::emitInitBitFieldActivateSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
33088 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateSint32, A0, A1, L);
33089}
33090bool ByteCodeEmitter::emitInitBitFieldActivateUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
33091 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateUint32, A0, A1, L);
33092}
33093bool ByteCodeEmitter::emitInitBitFieldActivateSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
33094 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateSint64, A0, A1, L);
33095}
33096bool ByteCodeEmitter::emitInitBitFieldActivateUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
33097 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateUint64, A0, A1, L);
33098}
33099bool ByteCodeEmitter::emitInitBitFieldActivateIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
33100 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateIntAP, A0, A1, L);
33101}
33102bool ByteCodeEmitter::emitInitBitFieldActivateIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
33103 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateIntAPS, A0, A1, L);
33104}
33105bool ByteCodeEmitter::emitInitBitFieldActivateBool( uint32_t A0, uint32_t A1, SourceInfo L) {
33106 return emitOp<uint32_t, uint32_t>(OP_InitBitFieldActivateBool, A0, A1, L);
33107}
33108#endif
33109#ifdef GET_EVAL_IMPL
33110bool EvalEmitter::emitInitBitFieldActivateSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
33111 if (!isActive()) return true;
33112 CurrentSource = L;
33113 return InitBitFieldActivate<PT_Sint8>(S, CodePtr(), A0, A1);
33114}
33115bool EvalEmitter::emitInitBitFieldActivateUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
33116 if (!isActive()) return true;
33117 CurrentSource = L;
33118 return InitBitFieldActivate<PT_Uint8>(S, CodePtr(), A0, A1);
33119}
33120bool EvalEmitter::emitInitBitFieldActivateSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
33121 if (!isActive()) return true;
33122 CurrentSource = L;
33123 return InitBitFieldActivate<PT_Sint16>(S, CodePtr(), A0, A1);
33124}
33125bool EvalEmitter::emitInitBitFieldActivateUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
33126 if (!isActive()) return true;
33127 CurrentSource = L;
33128 return InitBitFieldActivate<PT_Uint16>(S, CodePtr(), A0, A1);
33129}
33130bool EvalEmitter::emitInitBitFieldActivateSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
33131 if (!isActive()) return true;
33132 CurrentSource = L;
33133 return InitBitFieldActivate<PT_Sint32>(S, CodePtr(), A0, A1);
33134}
33135bool EvalEmitter::emitInitBitFieldActivateUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
33136 if (!isActive()) return true;
33137 CurrentSource = L;
33138 return InitBitFieldActivate<PT_Uint32>(S, CodePtr(), A0, A1);
33139}
33140bool EvalEmitter::emitInitBitFieldActivateSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
33141 if (!isActive()) return true;
33142 CurrentSource = L;
33143 return InitBitFieldActivate<PT_Sint64>(S, CodePtr(), A0, A1);
33144}
33145bool EvalEmitter::emitInitBitFieldActivateUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
33146 if (!isActive()) return true;
33147 CurrentSource = L;
33148 return InitBitFieldActivate<PT_Uint64>(S, CodePtr(), A0, A1);
33149}
33150bool EvalEmitter::emitInitBitFieldActivateIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
33151 if (!isActive()) return true;
33152 CurrentSource = L;
33153 return InitBitFieldActivate<PT_IntAP>(S, CodePtr(), A0, A1);
33154}
33155bool EvalEmitter::emitInitBitFieldActivateIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
33156 if (!isActive()) return true;
33157 CurrentSource = L;
33158 return InitBitFieldActivate<PT_IntAPS>(S, CodePtr(), A0, A1);
33159}
33160bool EvalEmitter::emitInitBitFieldActivateBool( uint32_t A0, uint32_t A1, SourceInfo L) {
33161 if (!isActive()) return true;
33162 CurrentSource = L;
33163 return InitBitFieldActivate<PT_Bool>(S, CodePtr(), A0, A1);
33164}
33165#endif
33166#ifdef GET_OPCODE_NAMES
33167OP_InitElemSint8,
33168OP_InitElemUint8,
33169OP_InitElemSint16,
33170OP_InitElemUint16,
33171OP_InitElemSint32,
33172OP_InitElemUint32,
33173OP_InitElemSint64,
33174OP_InitElemUint64,
33175OP_InitElemIntAP,
33176OP_InitElemIntAPS,
33177OP_InitElemBool,
33178OP_InitElemFixedPoint,
33179OP_InitElemPtr,
33180OP_InitElemMemberPtr,
33181OP_InitElemFloat,
33182OP_InitElemReflect,
33183#endif
33184#ifdef GET_INTERPFN_LIST
33185&Interp_InitElemSint8,
33186&Interp_InitElemUint8,
33187&Interp_InitElemSint16,
33188&Interp_InitElemUint16,
33189&Interp_InitElemSint32,
33190&Interp_InitElemUint32,
33191&Interp_InitElemSint64,
33192&Interp_InitElemUint64,
33193&Interp_InitElemIntAP,
33194&Interp_InitElemIntAPS,
33195&Interp_InitElemBool,
33196&Interp_InitElemFixedPoint,
33197&Interp_InitElemPtr,
33198&Interp_InitElemMemberPtr,
33199&Interp_InitElemFloat,
33200&Interp_InitElemReflect,
33201#endif
33202#ifdef GET_INTERPFN_DISPATCHERS
33203PRESERVE_NONE
33204static bool Interp_InitElemSint8(InterpState &S) {
33205 {
33206 CodePtr OpPC = S.PC;
33207 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33208 if (!InitElem<PT_Sint8>(S, OpPC, V0)) return false;
33209 }
33210#if USE_TAILCALLS
33211 MUSTTAIL return InterpNext(S);
33212#else
33213 return true;
33214#endif
33215}
33216PRESERVE_NONE
33217static bool Interp_InitElemUint8(InterpState &S) {
33218 {
33219 CodePtr OpPC = S.PC;
33220 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33221 if (!InitElem<PT_Uint8>(S, OpPC, V0)) return false;
33222 }
33223#if USE_TAILCALLS
33224 MUSTTAIL return InterpNext(S);
33225#else
33226 return true;
33227#endif
33228}
33229PRESERVE_NONE
33230static bool Interp_InitElemSint16(InterpState &S) {
33231 {
33232 CodePtr OpPC = S.PC;
33233 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33234 if (!InitElem<PT_Sint16>(S, OpPC, V0)) return false;
33235 }
33236#if USE_TAILCALLS
33237 MUSTTAIL return InterpNext(S);
33238#else
33239 return true;
33240#endif
33241}
33242PRESERVE_NONE
33243static bool Interp_InitElemUint16(InterpState &S) {
33244 {
33245 CodePtr OpPC = S.PC;
33246 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33247 if (!InitElem<PT_Uint16>(S, OpPC, V0)) return false;
33248 }
33249#if USE_TAILCALLS
33250 MUSTTAIL return InterpNext(S);
33251#else
33252 return true;
33253#endif
33254}
33255PRESERVE_NONE
33256static bool Interp_InitElemSint32(InterpState &S) {
33257 {
33258 CodePtr OpPC = S.PC;
33259 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33260 if (!InitElem<PT_Sint32>(S, OpPC, V0)) return false;
33261 }
33262#if USE_TAILCALLS
33263 MUSTTAIL return InterpNext(S);
33264#else
33265 return true;
33266#endif
33267}
33268PRESERVE_NONE
33269static bool Interp_InitElemUint32(InterpState &S) {
33270 {
33271 CodePtr OpPC = S.PC;
33272 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33273 if (!InitElem<PT_Uint32>(S, OpPC, V0)) return false;
33274 }
33275#if USE_TAILCALLS
33276 MUSTTAIL return InterpNext(S);
33277#else
33278 return true;
33279#endif
33280}
33281PRESERVE_NONE
33282static bool Interp_InitElemSint64(InterpState &S) {
33283 {
33284 CodePtr OpPC = S.PC;
33285 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33286 if (!InitElem<PT_Sint64>(S, OpPC, V0)) return false;
33287 }
33288#if USE_TAILCALLS
33289 MUSTTAIL return InterpNext(S);
33290#else
33291 return true;
33292#endif
33293}
33294PRESERVE_NONE
33295static bool Interp_InitElemUint64(InterpState &S) {
33296 {
33297 CodePtr OpPC = S.PC;
33298 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33299 if (!InitElem<PT_Uint64>(S, OpPC, V0)) return false;
33300 }
33301#if USE_TAILCALLS
33302 MUSTTAIL return InterpNext(S);
33303#else
33304 return true;
33305#endif
33306}
33307PRESERVE_NONE
33308static bool Interp_InitElemIntAP(InterpState &S) {
33309 {
33310 CodePtr OpPC = S.PC;
33311 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33312 if (!InitElem<PT_IntAP>(S, OpPC, V0)) return false;
33313 }
33314#if USE_TAILCALLS
33315 MUSTTAIL return InterpNext(S);
33316#else
33317 return true;
33318#endif
33319}
33320PRESERVE_NONE
33321static bool Interp_InitElemIntAPS(InterpState &S) {
33322 {
33323 CodePtr OpPC = S.PC;
33324 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33325 if (!InitElem<PT_IntAPS>(S, OpPC, V0)) return false;
33326 }
33327#if USE_TAILCALLS
33328 MUSTTAIL return InterpNext(S);
33329#else
33330 return true;
33331#endif
33332}
33333PRESERVE_NONE
33334static bool Interp_InitElemBool(InterpState &S) {
33335 {
33336 CodePtr OpPC = S.PC;
33337 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33338 if (!InitElem<PT_Bool>(S, OpPC, V0)) return false;
33339 }
33340#if USE_TAILCALLS
33341 MUSTTAIL return InterpNext(S);
33342#else
33343 return true;
33344#endif
33345}
33346PRESERVE_NONE
33347static bool Interp_InitElemFixedPoint(InterpState &S) {
33348 {
33349 CodePtr OpPC = S.PC;
33350 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33351 if (!InitElem<PT_FixedPoint>(S, OpPC, V0)) return false;
33352 }
33353#if USE_TAILCALLS
33354 MUSTTAIL return InterpNext(S);
33355#else
33356 return true;
33357#endif
33358}
33359PRESERVE_NONE
33360static bool Interp_InitElemPtr(InterpState &S) {
33361 {
33362 CodePtr OpPC = S.PC;
33363 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33364 if (!InitElem<PT_Ptr>(S, OpPC, V0)) return false;
33365 }
33366#if USE_TAILCALLS
33367 MUSTTAIL return InterpNext(S);
33368#else
33369 return true;
33370#endif
33371}
33372PRESERVE_NONE
33373static bool Interp_InitElemMemberPtr(InterpState &S) {
33374 {
33375 CodePtr OpPC = S.PC;
33376 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33377 if (!InitElem<PT_MemberPtr>(S, OpPC, V0)) return false;
33378 }
33379#if USE_TAILCALLS
33380 MUSTTAIL return InterpNext(S);
33381#else
33382 return true;
33383#endif
33384}
33385PRESERVE_NONE
33386static bool Interp_InitElemFloat(InterpState &S) {
33387 {
33388 CodePtr OpPC = S.PC;
33389 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33390 if (!InitElem<PT_Float>(S, OpPC, V0)) return false;
33391 }
33392#if USE_TAILCALLS
33393 MUSTTAIL return InterpNext(S);
33394#else
33395 return true;
33396#endif
33397}
33398PRESERVE_NONE
33399static bool Interp_InitElemReflect(InterpState &S) {
33400 {
33401 CodePtr OpPC = S.PC;
33402 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33403 if (!InitElem<PT_Reflect>(S, OpPC, V0)) return false;
33404 }
33405#if USE_TAILCALLS
33406 MUSTTAIL return InterpNext(S);
33407#else
33408 return true;
33409#endif
33410}
33411#endif
33412#ifdef GET_DISASM
33413case OP_InitElemSint8:
33414 Text.Op = PrintName("InitElemSint8");
33415 Text.Args.push_back(printArg<uint32_t>(PC));
33416 break;
33417case OP_InitElemUint8:
33418 Text.Op = PrintName("InitElemUint8");
33419 Text.Args.push_back(printArg<uint32_t>(PC));
33420 break;
33421case OP_InitElemSint16:
33422 Text.Op = PrintName("InitElemSint16");
33423 Text.Args.push_back(printArg<uint32_t>(PC));
33424 break;
33425case OP_InitElemUint16:
33426 Text.Op = PrintName("InitElemUint16");
33427 Text.Args.push_back(printArg<uint32_t>(PC));
33428 break;
33429case OP_InitElemSint32:
33430 Text.Op = PrintName("InitElemSint32");
33431 Text.Args.push_back(printArg<uint32_t>(PC));
33432 break;
33433case OP_InitElemUint32:
33434 Text.Op = PrintName("InitElemUint32");
33435 Text.Args.push_back(printArg<uint32_t>(PC));
33436 break;
33437case OP_InitElemSint64:
33438 Text.Op = PrintName("InitElemSint64");
33439 Text.Args.push_back(printArg<uint32_t>(PC));
33440 break;
33441case OP_InitElemUint64:
33442 Text.Op = PrintName("InitElemUint64");
33443 Text.Args.push_back(printArg<uint32_t>(PC));
33444 break;
33445case OP_InitElemIntAP:
33446 Text.Op = PrintName("InitElemIntAP");
33447 Text.Args.push_back(printArg<uint32_t>(PC));
33448 break;
33449case OP_InitElemIntAPS:
33450 Text.Op = PrintName("InitElemIntAPS");
33451 Text.Args.push_back(printArg<uint32_t>(PC));
33452 break;
33453case OP_InitElemBool:
33454 Text.Op = PrintName("InitElemBool");
33455 Text.Args.push_back(printArg<uint32_t>(PC));
33456 break;
33457case OP_InitElemFixedPoint:
33458 Text.Op = PrintName("InitElemFixedPoint");
33459 Text.Args.push_back(printArg<uint32_t>(PC));
33460 break;
33461case OP_InitElemPtr:
33462 Text.Op = PrintName("InitElemPtr");
33463 Text.Args.push_back(printArg<uint32_t>(PC));
33464 break;
33465case OP_InitElemMemberPtr:
33466 Text.Op = PrintName("InitElemMemberPtr");
33467 Text.Args.push_back(printArg<uint32_t>(PC));
33468 break;
33469case OP_InitElemFloat:
33470 Text.Op = PrintName("InitElemFloat");
33471 Text.Args.push_back(printArg<uint32_t>(PC));
33472 break;
33473case OP_InitElemReflect:
33474 Text.Op = PrintName("InitElemReflect");
33475 Text.Args.push_back(printArg<uint32_t>(PC));
33476 break;
33477#endif
33478#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
33479bool emitInitElemSint8( uint32_t , SourceInfo);
33480bool emitInitElemUint8( uint32_t , SourceInfo);
33481bool emitInitElemSint16( uint32_t , SourceInfo);
33482bool emitInitElemUint16( uint32_t , SourceInfo);
33483bool emitInitElemSint32( uint32_t , SourceInfo);
33484bool emitInitElemUint32( uint32_t , SourceInfo);
33485bool emitInitElemSint64( uint32_t , SourceInfo);
33486bool emitInitElemUint64( uint32_t , SourceInfo);
33487bool emitInitElemIntAP( uint32_t , SourceInfo);
33488bool emitInitElemIntAPS( uint32_t , SourceInfo);
33489bool emitInitElemBool( uint32_t , SourceInfo);
33490bool emitInitElemFixedPoint( uint32_t , SourceInfo);
33491bool emitInitElemPtr( uint32_t , SourceInfo);
33492bool emitInitElemMemberPtr( uint32_t , SourceInfo);
33493bool emitInitElemFloat( uint32_t , SourceInfo);
33494bool emitInitElemReflect( uint32_t , SourceInfo);
33495#endif
33496#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
33497[[nodiscard]] bool emitInitElem(PrimType, uint32_t, SourceInfo I);
33498#endif
33499#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
33500bool
33501#if defined(GET_EVAL_IMPL)
33502EvalEmitter
33503#else
33504ByteCodeEmitter
33505#endif
33506::emitInitElem(PrimType T0, uint32_t A0, SourceInfo I) {
33507 switch (T0) {
33508 case PT_Sint8:
33509 return emitInitElemSint8(A0, I);
33510 case PT_Uint8:
33511 return emitInitElemUint8(A0, I);
33512 case PT_Sint16:
33513 return emitInitElemSint16(A0, I);
33514 case PT_Uint16:
33515 return emitInitElemUint16(A0, I);
33516 case PT_Sint32:
33517 return emitInitElemSint32(A0, I);
33518 case PT_Uint32:
33519 return emitInitElemUint32(A0, I);
33520 case PT_Sint64:
33521 return emitInitElemSint64(A0, I);
33522 case PT_Uint64:
33523 return emitInitElemUint64(A0, I);
33524 case PT_IntAP:
33525 return emitInitElemIntAP(A0, I);
33526 case PT_IntAPS:
33527 return emitInitElemIntAPS(A0, I);
33528 case PT_Bool:
33529 return emitInitElemBool(A0, I);
33530 case PT_FixedPoint:
33531 return emitInitElemFixedPoint(A0, I);
33532 case PT_Ptr:
33533 return emitInitElemPtr(A0, I);
33534 case PT_MemberPtr:
33535 return emitInitElemMemberPtr(A0, I);
33536 case PT_Float:
33537 return emitInitElemFloat(A0, I);
33538 case PT_Reflect:
33539 return emitInitElemReflect(A0, I);
33540 }
33541 llvm_unreachable("invalid enum value");
33542}
33543#endif
33544#ifdef GET_LINK_IMPL
33545bool ByteCodeEmitter::emitInitElemSint8( uint32_t A0, SourceInfo L) {
33546 return emitOp<uint32_t>(OP_InitElemSint8, A0, L);
33547}
33548bool ByteCodeEmitter::emitInitElemUint8( uint32_t A0, SourceInfo L) {
33549 return emitOp<uint32_t>(OP_InitElemUint8, A0, L);
33550}
33551bool ByteCodeEmitter::emitInitElemSint16( uint32_t A0, SourceInfo L) {
33552 return emitOp<uint32_t>(OP_InitElemSint16, A0, L);
33553}
33554bool ByteCodeEmitter::emitInitElemUint16( uint32_t A0, SourceInfo L) {
33555 return emitOp<uint32_t>(OP_InitElemUint16, A0, L);
33556}
33557bool ByteCodeEmitter::emitInitElemSint32( uint32_t A0, SourceInfo L) {
33558 return emitOp<uint32_t>(OP_InitElemSint32, A0, L);
33559}
33560bool ByteCodeEmitter::emitInitElemUint32( uint32_t A0, SourceInfo L) {
33561 return emitOp<uint32_t>(OP_InitElemUint32, A0, L);
33562}
33563bool ByteCodeEmitter::emitInitElemSint64( uint32_t A0, SourceInfo L) {
33564 return emitOp<uint32_t>(OP_InitElemSint64, A0, L);
33565}
33566bool ByteCodeEmitter::emitInitElemUint64( uint32_t A0, SourceInfo L) {
33567 return emitOp<uint32_t>(OP_InitElemUint64, A0, L);
33568}
33569bool ByteCodeEmitter::emitInitElemIntAP( uint32_t A0, SourceInfo L) {
33570 return emitOp<uint32_t>(OP_InitElemIntAP, A0, L);
33571}
33572bool ByteCodeEmitter::emitInitElemIntAPS( uint32_t A0, SourceInfo L) {
33573 return emitOp<uint32_t>(OP_InitElemIntAPS, A0, L);
33574}
33575bool ByteCodeEmitter::emitInitElemBool( uint32_t A0, SourceInfo L) {
33576 return emitOp<uint32_t>(OP_InitElemBool, A0, L);
33577}
33578bool ByteCodeEmitter::emitInitElemFixedPoint( uint32_t A0, SourceInfo L) {
33579 return emitOp<uint32_t>(OP_InitElemFixedPoint, A0, L);
33580}
33581bool ByteCodeEmitter::emitInitElemPtr( uint32_t A0, SourceInfo L) {
33582 return emitOp<uint32_t>(OP_InitElemPtr, A0, L);
33583}
33584bool ByteCodeEmitter::emitInitElemMemberPtr( uint32_t A0, SourceInfo L) {
33585 return emitOp<uint32_t>(OP_InitElemMemberPtr, A0, L);
33586}
33587bool ByteCodeEmitter::emitInitElemFloat( uint32_t A0, SourceInfo L) {
33588 return emitOp<uint32_t>(OP_InitElemFloat, A0, L);
33589}
33590bool ByteCodeEmitter::emitInitElemReflect( uint32_t A0, SourceInfo L) {
33591 return emitOp<uint32_t>(OP_InitElemReflect, A0, L);
33592}
33593#endif
33594#ifdef GET_EVAL_IMPL
33595bool EvalEmitter::emitInitElemSint8( uint32_t A0, SourceInfo L) {
33596 if (!isActive()) return true;
33597 CurrentSource = L;
33598 return InitElem<PT_Sint8>(S, CodePtr(), A0);
33599}
33600bool EvalEmitter::emitInitElemUint8( uint32_t A0, SourceInfo L) {
33601 if (!isActive()) return true;
33602 CurrentSource = L;
33603 return InitElem<PT_Uint8>(S, CodePtr(), A0);
33604}
33605bool EvalEmitter::emitInitElemSint16( uint32_t A0, SourceInfo L) {
33606 if (!isActive()) return true;
33607 CurrentSource = L;
33608 return InitElem<PT_Sint16>(S, CodePtr(), A0);
33609}
33610bool EvalEmitter::emitInitElemUint16( uint32_t A0, SourceInfo L) {
33611 if (!isActive()) return true;
33612 CurrentSource = L;
33613 return InitElem<PT_Uint16>(S, CodePtr(), A0);
33614}
33615bool EvalEmitter::emitInitElemSint32( uint32_t A0, SourceInfo L) {
33616 if (!isActive()) return true;
33617 CurrentSource = L;
33618 return InitElem<PT_Sint32>(S, CodePtr(), A0);
33619}
33620bool EvalEmitter::emitInitElemUint32( uint32_t A0, SourceInfo L) {
33621 if (!isActive()) return true;
33622 CurrentSource = L;
33623 return InitElem<PT_Uint32>(S, CodePtr(), A0);
33624}
33625bool EvalEmitter::emitInitElemSint64( uint32_t A0, SourceInfo L) {
33626 if (!isActive()) return true;
33627 CurrentSource = L;
33628 return InitElem<PT_Sint64>(S, CodePtr(), A0);
33629}
33630bool EvalEmitter::emitInitElemUint64( uint32_t A0, SourceInfo L) {
33631 if (!isActive()) return true;
33632 CurrentSource = L;
33633 return InitElem<PT_Uint64>(S, CodePtr(), A0);
33634}
33635bool EvalEmitter::emitInitElemIntAP( uint32_t A0, SourceInfo L) {
33636 if (!isActive()) return true;
33637 CurrentSource = L;
33638 return InitElem<PT_IntAP>(S, CodePtr(), A0);
33639}
33640bool EvalEmitter::emitInitElemIntAPS( uint32_t A0, SourceInfo L) {
33641 if (!isActive()) return true;
33642 CurrentSource = L;
33643 return InitElem<PT_IntAPS>(S, CodePtr(), A0);
33644}
33645bool EvalEmitter::emitInitElemBool( uint32_t A0, SourceInfo L) {
33646 if (!isActive()) return true;
33647 CurrentSource = L;
33648 return InitElem<PT_Bool>(S, CodePtr(), A0);
33649}
33650bool EvalEmitter::emitInitElemFixedPoint( uint32_t A0, SourceInfo L) {
33651 if (!isActive()) return true;
33652 CurrentSource = L;
33653 return InitElem<PT_FixedPoint>(S, CodePtr(), A0);
33654}
33655bool EvalEmitter::emitInitElemPtr( uint32_t A0, SourceInfo L) {
33656 if (!isActive()) return true;
33657 CurrentSource = L;
33658 return InitElem<PT_Ptr>(S, CodePtr(), A0);
33659}
33660bool EvalEmitter::emitInitElemMemberPtr( uint32_t A0, SourceInfo L) {
33661 if (!isActive()) return true;
33662 CurrentSource = L;
33663 return InitElem<PT_MemberPtr>(S, CodePtr(), A0);
33664}
33665bool EvalEmitter::emitInitElemFloat( uint32_t A0, SourceInfo L) {
33666 if (!isActive()) return true;
33667 CurrentSource = L;
33668 return InitElem<PT_Float>(S, CodePtr(), A0);
33669}
33670bool EvalEmitter::emitInitElemReflect( uint32_t A0, SourceInfo L) {
33671 if (!isActive()) return true;
33672 CurrentSource = L;
33673 return InitElem<PT_Reflect>(S, CodePtr(), A0);
33674}
33675#endif
33676#ifdef GET_OPCODE_NAMES
33677OP_InitElemPopSint8,
33678OP_InitElemPopUint8,
33679OP_InitElemPopSint16,
33680OP_InitElemPopUint16,
33681OP_InitElemPopSint32,
33682OP_InitElemPopUint32,
33683OP_InitElemPopSint64,
33684OP_InitElemPopUint64,
33685OP_InitElemPopIntAP,
33686OP_InitElemPopIntAPS,
33687OP_InitElemPopBool,
33688OP_InitElemPopFixedPoint,
33689OP_InitElemPopPtr,
33690OP_InitElemPopMemberPtr,
33691OP_InitElemPopFloat,
33692OP_InitElemPopReflect,
33693#endif
33694#ifdef GET_INTERPFN_LIST
33695&Interp_InitElemPopSint8,
33696&Interp_InitElemPopUint8,
33697&Interp_InitElemPopSint16,
33698&Interp_InitElemPopUint16,
33699&Interp_InitElemPopSint32,
33700&Interp_InitElemPopUint32,
33701&Interp_InitElemPopSint64,
33702&Interp_InitElemPopUint64,
33703&Interp_InitElemPopIntAP,
33704&Interp_InitElemPopIntAPS,
33705&Interp_InitElemPopBool,
33706&Interp_InitElemPopFixedPoint,
33707&Interp_InitElemPopPtr,
33708&Interp_InitElemPopMemberPtr,
33709&Interp_InitElemPopFloat,
33710&Interp_InitElemPopReflect,
33711#endif
33712#ifdef GET_INTERPFN_DISPATCHERS
33713PRESERVE_NONE
33714static bool Interp_InitElemPopSint8(InterpState &S) {
33715 {
33716 CodePtr OpPC = S.PC;
33717 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33718 if (!InitElemPop<PT_Sint8>(S, OpPC, V0)) return false;
33719 }
33720#if USE_TAILCALLS
33721 MUSTTAIL return InterpNext(S);
33722#else
33723 return true;
33724#endif
33725}
33726PRESERVE_NONE
33727static bool Interp_InitElemPopUint8(InterpState &S) {
33728 {
33729 CodePtr OpPC = S.PC;
33730 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33731 if (!InitElemPop<PT_Uint8>(S, OpPC, V0)) return false;
33732 }
33733#if USE_TAILCALLS
33734 MUSTTAIL return InterpNext(S);
33735#else
33736 return true;
33737#endif
33738}
33739PRESERVE_NONE
33740static bool Interp_InitElemPopSint16(InterpState &S) {
33741 {
33742 CodePtr OpPC = S.PC;
33743 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33744 if (!InitElemPop<PT_Sint16>(S, OpPC, V0)) return false;
33745 }
33746#if USE_TAILCALLS
33747 MUSTTAIL return InterpNext(S);
33748#else
33749 return true;
33750#endif
33751}
33752PRESERVE_NONE
33753static bool Interp_InitElemPopUint16(InterpState &S) {
33754 {
33755 CodePtr OpPC = S.PC;
33756 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33757 if (!InitElemPop<PT_Uint16>(S, OpPC, V0)) return false;
33758 }
33759#if USE_TAILCALLS
33760 MUSTTAIL return InterpNext(S);
33761#else
33762 return true;
33763#endif
33764}
33765PRESERVE_NONE
33766static bool Interp_InitElemPopSint32(InterpState &S) {
33767 {
33768 CodePtr OpPC = S.PC;
33769 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33770 if (!InitElemPop<PT_Sint32>(S, OpPC, V0)) return false;
33771 }
33772#if USE_TAILCALLS
33773 MUSTTAIL return InterpNext(S);
33774#else
33775 return true;
33776#endif
33777}
33778PRESERVE_NONE
33779static bool Interp_InitElemPopUint32(InterpState &S) {
33780 {
33781 CodePtr OpPC = S.PC;
33782 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33783 if (!InitElemPop<PT_Uint32>(S, OpPC, V0)) return false;
33784 }
33785#if USE_TAILCALLS
33786 MUSTTAIL return InterpNext(S);
33787#else
33788 return true;
33789#endif
33790}
33791PRESERVE_NONE
33792static bool Interp_InitElemPopSint64(InterpState &S) {
33793 {
33794 CodePtr OpPC = S.PC;
33795 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33796 if (!InitElemPop<PT_Sint64>(S, OpPC, V0)) return false;
33797 }
33798#if USE_TAILCALLS
33799 MUSTTAIL return InterpNext(S);
33800#else
33801 return true;
33802#endif
33803}
33804PRESERVE_NONE
33805static bool Interp_InitElemPopUint64(InterpState &S) {
33806 {
33807 CodePtr OpPC = S.PC;
33808 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33809 if (!InitElemPop<PT_Uint64>(S, OpPC, V0)) return false;
33810 }
33811#if USE_TAILCALLS
33812 MUSTTAIL return InterpNext(S);
33813#else
33814 return true;
33815#endif
33816}
33817PRESERVE_NONE
33818static bool Interp_InitElemPopIntAP(InterpState &S) {
33819 {
33820 CodePtr OpPC = S.PC;
33821 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33822 if (!InitElemPop<PT_IntAP>(S, OpPC, V0)) return false;
33823 }
33824#if USE_TAILCALLS
33825 MUSTTAIL return InterpNext(S);
33826#else
33827 return true;
33828#endif
33829}
33830PRESERVE_NONE
33831static bool Interp_InitElemPopIntAPS(InterpState &S) {
33832 {
33833 CodePtr OpPC = S.PC;
33834 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33835 if (!InitElemPop<PT_IntAPS>(S, OpPC, V0)) return false;
33836 }
33837#if USE_TAILCALLS
33838 MUSTTAIL return InterpNext(S);
33839#else
33840 return true;
33841#endif
33842}
33843PRESERVE_NONE
33844static bool Interp_InitElemPopBool(InterpState &S) {
33845 {
33846 CodePtr OpPC = S.PC;
33847 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33848 if (!InitElemPop<PT_Bool>(S, OpPC, V0)) return false;
33849 }
33850#if USE_TAILCALLS
33851 MUSTTAIL return InterpNext(S);
33852#else
33853 return true;
33854#endif
33855}
33856PRESERVE_NONE
33857static bool Interp_InitElemPopFixedPoint(InterpState &S) {
33858 {
33859 CodePtr OpPC = S.PC;
33860 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33861 if (!InitElemPop<PT_FixedPoint>(S, OpPC, V0)) return false;
33862 }
33863#if USE_TAILCALLS
33864 MUSTTAIL return InterpNext(S);
33865#else
33866 return true;
33867#endif
33868}
33869PRESERVE_NONE
33870static bool Interp_InitElemPopPtr(InterpState &S) {
33871 {
33872 CodePtr OpPC = S.PC;
33873 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33874 if (!InitElemPop<PT_Ptr>(S, OpPC, V0)) return false;
33875 }
33876#if USE_TAILCALLS
33877 MUSTTAIL return InterpNext(S);
33878#else
33879 return true;
33880#endif
33881}
33882PRESERVE_NONE
33883static bool Interp_InitElemPopMemberPtr(InterpState &S) {
33884 {
33885 CodePtr OpPC = S.PC;
33886 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33887 if (!InitElemPop<PT_MemberPtr>(S, OpPC, V0)) return false;
33888 }
33889#if USE_TAILCALLS
33890 MUSTTAIL return InterpNext(S);
33891#else
33892 return true;
33893#endif
33894}
33895PRESERVE_NONE
33896static bool Interp_InitElemPopFloat(InterpState &S) {
33897 {
33898 CodePtr OpPC = S.PC;
33899 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33900 if (!InitElemPop<PT_Float>(S, OpPC, V0)) return false;
33901 }
33902#if USE_TAILCALLS
33903 MUSTTAIL return InterpNext(S);
33904#else
33905 return true;
33906#endif
33907}
33908PRESERVE_NONE
33909static bool Interp_InitElemPopReflect(InterpState &S) {
33910 {
33911 CodePtr OpPC = S.PC;
33912 const auto V0 = ReadArg<uint32_t>(S, S.PC);
33913 if (!InitElemPop<PT_Reflect>(S, OpPC, V0)) return false;
33914 }
33915#if USE_TAILCALLS
33916 MUSTTAIL return InterpNext(S);
33917#else
33918 return true;
33919#endif
33920}
33921#endif
33922#ifdef GET_DISASM
33923case OP_InitElemPopSint8:
33924 Text.Op = PrintName("InitElemPopSint8");
33925 Text.Args.push_back(printArg<uint32_t>(PC));
33926 break;
33927case OP_InitElemPopUint8:
33928 Text.Op = PrintName("InitElemPopUint8");
33929 Text.Args.push_back(printArg<uint32_t>(PC));
33930 break;
33931case OP_InitElemPopSint16:
33932 Text.Op = PrintName("InitElemPopSint16");
33933 Text.Args.push_back(printArg<uint32_t>(PC));
33934 break;
33935case OP_InitElemPopUint16:
33936 Text.Op = PrintName("InitElemPopUint16");
33937 Text.Args.push_back(printArg<uint32_t>(PC));
33938 break;
33939case OP_InitElemPopSint32:
33940 Text.Op = PrintName("InitElemPopSint32");
33941 Text.Args.push_back(printArg<uint32_t>(PC));
33942 break;
33943case OP_InitElemPopUint32:
33944 Text.Op = PrintName("InitElemPopUint32");
33945 Text.Args.push_back(printArg<uint32_t>(PC));
33946 break;
33947case OP_InitElemPopSint64:
33948 Text.Op = PrintName("InitElemPopSint64");
33949 Text.Args.push_back(printArg<uint32_t>(PC));
33950 break;
33951case OP_InitElemPopUint64:
33952 Text.Op = PrintName("InitElemPopUint64");
33953 Text.Args.push_back(printArg<uint32_t>(PC));
33954 break;
33955case OP_InitElemPopIntAP:
33956 Text.Op = PrintName("InitElemPopIntAP");
33957 Text.Args.push_back(printArg<uint32_t>(PC));
33958 break;
33959case OP_InitElemPopIntAPS:
33960 Text.Op = PrintName("InitElemPopIntAPS");
33961 Text.Args.push_back(printArg<uint32_t>(PC));
33962 break;
33963case OP_InitElemPopBool:
33964 Text.Op = PrintName("InitElemPopBool");
33965 Text.Args.push_back(printArg<uint32_t>(PC));
33966 break;
33967case OP_InitElemPopFixedPoint:
33968 Text.Op = PrintName("InitElemPopFixedPoint");
33969 Text.Args.push_back(printArg<uint32_t>(PC));
33970 break;
33971case OP_InitElemPopPtr:
33972 Text.Op = PrintName("InitElemPopPtr");
33973 Text.Args.push_back(printArg<uint32_t>(PC));
33974 break;
33975case OP_InitElemPopMemberPtr:
33976 Text.Op = PrintName("InitElemPopMemberPtr");
33977 Text.Args.push_back(printArg<uint32_t>(PC));
33978 break;
33979case OP_InitElemPopFloat:
33980 Text.Op = PrintName("InitElemPopFloat");
33981 Text.Args.push_back(printArg<uint32_t>(PC));
33982 break;
33983case OP_InitElemPopReflect:
33984 Text.Op = PrintName("InitElemPopReflect");
33985 Text.Args.push_back(printArg<uint32_t>(PC));
33986 break;
33987#endif
33988#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
33989bool emitInitElemPopSint8( uint32_t , SourceInfo);
33990bool emitInitElemPopUint8( uint32_t , SourceInfo);
33991bool emitInitElemPopSint16( uint32_t , SourceInfo);
33992bool emitInitElemPopUint16( uint32_t , SourceInfo);
33993bool emitInitElemPopSint32( uint32_t , SourceInfo);
33994bool emitInitElemPopUint32( uint32_t , SourceInfo);
33995bool emitInitElemPopSint64( uint32_t , SourceInfo);
33996bool emitInitElemPopUint64( uint32_t , SourceInfo);
33997bool emitInitElemPopIntAP( uint32_t , SourceInfo);
33998bool emitInitElemPopIntAPS( uint32_t , SourceInfo);
33999bool emitInitElemPopBool( uint32_t , SourceInfo);
34000bool emitInitElemPopFixedPoint( uint32_t , SourceInfo);
34001bool emitInitElemPopPtr( uint32_t , SourceInfo);
34002bool emitInitElemPopMemberPtr( uint32_t , SourceInfo);
34003bool emitInitElemPopFloat( uint32_t , SourceInfo);
34004bool emitInitElemPopReflect( uint32_t , SourceInfo);
34005#endif
34006#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
34007[[nodiscard]] bool emitInitElemPop(PrimType, uint32_t, SourceInfo I);
34008#endif
34009#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
34010bool
34011#if defined(GET_EVAL_IMPL)
34012EvalEmitter
34013#else
34014ByteCodeEmitter
34015#endif
34016::emitInitElemPop(PrimType T0, uint32_t A0, SourceInfo I) {
34017 switch (T0) {
34018 case PT_Sint8:
34019 return emitInitElemPopSint8(A0, I);
34020 case PT_Uint8:
34021 return emitInitElemPopUint8(A0, I);
34022 case PT_Sint16:
34023 return emitInitElemPopSint16(A0, I);
34024 case PT_Uint16:
34025 return emitInitElemPopUint16(A0, I);
34026 case PT_Sint32:
34027 return emitInitElemPopSint32(A0, I);
34028 case PT_Uint32:
34029 return emitInitElemPopUint32(A0, I);
34030 case PT_Sint64:
34031 return emitInitElemPopSint64(A0, I);
34032 case PT_Uint64:
34033 return emitInitElemPopUint64(A0, I);
34034 case PT_IntAP:
34035 return emitInitElemPopIntAP(A0, I);
34036 case PT_IntAPS:
34037 return emitInitElemPopIntAPS(A0, I);
34038 case PT_Bool:
34039 return emitInitElemPopBool(A0, I);
34040 case PT_FixedPoint:
34041 return emitInitElemPopFixedPoint(A0, I);
34042 case PT_Ptr:
34043 return emitInitElemPopPtr(A0, I);
34044 case PT_MemberPtr:
34045 return emitInitElemPopMemberPtr(A0, I);
34046 case PT_Float:
34047 return emitInitElemPopFloat(A0, I);
34048 case PT_Reflect:
34049 return emitInitElemPopReflect(A0, I);
34050 }
34051 llvm_unreachable("invalid enum value");
34052}
34053#endif
34054#ifdef GET_LINK_IMPL
34055bool ByteCodeEmitter::emitInitElemPopSint8( uint32_t A0, SourceInfo L) {
34056 return emitOp<uint32_t>(OP_InitElemPopSint8, A0, L);
34057}
34058bool ByteCodeEmitter::emitInitElemPopUint8( uint32_t A0, SourceInfo L) {
34059 return emitOp<uint32_t>(OP_InitElemPopUint8, A0, L);
34060}
34061bool ByteCodeEmitter::emitInitElemPopSint16( uint32_t A0, SourceInfo L) {
34062 return emitOp<uint32_t>(OP_InitElemPopSint16, A0, L);
34063}
34064bool ByteCodeEmitter::emitInitElemPopUint16( uint32_t A0, SourceInfo L) {
34065 return emitOp<uint32_t>(OP_InitElemPopUint16, A0, L);
34066}
34067bool ByteCodeEmitter::emitInitElemPopSint32( uint32_t A0, SourceInfo L) {
34068 return emitOp<uint32_t>(OP_InitElemPopSint32, A0, L);
34069}
34070bool ByteCodeEmitter::emitInitElemPopUint32( uint32_t A0, SourceInfo L) {
34071 return emitOp<uint32_t>(OP_InitElemPopUint32, A0, L);
34072}
34073bool ByteCodeEmitter::emitInitElemPopSint64( uint32_t A0, SourceInfo L) {
34074 return emitOp<uint32_t>(OP_InitElemPopSint64, A0, L);
34075}
34076bool ByteCodeEmitter::emitInitElemPopUint64( uint32_t A0, SourceInfo L) {
34077 return emitOp<uint32_t>(OP_InitElemPopUint64, A0, L);
34078}
34079bool ByteCodeEmitter::emitInitElemPopIntAP( uint32_t A0, SourceInfo L) {
34080 return emitOp<uint32_t>(OP_InitElemPopIntAP, A0, L);
34081}
34082bool ByteCodeEmitter::emitInitElemPopIntAPS( uint32_t A0, SourceInfo L) {
34083 return emitOp<uint32_t>(OP_InitElemPopIntAPS, A0, L);
34084}
34085bool ByteCodeEmitter::emitInitElemPopBool( uint32_t A0, SourceInfo L) {
34086 return emitOp<uint32_t>(OP_InitElemPopBool, A0, L);
34087}
34088bool ByteCodeEmitter::emitInitElemPopFixedPoint( uint32_t A0, SourceInfo L) {
34089 return emitOp<uint32_t>(OP_InitElemPopFixedPoint, A0, L);
34090}
34091bool ByteCodeEmitter::emitInitElemPopPtr( uint32_t A0, SourceInfo L) {
34092 return emitOp<uint32_t>(OP_InitElemPopPtr, A0, L);
34093}
34094bool ByteCodeEmitter::emitInitElemPopMemberPtr( uint32_t A0, SourceInfo L) {
34095 return emitOp<uint32_t>(OP_InitElemPopMemberPtr, A0, L);
34096}
34097bool ByteCodeEmitter::emitInitElemPopFloat( uint32_t A0, SourceInfo L) {
34098 return emitOp<uint32_t>(OP_InitElemPopFloat, A0, L);
34099}
34100bool ByteCodeEmitter::emitInitElemPopReflect( uint32_t A0, SourceInfo L) {
34101 return emitOp<uint32_t>(OP_InitElemPopReflect, A0, L);
34102}
34103#endif
34104#ifdef GET_EVAL_IMPL
34105bool EvalEmitter::emitInitElemPopSint8( uint32_t A0, SourceInfo L) {
34106 if (!isActive()) return true;
34107 CurrentSource = L;
34108 return InitElemPop<PT_Sint8>(S, CodePtr(), A0);
34109}
34110bool EvalEmitter::emitInitElemPopUint8( uint32_t A0, SourceInfo L) {
34111 if (!isActive()) return true;
34112 CurrentSource = L;
34113 return InitElemPop<PT_Uint8>(S, CodePtr(), A0);
34114}
34115bool EvalEmitter::emitInitElemPopSint16( uint32_t A0, SourceInfo L) {
34116 if (!isActive()) return true;
34117 CurrentSource = L;
34118 return InitElemPop<PT_Sint16>(S, CodePtr(), A0);
34119}
34120bool EvalEmitter::emitInitElemPopUint16( uint32_t A0, SourceInfo L) {
34121 if (!isActive()) return true;
34122 CurrentSource = L;
34123 return InitElemPop<PT_Uint16>(S, CodePtr(), A0);
34124}
34125bool EvalEmitter::emitInitElemPopSint32( uint32_t A0, SourceInfo L) {
34126 if (!isActive()) return true;
34127 CurrentSource = L;
34128 return InitElemPop<PT_Sint32>(S, CodePtr(), A0);
34129}
34130bool EvalEmitter::emitInitElemPopUint32( uint32_t A0, SourceInfo L) {
34131 if (!isActive()) return true;
34132 CurrentSource = L;
34133 return InitElemPop<PT_Uint32>(S, CodePtr(), A0);
34134}
34135bool EvalEmitter::emitInitElemPopSint64( uint32_t A0, SourceInfo L) {
34136 if (!isActive()) return true;
34137 CurrentSource = L;
34138 return InitElemPop<PT_Sint64>(S, CodePtr(), A0);
34139}
34140bool EvalEmitter::emitInitElemPopUint64( uint32_t A0, SourceInfo L) {
34141 if (!isActive()) return true;
34142 CurrentSource = L;
34143 return InitElemPop<PT_Uint64>(S, CodePtr(), A0);
34144}
34145bool EvalEmitter::emitInitElemPopIntAP( uint32_t A0, SourceInfo L) {
34146 if (!isActive()) return true;
34147 CurrentSource = L;
34148 return InitElemPop<PT_IntAP>(S, CodePtr(), A0);
34149}
34150bool EvalEmitter::emitInitElemPopIntAPS( uint32_t A0, SourceInfo L) {
34151 if (!isActive()) return true;
34152 CurrentSource = L;
34153 return InitElemPop<PT_IntAPS>(S, CodePtr(), A0);
34154}
34155bool EvalEmitter::emitInitElemPopBool( uint32_t A0, SourceInfo L) {
34156 if (!isActive()) return true;
34157 CurrentSource = L;
34158 return InitElemPop<PT_Bool>(S, CodePtr(), A0);
34159}
34160bool EvalEmitter::emitInitElemPopFixedPoint( uint32_t A0, SourceInfo L) {
34161 if (!isActive()) return true;
34162 CurrentSource = L;
34163 return InitElemPop<PT_FixedPoint>(S, CodePtr(), A0);
34164}
34165bool EvalEmitter::emitInitElemPopPtr( uint32_t A0, SourceInfo L) {
34166 if (!isActive()) return true;
34167 CurrentSource = L;
34168 return InitElemPop<PT_Ptr>(S, CodePtr(), A0);
34169}
34170bool EvalEmitter::emitInitElemPopMemberPtr( uint32_t A0, SourceInfo L) {
34171 if (!isActive()) return true;
34172 CurrentSource = L;
34173 return InitElemPop<PT_MemberPtr>(S, CodePtr(), A0);
34174}
34175bool EvalEmitter::emitInitElemPopFloat( uint32_t A0, SourceInfo L) {
34176 if (!isActive()) return true;
34177 CurrentSource = L;
34178 return InitElemPop<PT_Float>(S, CodePtr(), A0);
34179}
34180bool EvalEmitter::emitInitElemPopReflect( uint32_t A0, SourceInfo L) {
34181 if (!isActive()) return true;
34182 CurrentSource = L;
34183 return InitElemPop<PT_Reflect>(S, CodePtr(), A0);
34184}
34185#endif
34186#ifdef GET_OPCODE_NAMES
34187OP_InitFieldSint8,
34188OP_InitFieldUint8,
34189OP_InitFieldSint16,
34190OP_InitFieldUint16,
34191OP_InitFieldSint32,
34192OP_InitFieldUint32,
34193OP_InitFieldSint64,
34194OP_InitFieldUint64,
34195OP_InitFieldIntAP,
34196OP_InitFieldIntAPS,
34197OP_InitFieldBool,
34198OP_InitFieldFixedPoint,
34199OP_InitFieldPtr,
34200OP_InitFieldMemberPtr,
34201OP_InitFieldFloat,
34202OP_InitFieldReflect,
34203#endif
34204#ifdef GET_INTERPFN_LIST
34205&Interp_InitFieldSint8,
34206&Interp_InitFieldUint8,
34207&Interp_InitFieldSint16,
34208&Interp_InitFieldUint16,
34209&Interp_InitFieldSint32,
34210&Interp_InitFieldUint32,
34211&Interp_InitFieldSint64,
34212&Interp_InitFieldUint64,
34213&Interp_InitFieldIntAP,
34214&Interp_InitFieldIntAPS,
34215&Interp_InitFieldBool,
34216&Interp_InitFieldFixedPoint,
34217&Interp_InitFieldPtr,
34218&Interp_InitFieldMemberPtr,
34219&Interp_InitFieldFloat,
34220&Interp_InitFieldReflect,
34221#endif
34222#ifdef GET_INTERPFN_DISPATCHERS
34223PRESERVE_NONE
34224static bool Interp_InitFieldSint8(InterpState &S) {
34225 {
34226 CodePtr OpPC = S.PC;
34227 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34228 if (!InitField<PT_Sint8>(S, OpPC, V0)) return false;
34229 }
34230#if USE_TAILCALLS
34231 MUSTTAIL return InterpNext(S);
34232#else
34233 return true;
34234#endif
34235}
34236PRESERVE_NONE
34237static bool Interp_InitFieldUint8(InterpState &S) {
34238 {
34239 CodePtr OpPC = S.PC;
34240 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34241 if (!InitField<PT_Uint8>(S, OpPC, V0)) return false;
34242 }
34243#if USE_TAILCALLS
34244 MUSTTAIL return InterpNext(S);
34245#else
34246 return true;
34247#endif
34248}
34249PRESERVE_NONE
34250static bool Interp_InitFieldSint16(InterpState &S) {
34251 {
34252 CodePtr OpPC = S.PC;
34253 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34254 if (!InitField<PT_Sint16>(S, OpPC, V0)) return false;
34255 }
34256#if USE_TAILCALLS
34257 MUSTTAIL return InterpNext(S);
34258#else
34259 return true;
34260#endif
34261}
34262PRESERVE_NONE
34263static bool Interp_InitFieldUint16(InterpState &S) {
34264 {
34265 CodePtr OpPC = S.PC;
34266 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34267 if (!InitField<PT_Uint16>(S, OpPC, V0)) return false;
34268 }
34269#if USE_TAILCALLS
34270 MUSTTAIL return InterpNext(S);
34271#else
34272 return true;
34273#endif
34274}
34275PRESERVE_NONE
34276static bool Interp_InitFieldSint32(InterpState &S) {
34277 {
34278 CodePtr OpPC = S.PC;
34279 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34280 if (!InitField<PT_Sint32>(S, OpPC, V0)) return false;
34281 }
34282#if USE_TAILCALLS
34283 MUSTTAIL return InterpNext(S);
34284#else
34285 return true;
34286#endif
34287}
34288PRESERVE_NONE
34289static bool Interp_InitFieldUint32(InterpState &S) {
34290 {
34291 CodePtr OpPC = S.PC;
34292 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34293 if (!InitField<PT_Uint32>(S, OpPC, V0)) return false;
34294 }
34295#if USE_TAILCALLS
34296 MUSTTAIL return InterpNext(S);
34297#else
34298 return true;
34299#endif
34300}
34301PRESERVE_NONE
34302static bool Interp_InitFieldSint64(InterpState &S) {
34303 {
34304 CodePtr OpPC = S.PC;
34305 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34306 if (!InitField<PT_Sint64>(S, OpPC, V0)) return false;
34307 }
34308#if USE_TAILCALLS
34309 MUSTTAIL return InterpNext(S);
34310#else
34311 return true;
34312#endif
34313}
34314PRESERVE_NONE
34315static bool Interp_InitFieldUint64(InterpState &S) {
34316 {
34317 CodePtr OpPC = S.PC;
34318 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34319 if (!InitField<PT_Uint64>(S, OpPC, V0)) return false;
34320 }
34321#if USE_TAILCALLS
34322 MUSTTAIL return InterpNext(S);
34323#else
34324 return true;
34325#endif
34326}
34327PRESERVE_NONE
34328static bool Interp_InitFieldIntAP(InterpState &S) {
34329 {
34330 CodePtr OpPC = S.PC;
34331 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34332 if (!InitField<PT_IntAP>(S, OpPC, V0)) return false;
34333 }
34334#if USE_TAILCALLS
34335 MUSTTAIL return InterpNext(S);
34336#else
34337 return true;
34338#endif
34339}
34340PRESERVE_NONE
34341static bool Interp_InitFieldIntAPS(InterpState &S) {
34342 {
34343 CodePtr OpPC = S.PC;
34344 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34345 if (!InitField<PT_IntAPS>(S, OpPC, V0)) return false;
34346 }
34347#if USE_TAILCALLS
34348 MUSTTAIL return InterpNext(S);
34349#else
34350 return true;
34351#endif
34352}
34353PRESERVE_NONE
34354static bool Interp_InitFieldBool(InterpState &S) {
34355 {
34356 CodePtr OpPC = S.PC;
34357 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34358 if (!InitField<PT_Bool>(S, OpPC, V0)) return false;
34359 }
34360#if USE_TAILCALLS
34361 MUSTTAIL return InterpNext(S);
34362#else
34363 return true;
34364#endif
34365}
34366PRESERVE_NONE
34367static bool Interp_InitFieldFixedPoint(InterpState &S) {
34368 {
34369 CodePtr OpPC = S.PC;
34370 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34371 if (!InitField<PT_FixedPoint>(S, OpPC, V0)) return false;
34372 }
34373#if USE_TAILCALLS
34374 MUSTTAIL return InterpNext(S);
34375#else
34376 return true;
34377#endif
34378}
34379PRESERVE_NONE
34380static bool Interp_InitFieldPtr(InterpState &S) {
34381 {
34382 CodePtr OpPC = S.PC;
34383 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34384 if (!InitField<PT_Ptr>(S, OpPC, V0)) return false;
34385 }
34386#if USE_TAILCALLS
34387 MUSTTAIL return InterpNext(S);
34388#else
34389 return true;
34390#endif
34391}
34392PRESERVE_NONE
34393static bool Interp_InitFieldMemberPtr(InterpState &S) {
34394 {
34395 CodePtr OpPC = S.PC;
34396 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34397 if (!InitField<PT_MemberPtr>(S, OpPC, V0)) return false;
34398 }
34399#if USE_TAILCALLS
34400 MUSTTAIL return InterpNext(S);
34401#else
34402 return true;
34403#endif
34404}
34405PRESERVE_NONE
34406static bool Interp_InitFieldFloat(InterpState &S) {
34407 {
34408 CodePtr OpPC = S.PC;
34409 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34410 if (!InitField<PT_Float>(S, OpPC, V0)) return false;
34411 }
34412#if USE_TAILCALLS
34413 MUSTTAIL return InterpNext(S);
34414#else
34415 return true;
34416#endif
34417}
34418PRESERVE_NONE
34419static bool Interp_InitFieldReflect(InterpState &S) {
34420 {
34421 CodePtr OpPC = S.PC;
34422 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34423 if (!InitField<PT_Reflect>(S, OpPC, V0)) return false;
34424 }
34425#if USE_TAILCALLS
34426 MUSTTAIL return InterpNext(S);
34427#else
34428 return true;
34429#endif
34430}
34431#endif
34432#ifdef GET_DISASM
34433case OP_InitFieldSint8:
34434 Text.Op = PrintName("InitFieldSint8");
34435 Text.Args.push_back(printArg<uint32_t>(PC));
34436 break;
34437case OP_InitFieldUint8:
34438 Text.Op = PrintName("InitFieldUint8");
34439 Text.Args.push_back(printArg<uint32_t>(PC));
34440 break;
34441case OP_InitFieldSint16:
34442 Text.Op = PrintName("InitFieldSint16");
34443 Text.Args.push_back(printArg<uint32_t>(PC));
34444 break;
34445case OP_InitFieldUint16:
34446 Text.Op = PrintName("InitFieldUint16");
34447 Text.Args.push_back(printArg<uint32_t>(PC));
34448 break;
34449case OP_InitFieldSint32:
34450 Text.Op = PrintName("InitFieldSint32");
34451 Text.Args.push_back(printArg<uint32_t>(PC));
34452 break;
34453case OP_InitFieldUint32:
34454 Text.Op = PrintName("InitFieldUint32");
34455 Text.Args.push_back(printArg<uint32_t>(PC));
34456 break;
34457case OP_InitFieldSint64:
34458 Text.Op = PrintName("InitFieldSint64");
34459 Text.Args.push_back(printArg<uint32_t>(PC));
34460 break;
34461case OP_InitFieldUint64:
34462 Text.Op = PrintName("InitFieldUint64");
34463 Text.Args.push_back(printArg<uint32_t>(PC));
34464 break;
34465case OP_InitFieldIntAP:
34466 Text.Op = PrintName("InitFieldIntAP");
34467 Text.Args.push_back(printArg<uint32_t>(PC));
34468 break;
34469case OP_InitFieldIntAPS:
34470 Text.Op = PrintName("InitFieldIntAPS");
34471 Text.Args.push_back(printArg<uint32_t>(PC));
34472 break;
34473case OP_InitFieldBool:
34474 Text.Op = PrintName("InitFieldBool");
34475 Text.Args.push_back(printArg<uint32_t>(PC));
34476 break;
34477case OP_InitFieldFixedPoint:
34478 Text.Op = PrintName("InitFieldFixedPoint");
34479 Text.Args.push_back(printArg<uint32_t>(PC));
34480 break;
34481case OP_InitFieldPtr:
34482 Text.Op = PrintName("InitFieldPtr");
34483 Text.Args.push_back(printArg<uint32_t>(PC));
34484 break;
34485case OP_InitFieldMemberPtr:
34486 Text.Op = PrintName("InitFieldMemberPtr");
34487 Text.Args.push_back(printArg<uint32_t>(PC));
34488 break;
34489case OP_InitFieldFloat:
34490 Text.Op = PrintName("InitFieldFloat");
34491 Text.Args.push_back(printArg<uint32_t>(PC));
34492 break;
34493case OP_InitFieldReflect:
34494 Text.Op = PrintName("InitFieldReflect");
34495 Text.Args.push_back(printArg<uint32_t>(PC));
34496 break;
34497#endif
34498#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
34499bool emitInitFieldSint8( uint32_t , SourceInfo);
34500bool emitInitFieldUint8( uint32_t , SourceInfo);
34501bool emitInitFieldSint16( uint32_t , SourceInfo);
34502bool emitInitFieldUint16( uint32_t , SourceInfo);
34503bool emitInitFieldSint32( uint32_t , SourceInfo);
34504bool emitInitFieldUint32( uint32_t , SourceInfo);
34505bool emitInitFieldSint64( uint32_t , SourceInfo);
34506bool emitInitFieldUint64( uint32_t , SourceInfo);
34507bool emitInitFieldIntAP( uint32_t , SourceInfo);
34508bool emitInitFieldIntAPS( uint32_t , SourceInfo);
34509bool emitInitFieldBool( uint32_t , SourceInfo);
34510bool emitInitFieldFixedPoint( uint32_t , SourceInfo);
34511bool emitInitFieldPtr( uint32_t , SourceInfo);
34512bool emitInitFieldMemberPtr( uint32_t , SourceInfo);
34513bool emitInitFieldFloat( uint32_t , SourceInfo);
34514bool emitInitFieldReflect( uint32_t , SourceInfo);
34515#endif
34516#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
34517[[nodiscard]] bool emitInitField(PrimType, uint32_t, SourceInfo I);
34518#endif
34519#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
34520bool
34521#if defined(GET_EVAL_IMPL)
34522EvalEmitter
34523#else
34524ByteCodeEmitter
34525#endif
34526::emitInitField(PrimType T0, uint32_t A0, SourceInfo I) {
34527 switch (T0) {
34528 case PT_Sint8:
34529 return emitInitFieldSint8(A0, I);
34530 case PT_Uint8:
34531 return emitInitFieldUint8(A0, I);
34532 case PT_Sint16:
34533 return emitInitFieldSint16(A0, I);
34534 case PT_Uint16:
34535 return emitInitFieldUint16(A0, I);
34536 case PT_Sint32:
34537 return emitInitFieldSint32(A0, I);
34538 case PT_Uint32:
34539 return emitInitFieldUint32(A0, I);
34540 case PT_Sint64:
34541 return emitInitFieldSint64(A0, I);
34542 case PT_Uint64:
34543 return emitInitFieldUint64(A0, I);
34544 case PT_IntAP:
34545 return emitInitFieldIntAP(A0, I);
34546 case PT_IntAPS:
34547 return emitInitFieldIntAPS(A0, I);
34548 case PT_Bool:
34549 return emitInitFieldBool(A0, I);
34550 case PT_FixedPoint:
34551 return emitInitFieldFixedPoint(A0, I);
34552 case PT_Ptr:
34553 return emitInitFieldPtr(A0, I);
34554 case PT_MemberPtr:
34555 return emitInitFieldMemberPtr(A0, I);
34556 case PT_Float:
34557 return emitInitFieldFloat(A0, I);
34558 case PT_Reflect:
34559 return emitInitFieldReflect(A0, I);
34560 }
34561 llvm_unreachable("invalid enum value");
34562}
34563#endif
34564#ifdef GET_LINK_IMPL
34565bool ByteCodeEmitter::emitInitFieldSint8( uint32_t A0, SourceInfo L) {
34566 return emitOp<uint32_t>(OP_InitFieldSint8, A0, L);
34567}
34568bool ByteCodeEmitter::emitInitFieldUint8( uint32_t A0, SourceInfo L) {
34569 return emitOp<uint32_t>(OP_InitFieldUint8, A0, L);
34570}
34571bool ByteCodeEmitter::emitInitFieldSint16( uint32_t A0, SourceInfo L) {
34572 return emitOp<uint32_t>(OP_InitFieldSint16, A0, L);
34573}
34574bool ByteCodeEmitter::emitInitFieldUint16( uint32_t A0, SourceInfo L) {
34575 return emitOp<uint32_t>(OP_InitFieldUint16, A0, L);
34576}
34577bool ByteCodeEmitter::emitInitFieldSint32( uint32_t A0, SourceInfo L) {
34578 return emitOp<uint32_t>(OP_InitFieldSint32, A0, L);
34579}
34580bool ByteCodeEmitter::emitInitFieldUint32( uint32_t A0, SourceInfo L) {
34581 return emitOp<uint32_t>(OP_InitFieldUint32, A0, L);
34582}
34583bool ByteCodeEmitter::emitInitFieldSint64( uint32_t A0, SourceInfo L) {
34584 return emitOp<uint32_t>(OP_InitFieldSint64, A0, L);
34585}
34586bool ByteCodeEmitter::emitInitFieldUint64( uint32_t A0, SourceInfo L) {
34587 return emitOp<uint32_t>(OP_InitFieldUint64, A0, L);
34588}
34589bool ByteCodeEmitter::emitInitFieldIntAP( uint32_t A0, SourceInfo L) {
34590 return emitOp<uint32_t>(OP_InitFieldIntAP, A0, L);
34591}
34592bool ByteCodeEmitter::emitInitFieldIntAPS( uint32_t A0, SourceInfo L) {
34593 return emitOp<uint32_t>(OP_InitFieldIntAPS, A0, L);
34594}
34595bool ByteCodeEmitter::emitInitFieldBool( uint32_t A0, SourceInfo L) {
34596 return emitOp<uint32_t>(OP_InitFieldBool, A0, L);
34597}
34598bool ByteCodeEmitter::emitInitFieldFixedPoint( uint32_t A0, SourceInfo L) {
34599 return emitOp<uint32_t>(OP_InitFieldFixedPoint, A0, L);
34600}
34601bool ByteCodeEmitter::emitInitFieldPtr( uint32_t A0, SourceInfo L) {
34602 return emitOp<uint32_t>(OP_InitFieldPtr, A0, L);
34603}
34604bool ByteCodeEmitter::emitInitFieldMemberPtr( uint32_t A0, SourceInfo L) {
34605 return emitOp<uint32_t>(OP_InitFieldMemberPtr, A0, L);
34606}
34607bool ByteCodeEmitter::emitInitFieldFloat( uint32_t A0, SourceInfo L) {
34608 return emitOp<uint32_t>(OP_InitFieldFloat, A0, L);
34609}
34610bool ByteCodeEmitter::emitInitFieldReflect( uint32_t A0, SourceInfo L) {
34611 return emitOp<uint32_t>(OP_InitFieldReflect, A0, L);
34612}
34613#endif
34614#ifdef GET_EVAL_IMPL
34615bool EvalEmitter::emitInitFieldSint8( uint32_t A0, SourceInfo L) {
34616 if (!isActive()) return true;
34617 CurrentSource = L;
34618 return InitField<PT_Sint8>(S, CodePtr(), A0);
34619}
34620bool EvalEmitter::emitInitFieldUint8( uint32_t A0, SourceInfo L) {
34621 if (!isActive()) return true;
34622 CurrentSource = L;
34623 return InitField<PT_Uint8>(S, CodePtr(), A0);
34624}
34625bool EvalEmitter::emitInitFieldSint16( uint32_t A0, SourceInfo L) {
34626 if (!isActive()) return true;
34627 CurrentSource = L;
34628 return InitField<PT_Sint16>(S, CodePtr(), A0);
34629}
34630bool EvalEmitter::emitInitFieldUint16( uint32_t A0, SourceInfo L) {
34631 if (!isActive()) return true;
34632 CurrentSource = L;
34633 return InitField<PT_Uint16>(S, CodePtr(), A0);
34634}
34635bool EvalEmitter::emitInitFieldSint32( uint32_t A0, SourceInfo L) {
34636 if (!isActive()) return true;
34637 CurrentSource = L;
34638 return InitField<PT_Sint32>(S, CodePtr(), A0);
34639}
34640bool EvalEmitter::emitInitFieldUint32( uint32_t A0, SourceInfo L) {
34641 if (!isActive()) return true;
34642 CurrentSource = L;
34643 return InitField<PT_Uint32>(S, CodePtr(), A0);
34644}
34645bool EvalEmitter::emitInitFieldSint64( uint32_t A0, SourceInfo L) {
34646 if (!isActive()) return true;
34647 CurrentSource = L;
34648 return InitField<PT_Sint64>(S, CodePtr(), A0);
34649}
34650bool EvalEmitter::emitInitFieldUint64( uint32_t A0, SourceInfo L) {
34651 if (!isActive()) return true;
34652 CurrentSource = L;
34653 return InitField<PT_Uint64>(S, CodePtr(), A0);
34654}
34655bool EvalEmitter::emitInitFieldIntAP( uint32_t A0, SourceInfo L) {
34656 if (!isActive()) return true;
34657 CurrentSource = L;
34658 return InitField<PT_IntAP>(S, CodePtr(), A0);
34659}
34660bool EvalEmitter::emitInitFieldIntAPS( uint32_t A0, SourceInfo L) {
34661 if (!isActive()) return true;
34662 CurrentSource = L;
34663 return InitField<PT_IntAPS>(S, CodePtr(), A0);
34664}
34665bool EvalEmitter::emitInitFieldBool( uint32_t A0, SourceInfo L) {
34666 if (!isActive()) return true;
34667 CurrentSource = L;
34668 return InitField<PT_Bool>(S, CodePtr(), A0);
34669}
34670bool EvalEmitter::emitInitFieldFixedPoint( uint32_t A0, SourceInfo L) {
34671 if (!isActive()) return true;
34672 CurrentSource = L;
34673 return InitField<PT_FixedPoint>(S, CodePtr(), A0);
34674}
34675bool EvalEmitter::emitInitFieldPtr( uint32_t A0, SourceInfo L) {
34676 if (!isActive()) return true;
34677 CurrentSource = L;
34678 return InitField<PT_Ptr>(S, CodePtr(), A0);
34679}
34680bool EvalEmitter::emitInitFieldMemberPtr( uint32_t A0, SourceInfo L) {
34681 if (!isActive()) return true;
34682 CurrentSource = L;
34683 return InitField<PT_MemberPtr>(S, CodePtr(), A0);
34684}
34685bool EvalEmitter::emitInitFieldFloat( uint32_t A0, SourceInfo L) {
34686 if (!isActive()) return true;
34687 CurrentSource = L;
34688 return InitField<PT_Float>(S, CodePtr(), A0);
34689}
34690bool EvalEmitter::emitInitFieldReflect( uint32_t A0, SourceInfo L) {
34691 if (!isActive()) return true;
34692 CurrentSource = L;
34693 return InitField<PT_Reflect>(S, CodePtr(), A0);
34694}
34695#endif
34696#ifdef GET_OPCODE_NAMES
34697OP_InitFieldActivateSint8,
34698OP_InitFieldActivateUint8,
34699OP_InitFieldActivateSint16,
34700OP_InitFieldActivateUint16,
34701OP_InitFieldActivateSint32,
34702OP_InitFieldActivateUint32,
34703OP_InitFieldActivateSint64,
34704OP_InitFieldActivateUint64,
34705OP_InitFieldActivateIntAP,
34706OP_InitFieldActivateIntAPS,
34707OP_InitFieldActivateBool,
34708OP_InitFieldActivateFixedPoint,
34709OP_InitFieldActivatePtr,
34710OP_InitFieldActivateMemberPtr,
34711OP_InitFieldActivateFloat,
34712OP_InitFieldActivateReflect,
34713#endif
34714#ifdef GET_INTERPFN_LIST
34715&Interp_InitFieldActivateSint8,
34716&Interp_InitFieldActivateUint8,
34717&Interp_InitFieldActivateSint16,
34718&Interp_InitFieldActivateUint16,
34719&Interp_InitFieldActivateSint32,
34720&Interp_InitFieldActivateUint32,
34721&Interp_InitFieldActivateSint64,
34722&Interp_InitFieldActivateUint64,
34723&Interp_InitFieldActivateIntAP,
34724&Interp_InitFieldActivateIntAPS,
34725&Interp_InitFieldActivateBool,
34726&Interp_InitFieldActivateFixedPoint,
34727&Interp_InitFieldActivatePtr,
34728&Interp_InitFieldActivateMemberPtr,
34729&Interp_InitFieldActivateFloat,
34730&Interp_InitFieldActivateReflect,
34731#endif
34732#ifdef GET_INTERPFN_DISPATCHERS
34733PRESERVE_NONE
34734static bool Interp_InitFieldActivateSint8(InterpState &S) {
34735 {
34736 CodePtr OpPC = S.PC;
34737 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34738 if (!InitFieldActivate<PT_Sint8>(S, OpPC, V0)) return false;
34739 }
34740#if USE_TAILCALLS
34741 MUSTTAIL return InterpNext(S);
34742#else
34743 return true;
34744#endif
34745}
34746PRESERVE_NONE
34747static bool Interp_InitFieldActivateUint8(InterpState &S) {
34748 {
34749 CodePtr OpPC = S.PC;
34750 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34751 if (!InitFieldActivate<PT_Uint8>(S, OpPC, V0)) return false;
34752 }
34753#if USE_TAILCALLS
34754 MUSTTAIL return InterpNext(S);
34755#else
34756 return true;
34757#endif
34758}
34759PRESERVE_NONE
34760static bool Interp_InitFieldActivateSint16(InterpState &S) {
34761 {
34762 CodePtr OpPC = S.PC;
34763 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34764 if (!InitFieldActivate<PT_Sint16>(S, OpPC, V0)) return false;
34765 }
34766#if USE_TAILCALLS
34767 MUSTTAIL return InterpNext(S);
34768#else
34769 return true;
34770#endif
34771}
34772PRESERVE_NONE
34773static bool Interp_InitFieldActivateUint16(InterpState &S) {
34774 {
34775 CodePtr OpPC = S.PC;
34776 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34777 if (!InitFieldActivate<PT_Uint16>(S, OpPC, V0)) return false;
34778 }
34779#if USE_TAILCALLS
34780 MUSTTAIL return InterpNext(S);
34781#else
34782 return true;
34783#endif
34784}
34785PRESERVE_NONE
34786static bool Interp_InitFieldActivateSint32(InterpState &S) {
34787 {
34788 CodePtr OpPC = S.PC;
34789 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34790 if (!InitFieldActivate<PT_Sint32>(S, OpPC, V0)) return false;
34791 }
34792#if USE_TAILCALLS
34793 MUSTTAIL return InterpNext(S);
34794#else
34795 return true;
34796#endif
34797}
34798PRESERVE_NONE
34799static bool Interp_InitFieldActivateUint32(InterpState &S) {
34800 {
34801 CodePtr OpPC = S.PC;
34802 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34803 if (!InitFieldActivate<PT_Uint32>(S, OpPC, V0)) return false;
34804 }
34805#if USE_TAILCALLS
34806 MUSTTAIL return InterpNext(S);
34807#else
34808 return true;
34809#endif
34810}
34811PRESERVE_NONE
34812static bool Interp_InitFieldActivateSint64(InterpState &S) {
34813 {
34814 CodePtr OpPC = S.PC;
34815 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34816 if (!InitFieldActivate<PT_Sint64>(S, OpPC, V0)) return false;
34817 }
34818#if USE_TAILCALLS
34819 MUSTTAIL return InterpNext(S);
34820#else
34821 return true;
34822#endif
34823}
34824PRESERVE_NONE
34825static bool Interp_InitFieldActivateUint64(InterpState &S) {
34826 {
34827 CodePtr OpPC = S.PC;
34828 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34829 if (!InitFieldActivate<PT_Uint64>(S, OpPC, V0)) return false;
34830 }
34831#if USE_TAILCALLS
34832 MUSTTAIL return InterpNext(S);
34833#else
34834 return true;
34835#endif
34836}
34837PRESERVE_NONE
34838static bool Interp_InitFieldActivateIntAP(InterpState &S) {
34839 {
34840 CodePtr OpPC = S.PC;
34841 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34842 if (!InitFieldActivate<PT_IntAP>(S, OpPC, V0)) return false;
34843 }
34844#if USE_TAILCALLS
34845 MUSTTAIL return InterpNext(S);
34846#else
34847 return true;
34848#endif
34849}
34850PRESERVE_NONE
34851static bool Interp_InitFieldActivateIntAPS(InterpState &S) {
34852 {
34853 CodePtr OpPC = S.PC;
34854 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34855 if (!InitFieldActivate<PT_IntAPS>(S, OpPC, V0)) return false;
34856 }
34857#if USE_TAILCALLS
34858 MUSTTAIL return InterpNext(S);
34859#else
34860 return true;
34861#endif
34862}
34863PRESERVE_NONE
34864static bool Interp_InitFieldActivateBool(InterpState &S) {
34865 {
34866 CodePtr OpPC = S.PC;
34867 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34868 if (!InitFieldActivate<PT_Bool>(S, OpPC, V0)) return false;
34869 }
34870#if USE_TAILCALLS
34871 MUSTTAIL return InterpNext(S);
34872#else
34873 return true;
34874#endif
34875}
34876PRESERVE_NONE
34877static bool Interp_InitFieldActivateFixedPoint(InterpState &S) {
34878 {
34879 CodePtr OpPC = S.PC;
34880 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34881 if (!InitFieldActivate<PT_FixedPoint>(S, OpPC, V0)) return false;
34882 }
34883#if USE_TAILCALLS
34884 MUSTTAIL return InterpNext(S);
34885#else
34886 return true;
34887#endif
34888}
34889PRESERVE_NONE
34890static bool Interp_InitFieldActivatePtr(InterpState &S) {
34891 {
34892 CodePtr OpPC = S.PC;
34893 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34894 if (!InitFieldActivate<PT_Ptr>(S, OpPC, V0)) return false;
34895 }
34896#if USE_TAILCALLS
34897 MUSTTAIL return InterpNext(S);
34898#else
34899 return true;
34900#endif
34901}
34902PRESERVE_NONE
34903static bool Interp_InitFieldActivateMemberPtr(InterpState &S) {
34904 {
34905 CodePtr OpPC = S.PC;
34906 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34907 if (!InitFieldActivate<PT_MemberPtr>(S, OpPC, V0)) return false;
34908 }
34909#if USE_TAILCALLS
34910 MUSTTAIL return InterpNext(S);
34911#else
34912 return true;
34913#endif
34914}
34915PRESERVE_NONE
34916static bool Interp_InitFieldActivateFloat(InterpState &S) {
34917 {
34918 CodePtr OpPC = S.PC;
34919 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34920 if (!InitFieldActivate<PT_Float>(S, OpPC, V0)) return false;
34921 }
34922#if USE_TAILCALLS
34923 MUSTTAIL return InterpNext(S);
34924#else
34925 return true;
34926#endif
34927}
34928PRESERVE_NONE
34929static bool Interp_InitFieldActivateReflect(InterpState &S) {
34930 {
34931 CodePtr OpPC = S.PC;
34932 const auto V0 = ReadArg<uint32_t>(S, S.PC);
34933 if (!InitFieldActivate<PT_Reflect>(S, OpPC, V0)) return false;
34934 }
34935#if USE_TAILCALLS
34936 MUSTTAIL return InterpNext(S);
34937#else
34938 return true;
34939#endif
34940}
34941#endif
34942#ifdef GET_DISASM
34943case OP_InitFieldActivateSint8:
34944 Text.Op = PrintName("InitFieldActivateSint8");
34945 Text.Args.push_back(printArg<uint32_t>(PC));
34946 break;
34947case OP_InitFieldActivateUint8:
34948 Text.Op = PrintName("InitFieldActivateUint8");
34949 Text.Args.push_back(printArg<uint32_t>(PC));
34950 break;
34951case OP_InitFieldActivateSint16:
34952 Text.Op = PrintName("InitFieldActivateSint16");
34953 Text.Args.push_back(printArg<uint32_t>(PC));
34954 break;
34955case OP_InitFieldActivateUint16:
34956 Text.Op = PrintName("InitFieldActivateUint16");
34957 Text.Args.push_back(printArg<uint32_t>(PC));
34958 break;
34959case OP_InitFieldActivateSint32:
34960 Text.Op = PrintName("InitFieldActivateSint32");
34961 Text.Args.push_back(printArg<uint32_t>(PC));
34962 break;
34963case OP_InitFieldActivateUint32:
34964 Text.Op = PrintName("InitFieldActivateUint32");
34965 Text.Args.push_back(printArg<uint32_t>(PC));
34966 break;
34967case OP_InitFieldActivateSint64:
34968 Text.Op = PrintName("InitFieldActivateSint64");
34969 Text.Args.push_back(printArg<uint32_t>(PC));
34970 break;
34971case OP_InitFieldActivateUint64:
34972 Text.Op = PrintName("InitFieldActivateUint64");
34973 Text.Args.push_back(printArg<uint32_t>(PC));
34974 break;
34975case OP_InitFieldActivateIntAP:
34976 Text.Op = PrintName("InitFieldActivateIntAP");
34977 Text.Args.push_back(printArg<uint32_t>(PC));
34978 break;
34979case OP_InitFieldActivateIntAPS:
34980 Text.Op = PrintName("InitFieldActivateIntAPS");
34981 Text.Args.push_back(printArg<uint32_t>(PC));
34982 break;
34983case OP_InitFieldActivateBool:
34984 Text.Op = PrintName("InitFieldActivateBool");
34985 Text.Args.push_back(printArg<uint32_t>(PC));
34986 break;
34987case OP_InitFieldActivateFixedPoint:
34988 Text.Op = PrintName("InitFieldActivateFixedPoint");
34989 Text.Args.push_back(printArg<uint32_t>(PC));
34990 break;
34991case OP_InitFieldActivatePtr:
34992 Text.Op = PrintName("InitFieldActivatePtr");
34993 Text.Args.push_back(printArg<uint32_t>(PC));
34994 break;
34995case OP_InitFieldActivateMemberPtr:
34996 Text.Op = PrintName("InitFieldActivateMemberPtr");
34997 Text.Args.push_back(printArg<uint32_t>(PC));
34998 break;
34999case OP_InitFieldActivateFloat:
35000 Text.Op = PrintName("InitFieldActivateFloat");
35001 Text.Args.push_back(printArg<uint32_t>(PC));
35002 break;
35003case OP_InitFieldActivateReflect:
35004 Text.Op = PrintName("InitFieldActivateReflect");
35005 Text.Args.push_back(printArg<uint32_t>(PC));
35006 break;
35007#endif
35008#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
35009bool emitInitFieldActivateSint8( uint32_t , SourceInfo);
35010bool emitInitFieldActivateUint8( uint32_t , SourceInfo);
35011bool emitInitFieldActivateSint16( uint32_t , SourceInfo);
35012bool emitInitFieldActivateUint16( uint32_t , SourceInfo);
35013bool emitInitFieldActivateSint32( uint32_t , SourceInfo);
35014bool emitInitFieldActivateUint32( uint32_t , SourceInfo);
35015bool emitInitFieldActivateSint64( uint32_t , SourceInfo);
35016bool emitInitFieldActivateUint64( uint32_t , SourceInfo);
35017bool emitInitFieldActivateIntAP( uint32_t , SourceInfo);
35018bool emitInitFieldActivateIntAPS( uint32_t , SourceInfo);
35019bool emitInitFieldActivateBool( uint32_t , SourceInfo);
35020bool emitInitFieldActivateFixedPoint( uint32_t , SourceInfo);
35021bool emitInitFieldActivatePtr( uint32_t , SourceInfo);
35022bool emitInitFieldActivateMemberPtr( uint32_t , SourceInfo);
35023bool emitInitFieldActivateFloat( uint32_t , SourceInfo);
35024bool emitInitFieldActivateReflect( uint32_t , SourceInfo);
35025#endif
35026#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
35027[[nodiscard]] bool emitInitFieldActivate(PrimType, uint32_t, SourceInfo I);
35028#endif
35029#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
35030bool
35031#if defined(GET_EVAL_IMPL)
35032EvalEmitter
35033#else
35034ByteCodeEmitter
35035#endif
35036::emitInitFieldActivate(PrimType T0, uint32_t A0, SourceInfo I) {
35037 switch (T0) {
35038 case PT_Sint8:
35039 return emitInitFieldActivateSint8(A0, I);
35040 case PT_Uint8:
35041 return emitInitFieldActivateUint8(A0, I);
35042 case PT_Sint16:
35043 return emitInitFieldActivateSint16(A0, I);
35044 case PT_Uint16:
35045 return emitInitFieldActivateUint16(A0, I);
35046 case PT_Sint32:
35047 return emitInitFieldActivateSint32(A0, I);
35048 case PT_Uint32:
35049 return emitInitFieldActivateUint32(A0, I);
35050 case PT_Sint64:
35051 return emitInitFieldActivateSint64(A0, I);
35052 case PT_Uint64:
35053 return emitInitFieldActivateUint64(A0, I);
35054 case PT_IntAP:
35055 return emitInitFieldActivateIntAP(A0, I);
35056 case PT_IntAPS:
35057 return emitInitFieldActivateIntAPS(A0, I);
35058 case PT_Bool:
35059 return emitInitFieldActivateBool(A0, I);
35060 case PT_FixedPoint:
35061 return emitInitFieldActivateFixedPoint(A0, I);
35062 case PT_Ptr:
35063 return emitInitFieldActivatePtr(A0, I);
35064 case PT_MemberPtr:
35065 return emitInitFieldActivateMemberPtr(A0, I);
35066 case PT_Float:
35067 return emitInitFieldActivateFloat(A0, I);
35068 case PT_Reflect:
35069 return emitInitFieldActivateReflect(A0, I);
35070 }
35071 llvm_unreachable("invalid enum value");
35072}
35073#endif
35074#ifdef GET_LINK_IMPL
35075bool ByteCodeEmitter::emitInitFieldActivateSint8( uint32_t A0, SourceInfo L) {
35076 return emitOp<uint32_t>(OP_InitFieldActivateSint8, A0, L);
35077}
35078bool ByteCodeEmitter::emitInitFieldActivateUint8( uint32_t A0, SourceInfo L) {
35079 return emitOp<uint32_t>(OP_InitFieldActivateUint8, A0, L);
35080}
35081bool ByteCodeEmitter::emitInitFieldActivateSint16( uint32_t A0, SourceInfo L) {
35082 return emitOp<uint32_t>(OP_InitFieldActivateSint16, A0, L);
35083}
35084bool ByteCodeEmitter::emitInitFieldActivateUint16( uint32_t A0, SourceInfo L) {
35085 return emitOp<uint32_t>(OP_InitFieldActivateUint16, A0, L);
35086}
35087bool ByteCodeEmitter::emitInitFieldActivateSint32( uint32_t A0, SourceInfo L) {
35088 return emitOp<uint32_t>(OP_InitFieldActivateSint32, A0, L);
35089}
35090bool ByteCodeEmitter::emitInitFieldActivateUint32( uint32_t A0, SourceInfo L) {
35091 return emitOp<uint32_t>(OP_InitFieldActivateUint32, A0, L);
35092}
35093bool ByteCodeEmitter::emitInitFieldActivateSint64( uint32_t A0, SourceInfo L) {
35094 return emitOp<uint32_t>(OP_InitFieldActivateSint64, A0, L);
35095}
35096bool ByteCodeEmitter::emitInitFieldActivateUint64( uint32_t A0, SourceInfo L) {
35097 return emitOp<uint32_t>(OP_InitFieldActivateUint64, A0, L);
35098}
35099bool ByteCodeEmitter::emitInitFieldActivateIntAP( uint32_t A0, SourceInfo L) {
35100 return emitOp<uint32_t>(OP_InitFieldActivateIntAP, A0, L);
35101}
35102bool ByteCodeEmitter::emitInitFieldActivateIntAPS( uint32_t A0, SourceInfo L) {
35103 return emitOp<uint32_t>(OP_InitFieldActivateIntAPS, A0, L);
35104}
35105bool ByteCodeEmitter::emitInitFieldActivateBool( uint32_t A0, SourceInfo L) {
35106 return emitOp<uint32_t>(OP_InitFieldActivateBool, A0, L);
35107}
35108bool ByteCodeEmitter::emitInitFieldActivateFixedPoint( uint32_t A0, SourceInfo L) {
35109 return emitOp<uint32_t>(OP_InitFieldActivateFixedPoint, A0, L);
35110}
35111bool ByteCodeEmitter::emitInitFieldActivatePtr( uint32_t A0, SourceInfo L) {
35112 return emitOp<uint32_t>(OP_InitFieldActivatePtr, A0, L);
35113}
35114bool ByteCodeEmitter::emitInitFieldActivateMemberPtr( uint32_t A0, SourceInfo L) {
35115 return emitOp<uint32_t>(OP_InitFieldActivateMemberPtr, A0, L);
35116}
35117bool ByteCodeEmitter::emitInitFieldActivateFloat( uint32_t A0, SourceInfo L) {
35118 return emitOp<uint32_t>(OP_InitFieldActivateFloat, A0, L);
35119}
35120bool ByteCodeEmitter::emitInitFieldActivateReflect( uint32_t A0, SourceInfo L) {
35121 return emitOp<uint32_t>(OP_InitFieldActivateReflect, A0, L);
35122}
35123#endif
35124#ifdef GET_EVAL_IMPL
35125bool EvalEmitter::emitInitFieldActivateSint8( uint32_t A0, SourceInfo L) {
35126 if (!isActive()) return true;
35127 CurrentSource = L;
35128 return InitFieldActivate<PT_Sint8>(S, CodePtr(), A0);
35129}
35130bool EvalEmitter::emitInitFieldActivateUint8( uint32_t A0, SourceInfo L) {
35131 if (!isActive()) return true;
35132 CurrentSource = L;
35133 return InitFieldActivate<PT_Uint8>(S, CodePtr(), A0);
35134}
35135bool EvalEmitter::emitInitFieldActivateSint16( uint32_t A0, SourceInfo L) {
35136 if (!isActive()) return true;
35137 CurrentSource = L;
35138 return InitFieldActivate<PT_Sint16>(S, CodePtr(), A0);
35139}
35140bool EvalEmitter::emitInitFieldActivateUint16( uint32_t A0, SourceInfo L) {
35141 if (!isActive()) return true;
35142 CurrentSource = L;
35143 return InitFieldActivate<PT_Uint16>(S, CodePtr(), A0);
35144}
35145bool EvalEmitter::emitInitFieldActivateSint32( uint32_t A0, SourceInfo L) {
35146 if (!isActive()) return true;
35147 CurrentSource = L;
35148 return InitFieldActivate<PT_Sint32>(S, CodePtr(), A0);
35149}
35150bool EvalEmitter::emitInitFieldActivateUint32( uint32_t A0, SourceInfo L) {
35151 if (!isActive()) return true;
35152 CurrentSource = L;
35153 return InitFieldActivate<PT_Uint32>(S, CodePtr(), A0);
35154}
35155bool EvalEmitter::emitInitFieldActivateSint64( uint32_t A0, SourceInfo L) {
35156 if (!isActive()) return true;
35157 CurrentSource = L;
35158 return InitFieldActivate<PT_Sint64>(S, CodePtr(), A0);
35159}
35160bool EvalEmitter::emitInitFieldActivateUint64( uint32_t A0, SourceInfo L) {
35161 if (!isActive()) return true;
35162 CurrentSource = L;
35163 return InitFieldActivate<PT_Uint64>(S, CodePtr(), A0);
35164}
35165bool EvalEmitter::emitInitFieldActivateIntAP( uint32_t A0, SourceInfo L) {
35166 if (!isActive()) return true;
35167 CurrentSource = L;
35168 return InitFieldActivate<PT_IntAP>(S, CodePtr(), A0);
35169}
35170bool EvalEmitter::emitInitFieldActivateIntAPS( uint32_t A0, SourceInfo L) {
35171 if (!isActive()) return true;
35172 CurrentSource = L;
35173 return InitFieldActivate<PT_IntAPS>(S, CodePtr(), A0);
35174}
35175bool EvalEmitter::emitInitFieldActivateBool( uint32_t A0, SourceInfo L) {
35176 if (!isActive()) return true;
35177 CurrentSource = L;
35178 return InitFieldActivate<PT_Bool>(S, CodePtr(), A0);
35179}
35180bool EvalEmitter::emitInitFieldActivateFixedPoint( uint32_t A0, SourceInfo L) {
35181 if (!isActive()) return true;
35182 CurrentSource = L;
35183 return InitFieldActivate<PT_FixedPoint>(S, CodePtr(), A0);
35184}
35185bool EvalEmitter::emitInitFieldActivatePtr( uint32_t A0, SourceInfo L) {
35186 if (!isActive()) return true;
35187 CurrentSource = L;
35188 return InitFieldActivate<PT_Ptr>(S, CodePtr(), A0);
35189}
35190bool EvalEmitter::emitInitFieldActivateMemberPtr( uint32_t A0, SourceInfo L) {
35191 if (!isActive()) return true;
35192 CurrentSource = L;
35193 return InitFieldActivate<PT_MemberPtr>(S, CodePtr(), A0);
35194}
35195bool EvalEmitter::emitInitFieldActivateFloat( uint32_t A0, SourceInfo L) {
35196 if (!isActive()) return true;
35197 CurrentSource = L;
35198 return InitFieldActivate<PT_Float>(S, CodePtr(), A0);
35199}
35200bool EvalEmitter::emitInitFieldActivateReflect( uint32_t A0, SourceInfo L) {
35201 if (!isActive()) return true;
35202 CurrentSource = L;
35203 return InitFieldActivate<PT_Reflect>(S, CodePtr(), A0);
35204}
35205#endif
35206#ifdef GET_OPCODE_NAMES
35207OP_InitGlobalSint8,
35208OP_InitGlobalUint8,
35209OP_InitGlobalSint16,
35210OP_InitGlobalUint16,
35211OP_InitGlobalSint32,
35212OP_InitGlobalUint32,
35213OP_InitGlobalSint64,
35214OP_InitGlobalUint64,
35215OP_InitGlobalIntAP,
35216OP_InitGlobalIntAPS,
35217OP_InitGlobalBool,
35218OP_InitGlobalFixedPoint,
35219OP_InitGlobalPtr,
35220OP_InitGlobalMemberPtr,
35221OP_InitGlobalFloat,
35222OP_InitGlobalReflect,
35223#endif
35224#ifdef GET_INTERPFN_LIST
35225&Interp_InitGlobalSint8,
35226&Interp_InitGlobalUint8,
35227&Interp_InitGlobalSint16,
35228&Interp_InitGlobalUint16,
35229&Interp_InitGlobalSint32,
35230&Interp_InitGlobalUint32,
35231&Interp_InitGlobalSint64,
35232&Interp_InitGlobalUint64,
35233&Interp_InitGlobalIntAP,
35234&Interp_InitGlobalIntAPS,
35235&Interp_InitGlobalBool,
35236&Interp_InitGlobalFixedPoint,
35237&Interp_InitGlobalPtr,
35238&Interp_InitGlobalMemberPtr,
35239&Interp_InitGlobalFloat,
35240&Interp_InitGlobalReflect,
35241#endif
35242#ifdef GET_INTERPFN_DISPATCHERS
35243PRESERVE_NONE
35244static bool Interp_InitGlobalSint8(InterpState &S) {
35245 {
35246 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35247 InitGlobal<PT_Sint8>(S, V0);
35248 }
35249#if USE_TAILCALLS
35250 MUSTTAIL return InterpNext(S);
35251#else
35252 return true;
35253#endif
35254}
35255PRESERVE_NONE
35256static bool Interp_InitGlobalUint8(InterpState &S) {
35257 {
35258 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35259 InitGlobal<PT_Uint8>(S, V0);
35260 }
35261#if USE_TAILCALLS
35262 MUSTTAIL return InterpNext(S);
35263#else
35264 return true;
35265#endif
35266}
35267PRESERVE_NONE
35268static bool Interp_InitGlobalSint16(InterpState &S) {
35269 {
35270 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35271 InitGlobal<PT_Sint16>(S, V0);
35272 }
35273#if USE_TAILCALLS
35274 MUSTTAIL return InterpNext(S);
35275#else
35276 return true;
35277#endif
35278}
35279PRESERVE_NONE
35280static bool Interp_InitGlobalUint16(InterpState &S) {
35281 {
35282 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35283 InitGlobal<PT_Uint16>(S, V0);
35284 }
35285#if USE_TAILCALLS
35286 MUSTTAIL return InterpNext(S);
35287#else
35288 return true;
35289#endif
35290}
35291PRESERVE_NONE
35292static bool Interp_InitGlobalSint32(InterpState &S) {
35293 {
35294 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35295 InitGlobal<PT_Sint32>(S, V0);
35296 }
35297#if USE_TAILCALLS
35298 MUSTTAIL return InterpNext(S);
35299#else
35300 return true;
35301#endif
35302}
35303PRESERVE_NONE
35304static bool Interp_InitGlobalUint32(InterpState &S) {
35305 {
35306 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35307 InitGlobal<PT_Uint32>(S, V0);
35308 }
35309#if USE_TAILCALLS
35310 MUSTTAIL return InterpNext(S);
35311#else
35312 return true;
35313#endif
35314}
35315PRESERVE_NONE
35316static bool Interp_InitGlobalSint64(InterpState &S) {
35317 {
35318 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35319 InitGlobal<PT_Sint64>(S, V0);
35320 }
35321#if USE_TAILCALLS
35322 MUSTTAIL return InterpNext(S);
35323#else
35324 return true;
35325#endif
35326}
35327PRESERVE_NONE
35328static bool Interp_InitGlobalUint64(InterpState &S) {
35329 {
35330 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35331 InitGlobal<PT_Uint64>(S, V0);
35332 }
35333#if USE_TAILCALLS
35334 MUSTTAIL return InterpNext(S);
35335#else
35336 return true;
35337#endif
35338}
35339PRESERVE_NONE
35340static bool Interp_InitGlobalIntAP(InterpState &S) {
35341 {
35342 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35343 InitGlobal<PT_IntAP>(S, V0);
35344 }
35345#if USE_TAILCALLS
35346 MUSTTAIL return InterpNext(S);
35347#else
35348 return true;
35349#endif
35350}
35351PRESERVE_NONE
35352static bool Interp_InitGlobalIntAPS(InterpState &S) {
35353 {
35354 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35355 InitGlobal<PT_IntAPS>(S, V0);
35356 }
35357#if USE_TAILCALLS
35358 MUSTTAIL return InterpNext(S);
35359#else
35360 return true;
35361#endif
35362}
35363PRESERVE_NONE
35364static bool Interp_InitGlobalBool(InterpState &S) {
35365 {
35366 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35367 InitGlobal<PT_Bool>(S, V0);
35368 }
35369#if USE_TAILCALLS
35370 MUSTTAIL return InterpNext(S);
35371#else
35372 return true;
35373#endif
35374}
35375PRESERVE_NONE
35376static bool Interp_InitGlobalFixedPoint(InterpState &S) {
35377 {
35378 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35379 InitGlobal<PT_FixedPoint>(S, V0);
35380 }
35381#if USE_TAILCALLS
35382 MUSTTAIL return InterpNext(S);
35383#else
35384 return true;
35385#endif
35386}
35387PRESERVE_NONE
35388static bool Interp_InitGlobalPtr(InterpState &S) {
35389 {
35390 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35391 InitGlobal<PT_Ptr>(S, V0);
35392 }
35393#if USE_TAILCALLS
35394 MUSTTAIL return InterpNext(S);
35395#else
35396 return true;
35397#endif
35398}
35399PRESERVE_NONE
35400static bool Interp_InitGlobalMemberPtr(InterpState &S) {
35401 {
35402 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35403 InitGlobal<PT_MemberPtr>(S, V0);
35404 }
35405#if USE_TAILCALLS
35406 MUSTTAIL return InterpNext(S);
35407#else
35408 return true;
35409#endif
35410}
35411PRESERVE_NONE
35412static bool Interp_InitGlobalFloat(InterpState &S) {
35413 {
35414 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35415 InitGlobal<PT_Float>(S, V0);
35416 }
35417#if USE_TAILCALLS
35418 MUSTTAIL return InterpNext(S);
35419#else
35420 return true;
35421#endif
35422}
35423PRESERVE_NONE
35424static bool Interp_InitGlobalReflect(InterpState &S) {
35425 {
35426 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35427 InitGlobal<PT_Reflect>(S, V0);
35428 }
35429#if USE_TAILCALLS
35430 MUSTTAIL return InterpNext(S);
35431#else
35432 return true;
35433#endif
35434}
35435#endif
35436#ifdef GET_DISASM
35437case OP_InitGlobalSint8:
35438 Text.Op = PrintName("InitGlobalSint8");
35439 Text.Args.push_back(printArg<uint32_t>(PC));
35440 break;
35441case OP_InitGlobalUint8:
35442 Text.Op = PrintName("InitGlobalUint8");
35443 Text.Args.push_back(printArg<uint32_t>(PC));
35444 break;
35445case OP_InitGlobalSint16:
35446 Text.Op = PrintName("InitGlobalSint16");
35447 Text.Args.push_back(printArg<uint32_t>(PC));
35448 break;
35449case OP_InitGlobalUint16:
35450 Text.Op = PrintName("InitGlobalUint16");
35451 Text.Args.push_back(printArg<uint32_t>(PC));
35452 break;
35453case OP_InitGlobalSint32:
35454 Text.Op = PrintName("InitGlobalSint32");
35455 Text.Args.push_back(printArg<uint32_t>(PC));
35456 break;
35457case OP_InitGlobalUint32:
35458 Text.Op = PrintName("InitGlobalUint32");
35459 Text.Args.push_back(printArg<uint32_t>(PC));
35460 break;
35461case OP_InitGlobalSint64:
35462 Text.Op = PrintName("InitGlobalSint64");
35463 Text.Args.push_back(printArg<uint32_t>(PC));
35464 break;
35465case OP_InitGlobalUint64:
35466 Text.Op = PrintName("InitGlobalUint64");
35467 Text.Args.push_back(printArg<uint32_t>(PC));
35468 break;
35469case OP_InitGlobalIntAP:
35470 Text.Op = PrintName("InitGlobalIntAP");
35471 Text.Args.push_back(printArg<uint32_t>(PC));
35472 break;
35473case OP_InitGlobalIntAPS:
35474 Text.Op = PrintName("InitGlobalIntAPS");
35475 Text.Args.push_back(printArg<uint32_t>(PC));
35476 break;
35477case OP_InitGlobalBool:
35478 Text.Op = PrintName("InitGlobalBool");
35479 Text.Args.push_back(printArg<uint32_t>(PC));
35480 break;
35481case OP_InitGlobalFixedPoint:
35482 Text.Op = PrintName("InitGlobalFixedPoint");
35483 Text.Args.push_back(printArg<uint32_t>(PC));
35484 break;
35485case OP_InitGlobalPtr:
35486 Text.Op = PrintName("InitGlobalPtr");
35487 Text.Args.push_back(printArg<uint32_t>(PC));
35488 break;
35489case OP_InitGlobalMemberPtr:
35490 Text.Op = PrintName("InitGlobalMemberPtr");
35491 Text.Args.push_back(printArg<uint32_t>(PC));
35492 break;
35493case OP_InitGlobalFloat:
35494 Text.Op = PrintName("InitGlobalFloat");
35495 Text.Args.push_back(printArg<uint32_t>(PC));
35496 break;
35497case OP_InitGlobalReflect:
35498 Text.Op = PrintName("InitGlobalReflect");
35499 Text.Args.push_back(printArg<uint32_t>(PC));
35500 break;
35501#endif
35502#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
35503bool emitInitGlobalSint8( uint32_t , SourceInfo);
35504bool emitInitGlobalUint8( uint32_t , SourceInfo);
35505bool emitInitGlobalSint16( uint32_t , SourceInfo);
35506bool emitInitGlobalUint16( uint32_t , SourceInfo);
35507bool emitInitGlobalSint32( uint32_t , SourceInfo);
35508bool emitInitGlobalUint32( uint32_t , SourceInfo);
35509bool emitInitGlobalSint64( uint32_t , SourceInfo);
35510bool emitInitGlobalUint64( uint32_t , SourceInfo);
35511bool emitInitGlobalIntAP( uint32_t , SourceInfo);
35512bool emitInitGlobalIntAPS( uint32_t , SourceInfo);
35513bool emitInitGlobalBool( uint32_t , SourceInfo);
35514bool emitInitGlobalFixedPoint( uint32_t , SourceInfo);
35515bool emitInitGlobalPtr( uint32_t , SourceInfo);
35516bool emitInitGlobalMemberPtr( uint32_t , SourceInfo);
35517bool emitInitGlobalFloat( uint32_t , SourceInfo);
35518bool emitInitGlobalReflect( uint32_t , SourceInfo);
35519#endif
35520#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
35521[[nodiscard]] bool emitInitGlobal(PrimType, uint32_t, SourceInfo I);
35522#endif
35523#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
35524bool
35525#if defined(GET_EVAL_IMPL)
35526EvalEmitter
35527#else
35528ByteCodeEmitter
35529#endif
35530::emitInitGlobal(PrimType T0, uint32_t A0, SourceInfo I) {
35531 switch (T0) {
35532 case PT_Sint8:
35533 return emitInitGlobalSint8(A0, I);
35534 case PT_Uint8:
35535 return emitInitGlobalUint8(A0, I);
35536 case PT_Sint16:
35537 return emitInitGlobalSint16(A0, I);
35538 case PT_Uint16:
35539 return emitInitGlobalUint16(A0, I);
35540 case PT_Sint32:
35541 return emitInitGlobalSint32(A0, I);
35542 case PT_Uint32:
35543 return emitInitGlobalUint32(A0, I);
35544 case PT_Sint64:
35545 return emitInitGlobalSint64(A0, I);
35546 case PT_Uint64:
35547 return emitInitGlobalUint64(A0, I);
35548 case PT_IntAP:
35549 return emitInitGlobalIntAP(A0, I);
35550 case PT_IntAPS:
35551 return emitInitGlobalIntAPS(A0, I);
35552 case PT_Bool:
35553 return emitInitGlobalBool(A0, I);
35554 case PT_FixedPoint:
35555 return emitInitGlobalFixedPoint(A0, I);
35556 case PT_Ptr:
35557 return emitInitGlobalPtr(A0, I);
35558 case PT_MemberPtr:
35559 return emitInitGlobalMemberPtr(A0, I);
35560 case PT_Float:
35561 return emitInitGlobalFloat(A0, I);
35562 case PT_Reflect:
35563 return emitInitGlobalReflect(A0, I);
35564 }
35565 llvm_unreachable("invalid enum value");
35566}
35567#endif
35568#ifdef GET_LINK_IMPL
35569bool ByteCodeEmitter::emitInitGlobalSint8( uint32_t A0, SourceInfo L) {
35570 return emitOp<uint32_t>(OP_InitGlobalSint8, A0, L);
35571}
35572bool ByteCodeEmitter::emitInitGlobalUint8( uint32_t A0, SourceInfo L) {
35573 return emitOp<uint32_t>(OP_InitGlobalUint8, A0, L);
35574}
35575bool ByteCodeEmitter::emitInitGlobalSint16( uint32_t A0, SourceInfo L) {
35576 return emitOp<uint32_t>(OP_InitGlobalSint16, A0, L);
35577}
35578bool ByteCodeEmitter::emitInitGlobalUint16( uint32_t A0, SourceInfo L) {
35579 return emitOp<uint32_t>(OP_InitGlobalUint16, A0, L);
35580}
35581bool ByteCodeEmitter::emitInitGlobalSint32( uint32_t A0, SourceInfo L) {
35582 return emitOp<uint32_t>(OP_InitGlobalSint32, A0, L);
35583}
35584bool ByteCodeEmitter::emitInitGlobalUint32( uint32_t A0, SourceInfo L) {
35585 return emitOp<uint32_t>(OP_InitGlobalUint32, A0, L);
35586}
35587bool ByteCodeEmitter::emitInitGlobalSint64( uint32_t A0, SourceInfo L) {
35588 return emitOp<uint32_t>(OP_InitGlobalSint64, A0, L);
35589}
35590bool ByteCodeEmitter::emitInitGlobalUint64( uint32_t A0, SourceInfo L) {
35591 return emitOp<uint32_t>(OP_InitGlobalUint64, A0, L);
35592}
35593bool ByteCodeEmitter::emitInitGlobalIntAP( uint32_t A0, SourceInfo L) {
35594 return emitOp<uint32_t>(OP_InitGlobalIntAP, A0, L);
35595}
35596bool ByteCodeEmitter::emitInitGlobalIntAPS( uint32_t A0, SourceInfo L) {
35597 return emitOp<uint32_t>(OP_InitGlobalIntAPS, A0, L);
35598}
35599bool ByteCodeEmitter::emitInitGlobalBool( uint32_t A0, SourceInfo L) {
35600 return emitOp<uint32_t>(OP_InitGlobalBool, A0, L);
35601}
35602bool ByteCodeEmitter::emitInitGlobalFixedPoint( uint32_t A0, SourceInfo L) {
35603 return emitOp<uint32_t>(OP_InitGlobalFixedPoint, A0, L);
35604}
35605bool ByteCodeEmitter::emitInitGlobalPtr( uint32_t A0, SourceInfo L) {
35606 return emitOp<uint32_t>(OP_InitGlobalPtr, A0, L);
35607}
35608bool ByteCodeEmitter::emitInitGlobalMemberPtr( uint32_t A0, SourceInfo L) {
35609 return emitOp<uint32_t>(OP_InitGlobalMemberPtr, A0, L);
35610}
35611bool ByteCodeEmitter::emitInitGlobalFloat( uint32_t A0, SourceInfo L) {
35612 return emitOp<uint32_t>(OP_InitGlobalFloat, A0, L);
35613}
35614bool ByteCodeEmitter::emitInitGlobalReflect( uint32_t A0, SourceInfo L) {
35615 return emitOp<uint32_t>(OP_InitGlobalReflect, A0, L);
35616}
35617#endif
35618#ifdef GET_EVAL_IMPL
35619bool EvalEmitter::emitInitGlobalSint8( uint32_t A0, SourceInfo L) {
35620 if (!isActive()) return true;
35621 CurrentSource = L;
35622 return InitGlobal<PT_Sint8>(S, A0);
35623}
35624bool EvalEmitter::emitInitGlobalUint8( uint32_t A0, SourceInfo L) {
35625 if (!isActive()) return true;
35626 CurrentSource = L;
35627 return InitGlobal<PT_Uint8>(S, A0);
35628}
35629bool EvalEmitter::emitInitGlobalSint16( uint32_t A0, SourceInfo L) {
35630 if (!isActive()) return true;
35631 CurrentSource = L;
35632 return InitGlobal<PT_Sint16>(S, A0);
35633}
35634bool EvalEmitter::emitInitGlobalUint16( uint32_t A0, SourceInfo L) {
35635 if (!isActive()) return true;
35636 CurrentSource = L;
35637 return InitGlobal<PT_Uint16>(S, A0);
35638}
35639bool EvalEmitter::emitInitGlobalSint32( uint32_t A0, SourceInfo L) {
35640 if (!isActive()) return true;
35641 CurrentSource = L;
35642 return InitGlobal<PT_Sint32>(S, A0);
35643}
35644bool EvalEmitter::emitInitGlobalUint32( uint32_t A0, SourceInfo L) {
35645 if (!isActive()) return true;
35646 CurrentSource = L;
35647 return InitGlobal<PT_Uint32>(S, A0);
35648}
35649bool EvalEmitter::emitInitGlobalSint64( uint32_t A0, SourceInfo L) {
35650 if (!isActive()) return true;
35651 CurrentSource = L;
35652 return InitGlobal<PT_Sint64>(S, A0);
35653}
35654bool EvalEmitter::emitInitGlobalUint64( uint32_t A0, SourceInfo L) {
35655 if (!isActive()) return true;
35656 CurrentSource = L;
35657 return InitGlobal<PT_Uint64>(S, A0);
35658}
35659bool EvalEmitter::emitInitGlobalIntAP( uint32_t A0, SourceInfo L) {
35660 if (!isActive()) return true;
35661 CurrentSource = L;
35662 return InitGlobal<PT_IntAP>(S, A0);
35663}
35664bool EvalEmitter::emitInitGlobalIntAPS( uint32_t A0, SourceInfo L) {
35665 if (!isActive()) return true;
35666 CurrentSource = L;
35667 return InitGlobal<PT_IntAPS>(S, A0);
35668}
35669bool EvalEmitter::emitInitGlobalBool( uint32_t A0, SourceInfo L) {
35670 if (!isActive()) return true;
35671 CurrentSource = L;
35672 return InitGlobal<PT_Bool>(S, A0);
35673}
35674bool EvalEmitter::emitInitGlobalFixedPoint( uint32_t A0, SourceInfo L) {
35675 if (!isActive()) return true;
35676 CurrentSource = L;
35677 return InitGlobal<PT_FixedPoint>(S, A0);
35678}
35679bool EvalEmitter::emitInitGlobalPtr( uint32_t A0, SourceInfo L) {
35680 if (!isActive()) return true;
35681 CurrentSource = L;
35682 return InitGlobal<PT_Ptr>(S, A0);
35683}
35684bool EvalEmitter::emitInitGlobalMemberPtr( uint32_t A0, SourceInfo L) {
35685 if (!isActive()) return true;
35686 CurrentSource = L;
35687 return InitGlobal<PT_MemberPtr>(S, A0);
35688}
35689bool EvalEmitter::emitInitGlobalFloat( uint32_t A0, SourceInfo L) {
35690 if (!isActive()) return true;
35691 CurrentSource = L;
35692 return InitGlobal<PT_Float>(S, A0);
35693}
35694bool EvalEmitter::emitInitGlobalReflect( uint32_t A0, SourceInfo L) {
35695 if (!isActive()) return true;
35696 CurrentSource = L;
35697 return InitGlobal<PT_Reflect>(S, A0);
35698}
35699#endif
35700#ifdef GET_OPCODE_NAMES
35701OP_InitGlobalTempSint8,
35702OP_InitGlobalTempUint8,
35703OP_InitGlobalTempSint16,
35704OP_InitGlobalTempUint16,
35705OP_InitGlobalTempSint32,
35706OP_InitGlobalTempUint32,
35707OP_InitGlobalTempSint64,
35708OP_InitGlobalTempUint64,
35709OP_InitGlobalTempIntAP,
35710OP_InitGlobalTempIntAPS,
35711OP_InitGlobalTempBool,
35712OP_InitGlobalTempFixedPoint,
35713OP_InitGlobalTempPtr,
35714OP_InitGlobalTempMemberPtr,
35715OP_InitGlobalTempFloat,
35716OP_InitGlobalTempReflect,
35717#endif
35718#ifdef GET_INTERPFN_LIST
35719&Interp_InitGlobalTempSint8,
35720&Interp_InitGlobalTempUint8,
35721&Interp_InitGlobalTempSint16,
35722&Interp_InitGlobalTempUint16,
35723&Interp_InitGlobalTempSint32,
35724&Interp_InitGlobalTempUint32,
35725&Interp_InitGlobalTempSint64,
35726&Interp_InitGlobalTempUint64,
35727&Interp_InitGlobalTempIntAP,
35728&Interp_InitGlobalTempIntAPS,
35729&Interp_InitGlobalTempBool,
35730&Interp_InitGlobalTempFixedPoint,
35731&Interp_InitGlobalTempPtr,
35732&Interp_InitGlobalTempMemberPtr,
35733&Interp_InitGlobalTempFloat,
35734&Interp_InitGlobalTempReflect,
35735#endif
35736#ifdef GET_INTERPFN_DISPATCHERS
35737PRESERVE_NONE
35738static bool Interp_InitGlobalTempSint8(InterpState &S) {
35739 {
35740 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35741 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35742 if (!InitGlobalTemp<PT_Sint8>(S, V0, V1)) return false;
35743 }
35744#if USE_TAILCALLS
35745 MUSTTAIL return InterpNext(S);
35746#else
35747 return true;
35748#endif
35749}
35750PRESERVE_NONE
35751static bool Interp_InitGlobalTempUint8(InterpState &S) {
35752 {
35753 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35754 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35755 if (!InitGlobalTemp<PT_Uint8>(S, V0, V1)) return false;
35756 }
35757#if USE_TAILCALLS
35758 MUSTTAIL return InterpNext(S);
35759#else
35760 return true;
35761#endif
35762}
35763PRESERVE_NONE
35764static bool Interp_InitGlobalTempSint16(InterpState &S) {
35765 {
35766 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35767 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35768 if (!InitGlobalTemp<PT_Sint16>(S, V0, V1)) return false;
35769 }
35770#if USE_TAILCALLS
35771 MUSTTAIL return InterpNext(S);
35772#else
35773 return true;
35774#endif
35775}
35776PRESERVE_NONE
35777static bool Interp_InitGlobalTempUint16(InterpState &S) {
35778 {
35779 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35780 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35781 if (!InitGlobalTemp<PT_Uint16>(S, V0, V1)) return false;
35782 }
35783#if USE_TAILCALLS
35784 MUSTTAIL return InterpNext(S);
35785#else
35786 return true;
35787#endif
35788}
35789PRESERVE_NONE
35790static bool Interp_InitGlobalTempSint32(InterpState &S) {
35791 {
35792 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35793 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35794 if (!InitGlobalTemp<PT_Sint32>(S, V0, V1)) return false;
35795 }
35796#if USE_TAILCALLS
35797 MUSTTAIL return InterpNext(S);
35798#else
35799 return true;
35800#endif
35801}
35802PRESERVE_NONE
35803static bool Interp_InitGlobalTempUint32(InterpState &S) {
35804 {
35805 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35806 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35807 if (!InitGlobalTemp<PT_Uint32>(S, V0, V1)) return false;
35808 }
35809#if USE_TAILCALLS
35810 MUSTTAIL return InterpNext(S);
35811#else
35812 return true;
35813#endif
35814}
35815PRESERVE_NONE
35816static bool Interp_InitGlobalTempSint64(InterpState &S) {
35817 {
35818 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35819 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35820 if (!InitGlobalTemp<PT_Sint64>(S, V0, V1)) return false;
35821 }
35822#if USE_TAILCALLS
35823 MUSTTAIL return InterpNext(S);
35824#else
35825 return true;
35826#endif
35827}
35828PRESERVE_NONE
35829static bool Interp_InitGlobalTempUint64(InterpState &S) {
35830 {
35831 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35832 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35833 if (!InitGlobalTemp<PT_Uint64>(S, V0, V1)) return false;
35834 }
35835#if USE_TAILCALLS
35836 MUSTTAIL return InterpNext(S);
35837#else
35838 return true;
35839#endif
35840}
35841PRESERVE_NONE
35842static bool Interp_InitGlobalTempIntAP(InterpState &S) {
35843 {
35844 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35845 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35846 if (!InitGlobalTemp<PT_IntAP>(S, V0, V1)) return false;
35847 }
35848#if USE_TAILCALLS
35849 MUSTTAIL return InterpNext(S);
35850#else
35851 return true;
35852#endif
35853}
35854PRESERVE_NONE
35855static bool Interp_InitGlobalTempIntAPS(InterpState &S) {
35856 {
35857 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35858 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35859 if (!InitGlobalTemp<PT_IntAPS>(S, V0, V1)) return false;
35860 }
35861#if USE_TAILCALLS
35862 MUSTTAIL return InterpNext(S);
35863#else
35864 return true;
35865#endif
35866}
35867PRESERVE_NONE
35868static bool Interp_InitGlobalTempBool(InterpState &S) {
35869 {
35870 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35871 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35872 if (!InitGlobalTemp<PT_Bool>(S, V0, V1)) return false;
35873 }
35874#if USE_TAILCALLS
35875 MUSTTAIL return InterpNext(S);
35876#else
35877 return true;
35878#endif
35879}
35880PRESERVE_NONE
35881static bool Interp_InitGlobalTempFixedPoint(InterpState &S) {
35882 {
35883 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35884 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35885 if (!InitGlobalTemp<PT_FixedPoint>(S, V0, V1)) return false;
35886 }
35887#if USE_TAILCALLS
35888 MUSTTAIL return InterpNext(S);
35889#else
35890 return true;
35891#endif
35892}
35893PRESERVE_NONE
35894static bool Interp_InitGlobalTempPtr(InterpState &S) {
35895 {
35896 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35897 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35898 if (!InitGlobalTemp<PT_Ptr>(S, V0, V1)) return false;
35899 }
35900#if USE_TAILCALLS
35901 MUSTTAIL return InterpNext(S);
35902#else
35903 return true;
35904#endif
35905}
35906PRESERVE_NONE
35907static bool Interp_InitGlobalTempMemberPtr(InterpState &S) {
35908 {
35909 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35910 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35911 if (!InitGlobalTemp<PT_MemberPtr>(S, V0, V1)) return false;
35912 }
35913#if USE_TAILCALLS
35914 MUSTTAIL return InterpNext(S);
35915#else
35916 return true;
35917#endif
35918}
35919PRESERVE_NONE
35920static bool Interp_InitGlobalTempFloat(InterpState &S) {
35921 {
35922 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35923 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35924 if (!InitGlobalTemp<PT_Float>(S, V0, V1)) return false;
35925 }
35926#if USE_TAILCALLS
35927 MUSTTAIL return InterpNext(S);
35928#else
35929 return true;
35930#endif
35931}
35932PRESERVE_NONE
35933static bool Interp_InitGlobalTempReflect(InterpState &S) {
35934 {
35935 const auto V0 = ReadArg<uint32_t>(S, S.PC);
35936 const auto V1 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
35937 if (!InitGlobalTemp<PT_Reflect>(S, V0, V1)) return false;
35938 }
35939#if USE_TAILCALLS
35940 MUSTTAIL return InterpNext(S);
35941#else
35942 return true;
35943#endif
35944}
35945#endif
35946#ifdef GET_DISASM
35947case OP_InitGlobalTempSint8:
35948 Text.Op = PrintName("InitGlobalTempSint8");
35949 Text.Args.push_back(printArg<uint32_t>(PC));
35950 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35951 break;
35952case OP_InitGlobalTempUint8:
35953 Text.Op = PrintName("InitGlobalTempUint8");
35954 Text.Args.push_back(printArg<uint32_t>(PC));
35955 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35956 break;
35957case OP_InitGlobalTempSint16:
35958 Text.Op = PrintName("InitGlobalTempSint16");
35959 Text.Args.push_back(printArg<uint32_t>(PC));
35960 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35961 break;
35962case OP_InitGlobalTempUint16:
35963 Text.Op = PrintName("InitGlobalTempUint16");
35964 Text.Args.push_back(printArg<uint32_t>(PC));
35965 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35966 break;
35967case OP_InitGlobalTempSint32:
35968 Text.Op = PrintName("InitGlobalTempSint32");
35969 Text.Args.push_back(printArg<uint32_t>(PC));
35970 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35971 break;
35972case OP_InitGlobalTempUint32:
35973 Text.Op = PrintName("InitGlobalTempUint32");
35974 Text.Args.push_back(printArg<uint32_t>(PC));
35975 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35976 break;
35977case OP_InitGlobalTempSint64:
35978 Text.Op = PrintName("InitGlobalTempSint64");
35979 Text.Args.push_back(printArg<uint32_t>(PC));
35980 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35981 break;
35982case OP_InitGlobalTempUint64:
35983 Text.Op = PrintName("InitGlobalTempUint64");
35984 Text.Args.push_back(printArg<uint32_t>(PC));
35985 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35986 break;
35987case OP_InitGlobalTempIntAP:
35988 Text.Op = PrintName("InitGlobalTempIntAP");
35989 Text.Args.push_back(printArg<uint32_t>(PC));
35990 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35991 break;
35992case OP_InitGlobalTempIntAPS:
35993 Text.Op = PrintName("InitGlobalTempIntAPS");
35994 Text.Args.push_back(printArg<uint32_t>(PC));
35995 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
35996 break;
35997case OP_InitGlobalTempBool:
35998 Text.Op = PrintName("InitGlobalTempBool");
35999 Text.Args.push_back(printArg<uint32_t>(PC));
36000 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
36001 break;
36002case OP_InitGlobalTempFixedPoint:
36003 Text.Op = PrintName("InitGlobalTempFixedPoint");
36004 Text.Args.push_back(printArg<uint32_t>(PC));
36005 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
36006 break;
36007case OP_InitGlobalTempPtr:
36008 Text.Op = PrintName("InitGlobalTempPtr");
36009 Text.Args.push_back(printArg<uint32_t>(PC));
36010 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
36011 break;
36012case OP_InitGlobalTempMemberPtr:
36013 Text.Op = PrintName("InitGlobalTempMemberPtr");
36014 Text.Args.push_back(printArg<uint32_t>(PC));
36015 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
36016 break;
36017case OP_InitGlobalTempFloat:
36018 Text.Op = PrintName("InitGlobalTempFloat");
36019 Text.Args.push_back(printArg<uint32_t>(PC));
36020 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
36021 break;
36022case OP_InitGlobalTempReflect:
36023 Text.Op = PrintName("InitGlobalTempReflect");
36024 Text.Args.push_back(printArg<uint32_t>(PC));
36025 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
36026 break;
36027#endif
36028#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
36029bool emitInitGlobalTempSint8( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36030bool emitInitGlobalTempUint8( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36031bool emitInitGlobalTempSint16( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36032bool emitInitGlobalTempUint16( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36033bool emitInitGlobalTempSint32( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36034bool emitInitGlobalTempUint32( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36035bool emitInitGlobalTempSint64( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36036bool emitInitGlobalTempUint64( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36037bool emitInitGlobalTempIntAP( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36038bool emitInitGlobalTempIntAPS( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36039bool emitInitGlobalTempBool( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36040bool emitInitGlobalTempFixedPoint( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36041bool emitInitGlobalTempPtr( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36042bool emitInitGlobalTempMemberPtr( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36043bool emitInitGlobalTempFloat( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36044bool emitInitGlobalTempReflect( uint32_t , const LifetimeExtendedTemporaryDecl * , SourceInfo);
36045#endif
36046#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
36047[[nodiscard]] bool emitInitGlobalTemp(PrimType, uint32_t, const LifetimeExtendedTemporaryDecl *, SourceInfo I);
36048#endif
36049#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
36050bool
36051#if defined(GET_EVAL_IMPL)
36052EvalEmitter
36053#else
36054ByteCodeEmitter
36055#endif
36056::emitInitGlobalTemp(PrimType T0, uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo I) {
36057 switch (T0) {
36058 case PT_Sint8:
36059 return emitInitGlobalTempSint8(A0, A1, I);
36060 case PT_Uint8:
36061 return emitInitGlobalTempUint8(A0, A1, I);
36062 case PT_Sint16:
36063 return emitInitGlobalTempSint16(A0, A1, I);
36064 case PT_Uint16:
36065 return emitInitGlobalTempUint16(A0, A1, I);
36066 case PT_Sint32:
36067 return emitInitGlobalTempSint32(A0, A1, I);
36068 case PT_Uint32:
36069 return emitInitGlobalTempUint32(A0, A1, I);
36070 case PT_Sint64:
36071 return emitInitGlobalTempSint64(A0, A1, I);
36072 case PT_Uint64:
36073 return emitInitGlobalTempUint64(A0, A1, I);
36074 case PT_IntAP:
36075 return emitInitGlobalTempIntAP(A0, A1, I);
36076 case PT_IntAPS:
36077 return emitInitGlobalTempIntAPS(A0, A1, I);
36078 case PT_Bool:
36079 return emitInitGlobalTempBool(A0, A1, I);
36080 case PT_FixedPoint:
36081 return emitInitGlobalTempFixedPoint(A0, A1, I);
36082 case PT_Ptr:
36083 return emitInitGlobalTempPtr(A0, A1, I);
36084 case PT_MemberPtr:
36085 return emitInitGlobalTempMemberPtr(A0, A1, I);
36086 case PT_Float:
36087 return emitInitGlobalTempFloat(A0, A1, I);
36088 case PT_Reflect:
36089 return emitInitGlobalTempReflect(A0, A1, I);
36090 }
36091 llvm_unreachable("invalid enum value");
36092}
36093#endif
36094#ifdef GET_LINK_IMPL
36095bool ByteCodeEmitter::emitInitGlobalTempSint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36096 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint8, A0, A1, L);
36097}
36098bool ByteCodeEmitter::emitInitGlobalTempUint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36099 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint8, A0, A1, L);
36100}
36101bool ByteCodeEmitter::emitInitGlobalTempSint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36102 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint16, A0, A1, L);
36103}
36104bool ByteCodeEmitter::emitInitGlobalTempUint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36105 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint16, A0, A1, L);
36106}
36107bool ByteCodeEmitter::emitInitGlobalTempSint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36108 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint32, A0, A1, L);
36109}
36110bool ByteCodeEmitter::emitInitGlobalTempUint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36111 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint32, A0, A1, L);
36112}
36113bool ByteCodeEmitter::emitInitGlobalTempSint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36114 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempSint64, A0, A1, L);
36115}
36116bool ByteCodeEmitter::emitInitGlobalTempUint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36117 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempUint64, A0, A1, L);
36118}
36119bool ByteCodeEmitter::emitInitGlobalTempIntAP( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36120 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempIntAP, A0, A1, L);
36121}
36122bool ByteCodeEmitter::emitInitGlobalTempIntAPS( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36123 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempIntAPS, A0, A1, L);
36124}
36125bool ByteCodeEmitter::emitInitGlobalTempBool( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36126 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempBool, A0, A1, L);
36127}
36128bool ByteCodeEmitter::emitInitGlobalTempFixedPoint( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36129 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempFixedPoint, A0, A1, L);
36130}
36131bool ByteCodeEmitter::emitInitGlobalTempPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36132 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempPtr, A0, A1, L);
36133}
36134bool ByteCodeEmitter::emitInitGlobalTempMemberPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36135 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempMemberPtr, A0, A1, L);
36136}
36137bool ByteCodeEmitter::emitInitGlobalTempFloat( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36138 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempFloat, A0, A1, L);
36139}
36140bool ByteCodeEmitter::emitInitGlobalTempReflect( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36141 return emitOp<uint32_t, const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempReflect, A0, A1, L);
36142}
36143#endif
36144#ifdef GET_EVAL_IMPL
36145bool EvalEmitter::emitInitGlobalTempSint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36146 if (!isActive()) return true;
36147 CurrentSource = L;
36148 return InitGlobalTemp<PT_Sint8>(S, A0, A1);
36149}
36150bool EvalEmitter::emitInitGlobalTempUint8( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36151 if (!isActive()) return true;
36152 CurrentSource = L;
36153 return InitGlobalTemp<PT_Uint8>(S, A0, A1);
36154}
36155bool EvalEmitter::emitInitGlobalTempSint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36156 if (!isActive()) return true;
36157 CurrentSource = L;
36158 return InitGlobalTemp<PT_Sint16>(S, A0, A1);
36159}
36160bool EvalEmitter::emitInitGlobalTempUint16( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36161 if (!isActive()) return true;
36162 CurrentSource = L;
36163 return InitGlobalTemp<PT_Uint16>(S, A0, A1);
36164}
36165bool EvalEmitter::emitInitGlobalTempSint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36166 if (!isActive()) return true;
36167 CurrentSource = L;
36168 return InitGlobalTemp<PT_Sint32>(S, A0, A1);
36169}
36170bool EvalEmitter::emitInitGlobalTempUint32( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36171 if (!isActive()) return true;
36172 CurrentSource = L;
36173 return InitGlobalTemp<PT_Uint32>(S, A0, A1);
36174}
36175bool EvalEmitter::emitInitGlobalTempSint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36176 if (!isActive()) return true;
36177 CurrentSource = L;
36178 return InitGlobalTemp<PT_Sint64>(S, A0, A1);
36179}
36180bool EvalEmitter::emitInitGlobalTempUint64( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36181 if (!isActive()) return true;
36182 CurrentSource = L;
36183 return InitGlobalTemp<PT_Uint64>(S, A0, A1);
36184}
36185bool EvalEmitter::emitInitGlobalTempIntAP( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36186 if (!isActive()) return true;
36187 CurrentSource = L;
36188 return InitGlobalTemp<PT_IntAP>(S, A0, A1);
36189}
36190bool EvalEmitter::emitInitGlobalTempIntAPS( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36191 if (!isActive()) return true;
36192 CurrentSource = L;
36193 return InitGlobalTemp<PT_IntAPS>(S, A0, A1);
36194}
36195bool EvalEmitter::emitInitGlobalTempBool( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36196 if (!isActive()) return true;
36197 CurrentSource = L;
36198 return InitGlobalTemp<PT_Bool>(S, A0, A1);
36199}
36200bool EvalEmitter::emitInitGlobalTempFixedPoint( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36201 if (!isActive()) return true;
36202 CurrentSource = L;
36203 return InitGlobalTemp<PT_FixedPoint>(S, A0, A1);
36204}
36205bool EvalEmitter::emitInitGlobalTempPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36206 if (!isActive()) return true;
36207 CurrentSource = L;
36208 return InitGlobalTemp<PT_Ptr>(S, A0, A1);
36209}
36210bool EvalEmitter::emitInitGlobalTempMemberPtr( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36211 if (!isActive()) return true;
36212 CurrentSource = L;
36213 return InitGlobalTemp<PT_MemberPtr>(S, A0, A1);
36214}
36215bool EvalEmitter::emitInitGlobalTempFloat( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36216 if (!isActive()) return true;
36217 CurrentSource = L;
36218 return InitGlobalTemp<PT_Float>(S, A0, A1);
36219}
36220bool EvalEmitter::emitInitGlobalTempReflect( uint32_t A0, const LifetimeExtendedTemporaryDecl * A1, SourceInfo L) {
36221 if (!isActive()) return true;
36222 CurrentSource = L;
36223 return InitGlobalTemp<PT_Reflect>(S, A0, A1);
36224}
36225#endif
36226#ifdef GET_OPCODE_NAMES
36227OP_InitGlobalTempComp,
36228#endif
36229#ifdef GET_INTERPFN_LIST
36230&Interp_InitGlobalTempComp,
36231#endif
36232#ifdef GET_INTERPFN_DISPATCHERS
36233PRESERVE_NONE
36234static bool Interp_InitGlobalTempComp(InterpState &S) {
36235 {
36236 const auto V0 = ReadArg<const LifetimeExtendedTemporaryDecl *>(S, S.PC);
36237 if (!InitGlobalTempComp(S, V0)) return false;
36238 }
36239#if USE_TAILCALLS
36240 MUSTTAIL return InterpNext(S);
36241#else
36242 return true;
36243#endif
36244}
36245#endif
36246#ifdef GET_DISASM
36247case OP_InitGlobalTempComp:
36248 Text.Op = PrintName("InitGlobalTempComp");
36249 Text.Args.push_back(printArg<const LifetimeExtendedTemporaryDecl *>(PC));
36250 break;
36251#endif
36252#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
36253bool emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * , SourceInfo);
36254#endif
36255#ifdef GET_LINK_IMPL
36256bool ByteCodeEmitter::emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * A0, SourceInfo L) {
36257 return emitOp<const LifetimeExtendedTemporaryDecl *>(OP_InitGlobalTempComp, A0, L);
36258}
36259#endif
36260#ifdef GET_EVAL_IMPL
36261bool EvalEmitter::emitInitGlobalTempComp( const LifetimeExtendedTemporaryDecl * A0, SourceInfo L) {
36262 if (!isActive()) return true;
36263 CurrentSource = L;
36264 return InitGlobalTempComp(S, A0);
36265}
36266#endif
36267#ifdef GET_OPCODE_NAMES
36268OP_InitPopSint8,
36269OP_InitPopUint8,
36270OP_InitPopSint16,
36271OP_InitPopUint16,
36272OP_InitPopSint32,
36273OP_InitPopUint32,
36274OP_InitPopSint64,
36275OP_InitPopUint64,
36276OP_InitPopIntAP,
36277OP_InitPopIntAPS,
36278OP_InitPopBool,
36279OP_InitPopFixedPoint,
36280OP_InitPopPtr,
36281OP_InitPopMemberPtr,
36282OP_InitPopFloat,
36283OP_InitPopReflect,
36284#endif
36285#ifdef GET_INTERPFN_LIST
36286&Interp_InitPopSint8,
36287&Interp_InitPopUint8,
36288&Interp_InitPopSint16,
36289&Interp_InitPopUint16,
36290&Interp_InitPopSint32,
36291&Interp_InitPopUint32,
36292&Interp_InitPopSint64,
36293&Interp_InitPopUint64,
36294&Interp_InitPopIntAP,
36295&Interp_InitPopIntAPS,
36296&Interp_InitPopBool,
36297&Interp_InitPopFixedPoint,
36298&Interp_InitPopPtr,
36299&Interp_InitPopMemberPtr,
36300&Interp_InitPopFloat,
36301&Interp_InitPopReflect,
36302#endif
36303#ifdef GET_INTERPFN_DISPATCHERS
36304PRESERVE_NONE
36305static bool Interp_InitPopSint8(InterpState &S) {
36306 if (!InitPop<PT_Sint8>(S, S.PC)) return false;
36307#if USE_TAILCALLS
36308 MUSTTAIL return InterpNext(S);
36309#else
36310 return true;
36311#endif
36312}
36313PRESERVE_NONE
36314static bool Interp_InitPopUint8(InterpState &S) {
36315 if (!InitPop<PT_Uint8>(S, S.PC)) return false;
36316#if USE_TAILCALLS
36317 MUSTTAIL return InterpNext(S);
36318#else
36319 return true;
36320#endif
36321}
36322PRESERVE_NONE
36323static bool Interp_InitPopSint16(InterpState &S) {
36324 if (!InitPop<PT_Sint16>(S, S.PC)) return false;
36325#if USE_TAILCALLS
36326 MUSTTAIL return InterpNext(S);
36327#else
36328 return true;
36329#endif
36330}
36331PRESERVE_NONE
36332static bool Interp_InitPopUint16(InterpState &S) {
36333 if (!InitPop<PT_Uint16>(S, S.PC)) return false;
36334#if USE_TAILCALLS
36335 MUSTTAIL return InterpNext(S);
36336#else
36337 return true;
36338#endif
36339}
36340PRESERVE_NONE
36341static bool Interp_InitPopSint32(InterpState &S) {
36342 if (!InitPop<PT_Sint32>(S, S.PC)) return false;
36343#if USE_TAILCALLS
36344 MUSTTAIL return InterpNext(S);
36345#else
36346 return true;
36347#endif
36348}
36349PRESERVE_NONE
36350static bool Interp_InitPopUint32(InterpState &S) {
36351 if (!InitPop<PT_Uint32>(S, S.PC)) return false;
36352#if USE_TAILCALLS
36353 MUSTTAIL return InterpNext(S);
36354#else
36355 return true;
36356#endif
36357}
36358PRESERVE_NONE
36359static bool Interp_InitPopSint64(InterpState &S) {
36360 if (!InitPop<PT_Sint64>(S, S.PC)) return false;
36361#if USE_TAILCALLS
36362 MUSTTAIL return InterpNext(S);
36363#else
36364 return true;
36365#endif
36366}
36367PRESERVE_NONE
36368static bool Interp_InitPopUint64(InterpState &S) {
36369 if (!InitPop<PT_Uint64>(S, S.PC)) return false;
36370#if USE_TAILCALLS
36371 MUSTTAIL return InterpNext(S);
36372#else
36373 return true;
36374#endif
36375}
36376PRESERVE_NONE
36377static bool Interp_InitPopIntAP(InterpState &S) {
36378 if (!InitPop<PT_IntAP>(S, S.PC)) return false;
36379#if USE_TAILCALLS
36380 MUSTTAIL return InterpNext(S);
36381#else
36382 return true;
36383#endif
36384}
36385PRESERVE_NONE
36386static bool Interp_InitPopIntAPS(InterpState &S) {
36387 if (!InitPop<PT_IntAPS>(S, S.PC)) return false;
36388#if USE_TAILCALLS
36389 MUSTTAIL return InterpNext(S);
36390#else
36391 return true;
36392#endif
36393}
36394PRESERVE_NONE
36395static bool Interp_InitPopBool(InterpState &S) {
36396 if (!InitPop<PT_Bool>(S, S.PC)) return false;
36397#if USE_TAILCALLS
36398 MUSTTAIL return InterpNext(S);
36399#else
36400 return true;
36401#endif
36402}
36403PRESERVE_NONE
36404static bool Interp_InitPopFixedPoint(InterpState &S) {
36405 if (!InitPop<PT_FixedPoint>(S, S.PC)) return false;
36406#if USE_TAILCALLS
36407 MUSTTAIL return InterpNext(S);
36408#else
36409 return true;
36410#endif
36411}
36412PRESERVE_NONE
36413static bool Interp_InitPopPtr(InterpState &S) {
36414 if (!InitPop<PT_Ptr>(S, S.PC)) return false;
36415#if USE_TAILCALLS
36416 MUSTTAIL return InterpNext(S);
36417#else
36418 return true;
36419#endif
36420}
36421PRESERVE_NONE
36422static bool Interp_InitPopMemberPtr(InterpState &S) {
36423 if (!InitPop<PT_MemberPtr>(S, S.PC)) return false;
36424#if USE_TAILCALLS
36425 MUSTTAIL return InterpNext(S);
36426#else
36427 return true;
36428#endif
36429}
36430PRESERVE_NONE
36431static bool Interp_InitPopFloat(InterpState &S) {
36432 if (!InitPop<PT_Float>(S, S.PC)) return false;
36433#if USE_TAILCALLS
36434 MUSTTAIL return InterpNext(S);
36435#else
36436 return true;
36437#endif
36438}
36439PRESERVE_NONE
36440static bool Interp_InitPopReflect(InterpState &S) {
36441 if (!InitPop<PT_Reflect>(S, S.PC)) return false;
36442#if USE_TAILCALLS
36443 MUSTTAIL return InterpNext(S);
36444#else
36445 return true;
36446#endif
36447}
36448#endif
36449#ifdef GET_DISASM
36450case OP_InitPopSint8:
36451 Text.Op = PrintName("InitPopSint8");
36452 break;
36453case OP_InitPopUint8:
36454 Text.Op = PrintName("InitPopUint8");
36455 break;
36456case OP_InitPopSint16:
36457 Text.Op = PrintName("InitPopSint16");
36458 break;
36459case OP_InitPopUint16:
36460 Text.Op = PrintName("InitPopUint16");
36461 break;
36462case OP_InitPopSint32:
36463 Text.Op = PrintName("InitPopSint32");
36464 break;
36465case OP_InitPopUint32:
36466 Text.Op = PrintName("InitPopUint32");
36467 break;
36468case OP_InitPopSint64:
36469 Text.Op = PrintName("InitPopSint64");
36470 break;
36471case OP_InitPopUint64:
36472 Text.Op = PrintName("InitPopUint64");
36473 break;
36474case OP_InitPopIntAP:
36475 Text.Op = PrintName("InitPopIntAP");
36476 break;
36477case OP_InitPopIntAPS:
36478 Text.Op = PrintName("InitPopIntAPS");
36479 break;
36480case OP_InitPopBool:
36481 Text.Op = PrintName("InitPopBool");
36482 break;
36483case OP_InitPopFixedPoint:
36484 Text.Op = PrintName("InitPopFixedPoint");
36485 break;
36486case OP_InitPopPtr:
36487 Text.Op = PrintName("InitPopPtr");
36488 break;
36489case OP_InitPopMemberPtr:
36490 Text.Op = PrintName("InitPopMemberPtr");
36491 break;
36492case OP_InitPopFloat:
36493 Text.Op = PrintName("InitPopFloat");
36494 break;
36495case OP_InitPopReflect:
36496 Text.Op = PrintName("InitPopReflect");
36497 break;
36498#endif
36499#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
36500bool emitInitPopSint8(SourceInfo);
36501bool emitInitPopUint8(SourceInfo);
36502bool emitInitPopSint16(SourceInfo);
36503bool emitInitPopUint16(SourceInfo);
36504bool emitInitPopSint32(SourceInfo);
36505bool emitInitPopUint32(SourceInfo);
36506bool emitInitPopSint64(SourceInfo);
36507bool emitInitPopUint64(SourceInfo);
36508bool emitInitPopIntAP(SourceInfo);
36509bool emitInitPopIntAPS(SourceInfo);
36510bool emitInitPopBool(SourceInfo);
36511bool emitInitPopFixedPoint(SourceInfo);
36512bool emitInitPopPtr(SourceInfo);
36513bool emitInitPopMemberPtr(SourceInfo);
36514bool emitInitPopFloat(SourceInfo);
36515bool emitInitPopReflect(SourceInfo);
36516#endif
36517#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
36518[[nodiscard]] bool emitInitPop(PrimType, SourceInfo I);
36519#endif
36520#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
36521bool
36522#if defined(GET_EVAL_IMPL)
36523EvalEmitter
36524#else
36525ByteCodeEmitter
36526#endif
36527::emitInitPop(PrimType T0, SourceInfo I) {
36528 switch (T0) {
36529 case PT_Sint8:
36530 return emitInitPopSint8(I);
36531 case PT_Uint8:
36532 return emitInitPopUint8(I);
36533 case PT_Sint16:
36534 return emitInitPopSint16(I);
36535 case PT_Uint16:
36536 return emitInitPopUint16(I);
36537 case PT_Sint32:
36538 return emitInitPopSint32(I);
36539 case PT_Uint32:
36540 return emitInitPopUint32(I);
36541 case PT_Sint64:
36542 return emitInitPopSint64(I);
36543 case PT_Uint64:
36544 return emitInitPopUint64(I);
36545 case PT_IntAP:
36546 return emitInitPopIntAP(I);
36547 case PT_IntAPS:
36548 return emitInitPopIntAPS(I);
36549 case PT_Bool:
36550 return emitInitPopBool(I);
36551 case PT_FixedPoint:
36552 return emitInitPopFixedPoint(I);
36553 case PT_Ptr:
36554 return emitInitPopPtr(I);
36555 case PT_MemberPtr:
36556 return emitInitPopMemberPtr(I);
36557 case PT_Float:
36558 return emitInitPopFloat(I);
36559 case PT_Reflect:
36560 return emitInitPopReflect(I);
36561 }
36562 llvm_unreachable("invalid enum value");
36563}
36564#endif
36565#ifdef GET_LINK_IMPL
36566bool ByteCodeEmitter::emitInitPopSint8(SourceInfo L) {
36567 return emitOp<>(OP_InitPopSint8, L);
36568}
36569bool ByteCodeEmitter::emitInitPopUint8(SourceInfo L) {
36570 return emitOp<>(OP_InitPopUint8, L);
36571}
36572bool ByteCodeEmitter::emitInitPopSint16(SourceInfo L) {
36573 return emitOp<>(OP_InitPopSint16, L);
36574}
36575bool ByteCodeEmitter::emitInitPopUint16(SourceInfo L) {
36576 return emitOp<>(OP_InitPopUint16, L);
36577}
36578bool ByteCodeEmitter::emitInitPopSint32(SourceInfo L) {
36579 return emitOp<>(OP_InitPopSint32, L);
36580}
36581bool ByteCodeEmitter::emitInitPopUint32(SourceInfo L) {
36582 return emitOp<>(OP_InitPopUint32, L);
36583}
36584bool ByteCodeEmitter::emitInitPopSint64(SourceInfo L) {
36585 return emitOp<>(OP_InitPopSint64, L);
36586}
36587bool ByteCodeEmitter::emitInitPopUint64(SourceInfo L) {
36588 return emitOp<>(OP_InitPopUint64, L);
36589}
36590bool ByteCodeEmitter::emitInitPopIntAP(SourceInfo L) {
36591 return emitOp<>(OP_InitPopIntAP, L);
36592}
36593bool ByteCodeEmitter::emitInitPopIntAPS(SourceInfo L) {
36594 return emitOp<>(OP_InitPopIntAPS, L);
36595}
36596bool ByteCodeEmitter::emitInitPopBool(SourceInfo L) {
36597 return emitOp<>(OP_InitPopBool, L);
36598}
36599bool ByteCodeEmitter::emitInitPopFixedPoint(SourceInfo L) {
36600 return emitOp<>(OP_InitPopFixedPoint, L);
36601}
36602bool ByteCodeEmitter::emitInitPopPtr(SourceInfo L) {
36603 return emitOp<>(OP_InitPopPtr, L);
36604}
36605bool ByteCodeEmitter::emitInitPopMemberPtr(SourceInfo L) {
36606 return emitOp<>(OP_InitPopMemberPtr, L);
36607}
36608bool ByteCodeEmitter::emitInitPopFloat(SourceInfo L) {
36609 return emitOp<>(OP_InitPopFloat, L);
36610}
36611bool ByteCodeEmitter::emitInitPopReflect(SourceInfo L) {
36612 return emitOp<>(OP_InitPopReflect, L);
36613}
36614#endif
36615#ifdef GET_EVAL_IMPL
36616bool EvalEmitter::emitInitPopSint8(SourceInfo L) {
36617 if (!isActive()) return true;
36618 CurrentSource = L;
36619 return InitPop<PT_Sint8>(S, CodePtr());
36620}
36621bool EvalEmitter::emitInitPopUint8(SourceInfo L) {
36622 if (!isActive()) return true;
36623 CurrentSource = L;
36624 return InitPop<PT_Uint8>(S, CodePtr());
36625}
36626bool EvalEmitter::emitInitPopSint16(SourceInfo L) {
36627 if (!isActive()) return true;
36628 CurrentSource = L;
36629 return InitPop<PT_Sint16>(S, CodePtr());
36630}
36631bool EvalEmitter::emitInitPopUint16(SourceInfo L) {
36632 if (!isActive()) return true;
36633 CurrentSource = L;
36634 return InitPop<PT_Uint16>(S, CodePtr());
36635}
36636bool EvalEmitter::emitInitPopSint32(SourceInfo L) {
36637 if (!isActive()) return true;
36638 CurrentSource = L;
36639 return InitPop<PT_Sint32>(S, CodePtr());
36640}
36641bool EvalEmitter::emitInitPopUint32(SourceInfo L) {
36642 if (!isActive()) return true;
36643 CurrentSource = L;
36644 return InitPop<PT_Uint32>(S, CodePtr());
36645}
36646bool EvalEmitter::emitInitPopSint64(SourceInfo L) {
36647 if (!isActive()) return true;
36648 CurrentSource = L;
36649 return InitPop<PT_Sint64>(S, CodePtr());
36650}
36651bool EvalEmitter::emitInitPopUint64(SourceInfo L) {
36652 if (!isActive()) return true;
36653 CurrentSource = L;
36654 return InitPop<PT_Uint64>(S, CodePtr());
36655}
36656bool EvalEmitter::emitInitPopIntAP(SourceInfo L) {
36657 if (!isActive()) return true;
36658 CurrentSource = L;
36659 return InitPop<PT_IntAP>(S, CodePtr());
36660}
36661bool EvalEmitter::emitInitPopIntAPS(SourceInfo L) {
36662 if (!isActive()) return true;
36663 CurrentSource = L;
36664 return InitPop<PT_IntAPS>(S, CodePtr());
36665}
36666bool EvalEmitter::emitInitPopBool(SourceInfo L) {
36667 if (!isActive()) return true;
36668 CurrentSource = L;
36669 return InitPop<PT_Bool>(S, CodePtr());
36670}
36671bool EvalEmitter::emitInitPopFixedPoint(SourceInfo L) {
36672 if (!isActive()) return true;
36673 CurrentSource = L;
36674 return InitPop<PT_FixedPoint>(S, CodePtr());
36675}
36676bool EvalEmitter::emitInitPopPtr(SourceInfo L) {
36677 if (!isActive()) return true;
36678 CurrentSource = L;
36679 return InitPop<PT_Ptr>(S, CodePtr());
36680}
36681bool EvalEmitter::emitInitPopMemberPtr(SourceInfo L) {
36682 if (!isActive()) return true;
36683 CurrentSource = L;
36684 return InitPop<PT_MemberPtr>(S, CodePtr());
36685}
36686bool EvalEmitter::emitInitPopFloat(SourceInfo L) {
36687 if (!isActive()) return true;
36688 CurrentSource = L;
36689 return InitPop<PT_Float>(S, CodePtr());
36690}
36691bool EvalEmitter::emitInitPopReflect(SourceInfo L) {
36692 if (!isActive()) return true;
36693 CurrentSource = L;
36694 return InitPop<PT_Reflect>(S, CodePtr());
36695}
36696#endif
36697#ifdef GET_OPCODE_NAMES
36698OP_InitThisBitFieldSint8,
36699OP_InitThisBitFieldUint8,
36700OP_InitThisBitFieldSint16,
36701OP_InitThisBitFieldUint16,
36702OP_InitThisBitFieldSint32,
36703OP_InitThisBitFieldUint32,
36704OP_InitThisBitFieldSint64,
36705OP_InitThisBitFieldUint64,
36706OP_InitThisBitFieldIntAP,
36707OP_InitThisBitFieldIntAPS,
36708OP_InitThisBitFieldBool,
36709#endif
36710#ifdef GET_INTERPFN_LIST
36711&Interp_InitThisBitFieldSint8,
36712&Interp_InitThisBitFieldUint8,
36713&Interp_InitThisBitFieldSint16,
36714&Interp_InitThisBitFieldUint16,
36715&Interp_InitThisBitFieldSint32,
36716&Interp_InitThisBitFieldUint32,
36717&Interp_InitThisBitFieldSint64,
36718&Interp_InitThisBitFieldUint64,
36719&Interp_InitThisBitFieldIntAP,
36720&Interp_InitThisBitFieldIntAPS,
36721&Interp_InitThisBitFieldBool,
36722#endif
36723#ifdef GET_INTERPFN_DISPATCHERS
36724PRESERVE_NONE
36725static bool Interp_InitThisBitFieldSint8(InterpState &S) {
36726 {
36727 CodePtr OpPC = S.PC;
36728 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36729 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36730 if (!InitThisBitField<PT_Sint8>(S, OpPC, V0, V1)) return false;
36731 }
36732#if USE_TAILCALLS
36733 MUSTTAIL return InterpNext(S);
36734#else
36735 return true;
36736#endif
36737}
36738PRESERVE_NONE
36739static bool Interp_InitThisBitFieldUint8(InterpState &S) {
36740 {
36741 CodePtr OpPC = S.PC;
36742 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36743 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36744 if (!InitThisBitField<PT_Uint8>(S, OpPC, V0, V1)) return false;
36745 }
36746#if USE_TAILCALLS
36747 MUSTTAIL return InterpNext(S);
36748#else
36749 return true;
36750#endif
36751}
36752PRESERVE_NONE
36753static bool Interp_InitThisBitFieldSint16(InterpState &S) {
36754 {
36755 CodePtr OpPC = S.PC;
36756 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36757 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36758 if (!InitThisBitField<PT_Sint16>(S, OpPC, V0, V1)) return false;
36759 }
36760#if USE_TAILCALLS
36761 MUSTTAIL return InterpNext(S);
36762#else
36763 return true;
36764#endif
36765}
36766PRESERVE_NONE
36767static bool Interp_InitThisBitFieldUint16(InterpState &S) {
36768 {
36769 CodePtr OpPC = S.PC;
36770 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36771 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36772 if (!InitThisBitField<PT_Uint16>(S, OpPC, V0, V1)) return false;
36773 }
36774#if USE_TAILCALLS
36775 MUSTTAIL return InterpNext(S);
36776#else
36777 return true;
36778#endif
36779}
36780PRESERVE_NONE
36781static bool Interp_InitThisBitFieldSint32(InterpState &S) {
36782 {
36783 CodePtr OpPC = S.PC;
36784 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36785 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36786 if (!InitThisBitField<PT_Sint32>(S, OpPC, V0, V1)) return false;
36787 }
36788#if USE_TAILCALLS
36789 MUSTTAIL return InterpNext(S);
36790#else
36791 return true;
36792#endif
36793}
36794PRESERVE_NONE
36795static bool Interp_InitThisBitFieldUint32(InterpState &S) {
36796 {
36797 CodePtr OpPC = S.PC;
36798 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36799 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36800 if (!InitThisBitField<PT_Uint32>(S, OpPC, V0, V1)) return false;
36801 }
36802#if USE_TAILCALLS
36803 MUSTTAIL return InterpNext(S);
36804#else
36805 return true;
36806#endif
36807}
36808PRESERVE_NONE
36809static bool Interp_InitThisBitFieldSint64(InterpState &S) {
36810 {
36811 CodePtr OpPC = S.PC;
36812 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36813 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36814 if (!InitThisBitField<PT_Sint64>(S, OpPC, V0, V1)) return false;
36815 }
36816#if USE_TAILCALLS
36817 MUSTTAIL return InterpNext(S);
36818#else
36819 return true;
36820#endif
36821}
36822PRESERVE_NONE
36823static bool Interp_InitThisBitFieldUint64(InterpState &S) {
36824 {
36825 CodePtr OpPC = S.PC;
36826 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36827 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36828 if (!InitThisBitField<PT_Uint64>(S, OpPC, V0, V1)) return false;
36829 }
36830#if USE_TAILCALLS
36831 MUSTTAIL return InterpNext(S);
36832#else
36833 return true;
36834#endif
36835}
36836PRESERVE_NONE
36837static bool Interp_InitThisBitFieldIntAP(InterpState &S) {
36838 {
36839 CodePtr OpPC = S.PC;
36840 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36841 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36842 if (!InitThisBitField<PT_IntAP>(S, OpPC, V0, V1)) return false;
36843 }
36844#if USE_TAILCALLS
36845 MUSTTAIL return InterpNext(S);
36846#else
36847 return true;
36848#endif
36849}
36850PRESERVE_NONE
36851static bool Interp_InitThisBitFieldIntAPS(InterpState &S) {
36852 {
36853 CodePtr OpPC = S.PC;
36854 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36855 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36856 if (!InitThisBitField<PT_IntAPS>(S, OpPC, V0, V1)) return false;
36857 }
36858#if USE_TAILCALLS
36859 MUSTTAIL return InterpNext(S);
36860#else
36861 return true;
36862#endif
36863}
36864PRESERVE_NONE
36865static bool Interp_InitThisBitFieldBool(InterpState &S) {
36866 {
36867 CodePtr OpPC = S.PC;
36868 const auto V0 = ReadArg<uint32_t>(S, S.PC);
36869 const auto V1 = ReadArg<uint32_t>(S, S.PC);
36870 if (!InitThisBitField<PT_Bool>(S, OpPC, V0, V1)) return false;
36871 }
36872#if USE_TAILCALLS
36873 MUSTTAIL return InterpNext(S);
36874#else
36875 return true;
36876#endif
36877}
36878#endif
36879#ifdef GET_DISASM
36880case OP_InitThisBitFieldSint8:
36881 Text.Op = PrintName("InitThisBitFieldSint8");
36882 Text.Args.push_back(printArg<uint32_t>(PC));
36883 Text.Args.push_back(printArg<uint32_t>(PC));
36884 break;
36885case OP_InitThisBitFieldUint8:
36886 Text.Op = PrintName("InitThisBitFieldUint8");
36887 Text.Args.push_back(printArg<uint32_t>(PC));
36888 Text.Args.push_back(printArg<uint32_t>(PC));
36889 break;
36890case OP_InitThisBitFieldSint16:
36891 Text.Op = PrintName("InitThisBitFieldSint16");
36892 Text.Args.push_back(printArg<uint32_t>(PC));
36893 Text.Args.push_back(printArg<uint32_t>(PC));
36894 break;
36895case OP_InitThisBitFieldUint16:
36896 Text.Op = PrintName("InitThisBitFieldUint16");
36897 Text.Args.push_back(printArg<uint32_t>(PC));
36898 Text.Args.push_back(printArg<uint32_t>(PC));
36899 break;
36900case OP_InitThisBitFieldSint32:
36901 Text.Op = PrintName("InitThisBitFieldSint32");
36902 Text.Args.push_back(printArg<uint32_t>(PC));
36903 Text.Args.push_back(printArg<uint32_t>(PC));
36904 break;
36905case OP_InitThisBitFieldUint32:
36906 Text.Op = PrintName("InitThisBitFieldUint32");
36907 Text.Args.push_back(printArg<uint32_t>(PC));
36908 Text.Args.push_back(printArg<uint32_t>(PC));
36909 break;
36910case OP_InitThisBitFieldSint64:
36911 Text.Op = PrintName("InitThisBitFieldSint64");
36912 Text.Args.push_back(printArg<uint32_t>(PC));
36913 Text.Args.push_back(printArg<uint32_t>(PC));
36914 break;
36915case OP_InitThisBitFieldUint64:
36916 Text.Op = PrintName("InitThisBitFieldUint64");
36917 Text.Args.push_back(printArg<uint32_t>(PC));
36918 Text.Args.push_back(printArg<uint32_t>(PC));
36919 break;
36920case OP_InitThisBitFieldIntAP:
36921 Text.Op = PrintName("InitThisBitFieldIntAP");
36922 Text.Args.push_back(printArg<uint32_t>(PC));
36923 Text.Args.push_back(printArg<uint32_t>(PC));
36924 break;
36925case OP_InitThisBitFieldIntAPS:
36926 Text.Op = PrintName("InitThisBitFieldIntAPS");
36927 Text.Args.push_back(printArg<uint32_t>(PC));
36928 Text.Args.push_back(printArg<uint32_t>(PC));
36929 break;
36930case OP_InitThisBitFieldBool:
36931 Text.Op = PrintName("InitThisBitFieldBool");
36932 Text.Args.push_back(printArg<uint32_t>(PC));
36933 Text.Args.push_back(printArg<uint32_t>(PC));
36934 break;
36935#endif
36936#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
36937bool emitInitThisBitFieldSint8( uint32_t , uint32_t , SourceInfo);
36938bool emitInitThisBitFieldUint8( uint32_t , uint32_t , SourceInfo);
36939bool emitInitThisBitFieldSint16( uint32_t , uint32_t , SourceInfo);
36940bool emitInitThisBitFieldUint16( uint32_t , uint32_t , SourceInfo);
36941bool emitInitThisBitFieldSint32( uint32_t , uint32_t , SourceInfo);
36942bool emitInitThisBitFieldUint32( uint32_t , uint32_t , SourceInfo);
36943bool emitInitThisBitFieldSint64( uint32_t , uint32_t , SourceInfo);
36944bool emitInitThisBitFieldUint64( uint32_t , uint32_t , SourceInfo);
36945bool emitInitThisBitFieldIntAP( uint32_t , uint32_t , SourceInfo);
36946bool emitInitThisBitFieldIntAPS( uint32_t , uint32_t , SourceInfo);
36947bool emitInitThisBitFieldBool( uint32_t , uint32_t , SourceInfo);
36948#endif
36949#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
36950[[nodiscard]] bool emitInitThisBitField(PrimType, uint32_t, uint32_t, SourceInfo I);
36951#endif
36952#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
36953bool
36954#if defined(GET_EVAL_IMPL)
36955EvalEmitter
36956#else
36957ByteCodeEmitter
36958#endif
36959::emitInitThisBitField(PrimType T0, uint32_t A0, uint32_t A1, SourceInfo I) {
36960 switch (T0) {
36961 case PT_Sint8:
36962 return emitInitThisBitFieldSint8(A0, A1, I);
36963 case PT_Uint8:
36964 return emitInitThisBitFieldUint8(A0, A1, I);
36965 case PT_Sint16:
36966 return emitInitThisBitFieldSint16(A0, A1, I);
36967 case PT_Uint16:
36968 return emitInitThisBitFieldUint16(A0, A1, I);
36969 case PT_Sint32:
36970 return emitInitThisBitFieldSint32(A0, A1, I);
36971 case PT_Uint32:
36972 return emitInitThisBitFieldUint32(A0, A1, I);
36973 case PT_Sint64:
36974 return emitInitThisBitFieldSint64(A0, A1, I);
36975 case PT_Uint64:
36976 return emitInitThisBitFieldUint64(A0, A1, I);
36977 case PT_IntAP:
36978 return emitInitThisBitFieldIntAP(A0, A1, I);
36979 case PT_IntAPS:
36980 return emitInitThisBitFieldIntAPS(A0, A1, I);
36981 case PT_Bool:
36982 return emitInitThisBitFieldBool(A0, A1, I);
36983 default: llvm_unreachable("invalid type: emitInitThisBitField");
36984 }
36985 llvm_unreachable("invalid enum value");
36986}
36987#endif
36988#ifdef GET_LINK_IMPL
36989bool ByteCodeEmitter::emitInitThisBitFieldSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
36990 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldSint8, A0, A1, L);
36991}
36992bool ByteCodeEmitter::emitInitThisBitFieldUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
36993 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldUint8, A0, A1, L);
36994}
36995bool ByteCodeEmitter::emitInitThisBitFieldSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
36996 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldSint16, A0, A1, L);
36997}
36998bool ByteCodeEmitter::emitInitThisBitFieldUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
36999 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldUint16, A0, A1, L);
37000}
37001bool ByteCodeEmitter::emitInitThisBitFieldSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
37002 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldSint32, A0, A1, L);
37003}
37004bool ByteCodeEmitter::emitInitThisBitFieldUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
37005 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldUint32, A0, A1, L);
37006}
37007bool ByteCodeEmitter::emitInitThisBitFieldSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
37008 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldSint64, A0, A1, L);
37009}
37010bool ByteCodeEmitter::emitInitThisBitFieldUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
37011 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldUint64, A0, A1, L);
37012}
37013bool ByteCodeEmitter::emitInitThisBitFieldIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
37014 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldIntAP, A0, A1, L);
37015}
37016bool ByteCodeEmitter::emitInitThisBitFieldIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
37017 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldIntAPS, A0, A1, L);
37018}
37019bool ByteCodeEmitter::emitInitThisBitFieldBool( uint32_t A0, uint32_t A1, SourceInfo L) {
37020 return emitOp<uint32_t, uint32_t>(OP_InitThisBitFieldBool, A0, A1, L);
37021}
37022#endif
37023#ifdef GET_EVAL_IMPL
37024bool EvalEmitter::emitInitThisBitFieldSint8( uint32_t A0, uint32_t A1, SourceInfo L) {
37025 if (!isActive()) return true;
37026 CurrentSource = L;
37027 return InitThisBitField<PT_Sint8>(S, CodePtr(), A0, A1);
37028}
37029bool EvalEmitter::emitInitThisBitFieldUint8( uint32_t A0, uint32_t A1, SourceInfo L) {
37030 if (!isActive()) return true;
37031 CurrentSource = L;
37032 return InitThisBitField<PT_Uint8>(S, CodePtr(), A0, A1);
37033}
37034bool EvalEmitter::emitInitThisBitFieldSint16( uint32_t A0, uint32_t A1, SourceInfo L) {
37035 if (!isActive()) return true;
37036 CurrentSource = L;
37037 return InitThisBitField<PT_Sint16>(S, CodePtr(), A0, A1);
37038}
37039bool EvalEmitter::emitInitThisBitFieldUint16( uint32_t A0, uint32_t A1, SourceInfo L) {
37040 if (!isActive()) return true;
37041 CurrentSource = L;
37042 return InitThisBitField<PT_Uint16>(S, CodePtr(), A0, A1);
37043}
37044bool EvalEmitter::emitInitThisBitFieldSint32( uint32_t A0, uint32_t A1, SourceInfo L) {
37045 if (!isActive()) return true;
37046 CurrentSource = L;
37047 return InitThisBitField<PT_Sint32>(S, CodePtr(), A0, A1);
37048}
37049bool EvalEmitter::emitInitThisBitFieldUint32( uint32_t A0, uint32_t A1, SourceInfo L) {
37050 if (!isActive()) return true;
37051 CurrentSource = L;
37052 return InitThisBitField<PT_Uint32>(S, CodePtr(), A0, A1);
37053}
37054bool EvalEmitter::emitInitThisBitFieldSint64( uint32_t A0, uint32_t A1, SourceInfo L) {
37055 if (!isActive()) return true;
37056 CurrentSource = L;
37057 return InitThisBitField<PT_Sint64>(S, CodePtr(), A0, A1);
37058}
37059bool EvalEmitter::emitInitThisBitFieldUint64( uint32_t A0, uint32_t A1, SourceInfo L) {
37060 if (!isActive()) return true;
37061 CurrentSource = L;
37062 return InitThisBitField<PT_Uint64>(S, CodePtr(), A0, A1);
37063}
37064bool EvalEmitter::emitInitThisBitFieldIntAP( uint32_t A0, uint32_t A1, SourceInfo L) {
37065 if (!isActive()) return true;
37066 CurrentSource = L;
37067 return InitThisBitField<PT_IntAP>(S, CodePtr(), A0, A1);
37068}
37069bool EvalEmitter::emitInitThisBitFieldIntAPS( uint32_t A0, uint32_t A1, SourceInfo L) {
37070 if (!isActive()) return true;
37071 CurrentSource = L;
37072 return InitThisBitField<PT_IntAPS>(S, CodePtr(), A0, A1);
37073}
37074bool EvalEmitter::emitInitThisBitFieldBool( uint32_t A0, uint32_t A1, SourceInfo L) {
37075 if (!isActive()) return true;
37076 CurrentSource = L;
37077 return InitThisBitField<PT_Bool>(S, CodePtr(), A0, A1);
37078}
37079#endif
37080#ifdef GET_OPCODE_NAMES
37081OP_InitThisFieldSint8,
37082OP_InitThisFieldUint8,
37083OP_InitThisFieldSint16,
37084OP_InitThisFieldUint16,
37085OP_InitThisFieldSint32,
37086OP_InitThisFieldUint32,
37087OP_InitThisFieldSint64,
37088OP_InitThisFieldUint64,
37089OP_InitThisFieldIntAP,
37090OP_InitThisFieldIntAPS,
37091OP_InitThisFieldBool,
37092OP_InitThisFieldFixedPoint,
37093OP_InitThisFieldPtr,
37094OP_InitThisFieldMemberPtr,
37095OP_InitThisFieldFloat,
37096OP_InitThisFieldReflect,
37097#endif
37098#ifdef GET_INTERPFN_LIST
37099&Interp_InitThisFieldSint8,
37100&Interp_InitThisFieldUint8,
37101&Interp_InitThisFieldSint16,
37102&Interp_InitThisFieldUint16,
37103&Interp_InitThisFieldSint32,
37104&Interp_InitThisFieldUint32,
37105&Interp_InitThisFieldSint64,
37106&Interp_InitThisFieldUint64,
37107&Interp_InitThisFieldIntAP,
37108&Interp_InitThisFieldIntAPS,
37109&Interp_InitThisFieldBool,
37110&Interp_InitThisFieldFixedPoint,
37111&Interp_InitThisFieldPtr,
37112&Interp_InitThisFieldMemberPtr,
37113&Interp_InitThisFieldFloat,
37114&Interp_InitThisFieldReflect,
37115#endif
37116#ifdef GET_INTERPFN_DISPATCHERS
37117PRESERVE_NONE
37118static bool Interp_InitThisFieldSint8(InterpState &S) {
37119 {
37120 CodePtr OpPC = S.PC;
37121 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37122 if (!InitThisField<PT_Sint8>(S, OpPC, V0)) return false;
37123 }
37124#if USE_TAILCALLS
37125 MUSTTAIL return InterpNext(S);
37126#else
37127 return true;
37128#endif
37129}
37130PRESERVE_NONE
37131static bool Interp_InitThisFieldUint8(InterpState &S) {
37132 {
37133 CodePtr OpPC = S.PC;
37134 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37135 if (!InitThisField<PT_Uint8>(S, OpPC, V0)) return false;
37136 }
37137#if USE_TAILCALLS
37138 MUSTTAIL return InterpNext(S);
37139#else
37140 return true;
37141#endif
37142}
37143PRESERVE_NONE
37144static bool Interp_InitThisFieldSint16(InterpState &S) {
37145 {
37146 CodePtr OpPC = S.PC;
37147 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37148 if (!InitThisField<PT_Sint16>(S, OpPC, V0)) return false;
37149 }
37150#if USE_TAILCALLS
37151 MUSTTAIL return InterpNext(S);
37152#else
37153 return true;
37154#endif
37155}
37156PRESERVE_NONE
37157static bool Interp_InitThisFieldUint16(InterpState &S) {
37158 {
37159 CodePtr OpPC = S.PC;
37160 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37161 if (!InitThisField<PT_Uint16>(S, OpPC, V0)) return false;
37162 }
37163#if USE_TAILCALLS
37164 MUSTTAIL return InterpNext(S);
37165#else
37166 return true;
37167#endif
37168}
37169PRESERVE_NONE
37170static bool Interp_InitThisFieldSint32(InterpState &S) {
37171 {
37172 CodePtr OpPC = S.PC;
37173 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37174 if (!InitThisField<PT_Sint32>(S, OpPC, V0)) return false;
37175 }
37176#if USE_TAILCALLS
37177 MUSTTAIL return InterpNext(S);
37178#else
37179 return true;
37180#endif
37181}
37182PRESERVE_NONE
37183static bool Interp_InitThisFieldUint32(InterpState &S) {
37184 {
37185 CodePtr OpPC = S.PC;
37186 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37187 if (!InitThisField<PT_Uint32>(S, OpPC, V0)) return false;
37188 }
37189#if USE_TAILCALLS
37190 MUSTTAIL return InterpNext(S);
37191#else
37192 return true;
37193#endif
37194}
37195PRESERVE_NONE
37196static bool Interp_InitThisFieldSint64(InterpState &S) {
37197 {
37198 CodePtr OpPC = S.PC;
37199 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37200 if (!InitThisField<PT_Sint64>(S, OpPC, V0)) return false;
37201 }
37202#if USE_TAILCALLS
37203 MUSTTAIL return InterpNext(S);
37204#else
37205 return true;
37206#endif
37207}
37208PRESERVE_NONE
37209static bool Interp_InitThisFieldUint64(InterpState &S) {
37210 {
37211 CodePtr OpPC = S.PC;
37212 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37213 if (!InitThisField<PT_Uint64>(S, OpPC, V0)) return false;
37214 }
37215#if USE_TAILCALLS
37216 MUSTTAIL return InterpNext(S);
37217#else
37218 return true;
37219#endif
37220}
37221PRESERVE_NONE
37222static bool Interp_InitThisFieldIntAP(InterpState &S) {
37223 {
37224 CodePtr OpPC = S.PC;
37225 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37226 if (!InitThisField<PT_IntAP>(S, OpPC, V0)) return false;
37227 }
37228#if USE_TAILCALLS
37229 MUSTTAIL return InterpNext(S);
37230#else
37231 return true;
37232#endif
37233}
37234PRESERVE_NONE
37235static bool Interp_InitThisFieldIntAPS(InterpState &S) {
37236 {
37237 CodePtr OpPC = S.PC;
37238 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37239 if (!InitThisField<PT_IntAPS>(S, OpPC, V0)) return false;
37240 }
37241#if USE_TAILCALLS
37242 MUSTTAIL return InterpNext(S);
37243#else
37244 return true;
37245#endif
37246}
37247PRESERVE_NONE
37248static bool Interp_InitThisFieldBool(InterpState &S) {
37249 {
37250 CodePtr OpPC = S.PC;
37251 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37252 if (!InitThisField<PT_Bool>(S, OpPC, V0)) return false;
37253 }
37254#if USE_TAILCALLS
37255 MUSTTAIL return InterpNext(S);
37256#else
37257 return true;
37258#endif
37259}
37260PRESERVE_NONE
37261static bool Interp_InitThisFieldFixedPoint(InterpState &S) {
37262 {
37263 CodePtr OpPC = S.PC;
37264 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37265 if (!InitThisField<PT_FixedPoint>(S, OpPC, V0)) return false;
37266 }
37267#if USE_TAILCALLS
37268 MUSTTAIL return InterpNext(S);
37269#else
37270 return true;
37271#endif
37272}
37273PRESERVE_NONE
37274static bool Interp_InitThisFieldPtr(InterpState &S) {
37275 {
37276 CodePtr OpPC = S.PC;
37277 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37278 if (!InitThisField<PT_Ptr>(S, OpPC, V0)) return false;
37279 }
37280#if USE_TAILCALLS
37281 MUSTTAIL return InterpNext(S);
37282#else
37283 return true;
37284#endif
37285}
37286PRESERVE_NONE
37287static bool Interp_InitThisFieldMemberPtr(InterpState &S) {
37288 {
37289 CodePtr OpPC = S.PC;
37290 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37291 if (!InitThisField<PT_MemberPtr>(S, OpPC, V0)) return false;
37292 }
37293#if USE_TAILCALLS
37294 MUSTTAIL return InterpNext(S);
37295#else
37296 return true;
37297#endif
37298}
37299PRESERVE_NONE
37300static bool Interp_InitThisFieldFloat(InterpState &S) {
37301 {
37302 CodePtr OpPC = S.PC;
37303 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37304 if (!InitThisField<PT_Float>(S, OpPC, V0)) return false;
37305 }
37306#if USE_TAILCALLS
37307 MUSTTAIL return InterpNext(S);
37308#else
37309 return true;
37310#endif
37311}
37312PRESERVE_NONE
37313static bool Interp_InitThisFieldReflect(InterpState &S) {
37314 {
37315 CodePtr OpPC = S.PC;
37316 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37317 if (!InitThisField<PT_Reflect>(S, OpPC, V0)) return false;
37318 }
37319#if USE_TAILCALLS
37320 MUSTTAIL return InterpNext(S);
37321#else
37322 return true;
37323#endif
37324}
37325#endif
37326#ifdef GET_DISASM
37327case OP_InitThisFieldSint8:
37328 Text.Op = PrintName("InitThisFieldSint8");
37329 Text.Args.push_back(printArg<uint32_t>(PC));
37330 break;
37331case OP_InitThisFieldUint8:
37332 Text.Op = PrintName("InitThisFieldUint8");
37333 Text.Args.push_back(printArg<uint32_t>(PC));
37334 break;
37335case OP_InitThisFieldSint16:
37336 Text.Op = PrintName("InitThisFieldSint16");
37337 Text.Args.push_back(printArg<uint32_t>(PC));
37338 break;
37339case OP_InitThisFieldUint16:
37340 Text.Op = PrintName("InitThisFieldUint16");
37341 Text.Args.push_back(printArg<uint32_t>(PC));
37342 break;
37343case OP_InitThisFieldSint32:
37344 Text.Op = PrintName("InitThisFieldSint32");
37345 Text.Args.push_back(printArg<uint32_t>(PC));
37346 break;
37347case OP_InitThisFieldUint32:
37348 Text.Op = PrintName("InitThisFieldUint32");
37349 Text.Args.push_back(printArg<uint32_t>(PC));
37350 break;
37351case OP_InitThisFieldSint64:
37352 Text.Op = PrintName("InitThisFieldSint64");
37353 Text.Args.push_back(printArg<uint32_t>(PC));
37354 break;
37355case OP_InitThisFieldUint64:
37356 Text.Op = PrintName("InitThisFieldUint64");
37357 Text.Args.push_back(printArg<uint32_t>(PC));
37358 break;
37359case OP_InitThisFieldIntAP:
37360 Text.Op = PrintName("InitThisFieldIntAP");
37361 Text.Args.push_back(printArg<uint32_t>(PC));
37362 break;
37363case OP_InitThisFieldIntAPS:
37364 Text.Op = PrintName("InitThisFieldIntAPS");
37365 Text.Args.push_back(printArg<uint32_t>(PC));
37366 break;
37367case OP_InitThisFieldBool:
37368 Text.Op = PrintName("InitThisFieldBool");
37369 Text.Args.push_back(printArg<uint32_t>(PC));
37370 break;
37371case OP_InitThisFieldFixedPoint:
37372 Text.Op = PrintName("InitThisFieldFixedPoint");
37373 Text.Args.push_back(printArg<uint32_t>(PC));
37374 break;
37375case OP_InitThisFieldPtr:
37376 Text.Op = PrintName("InitThisFieldPtr");
37377 Text.Args.push_back(printArg<uint32_t>(PC));
37378 break;
37379case OP_InitThisFieldMemberPtr:
37380 Text.Op = PrintName("InitThisFieldMemberPtr");
37381 Text.Args.push_back(printArg<uint32_t>(PC));
37382 break;
37383case OP_InitThisFieldFloat:
37384 Text.Op = PrintName("InitThisFieldFloat");
37385 Text.Args.push_back(printArg<uint32_t>(PC));
37386 break;
37387case OP_InitThisFieldReflect:
37388 Text.Op = PrintName("InitThisFieldReflect");
37389 Text.Args.push_back(printArg<uint32_t>(PC));
37390 break;
37391#endif
37392#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
37393bool emitInitThisFieldSint8( uint32_t , SourceInfo);
37394bool emitInitThisFieldUint8( uint32_t , SourceInfo);
37395bool emitInitThisFieldSint16( uint32_t , SourceInfo);
37396bool emitInitThisFieldUint16( uint32_t , SourceInfo);
37397bool emitInitThisFieldSint32( uint32_t , SourceInfo);
37398bool emitInitThisFieldUint32( uint32_t , SourceInfo);
37399bool emitInitThisFieldSint64( uint32_t , SourceInfo);
37400bool emitInitThisFieldUint64( uint32_t , SourceInfo);
37401bool emitInitThisFieldIntAP( uint32_t , SourceInfo);
37402bool emitInitThisFieldIntAPS( uint32_t , SourceInfo);
37403bool emitInitThisFieldBool( uint32_t , SourceInfo);
37404bool emitInitThisFieldFixedPoint( uint32_t , SourceInfo);
37405bool emitInitThisFieldPtr( uint32_t , SourceInfo);
37406bool emitInitThisFieldMemberPtr( uint32_t , SourceInfo);
37407bool emitInitThisFieldFloat( uint32_t , SourceInfo);
37408bool emitInitThisFieldReflect( uint32_t , SourceInfo);
37409#endif
37410#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
37411[[nodiscard]] bool emitInitThisField(PrimType, uint32_t, SourceInfo I);
37412#endif
37413#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
37414bool
37415#if defined(GET_EVAL_IMPL)
37416EvalEmitter
37417#else
37418ByteCodeEmitter
37419#endif
37420::emitInitThisField(PrimType T0, uint32_t A0, SourceInfo I) {
37421 switch (T0) {
37422 case PT_Sint8:
37423 return emitInitThisFieldSint8(A0, I);
37424 case PT_Uint8:
37425 return emitInitThisFieldUint8(A0, I);
37426 case PT_Sint16:
37427 return emitInitThisFieldSint16(A0, I);
37428 case PT_Uint16:
37429 return emitInitThisFieldUint16(A0, I);
37430 case PT_Sint32:
37431 return emitInitThisFieldSint32(A0, I);
37432 case PT_Uint32:
37433 return emitInitThisFieldUint32(A0, I);
37434 case PT_Sint64:
37435 return emitInitThisFieldSint64(A0, I);
37436 case PT_Uint64:
37437 return emitInitThisFieldUint64(A0, I);
37438 case PT_IntAP:
37439 return emitInitThisFieldIntAP(A0, I);
37440 case PT_IntAPS:
37441 return emitInitThisFieldIntAPS(A0, I);
37442 case PT_Bool:
37443 return emitInitThisFieldBool(A0, I);
37444 case PT_FixedPoint:
37445 return emitInitThisFieldFixedPoint(A0, I);
37446 case PT_Ptr:
37447 return emitInitThisFieldPtr(A0, I);
37448 case PT_MemberPtr:
37449 return emitInitThisFieldMemberPtr(A0, I);
37450 case PT_Float:
37451 return emitInitThisFieldFloat(A0, I);
37452 case PT_Reflect:
37453 return emitInitThisFieldReflect(A0, I);
37454 }
37455 llvm_unreachable("invalid enum value");
37456}
37457#endif
37458#ifdef GET_LINK_IMPL
37459bool ByteCodeEmitter::emitInitThisFieldSint8( uint32_t A0, SourceInfo L) {
37460 return emitOp<uint32_t>(OP_InitThisFieldSint8, A0, L);
37461}
37462bool ByteCodeEmitter::emitInitThisFieldUint8( uint32_t A0, SourceInfo L) {
37463 return emitOp<uint32_t>(OP_InitThisFieldUint8, A0, L);
37464}
37465bool ByteCodeEmitter::emitInitThisFieldSint16( uint32_t A0, SourceInfo L) {
37466 return emitOp<uint32_t>(OP_InitThisFieldSint16, A0, L);
37467}
37468bool ByteCodeEmitter::emitInitThisFieldUint16( uint32_t A0, SourceInfo L) {
37469 return emitOp<uint32_t>(OP_InitThisFieldUint16, A0, L);
37470}
37471bool ByteCodeEmitter::emitInitThisFieldSint32( uint32_t A0, SourceInfo L) {
37472 return emitOp<uint32_t>(OP_InitThisFieldSint32, A0, L);
37473}
37474bool ByteCodeEmitter::emitInitThisFieldUint32( uint32_t A0, SourceInfo L) {
37475 return emitOp<uint32_t>(OP_InitThisFieldUint32, A0, L);
37476}
37477bool ByteCodeEmitter::emitInitThisFieldSint64( uint32_t A0, SourceInfo L) {
37478 return emitOp<uint32_t>(OP_InitThisFieldSint64, A0, L);
37479}
37480bool ByteCodeEmitter::emitInitThisFieldUint64( uint32_t A0, SourceInfo L) {
37481 return emitOp<uint32_t>(OP_InitThisFieldUint64, A0, L);
37482}
37483bool ByteCodeEmitter::emitInitThisFieldIntAP( uint32_t A0, SourceInfo L) {
37484 return emitOp<uint32_t>(OP_InitThisFieldIntAP, A0, L);
37485}
37486bool ByteCodeEmitter::emitInitThisFieldIntAPS( uint32_t A0, SourceInfo L) {
37487 return emitOp<uint32_t>(OP_InitThisFieldIntAPS, A0, L);
37488}
37489bool ByteCodeEmitter::emitInitThisFieldBool( uint32_t A0, SourceInfo L) {
37490 return emitOp<uint32_t>(OP_InitThisFieldBool, A0, L);
37491}
37492bool ByteCodeEmitter::emitInitThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
37493 return emitOp<uint32_t>(OP_InitThisFieldFixedPoint, A0, L);
37494}
37495bool ByteCodeEmitter::emitInitThisFieldPtr( uint32_t A0, SourceInfo L) {
37496 return emitOp<uint32_t>(OP_InitThisFieldPtr, A0, L);
37497}
37498bool ByteCodeEmitter::emitInitThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
37499 return emitOp<uint32_t>(OP_InitThisFieldMemberPtr, A0, L);
37500}
37501bool ByteCodeEmitter::emitInitThisFieldFloat( uint32_t A0, SourceInfo L) {
37502 return emitOp<uint32_t>(OP_InitThisFieldFloat, A0, L);
37503}
37504bool ByteCodeEmitter::emitInitThisFieldReflect( uint32_t A0, SourceInfo L) {
37505 return emitOp<uint32_t>(OP_InitThisFieldReflect, A0, L);
37506}
37507#endif
37508#ifdef GET_EVAL_IMPL
37509bool EvalEmitter::emitInitThisFieldSint8( uint32_t A0, SourceInfo L) {
37510 if (!isActive()) return true;
37511 CurrentSource = L;
37512 return InitThisField<PT_Sint8>(S, CodePtr(), A0);
37513}
37514bool EvalEmitter::emitInitThisFieldUint8( uint32_t A0, SourceInfo L) {
37515 if (!isActive()) return true;
37516 CurrentSource = L;
37517 return InitThisField<PT_Uint8>(S, CodePtr(), A0);
37518}
37519bool EvalEmitter::emitInitThisFieldSint16( uint32_t A0, SourceInfo L) {
37520 if (!isActive()) return true;
37521 CurrentSource = L;
37522 return InitThisField<PT_Sint16>(S, CodePtr(), A0);
37523}
37524bool EvalEmitter::emitInitThisFieldUint16( uint32_t A0, SourceInfo L) {
37525 if (!isActive()) return true;
37526 CurrentSource = L;
37527 return InitThisField<PT_Uint16>(S, CodePtr(), A0);
37528}
37529bool EvalEmitter::emitInitThisFieldSint32( uint32_t A0, SourceInfo L) {
37530 if (!isActive()) return true;
37531 CurrentSource = L;
37532 return InitThisField<PT_Sint32>(S, CodePtr(), A0);
37533}
37534bool EvalEmitter::emitInitThisFieldUint32( uint32_t A0, SourceInfo L) {
37535 if (!isActive()) return true;
37536 CurrentSource = L;
37537 return InitThisField<PT_Uint32>(S, CodePtr(), A0);
37538}
37539bool EvalEmitter::emitInitThisFieldSint64( uint32_t A0, SourceInfo L) {
37540 if (!isActive()) return true;
37541 CurrentSource = L;
37542 return InitThisField<PT_Sint64>(S, CodePtr(), A0);
37543}
37544bool EvalEmitter::emitInitThisFieldUint64( uint32_t A0, SourceInfo L) {
37545 if (!isActive()) return true;
37546 CurrentSource = L;
37547 return InitThisField<PT_Uint64>(S, CodePtr(), A0);
37548}
37549bool EvalEmitter::emitInitThisFieldIntAP( uint32_t A0, SourceInfo L) {
37550 if (!isActive()) return true;
37551 CurrentSource = L;
37552 return InitThisField<PT_IntAP>(S, CodePtr(), A0);
37553}
37554bool EvalEmitter::emitInitThisFieldIntAPS( uint32_t A0, SourceInfo L) {
37555 if (!isActive()) return true;
37556 CurrentSource = L;
37557 return InitThisField<PT_IntAPS>(S, CodePtr(), A0);
37558}
37559bool EvalEmitter::emitInitThisFieldBool( uint32_t A0, SourceInfo L) {
37560 if (!isActive()) return true;
37561 CurrentSource = L;
37562 return InitThisField<PT_Bool>(S, CodePtr(), A0);
37563}
37564bool EvalEmitter::emitInitThisFieldFixedPoint( uint32_t A0, SourceInfo L) {
37565 if (!isActive()) return true;
37566 CurrentSource = L;
37567 return InitThisField<PT_FixedPoint>(S, CodePtr(), A0);
37568}
37569bool EvalEmitter::emitInitThisFieldPtr( uint32_t A0, SourceInfo L) {
37570 if (!isActive()) return true;
37571 CurrentSource = L;
37572 return InitThisField<PT_Ptr>(S, CodePtr(), A0);
37573}
37574bool EvalEmitter::emitInitThisFieldMemberPtr( uint32_t A0, SourceInfo L) {
37575 if (!isActive()) return true;
37576 CurrentSource = L;
37577 return InitThisField<PT_MemberPtr>(S, CodePtr(), A0);
37578}
37579bool EvalEmitter::emitInitThisFieldFloat( uint32_t A0, SourceInfo L) {
37580 if (!isActive()) return true;
37581 CurrentSource = L;
37582 return InitThisField<PT_Float>(S, CodePtr(), A0);
37583}
37584bool EvalEmitter::emitInitThisFieldReflect( uint32_t A0, SourceInfo L) {
37585 if (!isActive()) return true;
37586 CurrentSource = L;
37587 return InitThisField<PT_Reflect>(S, CodePtr(), A0);
37588}
37589#endif
37590#ifdef GET_OPCODE_NAMES
37591OP_InitThisFieldActivateSint8,
37592OP_InitThisFieldActivateUint8,
37593OP_InitThisFieldActivateSint16,
37594OP_InitThisFieldActivateUint16,
37595OP_InitThisFieldActivateSint32,
37596OP_InitThisFieldActivateUint32,
37597OP_InitThisFieldActivateSint64,
37598OP_InitThisFieldActivateUint64,
37599OP_InitThisFieldActivateIntAP,
37600OP_InitThisFieldActivateIntAPS,
37601OP_InitThisFieldActivateBool,
37602OP_InitThisFieldActivateFixedPoint,
37603OP_InitThisFieldActivatePtr,
37604OP_InitThisFieldActivateMemberPtr,
37605OP_InitThisFieldActivateFloat,
37606OP_InitThisFieldActivateReflect,
37607#endif
37608#ifdef GET_INTERPFN_LIST
37609&Interp_InitThisFieldActivateSint8,
37610&Interp_InitThisFieldActivateUint8,
37611&Interp_InitThisFieldActivateSint16,
37612&Interp_InitThisFieldActivateUint16,
37613&Interp_InitThisFieldActivateSint32,
37614&Interp_InitThisFieldActivateUint32,
37615&Interp_InitThisFieldActivateSint64,
37616&Interp_InitThisFieldActivateUint64,
37617&Interp_InitThisFieldActivateIntAP,
37618&Interp_InitThisFieldActivateIntAPS,
37619&Interp_InitThisFieldActivateBool,
37620&Interp_InitThisFieldActivateFixedPoint,
37621&Interp_InitThisFieldActivatePtr,
37622&Interp_InitThisFieldActivateMemberPtr,
37623&Interp_InitThisFieldActivateFloat,
37624&Interp_InitThisFieldActivateReflect,
37625#endif
37626#ifdef GET_INTERPFN_DISPATCHERS
37627PRESERVE_NONE
37628static bool Interp_InitThisFieldActivateSint8(InterpState &S) {
37629 {
37630 CodePtr OpPC = S.PC;
37631 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37632 if (!InitThisFieldActivate<PT_Sint8>(S, OpPC, V0)) return false;
37633 }
37634#if USE_TAILCALLS
37635 MUSTTAIL return InterpNext(S);
37636#else
37637 return true;
37638#endif
37639}
37640PRESERVE_NONE
37641static bool Interp_InitThisFieldActivateUint8(InterpState &S) {
37642 {
37643 CodePtr OpPC = S.PC;
37644 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37645 if (!InitThisFieldActivate<PT_Uint8>(S, OpPC, V0)) return false;
37646 }
37647#if USE_TAILCALLS
37648 MUSTTAIL return InterpNext(S);
37649#else
37650 return true;
37651#endif
37652}
37653PRESERVE_NONE
37654static bool Interp_InitThisFieldActivateSint16(InterpState &S) {
37655 {
37656 CodePtr OpPC = S.PC;
37657 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37658 if (!InitThisFieldActivate<PT_Sint16>(S, OpPC, V0)) return false;
37659 }
37660#if USE_TAILCALLS
37661 MUSTTAIL return InterpNext(S);
37662#else
37663 return true;
37664#endif
37665}
37666PRESERVE_NONE
37667static bool Interp_InitThisFieldActivateUint16(InterpState &S) {
37668 {
37669 CodePtr OpPC = S.PC;
37670 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37671 if (!InitThisFieldActivate<PT_Uint16>(S, OpPC, V0)) return false;
37672 }
37673#if USE_TAILCALLS
37674 MUSTTAIL return InterpNext(S);
37675#else
37676 return true;
37677#endif
37678}
37679PRESERVE_NONE
37680static bool Interp_InitThisFieldActivateSint32(InterpState &S) {
37681 {
37682 CodePtr OpPC = S.PC;
37683 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37684 if (!InitThisFieldActivate<PT_Sint32>(S, OpPC, V0)) return false;
37685 }
37686#if USE_TAILCALLS
37687 MUSTTAIL return InterpNext(S);
37688#else
37689 return true;
37690#endif
37691}
37692PRESERVE_NONE
37693static bool Interp_InitThisFieldActivateUint32(InterpState &S) {
37694 {
37695 CodePtr OpPC = S.PC;
37696 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37697 if (!InitThisFieldActivate<PT_Uint32>(S, OpPC, V0)) return false;
37698 }
37699#if USE_TAILCALLS
37700 MUSTTAIL return InterpNext(S);
37701#else
37702 return true;
37703#endif
37704}
37705PRESERVE_NONE
37706static bool Interp_InitThisFieldActivateSint64(InterpState &S) {
37707 {
37708 CodePtr OpPC = S.PC;
37709 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37710 if (!InitThisFieldActivate<PT_Sint64>(S, OpPC, V0)) return false;
37711 }
37712#if USE_TAILCALLS
37713 MUSTTAIL return InterpNext(S);
37714#else
37715 return true;
37716#endif
37717}
37718PRESERVE_NONE
37719static bool Interp_InitThisFieldActivateUint64(InterpState &S) {
37720 {
37721 CodePtr OpPC = S.PC;
37722 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37723 if (!InitThisFieldActivate<PT_Uint64>(S, OpPC, V0)) return false;
37724 }
37725#if USE_TAILCALLS
37726 MUSTTAIL return InterpNext(S);
37727#else
37728 return true;
37729#endif
37730}
37731PRESERVE_NONE
37732static bool Interp_InitThisFieldActivateIntAP(InterpState &S) {
37733 {
37734 CodePtr OpPC = S.PC;
37735 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37736 if (!InitThisFieldActivate<PT_IntAP>(S, OpPC, V0)) return false;
37737 }
37738#if USE_TAILCALLS
37739 MUSTTAIL return InterpNext(S);
37740#else
37741 return true;
37742#endif
37743}
37744PRESERVE_NONE
37745static bool Interp_InitThisFieldActivateIntAPS(InterpState &S) {
37746 {
37747 CodePtr OpPC = S.PC;
37748 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37749 if (!InitThisFieldActivate<PT_IntAPS>(S, OpPC, V0)) return false;
37750 }
37751#if USE_TAILCALLS
37752 MUSTTAIL return InterpNext(S);
37753#else
37754 return true;
37755#endif
37756}
37757PRESERVE_NONE
37758static bool Interp_InitThisFieldActivateBool(InterpState &S) {
37759 {
37760 CodePtr OpPC = S.PC;
37761 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37762 if (!InitThisFieldActivate<PT_Bool>(S, OpPC, V0)) return false;
37763 }
37764#if USE_TAILCALLS
37765 MUSTTAIL return InterpNext(S);
37766#else
37767 return true;
37768#endif
37769}
37770PRESERVE_NONE
37771static bool Interp_InitThisFieldActivateFixedPoint(InterpState &S) {
37772 {
37773 CodePtr OpPC = S.PC;
37774 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37775 if (!InitThisFieldActivate<PT_FixedPoint>(S, OpPC, V0)) return false;
37776 }
37777#if USE_TAILCALLS
37778 MUSTTAIL return InterpNext(S);
37779#else
37780 return true;
37781#endif
37782}
37783PRESERVE_NONE
37784static bool Interp_InitThisFieldActivatePtr(InterpState &S) {
37785 {
37786 CodePtr OpPC = S.PC;
37787 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37788 if (!InitThisFieldActivate<PT_Ptr>(S, OpPC, V0)) return false;
37789 }
37790#if USE_TAILCALLS
37791 MUSTTAIL return InterpNext(S);
37792#else
37793 return true;
37794#endif
37795}
37796PRESERVE_NONE
37797static bool Interp_InitThisFieldActivateMemberPtr(InterpState &S) {
37798 {
37799 CodePtr OpPC = S.PC;
37800 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37801 if (!InitThisFieldActivate<PT_MemberPtr>(S, OpPC, V0)) return false;
37802 }
37803#if USE_TAILCALLS
37804 MUSTTAIL return InterpNext(S);
37805#else
37806 return true;
37807#endif
37808}
37809PRESERVE_NONE
37810static bool Interp_InitThisFieldActivateFloat(InterpState &S) {
37811 {
37812 CodePtr OpPC = S.PC;
37813 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37814 if (!InitThisFieldActivate<PT_Float>(S, OpPC, V0)) return false;
37815 }
37816#if USE_TAILCALLS
37817 MUSTTAIL return InterpNext(S);
37818#else
37819 return true;
37820#endif
37821}
37822PRESERVE_NONE
37823static bool Interp_InitThisFieldActivateReflect(InterpState &S) {
37824 {
37825 CodePtr OpPC = S.PC;
37826 const auto V0 = ReadArg<uint32_t>(S, S.PC);
37827 if (!InitThisFieldActivate<PT_Reflect>(S, OpPC, V0)) return false;
37828 }
37829#if USE_TAILCALLS
37830 MUSTTAIL return InterpNext(S);
37831#else
37832 return true;
37833#endif
37834}
37835#endif
37836#ifdef GET_DISASM
37837case OP_InitThisFieldActivateSint8:
37838 Text.Op = PrintName("InitThisFieldActivateSint8");
37839 Text.Args.push_back(printArg<uint32_t>(PC));
37840 break;
37841case OP_InitThisFieldActivateUint8:
37842 Text.Op = PrintName("InitThisFieldActivateUint8");
37843 Text.Args.push_back(printArg<uint32_t>(PC));
37844 break;
37845case OP_InitThisFieldActivateSint16:
37846 Text.Op = PrintName("InitThisFieldActivateSint16");
37847 Text.Args.push_back(printArg<uint32_t>(PC));
37848 break;
37849case OP_InitThisFieldActivateUint16:
37850 Text.Op = PrintName("InitThisFieldActivateUint16");
37851 Text.Args.push_back(printArg<uint32_t>(PC));
37852 break;
37853case OP_InitThisFieldActivateSint32:
37854 Text.Op = PrintName("InitThisFieldActivateSint32");
37855 Text.Args.push_back(printArg<uint32_t>(PC));
37856 break;
37857case OP_InitThisFieldActivateUint32:
37858 Text.Op = PrintName("InitThisFieldActivateUint32");
37859 Text.Args.push_back(printArg<uint32_t>(PC));
37860 break;
37861case OP_InitThisFieldActivateSint64:
37862 Text.Op = PrintName("InitThisFieldActivateSint64");
37863 Text.Args.push_back(printArg<uint32_t>(PC));
37864 break;
37865case OP_InitThisFieldActivateUint64:
37866 Text.Op = PrintName("InitThisFieldActivateUint64");
37867 Text.Args.push_back(printArg<uint32_t>(PC));
37868 break;
37869case OP_InitThisFieldActivateIntAP:
37870 Text.Op = PrintName("InitThisFieldActivateIntAP");
37871 Text.Args.push_back(printArg<uint32_t>(PC));
37872 break;
37873case OP_InitThisFieldActivateIntAPS:
37874 Text.Op = PrintName("InitThisFieldActivateIntAPS");
37875 Text.Args.push_back(printArg<uint32_t>(PC));
37876 break;
37877case OP_InitThisFieldActivateBool:
37878 Text.Op = PrintName("InitThisFieldActivateBool");
37879 Text.Args.push_back(printArg<uint32_t>(PC));
37880 break;
37881case OP_InitThisFieldActivateFixedPoint:
37882 Text.Op = PrintName("InitThisFieldActivateFixedPoint");
37883 Text.Args.push_back(printArg<uint32_t>(PC));
37884 break;
37885case OP_InitThisFieldActivatePtr:
37886 Text.Op = PrintName("InitThisFieldActivatePtr");
37887 Text.Args.push_back(printArg<uint32_t>(PC));
37888 break;
37889case OP_InitThisFieldActivateMemberPtr:
37890 Text.Op = PrintName("InitThisFieldActivateMemberPtr");
37891 Text.Args.push_back(printArg<uint32_t>(PC));
37892 break;
37893case OP_InitThisFieldActivateFloat:
37894 Text.Op = PrintName("InitThisFieldActivateFloat");
37895 Text.Args.push_back(printArg<uint32_t>(PC));
37896 break;
37897case OP_InitThisFieldActivateReflect:
37898 Text.Op = PrintName("InitThisFieldActivateReflect");
37899 Text.Args.push_back(printArg<uint32_t>(PC));
37900 break;
37901#endif
37902#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
37903bool emitInitThisFieldActivateSint8( uint32_t , SourceInfo);
37904bool emitInitThisFieldActivateUint8( uint32_t , SourceInfo);
37905bool emitInitThisFieldActivateSint16( uint32_t , SourceInfo);
37906bool emitInitThisFieldActivateUint16( uint32_t , SourceInfo);
37907bool emitInitThisFieldActivateSint32( uint32_t , SourceInfo);
37908bool emitInitThisFieldActivateUint32( uint32_t , SourceInfo);
37909bool emitInitThisFieldActivateSint64( uint32_t , SourceInfo);
37910bool emitInitThisFieldActivateUint64( uint32_t , SourceInfo);
37911bool emitInitThisFieldActivateIntAP( uint32_t , SourceInfo);
37912bool emitInitThisFieldActivateIntAPS( uint32_t , SourceInfo);
37913bool emitInitThisFieldActivateBool( uint32_t , SourceInfo);
37914bool emitInitThisFieldActivateFixedPoint( uint32_t , SourceInfo);
37915bool emitInitThisFieldActivatePtr( uint32_t , SourceInfo);
37916bool emitInitThisFieldActivateMemberPtr( uint32_t , SourceInfo);
37917bool emitInitThisFieldActivateFloat( uint32_t , SourceInfo);
37918bool emitInitThisFieldActivateReflect( uint32_t , SourceInfo);
37919#endif
37920#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
37921[[nodiscard]] bool emitInitThisFieldActivate(PrimType, uint32_t, SourceInfo I);
37922#endif
37923#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
37924bool
37925#if defined(GET_EVAL_IMPL)
37926EvalEmitter
37927#else
37928ByteCodeEmitter
37929#endif
37930::emitInitThisFieldActivate(PrimType T0, uint32_t A0, SourceInfo I) {
37931 switch (T0) {
37932 case PT_Sint8:
37933 return emitInitThisFieldActivateSint8(A0, I);
37934 case PT_Uint8:
37935 return emitInitThisFieldActivateUint8(A0, I);
37936 case PT_Sint16:
37937 return emitInitThisFieldActivateSint16(A0, I);
37938 case PT_Uint16:
37939 return emitInitThisFieldActivateUint16(A0, I);
37940 case PT_Sint32:
37941 return emitInitThisFieldActivateSint32(A0, I);
37942 case PT_Uint32:
37943 return emitInitThisFieldActivateUint32(A0, I);
37944 case PT_Sint64:
37945 return emitInitThisFieldActivateSint64(A0, I);
37946 case PT_Uint64:
37947 return emitInitThisFieldActivateUint64(A0, I);
37948 case PT_IntAP:
37949 return emitInitThisFieldActivateIntAP(A0, I);
37950 case PT_IntAPS:
37951 return emitInitThisFieldActivateIntAPS(A0, I);
37952 case PT_Bool:
37953 return emitInitThisFieldActivateBool(A0, I);
37954 case PT_FixedPoint:
37955 return emitInitThisFieldActivateFixedPoint(A0, I);
37956 case PT_Ptr:
37957 return emitInitThisFieldActivatePtr(A0, I);
37958 case PT_MemberPtr:
37959 return emitInitThisFieldActivateMemberPtr(A0, I);
37960 case PT_Float:
37961 return emitInitThisFieldActivateFloat(A0, I);
37962 case PT_Reflect:
37963 return emitInitThisFieldActivateReflect(A0, I);
37964 }
37965 llvm_unreachable("invalid enum value");
37966}
37967#endif
37968#ifdef GET_LINK_IMPL
37969bool ByteCodeEmitter::emitInitThisFieldActivateSint8( uint32_t A0, SourceInfo L) {
37970 return emitOp<uint32_t>(OP_InitThisFieldActivateSint8, A0, L);
37971}
37972bool ByteCodeEmitter::emitInitThisFieldActivateUint8( uint32_t A0, SourceInfo L) {
37973 return emitOp<uint32_t>(OP_InitThisFieldActivateUint8, A0, L);
37974}
37975bool ByteCodeEmitter::emitInitThisFieldActivateSint16( uint32_t A0, SourceInfo L) {
37976 return emitOp<uint32_t>(OP_InitThisFieldActivateSint16, A0, L);
37977}
37978bool ByteCodeEmitter::emitInitThisFieldActivateUint16( uint32_t A0, SourceInfo L) {
37979 return emitOp<uint32_t>(OP_InitThisFieldActivateUint16, A0, L);
37980}
37981bool ByteCodeEmitter::emitInitThisFieldActivateSint32( uint32_t A0, SourceInfo L) {
37982 return emitOp<uint32_t>(OP_InitThisFieldActivateSint32, A0, L);
37983}
37984bool ByteCodeEmitter::emitInitThisFieldActivateUint32( uint32_t A0, SourceInfo L) {
37985 return emitOp<uint32_t>(OP_InitThisFieldActivateUint32, A0, L);
37986}
37987bool ByteCodeEmitter::emitInitThisFieldActivateSint64( uint32_t A0, SourceInfo L) {
37988 return emitOp<uint32_t>(OP_InitThisFieldActivateSint64, A0, L);
37989}
37990bool ByteCodeEmitter::emitInitThisFieldActivateUint64( uint32_t A0, SourceInfo L) {
37991 return emitOp<uint32_t>(OP_InitThisFieldActivateUint64, A0, L);
37992}
37993bool ByteCodeEmitter::emitInitThisFieldActivateIntAP( uint32_t A0, SourceInfo L) {
37994 return emitOp<uint32_t>(OP_InitThisFieldActivateIntAP, A0, L);
37995}
37996bool ByteCodeEmitter::emitInitThisFieldActivateIntAPS( uint32_t A0, SourceInfo L) {
37997 return emitOp<uint32_t>(OP_InitThisFieldActivateIntAPS, A0, L);
37998}
37999bool ByteCodeEmitter::emitInitThisFieldActivateBool( uint32_t A0, SourceInfo L) {
38000 return emitOp<uint32_t>(OP_InitThisFieldActivateBool, A0, L);
38001}
38002bool ByteCodeEmitter::emitInitThisFieldActivateFixedPoint( uint32_t A0, SourceInfo L) {
38003 return emitOp<uint32_t>(OP_InitThisFieldActivateFixedPoint, A0, L);
38004}
38005bool ByteCodeEmitter::emitInitThisFieldActivatePtr( uint32_t A0, SourceInfo L) {
38006 return emitOp<uint32_t>(OP_InitThisFieldActivatePtr, A0, L);
38007}
38008bool ByteCodeEmitter::emitInitThisFieldActivateMemberPtr( uint32_t A0, SourceInfo L) {
38009 return emitOp<uint32_t>(OP_InitThisFieldActivateMemberPtr, A0, L);
38010}
38011bool ByteCodeEmitter::emitInitThisFieldActivateFloat( uint32_t A0, SourceInfo L) {
38012 return emitOp<uint32_t>(OP_InitThisFieldActivateFloat, A0, L);
38013}
38014bool ByteCodeEmitter::emitInitThisFieldActivateReflect( uint32_t A0, SourceInfo L) {
38015 return emitOp<uint32_t>(OP_InitThisFieldActivateReflect, A0, L);
38016}
38017#endif
38018#ifdef GET_EVAL_IMPL
38019bool EvalEmitter::emitInitThisFieldActivateSint8( uint32_t A0, SourceInfo L) {
38020 if (!isActive()) return true;
38021 CurrentSource = L;
38022 return InitThisFieldActivate<PT_Sint8>(S, CodePtr(), A0);
38023}
38024bool EvalEmitter::emitInitThisFieldActivateUint8( uint32_t A0, SourceInfo L) {
38025 if (!isActive()) return true;
38026 CurrentSource = L;
38027 return InitThisFieldActivate<PT_Uint8>(S, CodePtr(), A0);
38028}
38029bool EvalEmitter::emitInitThisFieldActivateSint16( uint32_t A0, SourceInfo L) {
38030 if (!isActive()) return true;
38031 CurrentSource = L;
38032 return InitThisFieldActivate<PT_Sint16>(S, CodePtr(), A0);
38033}
38034bool EvalEmitter::emitInitThisFieldActivateUint16( uint32_t A0, SourceInfo L) {
38035 if (!isActive()) return true;
38036 CurrentSource = L;
38037 return InitThisFieldActivate<PT_Uint16>(S, CodePtr(), A0);
38038}
38039bool EvalEmitter::emitInitThisFieldActivateSint32( uint32_t A0, SourceInfo L) {
38040 if (!isActive()) return true;
38041 CurrentSource = L;
38042 return InitThisFieldActivate<PT_Sint32>(S, CodePtr(), A0);
38043}
38044bool EvalEmitter::emitInitThisFieldActivateUint32( uint32_t A0, SourceInfo L) {
38045 if (!isActive()) return true;
38046 CurrentSource = L;
38047 return InitThisFieldActivate<PT_Uint32>(S, CodePtr(), A0);
38048}
38049bool EvalEmitter::emitInitThisFieldActivateSint64( uint32_t A0, SourceInfo L) {
38050 if (!isActive()) return true;
38051 CurrentSource = L;
38052 return InitThisFieldActivate<PT_Sint64>(S, CodePtr(), A0);
38053}
38054bool EvalEmitter::emitInitThisFieldActivateUint64( uint32_t A0, SourceInfo L) {
38055 if (!isActive()) return true;
38056 CurrentSource = L;
38057 return InitThisFieldActivate<PT_Uint64>(S, CodePtr(), A0);
38058}
38059bool EvalEmitter::emitInitThisFieldActivateIntAP( uint32_t A0, SourceInfo L) {
38060 if (!isActive()) return true;
38061 CurrentSource = L;
38062 return InitThisFieldActivate<PT_IntAP>(S, CodePtr(), A0);
38063}
38064bool EvalEmitter::emitInitThisFieldActivateIntAPS( uint32_t A0, SourceInfo L) {
38065 if (!isActive()) return true;
38066 CurrentSource = L;
38067 return InitThisFieldActivate<PT_IntAPS>(S, CodePtr(), A0);
38068}
38069bool EvalEmitter::emitInitThisFieldActivateBool( uint32_t A0, SourceInfo L) {
38070 if (!isActive()) return true;
38071 CurrentSource = L;
38072 return InitThisFieldActivate<PT_Bool>(S, CodePtr(), A0);
38073}
38074bool EvalEmitter::emitInitThisFieldActivateFixedPoint( uint32_t A0, SourceInfo L) {
38075 if (!isActive()) return true;
38076 CurrentSource = L;
38077 return InitThisFieldActivate<PT_FixedPoint>(S, CodePtr(), A0);
38078}
38079bool EvalEmitter::emitInitThisFieldActivatePtr( uint32_t A0, SourceInfo L) {
38080 if (!isActive()) return true;
38081 CurrentSource = L;
38082 return InitThisFieldActivate<PT_Ptr>(S, CodePtr(), A0);
38083}
38084bool EvalEmitter::emitInitThisFieldActivateMemberPtr( uint32_t A0, SourceInfo L) {
38085 if (!isActive()) return true;
38086 CurrentSource = L;
38087 return InitThisFieldActivate<PT_MemberPtr>(S, CodePtr(), A0);
38088}
38089bool EvalEmitter::emitInitThisFieldActivateFloat( uint32_t A0, SourceInfo L) {
38090 if (!isActive()) return true;
38091 CurrentSource = L;
38092 return InitThisFieldActivate<PT_Float>(S, CodePtr(), A0);
38093}
38094bool EvalEmitter::emitInitThisFieldActivateReflect( uint32_t A0, SourceInfo L) {
38095 if (!isActive()) return true;
38096 CurrentSource = L;
38097 return InitThisFieldActivate<PT_Reflect>(S, CodePtr(), A0);
38098}
38099#endif
38100#ifdef GET_OPCODE_NAMES
38101OP_Inv,
38102#endif
38103#ifdef GET_INTERPFN_LIST
38104&Interp_Inv,
38105#endif
38106#ifdef GET_INTERPFN_DISPATCHERS
38107PRESERVE_NONE
38108static bool Interp_Inv(InterpState &S) {
38109 Inv(S);
38110#if USE_TAILCALLS
38111 MUSTTAIL return InterpNext(S);
38112#else
38113 return true;
38114#endif
38115}
38116#endif
38117#ifdef GET_DISASM
38118case OP_Inv:
38119 Text.Op = PrintName("Inv");
38120 break;
38121#endif
38122#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38123bool emitInv(SourceInfo);
38124#endif
38125#ifdef GET_LINK_IMPL
38126bool ByteCodeEmitter::emitInv(SourceInfo L) {
38127 return emitOp<>(OP_Inv, L);
38128}
38129#endif
38130#ifdef GET_EVAL_IMPL
38131bool EvalEmitter::emitInv(SourceInfo L) {
38132 if (!isActive()) return true;
38133 CurrentSource = L;
38134 return Inv(S);
38135}
38136#endif
38137#ifdef GET_OPCODE_NAMES
38138OP_Invalid,
38139#endif
38140#ifdef GET_INTERPFN_LIST
38141&Interp_Invalid,
38142#endif
38143#ifdef GET_INTERPFN_DISPATCHERS
38144PRESERVE_NONE
38145static bool Interp_Invalid(InterpState &S) {
38146 if (!Invalid(S, S.PC)) return false;
38147#if USE_TAILCALLS
38148 MUSTTAIL return InterpNext(S);
38149#else
38150 return true;
38151#endif
38152}
38153#endif
38154#ifdef GET_DISASM
38155case OP_Invalid:
38156 Text.Op = PrintName("Invalid");
38157 break;
38158#endif
38159#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38160bool emitInvalid(SourceInfo);
38161#endif
38162#ifdef GET_LINK_IMPL
38163bool ByteCodeEmitter::emitInvalid(SourceInfo L) {
38164 return emitOp<>(OP_Invalid, L);
38165}
38166#endif
38167#ifdef GET_EVAL_IMPL
38168bool EvalEmitter::emitInvalid(SourceInfo L) {
38169 if (!isActive()) return true;
38170 CurrentSource = L;
38171 return Invalid(S, CodePtr());
38172}
38173#endif
38174#ifdef GET_OPCODE_NAMES
38175OP_InvalidAccessIndexAttr,
38176#endif
38177#ifdef GET_INTERPFN_LIST
38178&Interp_InvalidAccessIndexAttr,
38179#endif
38180#ifdef GET_INTERPFN_DISPATCHERS
38181PRESERVE_NONE
38182static bool Interp_InvalidAccessIndexAttr(InterpState &S) {
38183 {
38184 CodePtr OpPC = S.PC;
38185 const auto V0 = ReadArg<const ValueDecl*>(S, S.PC);
38186 const auto V1 = ReadArg<const Type *>(S, S.PC);
38187 if (!InvalidAccessIndexAttr(S, OpPC, V0, V1)) return false;
38188 }
38189#if USE_TAILCALLS
38190 MUSTTAIL return InterpNext(S);
38191#else
38192 return true;
38193#endif
38194}
38195#endif
38196#ifdef GET_DISASM
38197case OP_InvalidAccessIndexAttr:
38198 Text.Op = PrintName("InvalidAccessIndexAttr");
38199 Text.Args.push_back(printArg<const ValueDecl*>(PC));
38200 Text.Args.push_back(printArg<const Type *>(PC));
38201 break;
38202#endif
38203#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38204bool emitInvalidAccessIndexAttr( const ValueDecl* , const Type * , SourceInfo);
38205#endif
38206#ifdef GET_LINK_IMPL
38207bool ByteCodeEmitter::emitInvalidAccessIndexAttr( const ValueDecl* A0, const Type * A1, SourceInfo L) {
38208 return emitOp<const ValueDecl*, const Type *>(OP_InvalidAccessIndexAttr, A0, A1, L);
38209}
38210#endif
38211#ifdef GET_EVAL_IMPL
38212bool EvalEmitter::emitInvalidAccessIndexAttr( const ValueDecl* A0, const Type * A1, SourceInfo L) {
38213 if (!isActive()) return true;
38214 CurrentSource = L;
38215 return InvalidAccessIndexAttr(S, CodePtr(), A0, A1);
38216}
38217#endif
38218#ifdef GET_OPCODE_NAMES
38219OP_InvalidCast,
38220#endif
38221#ifdef GET_INTERPFN_LIST
38222&Interp_InvalidCast,
38223#endif
38224#ifdef GET_INTERPFN_DISPATCHERS
38225PRESERVE_NONE
38226static bool Interp_InvalidCast(InterpState &S) {
38227 {
38228 CodePtr OpPC = S.PC;
38229 const auto V0 = ReadArg<interp::CastKind>(S, S.PC);
38230 const auto V1 = ReadArg<bool>(S, S.PC);
38231 if (!InvalidCast(S, OpPC, V0, V1)) return false;
38232 }
38233#if USE_TAILCALLS
38234 MUSTTAIL return InterpNext(S);
38235#else
38236 return true;
38237#endif
38238}
38239#endif
38240#ifdef GET_DISASM
38241case OP_InvalidCast:
38242 Text.Op = PrintName("InvalidCast");
38243 Text.Args.push_back(printArg<interp::CastKind>(PC));
38244 Text.Args.push_back(printArg<bool>(PC));
38245 break;
38246#endif
38247#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38248bool emitInvalidCast( interp::CastKind , bool , SourceInfo);
38249#endif
38250#ifdef GET_LINK_IMPL
38251bool ByteCodeEmitter::emitInvalidCast( interp::CastKind A0, bool A1, SourceInfo L) {
38252 return emitOp<interp::CastKind, bool>(OP_InvalidCast, A0, A1, L);
38253}
38254#endif
38255#ifdef GET_EVAL_IMPL
38256bool EvalEmitter::emitInvalidCast( interp::CastKind A0, bool A1, SourceInfo L) {
38257 if (!isActive()) return true;
38258 CurrentSource = L;
38259 return InvalidCast(S, CodePtr(), A0, A1);
38260}
38261#endif
38262#ifdef GET_OPCODE_NAMES
38263OP_InvalidDeclRef,
38264#endif
38265#ifdef GET_INTERPFN_LIST
38266&Interp_InvalidDeclRef,
38267#endif
38268#ifdef GET_INTERPFN_DISPATCHERS
38269PRESERVE_NONE
38270static bool Interp_InvalidDeclRef(InterpState &S) {
38271 {
38272 CodePtr OpPC = S.PC;
38273 const auto V0 = ReadArg<const DeclRefExpr *>(S, S.PC);
38274 const auto V1 = ReadArg<bool>(S, S.PC);
38275 if (!InvalidDeclRef(S, OpPC, V0, V1)) return false;
38276 }
38277#if USE_TAILCALLS
38278 MUSTTAIL return InterpNext(S);
38279#else
38280 return true;
38281#endif
38282}
38283#endif
38284#ifdef GET_DISASM
38285case OP_InvalidDeclRef:
38286 Text.Op = PrintName("InvalidDeclRef");
38287 Text.Args.push_back(printArg<const DeclRefExpr *>(PC));
38288 Text.Args.push_back(printArg<bool>(PC));
38289 break;
38290#endif
38291#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38292bool emitInvalidDeclRef( const DeclRefExpr * , bool , SourceInfo);
38293#endif
38294#ifdef GET_LINK_IMPL
38295bool ByteCodeEmitter::emitInvalidDeclRef( const DeclRefExpr * A0, bool A1, SourceInfo L) {
38296 return emitOp<const DeclRefExpr *, bool>(OP_InvalidDeclRef, A0, A1, L);
38297}
38298#endif
38299#ifdef GET_EVAL_IMPL
38300bool EvalEmitter::emitInvalidDeclRef( const DeclRefExpr * A0, bool A1, SourceInfo L) {
38301 if (!isActive()) return true;
38302 CurrentSource = L;
38303 return InvalidDeclRef(S, CodePtr(), A0, A1);
38304}
38305#endif
38306#ifdef GET_OPCODE_NAMES
38307OP_InvalidNewDeleteExpr,
38308#endif
38309#ifdef GET_INTERPFN_LIST
38310&Interp_InvalidNewDeleteExpr,
38311#endif
38312#ifdef GET_INTERPFN_DISPATCHERS
38313PRESERVE_NONE
38314static bool Interp_InvalidNewDeleteExpr(InterpState &S) {
38315 {
38316 CodePtr OpPC = S.PC;
38317 const auto V0 = ReadArg<const Expr *>(S, S.PC);
38318 if (!InvalidNewDeleteExpr(S, OpPC, V0)) return false;
38319 }
38320#if USE_TAILCALLS
38321 MUSTTAIL return InterpNext(S);
38322#else
38323 return true;
38324#endif
38325}
38326#endif
38327#ifdef GET_DISASM
38328case OP_InvalidNewDeleteExpr:
38329 Text.Op = PrintName("InvalidNewDeleteExpr");
38330 Text.Args.push_back(printArg<const Expr *>(PC));
38331 break;
38332#endif
38333#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38334bool emitInvalidNewDeleteExpr( const Expr * , SourceInfo);
38335#endif
38336#ifdef GET_LINK_IMPL
38337bool ByteCodeEmitter::emitInvalidNewDeleteExpr( const Expr * A0, SourceInfo L) {
38338 return emitOp<const Expr *>(OP_InvalidNewDeleteExpr, A0, L);
38339}
38340#endif
38341#ifdef GET_EVAL_IMPL
38342bool EvalEmitter::emitInvalidNewDeleteExpr( const Expr * A0, SourceInfo L) {
38343 if (!isActive()) return true;
38344 CurrentSource = L;
38345 return InvalidNewDeleteExpr(S, CodePtr(), A0);
38346}
38347#endif
38348#ifdef GET_OPCODE_NAMES
38349OP_InvalidShuffleVectorIndex,
38350#endif
38351#ifdef GET_INTERPFN_LIST
38352&Interp_InvalidShuffleVectorIndex,
38353#endif
38354#ifdef GET_INTERPFN_DISPATCHERS
38355PRESERVE_NONE
38356static bool Interp_InvalidShuffleVectorIndex(InterpState &S) {
38357 {
38358 CodePtr OpPC = S.PC;
38359 const auto V0 = ReadArg<uint32_t>(S, S.PC);
38360 if (!InvalidShuffleVectorIndex(S, OpPC, V0)) return false;
38361 }
38362#if USE_TAILCALLS
38363 MUSTTAIL return InterpNext(S);
38364#else
38365 return true;
38366#endif
38367}
38368#endif
38369#ifdef GET_DISASM
38370case OP_InvalidShuffleVectorIndex:
38371 Text.Op = PrintName("InvalidShuffleVectorIndex");
38372 Text.Args.push_back(printArg<uint32_t>(PC));
38373 break;
38374#endif
38375#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38376bool emitInvalidShuffleVectorIndex( uint32_t , SourceInfo);
38377#endif
38378#ifdef GET_LINK_IMPL
38379bool ByteCodeEmitter::emitInvalidShuffleVectorIndex( uint32_t A0, SourceInfo L) {
38380 return emitOp<uint32_t>(OP_InvalidShuffleVectorIndex, A0, L);
38381}
38382#endif
38383#ifdef GET_EVAL_IMPL
38384bool EvalEmitter::emitInvalidShuffleVectorIndex( uint32_t A0, SourceInfo L) {
38385 if (!isActive()) return true;
38386 CurrentSource = L;
38387 return InvalidShuffleVectorIndex(S, CodePtr(), A0);
38388}
38389#endif
38390#ifdef GET_OPCODE_NAMES
38391OP_InvalidStore,
38392#endif
38393#ifdef GET_INTERPFN_LIST
38394&Interp_InvalidStore,
38395#endif
38396#ifdef GET_INTERPFN_DISPATCHERS
38397PRESERVE_NONE
38398static bool Interp_InvalidStore(InterpState &S) {
38399 {
38400 CodePtr OpPC = S.PC;
38401 const auto V0 = ReadArg<const Type *>(S, S.PC);
38402 if (!InvalidStore(S, OpPC, V0)) return false;
38403 }
38404#if USE_TAILCALLS
38405 MUSTTAIL return InterpNext(S);
38406#else
38407 return true;
38408#endif
38409}
38410#endif
38411#ifdef GET_DISASM
38412case OP_InvalidStore:
38413 Text.Op = PrintName("InvalidStore");
38414 Text.Args.push_back(printArg<const Type *>(PC));
38415 break;
38416#endif
38417#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38418bool emitInvalidStore( const Type * , SourceInfo);
38419#endif
38420#ifdef GET_LINK_IMPL
38421bool ByteCodeEmitter::emitInvalidStore( const Type * A0, SourceInfo L) {
38422 return emitOp<const Type *>(OP_InvalidStore, A0, L);
38423}
38424#endif
38425#ifdef GET_EVAL_IMPL
38426bool EvalEmitter::emitInvalidStore( const Type * A0, SourceInfo L) {
38427 if (!isActive()) return true;
38428 CurrentSource = L;
38429 return InvalidStore(S, CodePtr(), A0);
38430}
38431#endif
38432#ifdef GET_OPCODE_NAMES
38433OP_InvalidTargetLabel,
38434#endif
38435#ifdef GET_INTERPFN_LIST
38436&Interp_InvalidTargetLabel,
38437#endif
38438#ifdef GET_INTERPFN_DISPATCHERS
38439PRESERVE_NONE
38440static bool Interp_InvalidTargetLabel(InterpState &S) {
38441 {
38442 CodePtr OpPC = S.PC;
38443 const auto V0 = ReadArg<bool>(S, S.PC);
38444 if (!InvalidTargetLabel(S, OpPC, V0)) return false;
38445 }
38446#if USE_TAILCALLS
38447 MUSTTAIL return InterpNext(S);
38448#else
38449 return true;
38450#endif
38451}
38452#endif
38453#ifdef GET_DISASM
38454case OP_InvalidTargetLabel:
38455 Text.Op = PrintName("InvalidTargetLabel");
38456 Text.Args.push_back(printArg<bool>(PC));
38457 break;
38458#endif
38459#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38460bool emitInvalidTargetLabel( bool , SourceInfo);
38461#endif
38462#ifdef GET_LINK_IMPL
38463bool ByteCodeEmitter::emitInvalidTargetLabel( bool A0, SourceInfo L) {
38464 return emitOp<bool>(OP_InvalidTargetLabel, A0, L);
38465}
38466#endif
38467#ifdef GET_EVAL_IMPL
38468bool EvalEmitter::emitInvalidTargetLabel( bool A0, SourceInfo L) {
38469 if (!isActive()) return true;
38470 CurrentSource = L;
38471 return InvalidTargetLabel(S, CodePtr(), A0);
38472}
38473#endif
38474#ifdef GET_OPCODE_NAMES
38475OP_IsBaseClass,
38476#endif
38477#ifdef GET_INTERPFN_LIST
38478&Interp_IsBaseClass,
38479#endif
38480#ifdef GET_INTERPFN_DISPATCHERS
38481PRESERVE_NONE
38482static bool Interp_IsBaseClass(InterpState &S) {
38483 IsBaseClass(S);
38484#if USE_TAILCALLS
38485 MUSTTAIL return InterpNext(S);
38486#else
38487 return true;
38488#endif
38489}
38490#endif
38491#ifdef GET_DISASM
38492case OP_IsBaseClass:
38493 Text.Op = PrintName("IsBaseClass");
38494 break;
38495#endif
38496#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38497bool emitIsBaseClass(SourceInfo);
38498#endif
38499#ifdef GET_LINK_IMPL
38500bool ByteCodeEmitter::emitIsBaseClass(SourceInfo L) {
38501 return emitOp<>(OP_IsBaseClass, L);
38502}
38503#endif
38504#ifdef GET_EVAL_IMPL
38505bool EvalEmitter::emitIsBaseClass(SourceInfo L) {
38506 if (!isActive()) return true;
38507 CurrentSource = L;
38508 return IsBaseClass(S);
38509}
38510#endif
38511#ifdef GET_OPCODE_NAMES
38512OP_IsConstantContext,
38513#endif
38514#ifdef GET_INTERPFN_LIST
38515&Interp_IsConstantContext,
38516#endif
38517#ifdef GET_INTERPFN_DISPATCHERS
38518PRESERVE_NONE
38519static bool Interp_IsConstantContext(InterpState &S) {
38520 IsConstantContext(S);
38521#if USE_TAILCALLS
38522 MUSTTAIL return InterpNext(S);
38523#else
38524 return true;
38525#endif
38526}
38527#endif
38528#ifdef GET_DISASM
38529case OP_IsConstantContext:
38530 Text.Op = PrintName("IsConstantContext");
38531 break;
38532#endif
38533#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38534bool emitIsConstantContext(SourceInfo);
38535#endif
38536#ifdef GET_LINK_IMPL
38537bool ByteCodeEmitter::emitIsConstantContext(SourceInfo L) {
38538 return emitOp<>(OP_IsConstantContext, L);
38539}
38540#endif
38541#ifdef GET_EVAL_IMPL
38542bool EvalEmitter::emitIsConstantContext(SourceInfo L) {
38543 if (!isActive()) return true;
38544 CurrentSource = L;
38545 return IsConstantContext(S);
38546}
38547#endif
38548#ifdef GET_OPCODE_NAMES
38549OP_IsNonNullPtr,
38550OP_IsNonNullMemberPtr,
38551#endif
38552#ifdef GET_INTERPFN_LIST
38553&Interp_IsNonNullPtr,
38554&Interp_IsNonNullMemberPtr,
38555#endif
38556#ifdef GET_INTERPFN_DISPATCHERS
38557PRESERVE_NONE
38558static bool Interp_IsNonNullPtr(InterpState &S) {
38559 if (!IsNonNull<PT_Ptr>(S)) return false;
38560#if USE_TAILCALLS
38561 MUSTTAIL return InterpNext(S);
38562#else
38563 return true;
38564#endif
38565}
38566PRESERVE_NONE
38567static bool Interp_IsNonNullMemberPtr(InterpState &S) {
38568 if (!IsNonNull<PT_MemberPtr>(S)) return false;
38569#if USE_TAILCALLS
38570 MUSTTAIL return InterpNext(S);
38571#else
38572 return true;
38573#endif
38574}
38575#endif
38576#ifdef GET_DISASM
38577case OP_IsNonNullPtr:
38578 Text.Op = PrintName("IsNonNullPtr");
38579 break;
38580case OP_IsNonNullMemberPtr:
38581 Text.Op = PrintName("IsNonNullMemberPtr");
38582 break;
38583#endif
38584#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38585bool emitIsNonNullPtr(SourceInfo);
38586bool emitIsNonNullMemberPtr(SourceInfo);
38587#endif
38588#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38589[[nodiscard]] bool emitIsNonNull(PrimType, SourceInfo I);
38590#endif
38591#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
38592bool
38593#if defined(GET_EVAL_IMPL)
38594EvalEmitter
38595#else
38596ByteCodeEmitter
38597#endif
38598::emitIsNonNull(PrimType T0, SourceInfo I) {
38599 switch (T0) {
38600 case PT_Ptr:
38601 return emitIsNonNullPtr(I);
38602 case PT_MemberPtr:
38603 return emitIsNonNullMemberPtr(I);
38604 default: llvm_unreachable("invalid type: emitIsNonNull");
38605 }
38606 llvm_unreachable("invalid enum value");
38607}
38608#endif
38609#ifdef GET_LINK_IMPL
38610bool ByteCodeEmitter::emitIsNonNullPtr(SourceInfo L) {
38611 return emitOp<>(OP_IsNonNullPtr, L);
38612}
38613bool ByteCodeEmitter::emitIsNonNullMemberPtr(SourceInfo L) {
38614 return emitOp<>(OP_IsNonNullMemberPtr, L);
38615}
38616#endif
38617#ifdef GET_EVAL_IMPL
38618bool EvalEmitter::emitIsNonNullPtr(SourceInfo L) {
38619 if (!isActive()) return true;
38620 CurrentSource = L;
38621 return IsNonNull<PT_Ptr>(S);
38622}
38623bool EvalEmitter::emitIsNonNullMemberPtr(SourceInfo L) {
38624 if (!isActive()) return true;
38625 CurrentSource = L;
38626 return IsNonNull<PT_MemberPtr>(S);
38627}
38628#endif
38629#ifdef GET_OPCODE_NAMES
38630OP_Jf,
38631#endif
38632#ifdef GET_INTERPFN_LIST
38633&Interp_Jf,
38634#endif
38635#ifdef GET_INTERPFN_DISPATCHERS
38636PRESERVE_NONE
38637static bool Interp_Jf(InterpState &S) {
38638 {
38639 CodePtr OpPC = S.PC;
38640 const auto V0 = ReadArg<int32_t>(S, S.PC);
38641 if (!Jf(S, OpPC, V0)) return false;
38642 }
38643#if USE_TAILCALLS
38644 MUSTTAIL return InterpNext(S);
38645#else
38646 return true;
38647#endif
38648}
38649#endif
38650#ifdef GET_DISASM
38651case OP_Jf:
38652 Text.Op = PrintName("Jf");
38653 Text.Args.push_back(printArg<int32_t>(PC));
38654 break;
38655#endif
38656#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38657bool emitJf( int32_t , SourceInfo);
38658#endif
38659#ifdef GET_LINK_IMPL
38660bool ByteCodeEmitter::emitJf( int32_t A0, SourceInfo L) {
38661 return emitOp<int32_t>(OP_Jf, A0, L);
38662}
38663#endif
38664#ifdef GET_OPCODE_NAMES
38665OP_Jmp,
38666#endif
38667#ifdef GET_INTERPFN_LIST
38668&Interp_Jmp,
38669#endif
38670#ifdef GET_INTERPFN_DISPATCHERS
38671PRESERVE_NONE
38672static bool Interp_Jmp(InterpState &S) {
38673 {
38674 CodePtr OpPC = S.PC;
38675 const auto V0 = ReadArg<int32_t>(S, S.PC);
38676 if (!Jmp(S, OpPC, V0)) return false;
38677 }
38678#if USE_TAILCALLS
38679 MUSTTAIL return InterpNext(S);
38680#else
38681 return true;
38682#endif
38683}
38684#endif
38685#ifdef GET_DISASM
38686case OP_Jmp:
38687 Text.Op = PrintName("Jmp");
38688 Text.Args.push_back(printArg<int32_t>(PC));
38689 break;
38690#endif
38691#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38692bool emitJmp( int32_t , SourceInfo);
38693#endif
38694#ifdef GET_LINK_IMPL
38695bool ByteCodeEmitter::emitJmp( int32_t A0, SourceInfo L) {
38696 return emitOp<int32_t>(OP_Jmp, A0, L);
38697}
38698#endif
38699#ifdef GET_OPCODE_NAMES
38700OP_Jt,
38701#endif
38702#ifdef GET_INTERPFN_LIST
38703&Interp_Jt,
38704#endif
38705#ifdef GET_INTERPFN_DISPATCHERS
38706PRESERVE_NONE
38707static bool Interp_Jt(InterpState &S) {
38708 {
38709 CodePtr OpPC = S.PC;
38710 const auto V0 = ReadArg<int32_t>(S, S.PC);
38711 if (!Jt(S, OpPC, V0)) return false;
38712 }
38713#if USE_TAILCALLS
38714 MUSTTAIL return InterpNext(S);
38715#else
38716 return true;
38717#endif
38718}
38719#endif
38720#ifdef GET_DISASM
38721case OP_Jt:
38722 Text.Op = PrintName("Jt");
38723 Text.Args.push_back(printArg<int32_t>(PC));
38724 break;
38725#endif
38726#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38727bool emitJt( int32_t , SourceInfo);
38728#endif
38729#ifdef GET_LINK_IMPL
38730bool ByteCodeEmitter::emitJt( int32_t A0, SourceInfo L) {
38731 return emitOp<int32_t>(OP_Jt, A0, L);
38732}
38733#endif
38734#ifdef GET_OPCODE_NAMES
38735OP_LESint8,
38736OP_LEUint8,
38737OP_LESint16,
38738OP_LEUint16,
38739OP_LESint32,
38740OP_LEUint32,
38741OP_LESint64,
38742OP_LEUint64,
38743OP_LEIntAP,
38744OP_LEIntAPS,
38745OP_LEBool,
38746OP_LEFixedPoint,
38747OP_LEPtr,
38748OP_LEFloat,
38749#endif
38750#ifdef GET_INTERPFN_LIST
38751&Interp_LESint8,
38752&Interp_LEUint8,
38753&Interp_LESint16,
38754&Interp_LEUint16,
38755&Interp_LESint32,
38756&Interp_LEUint32,
38757&Interp_LESint64,
38758&Interp_LEUint64,
38759&Interp_LEIntAP,
38760&Interp_LEIntAPS,
38761&Interp_LEBool,
38762&Interp_LEFixedPoint,
38763&Interp_LEPtr,
38764&Interp_LEFloat,
38765#endif
38766#ifdef GET_INTERPFN_DISPATCHERS
38767PRESERVE_NONE
38768static bool Interp_LESint8(InterpState &S) {
38769 if (!LE<PT_Sint8>(S, S.PC)) return false;
38770#if USE_TAILCALLS
38771 MUSTTAIL return InterpNext(S);
38772#else
38773 return true;
38774#endif
38775}
38776PRESERVE_NONE
38777static bool Interp_LEUint8(InterpState &S) {
38778 if (!LE<PT_Uint8>(S, S.PC)) return false;
38779#if USE_TAILCALLS
38780 MUSTTAIL return InterpNext(S);
38781#else
38782 return true;
38783#endif
38784}
38785PRESERVE_NONE
38786static bool Interp_LESint16(InterpState &S) {
38787 if (!LE<PT_Sint16>(S, S.PC)) return false;
38788#if USE_TAILCALLS
38789 MUSTTAIL return InterpNext(S);
38790#else
38791 return true;
38792#endif
38793}
38794PRESERVE_NONE
38795static bool Interp_LEUint16(InterpState &S) {
38796 if (!LE<PT_Uint16>(S, S.PC)) return false;
38797#if USE_TAILCALLS
38798 MUSTTAIL return InterpNext(S);
38799#else
38800 return true;
38801#endif
38802}
38803PRESERVE_NONE
38804static bool Interp_LESint32(InterpState &S) {
38805 if (!LE<PT_Sint32>(S, S.PC)) return false;
38806#if USE_TAILCALLS
38807 MUSTTAIL return InterpNext(S);
38808#else
38809 return true;
38810#endif
38811}
38812PRESERVE_NONE
38813static bool Interp_LEUint32(InterpState &S) {
38814 if (!LE<PT_Uint32>(S, S.PC)) return false;
38815#if USE_TAILCALLS
38816 MUSTTAIL return InterpNext(S);
38817#else
38818 return true;
38819#endif
38820}
38821PRESERVE_NONE
38822static bool Interp_LESint64(InterpState &S) {
38823 if (!LE<PT_Sint64>(S, S.PC)) return false;
38824#if USE_TAILCALLS
38825 MUSTTAIL return InterpNext(S);
38826#else
38827 return true;
38828#endif
38829}
38830PRESERVE_NONE
38831static bool Interp_LEUint64(InterpState &S) {
38832 if (!LE<PT_Uint64>(S, S.PC)) return false;
38833#if USE_TAILCALLS
38834 MUSTTAIL return InterpNext(S);
38835#else
38836 return true;
38837#endif
38838}
38839PRESERVE_NONE
38840static bool Interp_LEIntAP(InterpState &S) {
38841 if (!LE<PT_IntAP>(S, S.PC)) return false;
38842#if USE_TAILCALLS
38843 MUSTTAIL return InterpNext(S);
38844#else
38845 return true;
38846#endif
38847}
38848PRESERVE_NONE
38849static bool Interp_LEIntAPS(InterpState &S) {
38850 if (!LE<PT_IntAPS>(S, S.PC)) return false;
38851#if USE_TAILCALLS
38852 MUSTTAIL return InterpNext(S);
38853#else
38854 return true;
38855#endif
38856}
38857PRESERVE_NONE
38858static bool Interp_LEBool(InterpState &S) {
38859 if (!LE<PT_Bool>(S, S.PC)) return false;
38860#if USE_TAILCALLS
38861 MUSTTAIL return InterpNext(S);
38862#else
38863 return true;
38864#endif
38865}
38866PRESERVE_NONE
38867static bool Interp_LEFixedPoint(InterpState &S) {
38868 if (!LE<PT_FixedPoint>(S, S.PC)) return false;
38869#if USE_TAILCALLS
38870 MUSTTAIL return InterpNext(S);
38871#else
38872 return true;
38873#endif
38874}
38875PRESERVE_NONE
38876static bool Interp_LEPtr(InterpState &S) {
38877 if (!LE<PT_Ptr>(S, S.PC)) return false;
38878#if USE_TAILCALLS
38879 MUSTTAIL return InterpNext(S);
38880#else
38881 return true;
38882#endif
38883}
38884PRESERVE_NONE
38885static bool Interp_LEFloat(InterpState &S) {
38886 if (!LE<PT_Float>(S, S.PC)) return false;
38887#if USE_TAILCALLS
38888 MUSTTAIL return InterpNext(S);
38889#else
38890 return true;
38891#endif
38892}
38893#endif
38894#ifdef GET_DISASM
38895case OP_LESint8:
38896 Text.Op = PrintName("LESint8");
38897 break;
38898case OP_LEUint8:
38899 Text.Op = PrintName("LEUint8");
38900 break;
38901case OP_LESint16:
38902 Text.Op = PrintName("LESint16");
38903 break;
38904case OP_LEUint16:
38905 Text.Op = PrintName("LEUint16");
38906 break;
38907case OP_LESint32:
38908 Text.Op = PrintName("LESint32");
38909 break;
38910case OP_LEUint32:
38911 Text.Op = PrintName("LEUint32");
38912 break;
38913case OP_LESint64:
38914 Text.Op = PrintName("LESint64");
38915 break;
38916case OP_LEUint64:
38917 Text.Op = PrintName("LEUint64");
38918 break;
38919case OP_LEIntAP:
38920 Text.Op = PrintName("LEIntAP");
38921 break;
38922case OP_LEIntAPS:
38923 Text.Op = PrintName("LEIntAPS");
38924 break;
38925case OP_LEBool:
38926 Text.Op = PrintName("LEBool");
38927 break;
38928case OP_LEFixedPoint:
38929 Text.Op = PrintName("LEFixedPoint");
38930 break;
38931case OP_LEPtr:
38932 Text.Op = PrintName("LEPtr");
38933 break;
38934case OP_LEFloat:
38935 Text.Op = PrintName("LEFloat");
38936 break;
38937#endif
38938#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38939bool emitLESint8(SourceInfo);
38940bool emitLEUint8(SourceInfo);
38941bool emitLESint16(SourceInfo);
38942bool emitLEUint16(SourceInfo);
38943bool emitLESint32(SourceInfo);
38944bool emitLEUint32(SourceInfo);
38945bool emitLESint64(SourceInfo);
38946bool emitLEUint64(SourceInfo);
38947bool emitLEIntAP(SourceInfo);
38948bool emitLEIntAPS(SourceInfo);
38949bool emitLEBool(SourceInfo);
38950bool emitLEFixedPoint(SourceInfo);
38951bool emitLEPtr(SourceInfo);
38952bool emitLEFloat(SourceInfo);
38953#endif
38954#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
38955[[nodiscard]] bool emitLE(PrimType, SourceInfo I);
38956#endif
38957#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
38958bool
38959#if defined(GET_EVAL_IMPL)
38960EvalEmitter
38961#else
38962ByteCodeEmitter
38963#endif
38964::emitLE(PrimType T0, SourceInfo I) {
38965 switch (T0) {
38966 case PT_Sint8:
38967 return emitLESint8(I);
38968 case PT_Uint8:
38969 return emitLEUint8(I);
38970 case PT_Sint16:
38971 return emitLESint16(I);
38972 case PT_Uint16:
38973 return emitLEUint16(I);
38974 case PT_Sint32:
38975 return emitLESint32(I);
38976 case PT_Uint32:
38977 return emitLEUint32(I);
38978 case PT_Sint64:
38979 return emitLESint64(I);
38980 case PT_Uint64:
38981 return emitLEUint64(I);
38982 case PT_IntAP:
38983 return emitLEIntAP(I);
38984 case PT_IntAPS:
38985 return emitLEIntAPS(I);
38986 case PT_Bool:
38987 return emitLEBool(I);
38988 case PT_FixedPoint:
38989 return emitLEFixedPoint(I);
38990 case PT_Ptr:
38991 return emitLEPtr(I);
38992 case PT_Float:
38993 return emitLEFloat(I);
38994 default: llvm_unreachable("invalid type: emitLE");
38995 }
38996 llvm_unreachable("invalid enum value");
38997}
38998#endif
38999#ifdef GET_LINK_IMPL
39000bool ByteCodeEmitter::emitLESint8(SourceInfo L) {
39001 return emitOp<>(OP_LESint8, L);
39002}
39003bool ByteCodeEmitter::emitLEUint8(SourceInfo L) {
39004 return emitOp<>(OP_LEUint8, L);
39005}
39006bool ByteCodeEmitter::emitLESint16(SourceInfo L) {
39007 return emitOp<>(OP_LESint16, L);
39008}
39009bool ByteCodeEmitter::emitLEUint16(SourceInfo L) {
39010 return emitOp<>(OP_LEUint16, L);
39011}
39012bool ByteCodeEmitter::emitLESint32(SourceInfo L) {
39013 return emitOp<>(OP_LESint32, L);
39014}
39015bool ByteCodeEmitter::emitLEUint32(SourceInfo L) {
39016 return emitOp<>(OP_LEUint32, L);
39017}
39018bool ByteCodeEmitter::emitLESint64(SourceInfo L) {
39019 return emitOp<>(OP_LESint64, L);
39020}
39021bool ByteCodeEmitter::emitLEUint64(SourceInfo L) {
39022 return emitOp<>(OP_LEUint64, L);
39023}
39024bool ByteCodeEmitter::emitLEIntAP(SourceInfo L) {
39025 return emitOp<>(OP_LEIntAP, L);
39026}
39027bool ByteCodeEmitter::emitLEIntAPS(SourceInfo L) {
39028 return emitOp<>(OP_LEIntAPS, L);
39029}
39030bool ByteCodeEmitter::emitLEBool(SourceInfo L) {
39031 return emitOp<>(OP_LEBool, L);
39032}
39033bool ByteCodeEmitter::emitLEFixedPoint(SourceInfo L) {
39034 return emitOp<>(OP_LEFixedPoint, L);
39035}
39036bool ByteCodeEmitter::emitLEPtr(SourceInfo L) {
39037 return emitOp<>(OP_LEPtr, L);
39038}
39039bool ByteCodeEmitter::emitLEFloat(SourceInfo L) {
39040 return emitOp<>(OP_LEFloat, L);
39041}
39042#endif
39043#ifdef GET_EVAL_IMPL
39044bool EvalEmitter::emitLESint8(SourceInfo L) {
39045 if (!isActive()) return true;
39046 CurrentSource = L;
39047 return LE<PT_Sint8>(S, CodePtr());
39048}
39049bool EvalEmitter::emitLEUint8(SourceInfo L) {
39050 if (!isActive()) return true;
39051 CurrentSource = L;
39052 return LE<PT_Uint8>(S, CodePtr());
39053}
39054bool EvalEmitter::emitLESint16(SourceInfo L) {
39055 if (!isActive()) return true;
39056 CurrentSource = L;
39057 return LE<PT_Sint16>(S, CodePtr());
39058}
39059bool EvalEmitter::emitLEUint16(SourceInfo L) {
39060 if (!isActive()) return true;
39061 CurrentSource = L;
39062 return LE<PT_Uint16>(S, CodePtr());
39063}
39064bool EvalEmitter::emitLESint32(SourceInfo L) {
39065 if (!isActive()) return true;
39066 CurrentSource = L;
39067 return LE<PT_Sint32>(S, CodePtr());
39068}
39069bool EvalEmitter::emitLEUint32(SourceInfo L) {
39070 if (!isActive()) return true;
39071 CurrentSource = L;
39072 return LE<PT_Uint32>(S, CodePtr());
39073}
39074bool EvalEmitter::emitLESint64(SourceInfo L) {
39075 if (!isActive()) return true;
39076 CurrentSource = L;
39077 return LE<PT_Sint64>(S, CodePtr());
39078}
39079bool EvalEmitter::emitLEUint64(SourceInfo L) {
39080 if (!isActive()) return true;
39081 CurrentSource = L;
39082 return LE<PT_Uint64>(S, CodePtr());
39083}
39084bool EvalEmitter::emitLEIntAP(SourceInfo L) {
39085 if (!isActive()) return true;
39086 CurrentSource = L;
39087 return LE<PT_IntAP>(S, CodePtr());
39088}
39089bool EvalEmitter::emitLEIntAPS(SourceInfo L) {
39090 if (!isActive()) return true;
39091 CurrentSource = L;
39092 return LE<PT_IntAPS>(S, CodePtr());
39093}
39094bool EvalEmitter::emitLEBool(SourceInfo L) {
39095 if (!isActive()) return true;
39096 CurrentSource = L;
39097 return LE<PT_Bool>(S, CodePtr());
39098}
39099bool EvalEmitter::emitLEFixedPoint(SourceInfo L) {
39100 if (!isActive()) return true;
39101 CurrentSource = L;
39102 return LE<PT_FixedPoint>(S, CodePtr());
39103}
39104bool EvalEmitter::emitLEPtr(SourceInfo L) {
39105 if (!isActive()) return true;
39106 CurrentSource = L;
39107 return LE<PT_Ptr>(S, CodePtr());
39108}
39109bool EvalEmitter::emitLEFloat(SourceInfo L) {
39110 if (!isActive()) return true;
39111 CurrentSource = L;
39112 return LE<PT_Float>(S, CodePtr());
39113}
39114#endif
39115#ifdef GET_OPCODE_NAMES
39116OP_LTSint8,
39117OP_LTUint8,
39118OP_LTSint16,
39119OP_LTUint16,
39120OP_LTSint32,
39121OP_LTUint32,
39122OP_LTSint64,
39123OP_LTUint64,
39124OP_LTIntAP,
39125OP_LTIntAPS,
39126OP_LTBool,
39127OP_LTFixedPoint,
39128OP_LTPtr,
39129OP_LTFloat,
39130#endif
39131#ifdef GET_INTERPFN_LIST
39132&Interp_LTSint8,
39133&Interp_LTUint8,
39134&Interp_LTSint16,
39135&Interp_LTUint16,
39136&Interp_LTSint32,
39137&Interp_LTUint32,
39138&Interp_LTSint64,
39139&Interp_LTUint64,
39140&Interp_LTIntAP,
39141&Interp_LTIntAPS,
39142&Interp_LTBool,
39143&Interp_LTFixedPoint,
39144&Interp_LTPtr,
39145&Interp_LTFloat,
39146#endif
39147#ifdef GET_INTERPFN_DISPATCHERS
39148PRESERVE_NONE
39149static bool Interp_LTSint8(InterpState &S) {
39150 if (!LT<PT_Sint8>(S, S.PC)) return false;
39151#if USE_TAILCALLS
39152 MUSTTAIL return InterpNext(S);
39153#else
39154 return true;
39155#endif
39156}
39157PRESERVE_NONE
39158static bool Interp_LTUint8(InterpState &S) {
39159 if (!LT<PT_Uint8>(S, S.PC)) return false;
39160#if USE_TAILCALLS
39161 MUSTTAIL return InterpNext(S);
39162#else
39163 return true;
39164#endif
39165}
39166PRESERVE_NONE
39167static bool Interp_LTSint16(InterpState &S) {
39168 if (!LT<PT_Sint16>(S, S.PC)) return false;
39169#if USE_TAILCALLS
39170 MUSTTAIL return InterpNext(S);
39171#else
39172 return true;
39173#endif
39174}
39175PRESERVE_NONE
39176static bool Interp_LTUint16(InterpState &S) {
39177 if (!LT<PT_Uint16>(S, S.PC)) return false;
39178#if USE_TAILCALLS
39179 MUSTTAIL return InterpNext(S);
39180#else
39181 return true;
39182#endif
39183}
39184PRESERVE_NONE
39185static bool Interp_LTSint32(InterpState &S) {
39186 if (!LT<PT_Sint32>(S, S.PC)) return false;
39187#if USE_TAILCALLS
39188 MUSTTAIL return InterpNext(S);
39189#else
39190 return true;
39191#endif
39192}
39193PRESERVE_NONE
39194static bool Interp_LTUint32(InterpState &S) {
39195 if (!LT<PT_Uint32>(S, S.PC)) return false;
39196#if USE_TAILCALLS
39197 MUSTTAIL return InterpNext(S);
39198#else
39199 return true;
39200#endif
39201}
39202PRESERVE_NONE
39203static bool Interp_LTSint64(InterpState &S) {
39204 if (!LT<PT_Sint64>(S, S.PC)) return false;
39205#if USE_TAILCALLS
39206 MUSTTAIL return InterpNext(S);
39207#else
39208 return true;
39209#endif
39210}
39211PRESERVE_NONE
39212static bool Interp_LTUint64(InterpState &S) {
39213 if (!LT<PT_Uint64>(S, S.PC)) return false;
39214#if USE_TAILCALLS
39215 MUSTTAIL return InterpNext(S);
39216#else
39217 return true;
39218#endif
39219}
39220PRESERVE_NONE
39221static bool Interp_LTIntAP(InterpState &S) {
39222 if (!LT<PT_IntAP>(S, S.PC)) return false;
39223#if USE_TAILCALLS
39224 MUSTTAIL return InterpNext(S);
39225#else
39226 return true;
39227#endif
39228}
39229PRESERVE_NONE
39230static bool Interp_LTIntAPS(InterpState &S) {
39231 if (!LT<PT_IntAPS>(S, S.PC)) return false;
39232#if USE_TAILCALLS
39233 MUSTTAIL return InterpNext(S);
39234#else
39235 return true;
39236#endif
39237}
39238PRESERVE_NONE
39239static bool Interp_LTBool(InterpState &S) {
39240 if (!LT<PT_Bool>(S, S.PC)) return false;
39241#if USE_TAILCALLS
39242 MUSTTAIL return InterpNext(S);
39243#else
39244 return true;
39245#endif
39246}
39247PRESERVE_NONE
39248static bool Interp_LTFixedPoint(InterpState &S) {
39249 if (!LT<PT_FixedPoint>(S, S.PC)) return false;
39250#if USE_TAILCALLS
39251 MUSTTAIL return InterpNext(S);
39252#else
39253 return true;
39254#endif
39255}
39256PRESERVE_NONE
39257static bool Interp_LTPtr(InterpState &S) {
39258 if (!LT<PT_Ptr>(S, S.PC)) return false;
39259#if USE_TAILCALLS
39260 MUSTTAIL return InterpNext(S);
39261#else
39262 return true;
39263#endif
39264}
39265PRESERVE_NONE
39266static bool Interp_LTFloat(InterpState &S) {
39267 if (!LT<PT_Float>(S, S.PC)) return false;
39268#if USE_TAILCALLS
39269 MUSTTAIL return InterpNext(S);
39270#else
39271 return true;
39272#endif
39273}
39274#endif
39275#ifdef GET_DISASM
39276case OP_LTSint8:
39277 Text.Op = PrintName("LTSint8");
39278 break;
39279case OP_LTUint8:
39280 Text.Op = PrintName("LTUint8");
39281 break;
39282case OP_LTSint16:
39283 Text.Op = PrintName("LTSint16");
39284 break;
39285case OP_LTUint16:
39286 Text.Op = PrintName("LTUint16");
39287 break;
39288case OP_LTSint32:
39289 Text.Op = PrintName("LTSint32");
39290 break;
39291case OP_LTUint32:
39292 Text.Op = PrintName("LTUint32");
39293 break;
39294case OP_LTSint64:
39295 Text.Op = PrintName("LTSint64");
39296 break;
39297case OP_LTUint64:
39298 Text.Op = PrintName("LTUint64");
39299 break;
39300case OP_LTIntAP:
39301 Text.Op = PrintName("LTIntAP");
39302 break;
39303case OP_LTIntAPS:
39304 Text.Op = PrintName("LTIntAPS");
39305 break;
39306case OP_LTBool:
39307 Text.Op = PrintName("LTBool");
39308 break;
39309case OP_LTFixedPoint:
39310 Text.Op = PrintName("LTFixedPoint");
39311 break;
39312case OP_LTPtr:
39313 Text.Op = PrintName("LTPtr");
39314 break;
39315case OP_LTFloat:
39316 Text.Op = PrintName("LTFloat");
39317 break;
39318#endif
39319#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
39320bool emitLTSint8(SourceInfo);
39321bool emitLTUint8(SourceInfo);
39322bool emitLTSint16(SourceInfo);
39323bool emitLTUint16(SourceInfo);
39324bool emitLTSint32(SourceInfo);
39325bool emitLTUint32(SourceInfo);
39326bool emitLTSint64(SourceInfo);
39327bool emitLTUint64(SourceInfo);
39328bool emitLTIntAP(SourceInfo);
39329bool emitLTIntAPS(SourceInfo);
39330bool emitLTBool(SourceInfo);
39331bool emitLTFixedPoint(SourceInfo);
39332bool emitLTPtr(SourceInfo);
39333bool emitLTFloat(SourceInfo);
39334#endif
39335#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
39336[[nodiscard]] bool emitLT(PrimType, SourceInfo I);
39337#endif
39338#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
39339bool
39340#if defined(GET_EVAL_IMPL)
39341EvalEmitter
39342#else
39343ByteCodeEmitter
39344#endif
39345::emitLT(PrimType T0, SourceInfo I) {
39346 switch (T0) {
39347 case PT_Sint8:
39348 return emitLTSint8(I);
39349 case PT_Uint8:
39350 return emitLTUint8(I);
39351 case PT_Sint16:
39352 return emitLTSint16(I);
39353 case PT_Uint16:
39354 return emitLTUint16(I);
39355 case PT_Sint32:
39356 return emitLTSint32(I);
39357 case PT_Uint32:
39358 return emitLTUint32(I);
39359 case PT_Sint64:
39360 return emitLTSint64(I);
39361 case PT_Uint64:
39362 return emitLTUint64(I);
39363 case PT_IntAP:
39364 return emitLTIntAP(I);
39365 case PT_IntAPS:
39366 return emitLTIntAPS(I);
39367 case PT_Bool:
39368 return emitLTBool(I);
39369 case PT_FixedPoint:
39370 return emitLTFixedPoint(I);
39371 case PT_Ptr:
39372 return emitLTPtr(I);
39373 case PT_Float:
39374 return emitLTFloat(I);
39375 default: llvm_unreachable("invalid type: emitLT");
39376 }
39377 llvm_unreachable("invalid enum value");
39378}
39379#endif
39380#ifdef GET_LINK_IMPL
39381bool ByteCodeEmitter::emitLTSint8(SourceInfo L) {
39382 return emitOp<>(OP_LTSint8, L);
39383}
39384bool ByteCodeEmitter::emitLTUint8(SourceInfo L) {
39385 return emitOp<>(OP_LTUint8, L);
39386}
39387bool ByteCodeEmitter::emitLTSint16(SourceInfo L) {
39388 return emitOp<>(OP_LTSint16, L);
39389}
39390bool ByteCodeEmitter::emitLTUint16(SourceInfo L) {
39391 return emitOp<>(OP_LTUint16, L);
39392}
39393bool ByteCodeEmitter::emitLTSint32(SourceInfo L) {
39394 return emitOp<>(OP_LTSint32, L);
39395}
39396bool ByteCodeEmitter::emitLTUint32(SourceInfo L) {
39397 return emitOp<>(OP_LTUint32, L);
39398}
39399bool ByteCodeEmitter::emitLTSint64(SourceInfo L) {
39400 return emitOp<>(OP_LTSint64, L);
39401}
39402bool ByteCodeEmitter::emitLTUint64(SourceInfo L) {
39403 return emitOp<>(OP_LTUint64, L);
39404}
39405bool ByteCodeEmitter::emitLTIntAP(SourceInfo L) {
39406 return emitOp<>(OP_LTIntAP, L);
39407}
39408bool ByteCodeEmitter::emitLTIntAPS(SourceInfo L) {
39409 return emitOp<>(OP_LTIntAPS, L);
39410}
39411bool ByteCodeEmitter::emitLTBool(SourceInfo L) {
39412 return emitOp<>(OP_LTBool, L);
39413}
39414bool ByteCodeEmitter::emitLTFixedPoint(SourceInfo L) {
39415 return emitOp<>(OP_LTFixedPoint, L);
39416}
39417bool ByteCodeEmitter::emitLTPtr(SourceInfo L) {
39418 return emitOp<>(OP_LTPtr, L);
39419}
39420bool ByteCodeEmitter::emitLTFloat(SourceInfo L) {
39421 return emitOp<>(OP_LTFloat, L);
39422}
39423#endif
39424#ifdef GET_EVAL_IMPL
39425bool EvalEmitter::emitLTSint8(SourceInfo L) {
39426 if (!isActive()) return true;
39427 CurrentSource = L;
39428 return LT<PT_Sint8>(S, CodePtr());
39429}
39430bool EvalEmitter::emitLTUint8(SourceInfo L) {
39431 if (!isActive()) return true;
39432 CurrentSource = L;
39433 return LT<PT_Uint8>(S, CodePtr());
39434}
39435bool EvalEmitter::emitLTSint16(SourceInfo L) {
39436 if (!isActive()) return true;
39437 CurrentSource = L;
39438 return LT<PT_Sint16>(S, CodePtr());
39439}
39440bool EvalEmitter::emitLTUint16(SourceInfo L) {
39441 if (!isActive()) return true;
39442 CurrentSource = L;
39443 return LT<PT_Uint16>(S, CodePtr());
39444}
39445bool EvalEmitter::emitLTSint32(SourceInfo L) {
39446 if (!isActive()) return true;
39447 CurrentSource = L;
39448 return LT<PT_Sint32>(S, CodePtr());
39449}
39450bool EvalEmitter::emitLTUint32(SourceInfo L) {
39451 if (!isActive()) return true;
39452 CurrentSource = L;
39453 return LT<PT_Uint32>(S, CodePtr());
39454}
39455bool EvalEmitter::emitLTSint64(SourceInfo L) {
39456 if (!isActive()) return true;
39457 CurrentSource = L;
39458 return LT<PT_Sint64>(S, CodePtr());
39459}
39460bool EvalEmitter::emitLTUint64(SourceInfo L) {
39461 if (!isActive()) return true;
39462 CurrentSource = L;
39463 return LT<PT_Uint64>(S, CodePtr());
39464}
39465bool EvalEmitter::emitLTIntAP(SourceInfo L) {
39466 if (!isActive()) return true;
39467 CurrentSource = L;
39468 return LT<PT_IntAP>(S, CodePtr());
39469}
39470bool EvalEmitter::emitLTIntAPS(SourceInfo L) {
39471 if (!isActive()) return true;
39472 CurrentSource = L;
39473 return LT<PT_IntAPS>(S, CodePtr());
39474}
39475bool EvalEmitter::emitLTBool(SourceInfo L) {
39476 if (!isActive()) return true;
39477 CurrentSource = L;
39478 return LT<PT_Bool>(S, CodePtr());
39479}
39480bool EvalEmitter::emitLTFixedPoint(SourceInfo L) {
39481 if (!isActive()) return true;
39482 CurrentSource = L;
39483 return LT<PT_FixedPoint>(S, CodePtr());
39484}
39485bool EvalEmitter::emitLTPtr(SourceInfo L) {
39486 if (!isActive()) return true;
39487 CurrentSource = L;
39488 return LT<PT_Ptr>(S, CodePtr());
39489}
39490bool EvalEmitter::emitLTFloat(SourceInfo L) {
39491 if (!isActive()) return true;
39492 CurrentSource = L;
39493 return LT<PT_Float>(S, CodePtr());
39494}
39495#endif
39496#ifdef GET_OPCODE_NAMES
39497OP_LoadSint8,
39498OP_LoadUint8,
39499OP_LoadSint16,
39500OP_LoadUint16,
39501OP_LoadSint32,
39502OP_LoadUint32,
39503OP_LoadSint64,
39504OP_LoadUint64,
39505OP_LoadIntAP,
39506OP_LoadIntAPS,
39507OP_LoadBool,
39508OP_LoadFixedPoint,
39509OP_LoadPtr,
39510OP_LoadMemberPtr,
39511OP_LoadFloat,
39512OP_LoadReflect,
39513#endif
39514#ifdef GET_INTERPFN_LIST
39515&Interp_LoadSint8,
39516&Interp_LoadUint8,
39517&Interp_LoadSint16,
39518&Interp_LoadUint16,
39519&Interp_LoadSint32,
39520&Interp_LoadUint32,
39521&Interp_LoadSint64,
39522&Interp_LoadUint64,
39523&Interp_LoadIntAP,
39524&Interp_LoadIntAPS,
39525&Interp_LoadBool,
39526&Interp_LoadFixedPoint,
39527&Interp_LoadPtr,
39528&Interp_LoadMemberPtr,
39529&Interp_LoadFloat,
39530&Interp_LoadReflect,
39531#endif
39532#ifdef GET_INTERPFN_DISPATCHERS
39533PRESERVE_NONE
39534static bool Interp_LoadSint8(InterpState &S) {
39535 if (!Load<PT_Sint8>(S, S.PC)) return false;
39536#if USE_TAILCALLS
39537 MUSTTAIL return InterpNext(S);
39538#else
39539 return true;
39540#endif
39541}
39542PRESERVE_NONE
39543static bool Interp_LoadUint8(InterpState &S) {
39544 if (!Load<PT_Uint8>(S, S.PC)) return false;
39545#if USE_TAILCALLS
39546 MUSTTAIL return InterpNext(S);
39547#else
39548 return true;
39549#endif
39550}
39551PRESERVE_NONE
39552static bool Interp_LoadSint16(InterpState &S) {
39553 if (!Load<PT_Sint16>(S, S.PC)) return false;
39554#if USE_TAILCALLS
39555 MUSTTAIL return InterpNext(S);
39556#else
39557 return true;
39558#endif
39559}
39560PRESERVE_NONE
39561static bool Interp_LoadUint16(InterpState &S) {
39562 if (!Load<PT_Uint16>(S, S.PC)) return false;
39563#if USE_TAILCALLS
39564 MUSTTAIL return InterpNext(S);
39565#else
39566 return true;
39567#endif
39568}
39569PRESERVE_NONE
39570static bool Interp_LoadSint32(InterpState &S) {
39571 if (!Load<PT_Sint32>(S, S.PC)) return false;
39572#if USE_TAILCALLS
39573 MUSTTAIL return InterpNext(S);
39574#else
39575 return true;
39576#endif
39577}
39578PRESERVE_NONE
39579static bool Interp_LoadUint32(InterpState &S) {
39580 if (!Load<PT_Uint32>(S, S.PC)) return false;
39581#if USE_TAILCALLS
39582 MUSTTAIL return InterpNext(S);
39583#else
39584 return true;
39585#endif
39586}
39587PRESERVE_NONE
39588static bool Interp_LoadSint64(InterpState &S) {
39589 if (!Load<PT_Sint64>(S, S.PC)) return false;
39590#if USE_TAILCALLS
39591 MUSTTAIL return InterpNext(S);
39592#else
39593 return true;
39594#endif
39595}
39596PRESERVE_NONE
39597static bool Interp_LoadUint64(InterpState &S) {
39598 if (!Load<PT_Uint64>(S, S.PC)) return false;
39599#if USE_TAILCALLS
39600 MUSTTAIL return InterpNext(S);
39601#else
39602 return true;
39603#endif
39604}
39605PRESERVE_NONE
39606static bool Interp_LoadIntAP(InterpState &S) {
39607 if (!Load<PT_IntAP>(S, S.PC)) return false;
39608#if USE_TAILCALLS
39609 MUSTTAIL return InterpNext(S);
39610#else
39611 return true;
39612#endif
39613}
39614PRESERVE_NONE
39615static bool Interp_LoadIntAPS(InterpState &S) {
39616 if (!Load<PT_IntAPS>(S, S.PC)) return false;
39617#if USE_TAILCALLS
39618 MUSTTAIL return InterpNext(S);
39619#else
39620 return true;
39621#endif
39622}
39623PRESERVE_NONE
39624static bool Interp_LoadBool(InterpState &S) {
39625 if (!Load<PT_Bool>(S, S.PC)) return false;
39626#if USE_TAILCALLS
39627 MUSTTAIL return InterpNext(S);
39628#else
39629 return true;
39630#endif
39631}
39632PRESERVE_NONE
39633static bool Interp_LoadFixedPoint(InterpState &S) {
39634 if (!Load<PT_FixedPoint>(S, S.PC)) return false;
39635#if USE_TAILCALLS
39636 MUSTTAIL return InterpNext(S);
39637#else
39638 return true;
39639#endif
39640}
39641PRESERVE_NONE
39642static bool Interp_LoadPtr(InterpState &S) {
39643 if (!Load<PT_Ptr>(S, S.PC)) return false;
39644#if USE_TAILCALLS
39645 MUSTTAIL return InterpNext(S);
39646#else
39647 return true;
39648#endif
39649}
39650PRESERVE_NONE
39651static bool Interp_LoadMemberPtr(InterpState &S) {
39652 if (!Load<PT_MemberPtr>(S, S.PC)) return false;
39653#if USE_TAILCALLS
39654 MUSTTAIL return InterpNext(S);
39655#else
39656 return true;
39657#endif
39658}
39659PRESERVE_NONE
39660static bool Interp_LoadFloat(InterpState &S) {
39661 if (!Load<PT_Float>(S, S.PC)) return false;
39662#if USE_TAILCALLS
39663 MUSTTAIL return InterpNext(S);
39664#else
39665 return true;
39666#endif
39667}
39668PRESERVE_NONE
39669static bool Interp_LoadReflect(InterpState &S) {
39670 if (!Load<PT_Reflect>(S, S.PC)) return false;
39671#if USE_TAILCALLS
39672 MUSTTAIL return InterpNext(S);
39673#else
39674 return true;
39675#endif
39676}
39677#endif
39678#ifdef GET_DISASM
39679case OP_LoadSint8:
39680 Text.Op = PrintName("LoadSint8");
39681 break;
39682case OP_LoadUint8:
39683 Text.Op = PrintName("LoadUint8");
39684 break;
39685case OP_LoadSint16:
39686 Text.Op = PrintName("LoadSint16");
39687 break;
39688case OP_LoadUint16:
39689 Text.Op = PrintName("LoadUint16");
39690 break;
39691case OP_LoadSint32:
39692 Text.Op = PrintName("LoadSint32");
39693 break;
39694case OP_LoadUint32:
39695 Text.Op = PrintName("LoadUint32");
39696 break;
39697case OP_LoadSint64:
39698 Text.Op = PrintName("LoadSint64");
39699 break;
39700case OP_LoadUint64:
39701 Text.Op = PrintName("LoadUint64");
39702 break;
39703case OP_LoadIntAP:
39704 Text.Op = PrintName("LoadIntAP");
39705 break;
39706case OP_LoadIntAPS:
39707 Text.Op = PrintName("LoadIntAPS");
39708 break;
39709case OP_LoadBool:
39710 Text.Op = PrintName("LoadBool");
39711 break;
39712case OP_LoadFixedPoint:
39713 Text.Op = PrintName("LoadFixedPoint");
39714 break;
39715case OP_LoadPtr:
39716 Text.Op = PrintName("LoadPtr");
39717 break;
39718case OP_LoadMemberPtr:
39719 Text.Op = PrintName("LoadMemberPtr");
39720 break;
39721case OP_LoadFloat:
39722 Text.Op = PrintName("LoadFloat");
39723 break;
39724case OP_LoadReflect:
39725 Text.Op = PrintName("LoadReflect");
39726 break;
39727#endif
39728#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
39729bool emitLoadSint8(SourceInfo);
39730bool emitLoadUint8(SourceInfo);
39731bool emitLoadSint16(SourceInfo);
39732bool emitLoadUint16(SourceInfo);
39733bool emitLoadSint32(SourceInfo);
39734bool emitLoadUint32(SourceInfo);
39735bool emitLoadSint64(SourceInfo);
39736bool emitLoadUint64(SourceInfo);
39737bool emitLoadIntAP(SourceInfo);
39738bool emitLoadIntAPS(SourceInfo);
39739bool emitLoadBool(SourceInfo);
39740bool emitLoadFixedPoint(SourceInfo);
39741bool emitLoadPtr(SourceInfo);
39742bool emitLoadMemberPtr(SourceInfo);
39743bool emitLoadFloat(SourceInfo);
39744bool emitLoadReflect(SourceInfo);
39745#endif
39746#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
39747[[nodiscard]] bool emitLoad(PrimType, SourceInfo I);
39748#endif
39749#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
39750bool
39751#if defined(GET_EVAL_IMPL)
39752EvalEmitter
39753#else
39754ByteCodeEmitter
39755#endif
39756::emitLoad(PrimType T0, SourceInfo I) {
39757 switch (T0) {
39758 case PT_Sint8:
39759 return emitLoadSint8(I);
39760 case PT_Uint8:
39761 return emitLoadUint8(I);
39762 case PT_Sint16:
39763 return emitLoadSint16(I);
39764 case PT_Uint16:
39765 return emitLoadUint16(I);
39766 case PT_Sint32:
39767 return emitLoadSint32(I);
39768 case PT_Uint32:
39769 return emitLoadUint32(I);
39770 case PT_Sint64:
39771 return emitLoadSint64(I);
39772 case PT_Uint64:
39773 return emitLoadUint64(I);
39774 case PT_IntAP:
39775 return emitLoadIntAP(I);
39776 case PT_IntAPS:
39777 return emitLoadIntAPS(I);
39778 case PT_Bool:
39779 return emitLoadBool(I);
39780 case PT_FixedPoint:
39781 return emitLoadFixedPoint(I);
39782 case PT_Ptr:
39783 return emitLoadPtr(I);
39784 case PT_MemberPtr:
39785 return emitLoadMemberPtr(I);
39786 case PT_Float:
39787 return emitLoadFloat(I);
39788 case PT_Reflect:
39789 return emitLoadReflect(I);
39790 }
39791 llvm_unreachable("invalid enum value");
39792}
39793#endif
39794#ifdef GET_LINK_IMPL
39795bool ByteCodeEmitter::emitLoadSint8(SourceInfo L) {
39796 return emitOp<>(OP_LoadSint8, L);
39797}
39798bool ByteCodeEmitter::emitLoadUint8(SourceInfo L) {
39799 return emitOp<>(OP_LoadUint8, L);
39800}
39801bool ByteCodeEmitter::emitLoadSint16(SourceInfo L) {
39802 return emitOp<>(OP_LoadSint16, L);
39803}
39804bool ByteCodeEmitter::emitLoadUint16(SourceInfo L) {
39805 return emitOp<>(OP_LoadUint16, L);
39806}
39807bool ByteCodeEmitter::emitLoadSint32(SourceInfo L) {
39808 return emitOp<>(OP_LoadSint32, L);
39809}
39810bool ByteCodeEmitter::emitLoadUint32(SourceInfo L) {
39811 return emitOp<>(OP_LoadUint32, L);
39812}
39813bool ByteCodeEmitter::emitLoadSint64(SourceInfo L) {
39814 return emitOp<>(OP_LoadSint64, L);
39815}
39816bool ByteCodeEmitter::emitLoadUint64(SourceInfo L) {
39817 return emitOp<>(OP_LoadUint64, L);
39818}
39819bool ByteCodeEmitter::emitLoadIntAP(SourceInfo L) {
39820 return emitOp<>(OP_LoadIntAP, L);
39821}
39822bool ByteCodeEmitter::emitLoadIntAPS(SourceInfo L) {
39823 return emitOp<>(OP_LoadIntAPS, L);
39824}
39825bool ByteCodeEmitter::emitLoadBool(SourceInfo L) {
39826 return emitOp<>(OP_LoadBool, L);
39827}
39828bool ByteCodeEmitter::emitLoadFixedPoint(SourceInfo L) {
39829 return emitOp<>(OP_LoadFixedPoint, L);
39830}
39831bool ByteCodeEmitter::emitLoadPtr(SourceInfo L) {
39832 return emitOp<>(OP_LoadPtr, L);
39833}
39834bool ByteCodeEmitter::emitLoadMemberPtr(SourceInfo L) {
39835 return emitOp<>(OP_LoadMemberPtr, L);
39836}
39837bool ByteCodeEmitter::emitLoadFloat(SourceInfo L) {
39838 return emitOp<>(OP_LoadFloat, L);
39839}
39840bool ByteCodeEmitter::emitLoadReflect(SourceInfo L) {
39841 return emitOp<>(OP_LoadReflect, L);
39842}
39843#endif
39844#ifdef GET_EVAL_IMPL
39845bool EvalEmitter::emitLoadSint8(SourceInfo L) {
39846 if (!isActive()) return true;
39847 CurrentSource = L;
39848 return Load<PT_Sint8>(S, CodePtr());
39849}
39850bool EvalEmitter::emitLoadUint8(SourceInfo L) {
39851 if (!isActive()) return true;
39852 CurrentSource = L;
39853 return Load<PT_Uint8>(S, CodePtr());
39854}
39855bool EvalEmitter::emitLoadSint16(SourceInfo L) {
39856 if (!isActive()) return true;
39857 CurrentSource = L;
39858 return Load<PT_Sint16>(S, CodePtr());
39859}
39860bool EvalEmitter::emitLoadUint16(SourceInfo L) {
39861 if (!isActive()) return true;
39862 CurrentSource = L;
39863 return Load<PT_Uint16>(S, CodePtr());
39864}
39865bool EvalEmitter::emitLoadSint32(SourceInfo L) {
39866 if (!isActive()) return true;
39867 CurrentSource = L;
39868 return Load<PT_Sint32>(S, CodePtr());
39869}
39870bool EvalEmitter::emitLoadUint32(SourceInfo L) {
39871 if (!isActive()) return true;
39872 CurrentSource = L;
39873 return Load<PT_Uint32>(S, CodePtr());
39874}
39875bool EvalEmitter::emitLoadSint64(SourceInfo L) {
39876 if (!isActive()) return true;
39877 CurrentSource = L;
39878 return Load<PT_Sint64>(S, CodePtr());
39879}
39880bool EvalEmitter::emitLoadUint64(SourceInfo L) {
39881 if (!isActive()) return true;
39882 CurrentSource = L;
39883 return Load<PT_Uint64>(S, CodePtr());
39884}
39885bool EvalEmitter::emitLoadIntAP(SourceInfo L) {
39886 if (!isActive()) return true;
39887 CurrentSource = L;
39888 return Load<PT_IntAP>(S, CodePtr());
39889}
39890bool EvalEmitter::emitLoadIntAPS(SourceInfo L) {
39891 if (!isActive()) return true;
39892 CurrentSource = L;
39893 return Load<PT_IntAPS>(S, CodePtr());
39894}
39895bool EvalEmitter::emitLoadBool(SourceInfo L) {
39896 if (!isActive()) return true;
39897 CurrentSource = L;
39898 return Load<PT_Bool>(S, CodePtr());
39899}
39900bool EvalEmitter::emitLoadFixedPoint(SourceInfo L) {
39901 if (!isActive()) return true;
39902 CurrentSource = L;
39903 return Load<PT_FixedPoint>(S, CodePtr());
39904}
39905bool EvalEmitter::emitLoadPtr(SourceInfo L) {
39906 if (!isActive()) return true;
39907 CurrentSource = L;
39908 return Load<PT_Ptr>(S, CodePtr());
39909}
39910bool EvalEmitter::emitLoadMemberPtr(SourceInfo L) {
39911 if (!isActive()) return true;
39912 CurrentSource = L;
39913 return Load<PT_MemberPtr>(S, CodePtr());
39914}
39915bool EvalEmitter::emitLoadFloat(SourceInfo L) {
39916 if (!isActive()) return true;
39917 CurrentSource = L;
39918 return Load<PT_Float>(S, CodePtr());
39919}
39920bool EvalEmitter::emitLoadReflect(SourceInfo L) {
39921 if (!isActive()) return true;
39922 CurrentSource = L;
39923 return Load<PT_Reflect>(S, CodePtr());
39924}
39925#endif
39926#ifdef GET_OPCODE_NAMES
39927OP_LoadPopSint8,
39928OP_LoadPopUint8,
39929OP_LoadPopSint16,
39930OP_LoadPopUint16,
39931OP_LoadPopSint32,
39932OP_LoadPopUint32,
39933OP_LoadPopSint64,
39934OP_LoadPopUint64,
39935OP_LoadPopIntAP,
39936OP_LoadPopIntAPS,
39937OP_LoadPopBool,
39938OP_LoadPopFixedPoint,
39939OP_LoadPopPtr,
39940OP_LoadPopMemberPtr,
39941OP_LoadPopFloat,
39942OP_LoadPopReflect,
39943#endif
39944#ifdef GET_INTERPFN_LIST
39945&Interp_LoadPopSint8,
39946&Interp_LoadPopUint8,
39947&Interp_LoadPopSint16,
39948&Interp_LoadPopUint16,
39949&Interp_LoadPopSint32,
39950&Interp_LoadPopUint32,
39951&Interp_LoadPopSint64,
39952&Interp_LoadPopUint64,
39953&Interp_LoadPopIntAP,
39954&Interp_LoadPopIntAPS,
39955&Interp_LoadPopBool,
39956&Interp_LoadPopFixedPoint,
39957&Interp_LoadPopPtr,
39958&Interp_LoadPopMemberPtr,
39959&Interp_LoadPopFloat,
39960&Interp_LoadPopReflect,
39961#endif
39962#ifdef GET_INTERPFN_DISPATCHERS
39963PRESERVE_NONE
39964static bool Interp_LoadPopSint8(InterpState &S) {
39965 if (!LoadPop<PT_Sint8>(S, S.PC)) return false;
39966#if USE_TAILCALLS
39967 MUSTTAIL return InterpNext(S);
39968#else
39969 return true;
39970#endif
39971}
39972PRESERVE_NONE
39973static bool Interp_LoadPopUint8(InterpState &S) {
39974 if (!LoadPop<PT_Uint8>(S, S.PC)) return false;
39975#if USE_TAILCALLS
39976 MUSTTAIL return InterpNext(S);
39977#else
39978 return true;
39979#endif
39980}
39981PRESERVE_NONE
39982static bool Interp_LoadPopSint16(InterpState &S) {
39983 if (!LoadPop<PT_Sint16>(S, S.PC)) return false;
39984#if USE_TAILCALLS
39985 MUSTTAIL return InterpNext(S);
39986#else
39987 return true;
39988#endif
39989}
39990PRESERVE_NONE
39991static bool Interp_LoadPopUint16(InterpState &S) {
39992 if (!LoadPop<PT_Uint16>(S, S.PC)) return false;
39993#if USE_TAILCALLS
39994 MUSTTAIL return InterpNext(S);
39995#else
39996 return true;
39997#endif
39998}
39999PRESERVE_NONE
40000static bool Interp_LoadPopSint32(InterpState &S) {
40001 if (!LoadPop<PT_Sint32>(S, S.PC)) return false;
40002#if USE_TAILCALLS
40003 MUSTTAIL return InterpNext(S);
40004#else
40005 return true;
40006#endif
40007}
40008PRESERVE_NONE
40009static bool Interp_LoadPopUint32(InterpState &S) {
40010 if (!LoadPop<PT_Uint32>(S, S.PC)) return false;
40011#if USE_TAILCALLS
40012 MUSTTAIL return InterpNext(S);
40013#else
40014 return true;
40015#endif
40016}
40017PRESERVE_NONE
40018static bool Interp_LoadPopSint64(InterpState &S) {
40019 if (!LoadPop<PT_Sint64>(S, S.PC)) return false;
40020#if USE_TAILCALLS
40021 MUSTTAIL return InterpNext(S);
40022#else
40023 return true;
40024#endif
40025}
40026PRESERVE_NONE
40027static bool Interp_LoadPopUint64(InterpState &S) {
40028 if (!LoadPop<PT_Uint64>(S, S.PC)) return false;
40029#if USE_TAILCALLS
40030 MUSTTAIL return InterpNext(S);
40031#else
40032 return true;
40033#endif
40034}
40035PRESERVE_NONE
40036static bool Interp_LoadPopIntAP(InterpState &S) {
40037 if (!LoadPop<PT_IntAP>(S, S.PC)) return false;
40038#if USE_TAILCALLS
40039 MUSTTAIL return InterpNext(S);
40040#else
40041 return true;
40042#endif
40043}
40044PRESERVE_NONE
40045static bool Interp_LoadPopIntAPS(InterpState &S) {
40046 if (!LoadPop<PT_IntAPS>(S, S.PC)) return false;
40047#if USE_TAILCALLS
40048 MUSTTAIL return InterpNext(S);
40049#else
40050 return true;
40051#endif
40052}
40053PRESERVE_NONE
40054static bool Interp_LoadPopBool(InterpState &S) {
40055 if (!LoadPop<PT_Bool>(S, S.PC)) return false;
40056#if USE_TAILCALLS
40057 MUSTTAIL return InterpNext(S);
40058#else
40059 return true;
40060#endif
40061}
40062PRESERVE_NONE
40063static bool Interp_LoadPopFixedPoint(InterpState &S) {
40064 if (!LoadPop<PT_FixedPoint>(S, S.PC)) return false;
40065#if USE_TAILCALLS
40066 MUSTTAIL return InterpNext(S);
40067#else
40068 return true;
40069#endif
40070}
40071PRESERVE_NONE
40072static bool Interp_LoadPopPtr(InterpState &S) {
40073 if (!LoadPop<PT_Ptr>(S, S.PC)) return false;
40074#if USE_TAILCALLS
40075 MUSTTAIL return InterpNext(S);
40076#else
40077 return true;
40078#endif
40079}
40080PRESERVE_NONE
40081static bool Interp_LoadPopMemberPtr(InterpState &S) {
40082 if (!LoadPop<PT_MemberPtr>(S, S.PC)) return false;
40083#if USE_TAILCALLS
40084 MUSTTAIL return InterpNext(S);
40085#else
40086 return true;
40087#endif
40088}
40089PRESERVE_NONE
40090static bool Interp_LoadPopFloat(InterpState &S) {
40091 if (!LoadPop<PT_Float>(S, S.PC)) return false;
40092#if USE_TAILCALLS
40093 MUSTTAIL return InterpNext(S);
40094#else
40095 return true;
40096#endif
40097}
40098PRESERVE_NONE
40099static bool Interp_LoadPopReflect(InterpState &S) {
40100 if (!LoadPop<PT_Reflect>(S, S.PC)) return false;
40101#if USE_TAILCALLS
40102 MUSTTAIL return InterpNext(S);
40103#else
40104 return true;
40105#endif
40106}
40107#endif
40108#ifdef GET_DISASM
40109case OP_LoadPopSint8:
40110 Text.Op = PrintName("LoadPopSint8");
40111 break;
40112case OP_LoadPopUint8:
40113 Text.Op = PrintName("LoadPopUint8");
40114 break;
40115case OP_LoadPopSint16:
40116 Text.Op = PrintName("LoadPopSint16");
40117 break;
40118case OP_LoadPopUint16:
40119 Text.Op = PrintName("LoadPopUint16");
40120 break;
40121case OP_LoadPopSint32:
40122 Text.Op = PrintName("LoadPopSint32");
40123 break;
40124case OP_LoadPopUint32:
40125 Text.Op = PrintName("LoadPopUint32");
40126 break;
40127case OP_LoadPopSint64:
40128 Text.Op = PrintName("LoadPopSint64");
40129 break;
40130case OP_LoadPopUint64:
40131 Text.Op = PrintName("LoadPopUint64");
40132 break;
40133case OP_LoadPopIntAP:
40134 Text.Op = PrintName("LoadPopIntAP");
40135 break;
40136case OP_LoadPopIntAPS:
40137 Text.Op = PrintName("LoadPopIntAPS");
40138 break;
40139case OP_LoadPopBool:
40140 Text.Op = PrintName("LoadPopBool");
40141 break;
40142case OP_LoadPopFixedPoint:
40143 Text.Op = PrintName("LoadPopFixedPoint");
40144 break;
40145case OP_LoadPopPtr:
40146 Text.Op = PrintName("LoadPopPtr");
40147 break;
40148case OP_LoadPopMemberPtr:
40149 Text.Op = PrintName("LoadPopMemberPtr");
40150 break;
40151case OP_LoadPopFloat:
40152 Text.Op = PrintName("LoadPopFloat");
40153 break;
40154case OP_LoadPopReflect:
40155 Text.Op = PrintName("LoadPopReflect");
40156 break;
40157#endif
40158#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40159bool emitLoadPopSint8(SourceInfo);
40160bool emitLoadPopUint8(SourceInfo);
40161bool emitLoadPopSint16(SourceInfo);
40162bool emitLoadPopUint16(SourceInfo);
40163bool emitLoadPopSint32(SourceInfo);
40164bool emitLoadPopUint32(SourceInfo);
40165bool emitLoadPopSint64(SourceInfo);
40166bool emitLoadPopUint64(SourceInfo);
40167bool emitLoadPopIntAP(SourceInfo);
40168bool emitLoadPopIntAPS(SourceInfo);
40169bool emitLoadPopBool(SourceInfo);
40170bool emitLoadPopFixedPoint(SourceInfo);
40171bool emitLoadPopPtr(SourceInfo);
40172bool emitLoadPopMemberPtr(SourceInfo);
40173bool emitLoadPopFloat(SourceInfo);
40174bool emitLoadPopReflect(SourceInfo);
40175#endif
40176#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40177[[nodiscard]] bool emitLoadPop(PrimType, SourceInfo I);
40178#endif
40179#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
40180bool
40181#if defined(GET_EVAL_IMPL)
40182EvalEmitter
40183#else
40184ByteCodeEmitter
40185#endif
40186::emitLoadPop(PrimType T0, SourceInfo I) {
40187 switch (T0) {
40188 case PT_Sint8:
40189 return emitLoadPopSint8(I);
40190 case PT_Uint8:
40191 return emitLoadPopUint8(I);
40192 case PT_Sint16:
40193 return emitLoadPopSint16(I);
40194 case PT_Uint16:
40195 return emitLoadPopUint16(I);
40196 case PT_Sint32:
40197 return emitLoadPopSint32(I);
40198 case PT_Uint32:
40199 return emitLoadPopUint32(I);
40200 case PT_Sint64:
40201 return emitLoadPopSint64(I);
40202 case PT_Uint64:
40203 return emitLoadPopUint64(I);
40204 case PT_IntAP:
40205 return emitLoadPopIntAP(I);
40206 case PT_IntAPS:
40207 return emitLoadPopIntAPS(I);
40208 case PT_Bool:
40209 return emitLoadPopBool(I);
40210 case PT_FixedPoint:
40211 return emitLoadPopFixedPoint(I);
40212 case PT_Ptr:
40213 return emitLoadPopPtr(I);
40214 case PT_MemberPtr:
40215 return emitLoadPopMemberPtr(I);
40216 case PT_Float:
40217 return emitLoadPopFloat(I);
40218 case PT_Reflect:
40219 return emitLoadPopReflect(I);
40220 }
40221 llvm_unreachable("invalid enum value");
40222}
40223#endif
40224#ifdef GET_LINK_IMPL
40225bool ByteCodeEmitter::emitLoadPopSint8(SourceInfo L) {
40226 return emitOp<>(OP_LoadPopSint8, L);
40227}
40228bool ByteCodeEmitter::emitLoadPopUint8(SourceInfo L) {
40229 return emitOp<>(OP_LoadPopUint8, L);
40230}
40231bool ByteCodeEmitter::emitLoadPopSint16(SourceInfo L) {
40232 return emitOp<>(OP_LoadPopSint16, L);
40233}
40234bool ByteCodeEmitter::emitLoadPopUint16(SourceInfo L) {
40235 return emitOp<>(OP_LoadPopUint16, L);
40236}
40237bool ByteCodeEmitter::emitLoadPopSint32(SourceInfo L) {
40238 return emitOp<>(OP_LoadPopSint32, L);
40239}
40240bool ByteCodeEmitter::emitLoadPopUint32(SourceInfo L) {
40241 return emitOp<>(OP_LoadPopUint32, L);
40242}
40243bool ByteCodeEmitter::emitLoadPopSint64(SourceInfo L) {
40244 return emitOp<>(OP_LoadPopSint64, L);
40245}
40246bool ByteCodeEmitter::emitLoadPopUint64(SourceInfo L) {
40247 return emitOp<>(OP_LoadPopUint64, L);
40248}
40249bool ByteCodeEmitter::emitLoadPopIntAP(SourceInfo L) {
40250 return emitOp<>(OP_LoadPopIntAP, L);
40251}
40252bool ByteCodeEmitter::emitLoadPopIntAPS(SourceInfo L) {
40253 return emitOp<>(OP_LoadPopIntAPS, L);
40254}
40255bool ByteCodeEmitter::emitLoadPopBool(SourceInfo L) {
40256 return emitOp<>(OP_LoadPopBool, L);
40257}
40258bool ByteCodeEmitter::emitLoadPopFixedPoint(SourceInfo L) {
40259 return emitOp<>(OP_LoadPopFixedPoint, L);
40260}
40261bool ByteCodeEmitter::emitLoadPopPtr(SourceInfo L) {
40262 return emitOp<>(OP_LoadPopPtr, L);
40263}
40264bool ByteCodeEmitter::emitLoadPopMemberPtr(SourceInfo L) {
40265 return emitOp<>(OP_LoadPopMemberPtr, L);
40266}
40267bool ByteCodeEmitter::emitLoadPopFloat(SourceInfo L) {
40268 return emitOp<>(OP_LoadPopFloat, L);
40269}
40270bool ByteCodeEmitter::emitLoadPopReflect(SourceInfo L) {
40271 return emitOp<>(OP_LoadPopReflect, L);
40272}
40273#endif
40274#ifdef GET_EVAL_IMPL
40275bool EvalEmitter::emitLoadPopSint8(SourceInfo L) {
40276 if (!isActive()) return true;
40277 CurrentSource = L;
40278 return LoadPop<PT_Sint8>(S, CodePtr());
40279}
40280bool EvalEmitter::emitLoadPopUint8(SourceInfo L) {
40281 if (!isActive()) return true;
40282 CurrentSource = L;
40283 return LoadPop<PT_Uint8>(S, CodePtr());
40284}
40285bool EvalEmitter::emitLoadPopSint16(SourceInfo L) {
40286 if (!isActive()) return true;
40287 CurrentSource = L;
40288 return LoadPop<PT_Sint16>(S, CodePtr());
40289}
40290bool EvalEmitter::emitLoadPopUint16(SourceInfo L) {
40291 if (!isActive()) return true;
40292 CurrentSource = L;
40293 return LoadPop<PT_Uint16>(S, CodePtr());
40294}
40295bool EvalEmitter::emitLoadPopSint32(SourceInfo L) {
40296 if (!isActive()) return true;
40297 CurrentSource = L;
40298 return LoadPop<PT_Sint32>(S, CodePtr());
40299}
40300bool EvalEmitter::emitLoadPopUint32(SourceInfo L) {
40301 if (!isActive()) return true;
40302 CurrentSource = L;
40303 return LoadPop<PT_Uint32>(S, CodePtr());
40304}
40305bool EvalEmitter::emitLoadPopSint64(SourceInfo L) {
40306 if (!isActive()) return true;
40307 CurrentSource = L;
40308 return LoadPop<PT_Sint64>(S, CodePtr());
40309}
40310bool EvalEmitter::emitLoadPopUint64(SourceInfo L) {
40311 if (!isActive()) return true;
40312 CurrentSource = L;
40313 return LoadPop<PT_Uint64>(S, CodePtr());
40314}
40315bool EvalEmitter::emitLoadPopIntAP(SourceInfo L) {
40316 if (!isActive()) return true;
40317 CurrentSource = L;
40318 return LoadPop<PT_IntAP>(S, CodePtr());
40319}
40320bool EvalEmitter::emitLoadPopIntAPS(SourceInfo L) {
40321 if (!isActive()) return true;
40322 CurrentSource = L;
40323 return LoadPop<PT_IntAPS>(S, CodePtr());
40324}
40325bool EvalEmitter::emitLoadPopBool(SourceInfo L) {
40326 if (!isActive()) return true;
40327 CurrentSource = L;
40328 return LoadPop<PT_Bool>(S, CodePtr());
40329}
40330bool EvalEmitter::emitLoadPopFixedPoint(SourceInfo L) {
40331 if (!isActive()) return true;
40332 CurrentSource = L;
40333 return LoadPop<PT_FixedPoint>(S, CodePtr());
40334}
40335bool EvalEmitter::emitLoadPopPtr(SourceInfo L) {
40336 if (!isActive()) return true;
40337 CurrentSource = L;
40338 return LoadPop<PT_Ptr>(S, CodePtr());
40339}
40340bool EvalEmitter::emitLoadPopMemberPtr(SourceInfo L) {
40341 if (!isActive()) return true;
40342 CurrentSource = L;
40343 return LoadPop<PT_MemberPtr>(S, CodePtr());
40344}
40345bool EvalEmitter::emitLoadPopFloat(SourceInfo L) {
40346 if (!isActive()) return true;
40347 CurrentSource = L;
40348 return LoadPop<PT_Float>(S, CodePtr());
40349}
40350bool EvalEmitter::emitLoadPopReflect(SourceInfo L) {
40351 if (!isActive()) return true;
40352 CurrentSource = L;
40353 return LoadPop<PT_Reflect>(S, CodePtr());
40354}
40355#endif
40356#ifdef GET_OPCODE_NAMES
40357OP_LoadPopL,
40358#endif
40359#ifdef GET_INTERPFN_LIST
40360&Interp_LoadPopL,
40361#endif
40362#ifdef GET_INTERPFN_DISPATCHERS
40363PRESERVE_NONE
40364static bool Interp_LoadPopL(InterpState &S) {
40365 if (!LoadPopL(S, S.PC)) return false;
40366#if USE_TAILCALLS
40367 MUSTTAIL return InterpNext(S);
40368#else
40369 return true;
40370#endif
40371}
40372#endif
40373#ifdef GET_DISASM
40374case OP_LoadPopL:
40375 Text.Op = PrintName("LoadPopL");
40376 break;
40377#endif
40378#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40379bool emitLoadPopL(SourceInfo);
40380#endif
40381#ifdef GET_LINK_IMPL
40382bool ByteCodeEmitter::emitLoadPopL(SourceInfo L) {
40383 return emitOp<>(OP_LoadPopL, L);
40384}
40385#endif
40386#ifdef GET_EVAL_IMPL
40387bool EvalEmitter::emitLoadPopL(SourceInfo L) {
40388 if (!isActive()) return true;
40389 CurrentSource = L;
40390 return LoadPopL(S, CodePtr());
40391}
40392#endif
40393#ifdef GET_OPCODE_NAMES
40394OP_MarkDestroyed,
40395#endif
40396#ifdef GET_INTERPFN_LIST
40397&Interp_MarkDestroyed,
40398#endif
40399#ifdef GET_INTERPFN_DISPATCHERS
40400PRESERVE_NONE
40401static bool Interp_MarkDestroyed(InterpState &S) {
40402 if (!MarkDestroyed(S, S.PC)) return false;
40403#if USE_TAILCALLS
40404 MUSTTAIL return InterpNext(S);
40405#else
40406 return true;
40407#endif
40408}
40409#endif
40410#ifdef GET_DISASM
40411case OP_MarkDestroyed:
40412 Text.Op = PrintName("MarkDestroyed");
40413 break;
40414#endif
40415#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40416bool emitMarkDestroyed(SourceInfo);
40417#endif
40418#ifdef GET_LINK_IMPL
40419bool ByteCodeEmitter::emitMarkDestroyed(SourceInfo L) {
40420 return emitOp<>(OP_MarkDestroyed, L);
40421}
40422#endif
40423#ifdef GET_EVAL_IMPL
40424bool EvalEmitter::emitMarkDestroyed(SourceInfo L) {
40425 if (!isActive()) return true;
40426 CurrentSource = L;
40427 return MarkDestroyed(S, CodePtr());
40428}
40429#endif
40430#ifdef GET_OPCODE_NAMES
40431OP_Memcpy,
40432#endif
40433#ifdef GET_INTERPFN_LIST
40434&Interp_Memcpy,
40435#endif
40436#ifdef GET_INTERPFN_DISPATCHERS
40437PRESERVE_NONE
40438static bool Interp_Memcpy(InterpState &S) {
40439 if (!Memcpy(S, S.PC)) return false;
40440#if USE_TAILCALLS
40441 MUSTTAIL return InterpNext(S);
40442#else
40443 return true;
40444#endif
40445}
40446#endif
40447#ifdef GET_DISASM
40448case OP_Memcpy:
40449 Text.Op = PrintName("Memcpy");
40450 break;
40451#endif
40452#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40453bool emitMemcpy(SourceInfo);
40454#endif
40455#ifdef GET_LINK_IMPL
40456bool ByteCodeEmitter::emitMemcpy(SourceInfo L) {
40457 return emitOp<>(OP_Memcpy, L);
40458}
40459#endif
40460#ifdef GET_EVAL_IMPL
40461bool EvalEmitter::emitMemcpy(SourceInfo L) {
40462 if (!isActive()) return true;
40463 CurrentSource = L;
40464 return Memcpy(S, CodePtr());
40465}
40466#endif
40467#ifdef GET_OPCODE_NAMES
40468OP_MulSint8,
40469OP_MulUint8,
40470OP_MulSint16,
40471OP_MulUint16,
40472OP_MulSint32,
40473OP_MulUint32,
40474OP_MulSint64,
40475OP_MulUint64,
40476OP_MulIntAP,
40477OP_MulIntAPS,
40478OP_MulBool,
40479OP_MulFixedPoint,
40480#endif
40481#ifdef GET_INTERPFN_LIST
40482&Interp_MulSint8,
40483&Interp_MulUint8,
40484&Interp_MulSint16,
40485&Interp_MulUint16,
40486&Interp_MulSint32,
40487&Interp_MulUint32,
40488&Interp_MulSint64,
40489&Interp_MulUint64,
40490&Interp_MulIntAP,
40491&Interp_MulIntAPS,
40492&Interp_MulBool,
40493&Interp_MulFixedPoint,
40494#endif
40495#ifdef GET_INTERPFN_DISPATCHERS
40496PRESERVE_NONE
40497static bool Interp_MulSint8(InterpState &S) {
40498 if (!Mul<PT_Sint8>(S, S.PC)) return false;
40499#if USE_TAILCALLS
40500 MUSTTAIL return InterpNext(S);
40501#else
40502 return true;
40503#endif
40504}
40505PRESERVE_NONE
40506static bool Interp_MulUint8(InterpState &S) {
40507 if (!Mul<PT_Uint8>(S, S.PC)) return false;
40508#if USE_TAILCALLS
40509 MUSTTAIL return InterpNext(S);
40510#else
40511 return true;
40512#endif
40513}
40514PRESERVE_NONE
40515static bool Interp_MulSint16(InterpState &S) {
40516 if (!Mul<PT_Sint16>(S, S.PC)) return false;
40517#if USE_TAILCALLS
40518 MUSTTAIL return InterpNext(S);
40519#else
40520 return true;
40521#endif
40522}
40523PRESERVE_NONE
40524static bool Interp_MulUint16(InterpState &S) {
40525 if (!Mul<PT_Uint16>(S, S.PC)) return false;
40526#if USE_TAILCALLS
40527 MUSTTAIL return InterpNext(S);
40528#else
40529 return true;
40530#endif
40531}
40532PRESERVE_NONE
40533static bool Interp_MulSint32(InterpState &S) {
40534 if (!Mul<PT_Sint32>(S, S.PC)) return false;
40535#if USE_TAILCALLS
40536 MUSTTAIL return InterpNext(S);
40537#else
40538 return true;
40539#endif
40540}
40541PRESERVE_NONE
40542static bool Interp_MulUint32(InterpState &S) {
40543 if (!Mul<PT_Uint32>(S, S.PC)) return false;
40544#if USE_TAILCALLS
40545 MUSTTAIL return InterpNext(S);
40546#else
40547 return true;
40548#endif
40549}
40550PRESERVE_NONE
40551static bool Interp_MulSint64(InterpState &S) {
40552 if (!Mul<PT_Sint64>(S, S.PC)) return false;
40553#if USE_TAILCALLS
40554 MUSTTAIL return InterpNext(S);
40555#else
40556 return true;
40557#endif
40558}
40559PRESERVE_NONE
40560static bool Interp_MulUint64(InterpState &S) {
40561 if (!Mul<PT_Uint64>(S, S.PC)) return false;
40562#if USE_TAILCALLS
40563 MUSTTAIL return InterpNext(S);
40564#else
40565 return true;
40566#endif
40567}
40568PRESERVE_NONE
40569static bool Interp_MulIntAP(InterpState &S) {
40570 if (!Mul<PT_IntAP>(S, S.PC)) return false;
40571#if USE_TAILCALLS
40572 MUSTTAIL return InterpNext(S);
40573#else
40574 return true;
40575#endif
40576}
40577PRESERVE_NONE
40578static bool Interp_MulIntAPS(InterpState &S) {
40579 if (!Mul<PT_IntAPS>(S, S.PC)) return false;
40580#if USE_TAILCALLS
40581 MUSTTAIL return InterpNext(S);
40582#else
40583 return true;
40584#endif
40585}
40586PRESERVE_NONE
40587static bool Interp_MulBool(InterpState &S) {
40588 if (!Mul<PT_Bool>(S, S.PC)) return false;
40589#if USE_TAILCALLS
40590 MUSTTAIL return InterpNext(S);
40591#else
40592 return true;
40593#endif
40594}
40595PRESERVE_NONE
40596static bool Interp_MulFixedPoint(InterpState &S) {
40597 if (!Mul<PT_FixedPoint>(S, S.PC)) return false;
40598#if USE_TAILCALLS
40599 MUSTTAIL return InterpNext(S);
40600#else
40601 return true;
40602#endif
40603}
40604#endif
40605#ifdef GET_DISASM
40606case OP_MulSint8:
40607 Text.Op = PrintName("MulSint8");
40608 break;
40609case OP_MulUint8:
40610 Text.Op = PrintName("MulUint8");
40611 break;
40612case OP_MulSint16:
40613 Text.Op = PrintName("MulSint16");
40614 break;
40615case OP_MulUint16:
40616 Text.Op = PrintName("MulUint16");
40617 break;
40618case OP_MulSint32:
40619 Text.Op = PrintName("MulSint32");
40620 break;
40621case OP_MulUint32:
40622 Text.Op = PrintName("MulUint32");
40623 break;
40624case OP_MulSint64:
40625 Text.Op = PrintName("MulSint64");
40626 break;
40627case OP_MulUint64:
40628 Text.Op = PrintName("MulUint64");
40629 break;
40630case OP_MulIntAP:
40631 Text.Op = PrintName("MulIntAP");
40632 break;
40633case OP_MulIntAPS:
40634 Text.Op = PrintName("MulIntAPS");
40635 break;
40636case OP_MulBool:
40637 Text.Op = PrintName("MulBool");
40638 break;
40639case OP_MulFixedPoint:
40640 Text.Op = PrintName("MulFixedPoint");
40641 break;
40642#endif
40643#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40644bool emitMulSint8(SourceInfo);
40645bool emitMulUint8(SourceInfo);
40646bool emitMulSint16(SourceInfo);
40647bool emitMulUint16(SourceInfo);
40648bool emitMulSint32(SourceInfo);
40649bool emitMulUint32(SourceInfo);
40650bool emitMulSint64(SourceInfo);
40651bool emitMulUint64(SourceInfo);
40652bool emitMulIntAP(SourceInfo);
40653bool emitMulIntAPS(SourceInfo);
40654bool emitMulBool(SourceInfo);
40655bool emitMulFixedPoint(SourceInfo);
40656#endif
40657#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40658[[nodiscard]] bool emitMul(PrimType, SourceInfo I);
40659#endif
40660#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
40661bool
40662#if defined(GET_EVAL_IMPL)
40663EvalEmitter
40664#else
40665ByteCodeEmitter
40666#endif
40667::emitMul(PrimType T0, SourceInfo I) {
40668 switch (T0) {
40669 case PT_Sint8:
40670 return emitMulSint8(I);
40671 case PT_Uint8:
40672 return emitMulUint8(I);
40673 case PT_Sint16:
40674 return emitMulSint16(I);
40675 case PT_Uint16:
40676 return emitMulUint16(I);
40677 case PT_Sint32:
40678 return emitMulSint32(I);
40679 case PT_Uint32:
40680 return emitMulUint32(I);
40681 case PT_Sint64:
40682 return emitMulSint64(I);
40683 case PT_Uint64:
40684 return emitMulUint64(I);
40685 case PT_IntAP:
40686 return emitMulIntAP(I);
40687 case PT_IntAPS:
40688 return emitMulIntAPS(I);
40689 case PT_Bool:
40690 return emitMulBool(I);
40691 case PT_FixedPoint:
40692 return emitMulFixedPoint(I);
40693 default: llvm_unreachable("invalid type: emitMul");
40694 }
40695 llvm_unreachable("invalid enum value");
40696}
40697#endif
40698#ifdef GET_LINK_IMPL
40699bool ByteCodeEmitter::emitMulSint8(SourceInfo L) {
40700 return emitOp<>(OP_MulSint8, L);
40701}
40702bool ByteCodeEmitter::emitMulUint8(SourceInfo L) {
40703 return emitOp<>(OP_MulUint8, L);
40704}
40705bool ByteCodeEmitter::emitMulSint16(SourceInfo L) {
40706 return emitOp<>(OP_MulSint16, L);
40707}
40708bool ByteCodeEmitter::emitMulUint16(SourceInfo L) {
40709 return emitOp<>(OP_MulUint16, L);
40710}
40711bool ByteCodeEmitter::emitMulSint32(SourceInfo L) {
40712 return emitOp<>(OP_MulSint32, L);
40713}
40714bool ByteCodeEmitter::emitMulUint32(SourceInfo L) {
40715 return emitOp<>(OP_MulUint32, L);
40716}
40717bool ByteCodeEmitter::emitMulSint64(SourceInfo L) {
40718 return emitOp<>(OP_MulSint64, L);
40719}
40720bool ByteCodeEmitter::emitMulUint64(SourceInfo L) {
40721 return emitOp<>(OP_MulUint64, L);
40722}
40723bool ByteCodeEmitter::emitMulIntAP(SourceInfo L) {
40724 return emitOp<>(OP_MulIntAP, L);
40725}
40726bool ByteCodeEmitter::emitMulIntAPS(SourceInfo L) {
40727 return emitOp<>(OP_MulIntAPS, L);
40728}
40729bool ByteCodeEmitter::emitMulBool(SourceInfo L) {
40730 return emitOp<>(OP_MulBool, L);
40731}
40732bool ByteCodeEmitter::emitMulFixedPoint(SourceInfo L) {
40733 return emitOp<>(OP_MulFixedPoint, L);
40734}
40735#endif
40736#ifdef GET_EVAL_IMPL
40737bool EvalEmitter::emitMulSint8(SourceInfo L) {
40738 if (!isActive()) return true;
40739 CurrentSource = L;
40740 return Mul<PT_Sint8>(S, CodePtr());
40741}
40742bool EvalEmitter::emitMulUint8(SourceInfo L) {
40743 if (!isActive()) return true;
40744 CurrentSource = L;
40745 return Mul<PT_Uint8>(S, CodePtr());
40746}
40747bool EvalEmitter::emitMulSint16(SourceInfo L) {
40748 if (!isActive()) return true;
40749 CurrentSource = L;
40750 return Mul<PT_Sint16>(S, CodePtr());
40751}
40752bool EvalEmitter::emitMulUint16(SourceInfo L) {
40753 if (!isActive()) return true;
40754 CurrentSource = L;
40755 return Mul<PT_Uint16>(S, CodePtr());
40756}
40757bool EvalEmitter::emitMulSint32(SourceInfo L) {
40758 if (!isActive()) return true;
40759 CurrentSource = L;
40760 return Mul<PT_Sint32>(S, CodePtr());
40761}
40762bool EvalEmitter::emitMulUint32(SourceInfo L) {
40763 if (!isActive()) return true;
40764 CurrentSource = L;
40765 return Mul<PT_Uint32>(S, CodePtr());
40766}
40767bool EvalEmitter::emitMulSint64(SourceInfo L) {
40768 if (!isActive()) return true;
40769 CurrentSource = L;
40770 return Mul<PT_Sint64>(S, CodePtr());
40771}
40772bool EvalEmitter::emitMulUint64(SourceInfo L) {
40773 if (!isActive()) return true;
40774 CurrentSource = L;
40775 return Mul<PT_Uint64>(S, CodePtr());
40776}
40777bool EvalEmitter::emitMulIntAP(SourceInfo L) {
40778 if (!isActive()) return true;
40779 CurrentSource = L;
40780 return Mul<PT_IntAP>(S, CodePtr());
40781}
40782bool EvalEmitter::emitMulIntAPS(SourceInfo L) {
40783 if (!isActive()) return true;
40784 CurrentSource = L;
40785 return Mul<PT_IntAPS>(S, CodePtr());
40786}
40787bool EvalEmitter::emitMulBool(SourceInfo L) {
40788 if (!isActive()) return true;
40789 CurrentSource = L;
40790 return Mul<PT_Bool>(S, CodePtr());
40791}
40792bool EvalEmitter::emitMulFixedPoint(SourceInfo L) {
40793 if (!isActive()) return true;
40794 CurrentSource = L;
40795 return Mul<PT_FixedPoint>(S, CodePtr());
40796}
40797#endif
40798#ifdef GET_OPCODE_NAMES
40799OP_MulcSint8,
40800OP_MulcUint8,
40801OP_MulcSint16,
40802OP_MulcUint16,
40803OP_MulcSint32,
40804OP_MulcUint32,
40805OP_MulcSint64,
40806OP_MulcUint64,
40807OP_MulcIntAP,
40808OP_MulcIntAPS,
40809OP_MulcFloat,
40810#endif
40811#ifdef GET_INTERPFN_LIST
40812&Interp_MulcSint8,
40813&Interp_MulcUint8,
40814&Interp_MulcSint16,
40815&Interp_MulcUint16,
40816&Interp_MulcSint32,
40817&Interp_MulcUint32,
40818&Interp_MulcSint64,
40819&Interp_MulcUint64,
40820&Interp_MulcIntAP,
40821&Interp_MulcIntAPS,
40822&Interp_MulcFloat,
40823#endif
40824#ifdef GET_INTERPFN_DISPATCHERS
40825PRESERVE_NONE
40826static bool Interp_MulcSint8(InterpState &S) {
40827 if (!Mulc<PT_Sint8>(S)) return false;
40828#if USE_TAILCALLS
40829 MUSTTAIL return InterpNext(S);
40830#else
40831 return true;
40832#endif
40833}
40834PRESERVE_NONE
40835static bool Interp_MulcUint8(InterpState &S) {
40836 if (!Mulc<PT_Uint8>(S)) return false;
40837#if USE_TAILCALLS
40838 MUSTTAIL return InterpNext(S);
40839#else
40840 return true;
40841#endif
40842}
40843PRESERVE_NONE
40844static bool Interp_MulcSint16(InterpState &S) {
40845 if (!Mulc<PT_Sint16>(S)) return false;
40846#if USE_TAILCALLS
40847 MUSTTAIL return InterpNext(S);
40848#else
40849 return true;
40850#endif
40851}
40852PRESERVE_NONE
40853static bool Interp_MulcUint16(InterpState &S) {
40854 if (!Mulc<PT_Uint16>(S)) return false;
40855#if USE_TAILCALLS
40856 MUSTTAIL return InterpNext(S);
40857#else
40858 return true;
40859#endif
40860}
40861PRESERVE_NONE
40862static bool Interp_MulcSint32(InterpState &S) {
40863 if (!Mulc<PT_Sint32>(S)) return false;
40864#if USE_TAILCALLS
40865 MUSTTAIL return InterpNext(S);
40866#else
40867 return true;
40868#endif
40869}
40870PRESERVE_NONE
40871static bool Interp_MulcUint32(InterpState &S) {
40872 if (!Mulc<PT_Uint32>(S)) return false;
40873#if USE_TAILCALLS
40874 MUSTTAIL return InterpNext(S);
40875#else
40876 return true;
40877#endif
40878}
40879PRESERVE_NONE
40880static bool Interp_MulcSint64(InterpState &S) {
40881 if (!Mulc<PT_Sint64>(S)) return false;
40882#if USE_TAILCALLS
40883 MUSTTAIL return InterpNext(S);
40884#else
40885 return true;
40886#endif
40887}
40888PRESERVE_NONE
40889static bool Interp_MulcUint64(InterpState &S) {
40890 if (!Mulc<PT_Uint64>(S)) return false;
40891#if USE_TAILCALLS
40892 MUSTTAIL return InterpNext(S);
40893#else
40894 return true;
40895#endif
40896}
40897PRESERVE_NONE
40898static bool Interp_MulcIntAP(InterpState &S) {
40899 if (!Mulc<PT_IntAP>(S)) return false;
40900#if USE_TAILCALLS
40901 MUSTTAIL return InterpNext(S);
40902#else
40903 return true;
40904#endif
40905}
40906PRESERVE_NONE
40907static bool Interp_MulcIntAPS(InterpState &S) {
40908 if (!Mulc<PT_IntAPS>(S)) return false;
40909#if USE_TAILCALLS
40910 MUSTTAIL return InterpNext(S);
40911#else
40912 return true;
40913#endif
40914}
40915PRESERVE_NONE
40916static bool Interp_MulcFloat(InterpState &S) {
40917 if (!Mulc<PT_Float>(S)) return false;
40918#if USE_TAILCALLS
40919 MUSTTAIL return InterpNext(S);
40920#else
40921 return true;
40922#endif
40923}
40924#endif
40925#ifdef GET_DISASM
40926case OP_MulcSint8:
40927 Text.Op = PrintName("MulcSint8");
40928 break;
40929case OP_MulcUint8:
40930 Text.Op = PrintName("MulcUint8");
40931 break;
40932case OP_MulcSint16:
40933 Text.Op = PrintName("MulcSint16");
40934 break;
40935case OP_MulcUint16:
40936 Text.Op = PrintName("MulcUint16");
40937 break;
40938case OP_MulcSint32:
40939 Text.Op = PrintName("MulcSint32");
40940 break;
40941case OP_MulcUint32:
40942 Text.Op = PrintName("MulcUint32");
40943 break;
40944case OP_MulcSint64:
40945 Text.Op = PrintName("MulcSint64");
40946 break;
40947case OP_MulcUint64:
40948 Text.Op = PrintName("MulcUint64");
40949 break;
40950case OP_MulcIntAP:
40951 Text.Op = PrintName("MulcIntAP");
40952 break;
40953case OP_MulcIntAPS:
40954 Text.Op = PrintName("MulcIntAPS");
40955 break;
40956case OP_MulcFloat:
40957 Text.Op = PrintName("MulcFloat");
40958 break;
40959#endif
40960#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40961bool emitMulcSint8(SourceInfo);
40962bool emitMulcUint8(SourceInfo);
40963bool emitMulcSint16(SourceInfo);
40964bool emitMulcUint16(SourceInfo);
40965bool emitMulcSint32(SourceInfo);
40966bool emitMulcUint32(SourceInfo);
40967bool emitMulcSint64(SourceInfo);
40968bool emitMulcUint64(SourceInfo);
40969bool emitMulcIntAP(SourceInfo);
40970bool emitMulcIntAPS(SourceInfo);
40971bool emitMulcFloat(SourceInfo);
40972#endif
40973#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
40974[[nodiscard]] bool emitMulc(PrimType, SourceInfo I);
40975#endif
40976#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
40977bool
40978#if defined(GET_EVAL_IMPL)
40979EvalEmitter
40980#else
40981ByteCodeEmitter
40982#endif
40983::emitMulc(PrimType T0, SourceInfo I) {
40984 switch (T0) {
40985 case PT_Sint8:
40986 return emitMulcSint8(I);
40987 case PT_Uint8:
40988 return emitMulcUint8(I);
40989 case PT_Sint16:
40990 return emitMulcSint16(I);
40991 case PT_Uint16:
40992 return emitMulcUint16(I);
40993 case PT_Sint32:
40994 return emitMulcSint32(I);
40995 case PT_Uint32:
40996 return emitMulcUint32(I);
40997 case PT_Sint64:
40998 return emitMulcSint64(I);
40999 case PT_Uint64:
41000 return emitMulcUint64(I);
41001 case PT_IntAP:
41002 return emitMulcIntAP(I);
41003 case PT_IntAPS:
41004 return emitMulcIntAPS(I);
41005 case PT_Float:
41006 return emitMulcFloat(I);
41007 default: llvm_unreachable("invalid type: emitMulc");
41008 }
41009 llvm_unreachable("invalid enum value");
41010}
41011#endif
41012#ifdef GET_LINK_IMPL
41013bool ByteCodeEmitter::emitMulcSint8(SourceInfo L) {
41014 return emitOp<>(OP_MulcSint8, L);
41015}
41016bool ByteCodeEmitter::emitMulcUint8(SourceInfo L) {
41017 return emitOp<>(OP_MulcUint8, L);
41018}
41019bool ByteCodeEmitter::emitMulcSint16(SourceInfo L) {
41020 return emitOp<>(OP_MulcSint16, L);
41021}
41022bool ByteCodeEmitter::emitMulcUint16(SourceInfo L) {
41023 return emitOp<>(OP_MulcUint16, L);
41024}
41025bool ByteCodeEmitter::emitMulcSint32(SourceInfo L) {
41026 return emitOp<>(OP_MulcSint32, L);
41027}
41028bool ByteCodeEmitter::emitMulcUint32(SourceInfo L) {
41029 return emitOp<>(OP_MulcUint32, L);
41030}
41031bool ByteCodeEmitter::emitMulcSint64(SourceInfo L) {
41032 return emitOp<>(OP_MulcSint64, L);
41033}
41034bool ByteCodeEmitter::emitMulcUint64(SourceInfo L) {
41035 return emitOp<>(OP_MulcUint64, L);
41036}
41037bool ByteCodeEmitter::emitMulcIntAP(SourceInfo L) {
41038 return emitOp<>(OP_MulcIntAP, L);
41039}
41040bool ByteCodeEmitter::emitMulcIntAPS(SourceInfo L) {
41041 return emitOp<>(OP_MulcIntAPS, L);
41042}
41043bool ByteCodeEmitter::emitMulcFloat(SourceInfo L) {
41044 return emitOp<>(OP_MulcFloat, L);
41045}
41046#endif
41047#ifdef GET_EVAL_IMPL
41048bool EvalEmitter::emitMulcSint8(SourceInfo L) {
41049 if (!isActive()) return true;
41050 CurrentSource = L;
41051 return Mulc<PT_Sint8>(S);
41052}
41053bool EvalEmitter::emitMulcUint8(SourceInfo L) {
41054 if (!isActive()) return true;
41055 CurrentSource = L;
41056 return Mulc<PT_Uint8>(S);
41057}
41058bool EvalEmitter::emitMulcSint16(SourceInfo L) {
41059 if (!isActive()) return true;
41060 CurrentSource = L;
41061 return Mulc<PT_Sint16>(S);
41062}
41063bool EvalEmitter::emitMulcUint16(SourceInfo L) {
41064 if (!isActive()) return true;
41065 CurrentSource = L;
41066 return Mulc<PT_Uint16>(S);
41067}
41068bool EvalEmitter::emitMulcSint32(SourceInfo L) {
41069 if (!isActive()) return true;
41070 CurrentSource = L;
41071 return Mulc<PT_Sint32>(S);
41072}
41073bool EvalEmitter::emitMulcUint32(SourceInfo L) {
41074 if (!isActive()) return true;
41075 CurrentSource = L;
41076 return Mulc<PT_Uint32>(S);
41077}
41078bool EvalEmitter::emitMulcSint64(SourceInfo L) {
41079 if (!isActive()) return true;
41080 CurrentSource = L;
41081 return Mulc<PT_Sint64>(S);
41082}
41083bool EvalEmitter::emitMulcUint64(SourceInfo L) {
41084 if (!isActive()) return true;
41085 CurrentSource = L;
41086 return Mulc<PT_Uint64>(S);
41087}
41088bool EvalEmitter::emitMulcIntAP(SourceInfo L) {
41089 if (!isActive()) return true;
41090 CurrentSource = L;
41091 return Mulc<PT_IntAP>(S);
41092}
41093bool EvalEmitter::emitMulcIntAPS(SourceInfo L) {
41094 if (!isActive()) return true;
41095 CurrentSource = L;
41096 return Mulc<PT_IntAPS>(S);
41097}
41098bool EvalEmitter::emitMulcFloat(SourceInfo L) {
41099 if (!isActive()) return true;
41100 CurrentSource = L;
41101 return Mulc<PT_Float>(S);
41102}
41103#endif
41104#ifdef GET_OPCODE_NAMES
41105OP_Mulf,
41106#endif
41107#ifdef GET_INTERPFN_LIST
41108&Interp_Mulf,
41109#endif
41110#ifdef GET_INTERPFN_DISPATCHERS
41111PRESERVE_NONE
41112static bool Interp_Mulf(InterpState &S) {
41113 {
41114 CodePtr OpPC = S.PC;
41115 const auto V0 = ReadArg<uint32_t>(S, S.PC);
41116 if (!Mulf(S, OpPC, V0)) return false;
41117 }
41118#if USE_TAILCALLS
41119 MUSTTAIL return InterpNext(S);
41120#else
41121 return true;
41122#endif
41123}
41124#endif
41125#ifdef GET_DISASM
41126case OP_Mulf:
41127 Text.Op = PrintName("Mulf");
41128 Text.Args.push_back(printArg<uint32_t>(PC));
41129 break;
41130#endif
41131#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
41132bool emitMulf( uint32_t , SourceInfo);
41133#endif
41134#ifdef GET_LINK_IMPL
41135bool ByteCodeEmitter::emitMulf( uint32_t A0, SourceInfo L) {
41136 return emitOp<uint32_t>(OP_Mulf, A0, L);
41137}
41138#endif
41139#ifdef GET_EVAL_IMPL
41140bool EvalEmitter::emitMulf( uint32_t A0, SourceInfo L) {
41141 if (!isActive()) return true;
41142 CurrentSource = L;
41143 return Mulf(S, CodePtr(), A0);
41144}
41145#endif
41146#ifdef GET_OPCODE_NAMES
41147OP_NESint8,
41148OP_NEUint8,
41149OP_NESint16,
41150OP_NEUint16,
41151OP_NESint32,
41152OP_NEUint32,
41153OP_NESint64,
41154OP_NEUint64,
41155OP_NEIntAP,
41156OP_NEIntAPS,
41157OP_NEBool,
41158OP_NEFixedPoint,
41159OP_NEPtr,
41160OP_NEMemberPtr,
41161OP_NEFloat,
41162OP_NEReflect,
41163#endif
41164#ifdef GET_INTERPFN_LIST
41165&Interp_NESint8,
41166&Interp_NEUint8,
41167&Interp_NESint16,
41168&Interp_NEUint16,
41169&Interp_NESint32,
41170&Interp_NEUint32,
41171&Interp_NESint64,
41172&Interp_NEUint64,
41173&Interp_NEIntAP,
41174&Interp_NEIntAPS,
41175&Interp_NEBool,
41176&Interp_NEFixedPoint,
41177&Interp_NEPtr,
41178&Interp_NEMemberPtr,
41179&Interp_NEFloat,
41180&Interp_NEReflect,
41181#endif
41182#ifdef GET_INTERPFN_DISPATCHERS
41183PRESERVE_NONE
41184static bool Interp_NESint8(InterpState &S) {
41185 if (!NE<PT_Sint8>(S, S.PC)) return false;
41186#if USE_TAILCALLS
41187 MUSTTAIL return InterpNext(S);
41188#else
41189 return true;
41190#endif
41191}
41192PRESERVE_NONE
41193static bool Interp_NEUint8(InterpState &S) {
41194 if (!NE<PT_Uint8>(S, S.PC)) return false;
41195#if USE_TAILCALLS
41196 MUSTTAIL return InterpNext(S);
41197#else
41198 return true;
41199#endif
41200}
41201PRESERVE_NONE
41202static bool Interp_NESint16(InterpState &S) {
41203 if (!NE<PT_Sint16>(S, S.PC)) return false;
41204#if USE_TAILCALLS
41205 MUSTTAIL return InterpNext(S);
41206#else
41207 return true;
41208#endif
41209}
41210PRESERVE_NONE
41211static bool Interp_NEUint16(InterpState &S) {
41212 if (!NE<PT_Uint16>(S, S.PC)) return false;
41213#if USE_TAILCALLS
41214 MUSTTAIL return InterpNext(S);
41215#else
41216 return true;
41217#endif
41218}
41219PRESERVE_NONE
41220static bool Interp_NESint32(InterpState &S) {
41221 if (!NE<PT_Sint32>(S, S.PC)) return false;
41222#if USE_TAILCALLS
41223 MUSTTAIL return InterpNext(S);
41224#else
41225 return true;
41226#endif
41227}
41228PRESERVE_NONE
41229static bool Interp_NEUint32(InterpState &S) {
41230 if (!NE<PT_Uint32>(S, S.PC)) return false;
41231#if USE_TAILCALLS
41232 MUSTTAIL return InterpNext(S);
41233#else
41234 return true;
41235#endif
41236}
41237PRESERVE_NONE
41238static bool Interp_NESint64(InterpState &S) {
41239 if (!NE<PT_Sint64>(S, S.PC)) return false;
41240#if USE_TAILCALLS
41241 MUSTTAIL return InterpNext(S);
41242#else
41243 return true;
41244#endif
41245}
41246PRESERVE_NONE
41247static bool Interp_NEUint64(InterpState &S) {
41248 if (!NE<PT_Uint64>(S, S.PC)) return false;
41249#if USE_TAILCALLS
41250 MUSTTAIL return InterpNext(S);
41251#else
41252 return true;
41253#endif
41254}
41255PRESERVE_NONE
41256static bool Interp_NEIntAP(InterpState &S) {
41257 if (!NE<PT_IntAP>(S, S.PC)) return false;
41258#if USE_TAILCALLS
41259 MUSTTAIL return InterpNext(S);
41260#else
41261 return true;
41262#endif
41263}
41264PRESERVE_NONE
41265static bool Interp_NEIntAPS(InterpState &S) {
41266 if (!NE<PT_IntAPS>(S, S.PC)) return false;
41267#if USE_TAILCALLS
41268 MUSTTAIL return InterpNext(S);
41269#else
41270 return true;
41271#endif
41272}
41273PRESERVE_NONE
41274static bool Interp_NEBool(InterpState &S) {
41275 if (!NE<PT_Bool>(S, S.PC)) return false;
41276#if USE_TAILCALLS
41277 MUSTTAIL return InterpNext(S);
41278#else
41279 return true;
41280#endif
41281}
41282PRESERVE_NONE
41283static bool Interp_NEFixedPoint(InterpState &S) {
41284 if (!NE<PT_FixedPoint>(S, S.PC)) return false;
41285#if USE_TAILCALLS
41286 MUSTTAIL return InterpNext(S);
41287#else
41288 return true;
41289#endif
41290}
41291PRESERVE_NONE
41292static bool Interp_NEPtr(InterpState &S) {
41293 if (!NE<PT_Ptr>(S, S.PC)) return false;
41294#if USE_TAILCALLS
41295 MUSTTAIL return InterpNext(S);
41296#else
41297 return true;
41298#endif
41299}
41300PRESERVE_NONE
41301static bool Interp_NEMemberPtr(InterpState &S) {
41302 if (!NE<PT_MemberPtr>(S, S.PC)) return false;
41303#if USE_TAILCALLS
41304 MUSTTAIL return InterpNext(S);
41305#else
41306 return true;
41307#endif
41308}
41309PRESERVE_NONE
41310static bool Interp_NEFloat(InterpState &S) {
41311 if (!NE<PT_Float>(S, S.PC)) return false;
41312#if USE_TAILCALLS
41313 MUSTTAIL return InterpNext(S);
41314#else
41315 return true;
41316#endif
41317}
41318PRESERVE_NONE
41319static bool Interp_NEReflect(InterpState &S) {
41320 if (!NE<PT_Reflect>(S, S.PC)) return false;
41321#if USE_TAILCALLS
41322 MUSTTAIL return InterpNext(S);
41323#else
41324 return true;
41325#endif
41326}
41327#endif
41328#ifdef GET_DISASM
41329case OP_NESint8:
41330 Text.Op = PrintName("NESint8");
41331 break;
41332case OP_NEUint8:
41333 Text.Op = PrintName("NEUint8");
41334 break;
41335case OP_NESint16:
41336 Text.Op = PrintName("NESint16");
41337 break;
41338case OP_NEUint16:
41339 Text.Op = PrintName("NEUint16");
41340 break;
41341case OP_NESint32:
41342 Text.Op = PrintName("NESint32");
41343 break;
41344case OP_NEUint32:
41345 Text.Op = PrintName("NEUint32");
41346 break;
41347case OP_NESint64:
41348 Text.Op = PrintName("NESint64");
41349 break;
41350case OP_NEUint64:
41351 Text.Op = PrintName("NEUint64");
41352 break;
41353case OP_NEIntAP:
41354 Text.Op = PrintName("NEIntAP");
41355 break;
41356case OP_NEIntAPS:
41357 Text.Op = PrintName("NEIntAPS");
41358 break;
41359case OP_NEBool:
41360 Text.Op = PrintName("NEBool");
41361 break;
41362case OP_NEFixedPoint:
41363 Text.Op = PrintName("NEFixedPoint");
41364 break;
41365case OP_NEPtr:
41366 Text.Op = PrintName("NEPtr");
41367 break;
41368case OP_NEMemberPtr:
41369 Text.Op = PrintName("NEMemberPtr");
41370 break;
41371case OP_NEFloat:
41372 Text.Op = PrintName("NEFloat");
41373 break;
41374case OP_NEReflect:
41375 Text.Op = PrintName("NEReflect");
41376 break;
41377#endif
41378#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
41379bool emitNESint8(SourceInfo);
41380bool emitNEUint8(SourceInfo);
41381bool emitNESint16(SourceInfo);
41382bool emitNEUint16(SourceInfo);
41383bool emitNESint32(SourceInfo);
41384bool emitNEUint32(SourceInfo);
41385bool emitNESint64(SourceInfo);
41386bool emitNEUint64(SourceInfo);
41387bool emitNEIntAP(SourceInfo);
41388bool emitNEIntAPS(SourceInfo);
41389bool emitNEBool(SourceInfo);
41390bool emitNEFixedPoint(SourceInfo);
41391bool emitNEPtr(SourceInfo);
41392bool emitNEMemberPtr(SourceInfo);
41393bool emitNEFloat(SourceInfo);
41394bool emitNEReflect(SourceInfo);
41395#endif
41396#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
41397[[nodiscard]] bool emitNE(PrimType, SourceInfo I);
41398#endif
41399#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
41400bool
41401#if defined(GET_EVAL_IMPL)
41402EvalEmitter
41403#else
41404ByteCodeEmitter
41405#endif
41406::emitNE(PrimType T0, SourceInfo I) {
41407 switch (T0) {
41408 case PT_Sint8:
41409 return emitNESint8(I);
41410 case PT_Uint8:
41411 return emitNEUint8(I);
41412 case PT_Sint16:
41413 return emitNESint16(I);
41414 case PT_Uint16:
41415 return emitNEUint16(I);
41416 case PT_Sint32:
41417 return emitNESint32(I);
41418 case PT_Uint32:
41419 return emitNEUint32(I);
41420 case PT_Sint64:
41421 return emitNESint64(I);
41422 case PT_Uint64:
41423 return emitNEUint64(I);
41424 case PT_IntAP:
41425 return emitNEIntAP(I);
41426 case PT_IntAPS:
41427 return emitNEIntAPS(I);
41428 case PT_Bool:
41429 return emitNEBool(I);
41430 case PT_FixedPoint:
41431 return emitNEFixedPoint(I);
41432 case PT_Ptr:
41433 return emitNEPtr(I);
41434 case PT_MemberPtr:
41435 return emitNEMemberPtr(I);
41436 case PT_Float:
41437 return emitNEFloat(I);
41438 case PT_Reflect:
41439 return emitNEReflect(I);
41440 }
41441 llvm_unreachable("invalid enum value");
41442}
41443#endif
41444#ifdef GET_LINK_IMPL
41445bool ByteCodeEmitter::emitNESint8(SourceInfo L) {
41446 return emitOp<>(OP_NESint8, L);
41447}
41448bool ByteCodeEmitter::emitNEUint8(SourceInfo L) {
41449 return emitOp<>(OP_NEUint8, L);
41450}
41451bool ByteCodeEmitter::emitNESint16(SourceInfo L) {
41452 return emitOp<>(OP_NESint16, L);
41453}
41454bool ByteCodeEmitter::emitNEUint16(SourceInfo L) {
41455 return emitOp<>(OP_NEUint16, L);
41456}
41457bool ByteCodeEmitter::emitNESint32(SourceInfo L) {
41458 return emitOp<>(OP_NESint32, L);
41459}
41460bool ByteCodeEmitter::emitNEUint32(SourceInfo L) {
41461 return emitOp<>(OP_NEUint32, L);
41462}
41463bool ByteCodeEmitter::emitNESint64(SourceInfo L) {
41464 return emitOp<>(OP_NESint64, L);
41465}
41466bool ByteCodeEmitter::emitNEUint64(SourceInfo L) {
41467 return emitOp<>(OP_NEUint64, L);
41468}
41469bool ByteCodeEmitter::emitNEIntAP(SourceInfo L) {
41470 return emitOp<>(OP_NEIntAP, L);
41471}
41472bool ByteCodeEmitter::emitNEIntAPS(SourceInfo L) {
41473 return emitOp<>(OP_NEIntAPS, L);
41474}
41475bool ByteCodeEmitter::emitNEBool(SourceInfo L) {
41476 return emitOp<>(OP_NEBool, L);
41477}
41478bool ByteCodeEmitter::emitNEFixedPoint(SourceInfo L) {
41479 return emitOp<>(OP_NEFixedPoint, L);
41480}
41481bool ByteCodeEmitter::emitNEPtr(SourceInfo L) {
41482 return emitOp<>(OP_NEPtr, L);
41483}
41484bool ByteCodeEmitter::emitNEMemberPtr(SourceInfo L) {
41485 return emitOp<>(OP_NEMemberPtr, L);
41486}
41487bool ByteCodeEmitter::emitNEFloat(SourceInfo L) {
41488 return emitOp<>(OP_NEFloat, L);
41489}
41490bool ByteCodeEmitter::emitNEReflect(SourceInfo L) {
41491 return emitOp<>(OP_NEReflect, L);
41492}
41493#endif
41494#ifdef GET_EVAL_IMPL
41495bool EvalEmitter::emitNESint8(SourceInfo L) {
41496 if (!isActive()) return true;
41497 CurrentSource = L;
41498 return NE<PT_Sint8>(S, CodePtr());
41499}
41500bool EvalEmitter::emitNEUint8(SourceInfo L) {
41501 if (!isActive()) return true;
41502 CurrentSource = L;
41503 return NE<PT_Uint8>(S, CodePtr());
41504}
41505bool EvalEmitter::emitNESint16(SourceInfo L) {
41506 if (!isActive()) return true;
41507 CurrentSource = L;
41508 return NE<PT_Sint16>(S, CodePtr());
41509}
41510bool EvalEmitter::emitNEUint16(SourceInfo L) {
41511 if (!isActive()) return true;
41512 CurrentSource = L;
41513 return NE<PT_Uint16>(S, CodePtr());
41514}
41515bool EvalEmitter::emitNESint32(SourceInfo L) {
41516 if (!isActive()) return true;
41517 CurrentSource = L;
41518 return NE<PT_Sint32>(S, CodePtr());
41519}
41520bool EvalEmitter::emitNEUint32(SourceInfo L) {
41521 if (!isActive()) return true;
41522 CurrentSource = L;
41523 return NE<PT_Uint32>(S, CodePtr());
41524}
41525bool EvalEmitter::emitNESint64(SourceInfo L) {
41526 if (!isActive()) return true;
41527 CurrentSource = L;
41528 return NE<PT_Sint64>(S, CodePtr());
41529}
41530bool EvalEmitter::emitNEUint64(SourceInfo L) {
41531 if (!isActive()) return true;
41532 CurrentSource = L;
41533 return NE<PT_Uint64>(S, CodePtr());
41534}
41535bool EvalEmitter::emitNEIntAP(SourceInfo L) {
41536 if (!isActive()) return true;
41537 CurrentSource = L;
41538 return NE<PT_IntAP>(S, CodePtr());
41539}
41540bool EvalEmitter::emitNEIntAPS(SourceInfo L) {
41541 if (!isActive()) return true;
41542 CurrentSource = L;
41543 return NE<PT_IntAPS>(S, CodePtr());
41544}
41545bool EvalEmitter::emitNEBool(SourceInfo L) {
41546 if (!isActive()) return true;
41547 CurrentSource = L;
41548 return NE<PT_Bool>(S, CodePtr());
41549}
41550bool EvalEmitter::emitNEFixedPoint(SourceInfo L) {
41551 if (!isActive()) return true;
41552 CurrentSource = L;
41553 return NE<PT_FixedPoint>(S, CodePtr());
41554}
41555bool EvalEmitter::emitNEPtr(SourceInfo L) {
41556 if (!isActive()) return true;
41557 CurrentSource = L;
41558 return NE<PT_Ptr>(S, CodePtr());
41559}
41560bool EvalEmitter::emitNEMemberPtr(SourceInfo L) {
41561 if (!isActive()) return true;
41562 CurrentSource = L;
41563 return NE<PT_MemberPtr>(S, CodePtr());
41564}
41565bool EvalEmitter::emitNEFloat(SourceInfo L) {
41566 if (!isActive()) return true;
41567 CurrentSource = L;
41568 return NE<PT_Float>(S, CodePtr());
41569}
41570bool EvalEmitter::emitNEReflect(SourceInfo L) {
41571 if (!isActive()) return true;
41572 CurrentSource = L;
41573 return NE<PT_Reflect>(S, CodePtr());
41574}
41575#endif
41576#ifdef GET_OPCODE_NAMES
41577OP_NarrowPtr,
41578#endif
41579#ifdef GET_INTERPFN_LIST
41580&Interp_NarrowPtr,
41581#endif
41582#ifdef GET_INTERPFN_DISPATCHERS
41583PRESERVE_NONE
41584static bool Interp_NarrowPtr(InterpState &S) {
41585 NarrowPtr(S);
41586#if USE_TAILCALLS
41587 MUSTTAIL return InterpNext(S);
41588#else
41589 return true;
41590#endif
41591}
41592#endif
41593#ifdef GET_DISASM
41594case OP_NarrowPtr:
41595 Text.Op = PrintName("NarrowPtr");
41596 break;
41597#endif
41598#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
41599bool emitNarrowPtr(SourceInfo);
41600#endif
41601#ifdef GET_LINK_IMPL
41602bool ByteCodeEmitter::emitNarrowPtr(SourceInfo L) {
41603 return emitOp<>(OP_NarrowPtr, L);
41604}
41605#endif
41606#ifdef GET_EVAL_IMPL
41607bool EvalEmitter::emitNarrowPtr(SourceInfo L) {
41608 if (!isActive()) return true;
41609 CurrentSource = L;
41610 return NarrowPtr(S);
41611}
41612#endif
41613#ifdef GET_OPCODE_NAMES
41614OP_NegSint8,
41615OP_NegUint8,
41616OP_NegSint16,
41617OP_NegUint16,
41618OP_NegSint32,
41619OP_NegUint32,
41620OP_NegSint64,
41621OP_NegUint64,
41622OP_NegIntAP,
41623OP_NegIntAPS,
41624OP_NegBool,
41625OP_NegFloat,
41626OP_NegFixedPoint,
41627#endif
41628#ifdef GET_INTERPFN_LIST
41629&Interp_NegSint8,
41630&Interp_NegUint8,
41631&Interp_NegSint16,
41632&Interp_NegUint16,
41633&Interp_NegSint32,
41634&Interp_NegUint32,
41635&Interp_NegSint64,
41636&Interp_NegUint64,
41637&Interp_NegIntAP,
41638&Interp_NegIntAPS,
41639&Interp_NegBool,
41640&Interp_NegFloat,
41641&Interp_NegFixedPoint,
41642#endif
41643#ifdef GET_INTERPFN_DISPATCHERS
41644PRESERVE_NONE
41645static bool Interp_NegSint8(InterpState &S) {
41646 if (!Neg<PT_Sint8>(S, S.PC)) return false;
41647#if USE_TAILCALLS
41648 MUSTTAIL return InterpNext(S);
41649#else
41650 return true;
41651#endif
41652}
41653PRESERVE_NONE
41654static bool Interp_NegUint8(InterpState &S) {
41655 if (!Neg<PT_Uint8>(S, S.PC)) return false;
41656#if USE_TAILCALLS
41657 MUSTTAIL return InterpNext(S);
41658#else
41659 return true;
41660#endif
41661}
41662PRESERVE_NONE
41663static bool Interp_NegSint16(InterpState &S) {
41664 if (!Neg<PT_Sint16>(S, S.PC)) return false;
41665#if USE_TAILCALLS
41666 MUSTTAIL return InterpNext(S);
41667#else
41668 return true;
41669#endif
41670}
41671PRESERVE_NONE
41672static bool Interp_NegUint16(InterpState &S) {
41673 if (!Neg<PT_Uint16>(S, S.PC)) return false;
41674#if USE_TAILCALLS
41675 MUSTTAIL return InterpNext(S);
41676#else
41677 return true;
41678#endif
41679}
41680PRESERVE_NONE
41681static bool Interp_NegSint32(InterpState &S) {
41682 if (!Neg<PT_Sint32>(S, S.PC)) return false;
41683#if USE_TAILCALLS
41684 MUSTTAIL return InterpNext(S);
41685#else
41686 return true;
41687#endif
41688}
41689PRESERVE_NONE
41690static bool Interp_NegUint32(InterpState &S) {
41691 if (!Neg<PT_Uint32>(S, S.PC)) return false;
41692#if USE_TAILCALLS
41693 MUSTTAIL return InterpNext(S);
41694#else
41695 return true;
41696#endif
41697}
41698PRESERVE_NONE
41699static bool Interp_NegSint64(InterpState &S) {
41700 if (!Neg<PT_Sint64>(S, S.PC)) return false;
41701#if USE_TAILCALLS
41702 MUSTTAIL return InterpNext(S);
41703#else
41704 return true;
41705#endif
41706}
41707PRESERVE_NONE
41708static bool Interp_NegUint64(InterpState &S) {
41709 if (!Neg<PT_Uint64>(S, S.PC)) return false;
41710#if USE_TAILCALLS
41711 MUSTTAIL return InterpNext(S);
41712#else
41713 return true;
41714#endif
41715}
41716PRESERVE_NONE
41717static bool Interp_NegIntAP(InterpState &S) {
41718 if (!Neg<PT_IntAP>(S, S.PC)) return false;
41719#if USE_TAILCALLS
41720 MUSTTAIL return InterpNext(S);
41721#else
41722 return true;
41723#endif
41724}
41725PRESERVE_NONE
41726static bool Interp_NegIntAPS(InterpState &S) {
41727 if (!Neg<PT_IntAPS>(S, S.PC)) return false;
41728#if USE_TAILCALLS
41729 MUSTTAIL return InterpNext(S);
41730#else
41731 return true;
41732#endif
41733}
41734PRESERVE_NONE
41735static bool Interp_NegBool(InterpState &S) {
41736 if (!Neg<PT_Bool>(S, S.PC)) return false;
41737#if USE_TAILCALLS
41738 MUSTTAIL return InterpNext(S);
41739#else
41740 return true;
41741#endif
41742}
41743PRESERVE_NONE
41744static bool Interp_NegFloat(InterpState &S) {
41745 if (!Neg<PT_Float>(S, S.PC)) return false;
41746#if USE_TAILCALLS
41747 MUSTTAIL return InterpNext(S);
41748#else
41749 return true;
41750#endif
41751}
41752PRESERVE_NONE
41753static bool Interp_NegFixedPoint(InterpState &S) {
41754 if (!Neg<PT_FixedPoint>(S, S.PC)) return false;
41755#if USE_TAILCALLS
41756 MUSTTAIL return InterpNext(S);
41757#else
41758 return true;
41759#endif
41760}
41761#endif
41762#ifdef GET_DISASM
41763case OP_NegSint8:
41764 Text.Op = PrintName("NegSint8");
41765 break;
41766case OP_NegUint8:
41767 Text.Op = PrintName("NegUint8");
41768 break;
41769case OP_NegSint16:
41770 Text.Op = PrintName("NegSint16");
41771 break;
41772case OP_NegUint16:
41773 Text.Op = PrintName("NegUint16");
41774 break;
41775case OP_NegSint32:
41776 Text.Op = PrintName("NegSint32");
41777 break;
41778case OP_NegUint32:
41779 Text.Op = PrintName("NegUint32");
41780 break;
41781case OP_NegSint64:
41782 Text.Op = PrintName("NegSint64");
41783 break;
41784case OP_NegUint64:
41785 Text.Op = PrintName("NegUint64");
41786 break;
41787case OP_NegIntAP:
41788 Text.Op = PrintName("NegIntAP");
41789 break;
41790case OP_NegIntAPS:
41791 Text.Op = PrintName("NegIntAPS");
41792 break;
41793case OP_NegBool:
41794 Text.Op = PrintName("NegBool");
41795 break;
41796case OP_NegFloat:
41797 Text.Op = PrintName("NegFloat");
41798 break;
41799case OP_NegFixedPoint:
41800 Text.Op = PrintName("NegFixedPoint");
41801 break;
41802#endif
41803#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
41804bool emitNegSint8(SourceInfo);
41805bool emitNegUint8(SourceInfo);
41806bool emitNegSint16(SourceInfo);
41807bool emitNegUint16(SourceInfo);
41808bool emitNegSint32(SourceInfo);
41809bool emitNegUint32(SourceInfo);
41810bool emitNegSint64(SourceInfo);
41811bool emitNegUint64(SourceInfo);
41812bool emitNegIntAP(SourceInfo);
41813bool emitNegIntAPS(SourceInfo);
41814bool emitNegBool(SourceInfo);
41815bool emitNegFloat(SourceInfo);
41816bool emitNegFixedPoint(SourceInfo);
41817#endif
41818#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
41819[[nodiscard]] bool emitNeg(PrimType, SourceInfo I);
41820#endif
41821#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
41822bool
41823#if defined(GET_EVAL_IMPL)
41824EvalEmitter
41825#else
41826ByteCodeEmitter
41827#endif
41828::emitNeg(PrimType T0, SourceInfo I) {
41829 switch (T0) {
41830 case PT_Sint8:
41831 return emitNegSint8(I);
41832 case PT_Uint8:
41833 return emitNegUint8(I);
41834 case PT_Sint16:
41835 return emitNegSint16(I);
41836 case PT_Uint16:
41837 return emitNegUint16(I);
41838 case PT_Sint32:
41839 return emitNegSint32(I);
41840 case PT_Uint32:
41841 return emitNegUint32(I);
41842 case PT_Sint64:
41843 return emitNegSint64(I);
41844 case PT_Uint64:
41845 return emitNegUint64(I);
41846 case PT_IntAP:
41847 return emitNegIntAP(I);
41848 case PT_IntAPS:
41849 return emitNegIntAPS(I);
41850 case PT_Bool:
41851 return emitNegBool(I);
41852 case PT_Float:
41853 return emitNegFloat(I);
41854 case PT_FixedPoint:
41855 return emitNegFixedPoint(I);
41856 default: llvm_unreachable("invalid type: emitNeg");
41857 }
41858 llvm_unreachable("invalid enum value");
41859}
41860#endif
41861#ifdef GET_LINK_IMPL
41862bool ByteCodeEmitter::emitNegSint8(SourceInfo L) {
41863 return emitOp<>(OP_NegSint8, L);
41864}
41865bool ByteCodeEmitter::emitNegUint8(SourceInfo L) {
41866 return emitOp<>(OP_NegUint8, L);
41867}
41868bool ByteCodeEmitter::emitNegSint16(SourceInfo L) {
41869 return emitOp<>(OP_NegSint16, L);
41870}
41871bool ByteCodeEmitter::emitNegUint16(SourceInfo L) {
41872 return emitOp<>(OP_NegUint16, L);
41873}
41874bool ByteCodeEmitter::emitNegSint32(SourceInfo L) {
41875 return emitOp<>(OP_NegSint32, L);
41876}
41877bool ByteCodeEmitter::emitNegUint32(SourceInfo L) {
41878 return emitOp<>(OP_NegUint32, L);
41879}
41880bool ByteCodeEmitter::emitNegSint64(SourceInfo L) {
41881 return emitOp<>(OP_NegSint64, L);
41882}
41883bool ByteCodeEmitter::emitNegUint64(SourceInfo L) {
41884 return emitOp<>(OP_NegUint64, L);
41885}
41886bool ByteCodeEmitter::emitNegIntAP(SourceInfo L) {
41887 return emitOp<>(OP_NegIntAP, L);
41888}
41889bool ByteCodeEmitter::emitNegIntAPS(SourceInfo L) {
41890 return emitOp<>(OP_NegIntAPS, L);
41891}
41892bool ByteCodeEmitter::emitNegBool(SourceInfo L) {
41893 return emitOp<>(OP_NegBool, L);
41894}
41895bool ByteCodeEmitter::emitNegFloat(SourceInfo L) {
41896 return emitOp<>(OP_NegFloat, L);
41897}
41898bool ByteCodeEmitter::emitNegFixedPoint(SourceInfo L) {
41899 return emitOp<>(OP_NegFixedPoint, L);
41900}
41901#endif
41902#ifdef GET_EVAL_IMPL
41903bool EvalEmitter::emitNegSint8(SourceInfo L) {
41904 if (!isActive()) return true;
41905 CurrentSource = L;
41906 return Neg<PT_Sint8>(S, CodePtr());
41907}
41908bool EvalEmitter::emitNegUint8(SourceInfo L) {
41909 if (!isActive()) return true;
41910 CurrentSource = L;
41911 return Neg<PT_Uint8>(S, CodePtr());
41912}
41913bool EvalEmitter::emitNegSint16(SourceInfo L) {
41914 if (!isActive()) return true;
41915 CurrentSource = L;
41916 return Neg<PT_Sint16>(S, CodePtr());
41917}
41918bool EvalEmitter::emitNegUint16(SourceInfo L) {
41919 if (!isActive()) return true;
41920 CurrentSource = L;
41921 return Neg<PT_Uint16>(S, CodePtr());
41922}
41923bool EvalEmitter::emitNegSint32(SourceInfo L) {
41924 if (!isActive()) return true;
41925 CurrentSource = L;
41926 return Neg<PT_Sint32>(S, CodePtr());
41927}
41928bool EvalEmitter::emitNegUint32(SourceInfo L) {
41929 if (!isActive()) return true;
41930 CurrentSource = L;
41931 return Neg<PT_Uint32>(S, CodePtr());
41932}
41933bool EvalEmitter::emitNegSint64(SourceInfo L) {
41934 if (!isActive()) return true;
41935 CurrentSource = L;
41936 return Neg<PT_Sint64>(S, CodePtr());
41937}
41938bool EvalEmitter::emitNegUint64(SourceInfo L) {
41939 if (!isActive()) return true;
41940 CurrentSource = L;
41941 return Neg<PT_Uint64>(S, CodePtr());
41942}
41943bool EvalEmitter::emitNegIntAP(SourceInfo L) {
41944 if (!isActive()) return true;
41945 CurrentSource = L;
41946 return Neg<PT_IntAP>(S, CodePtr());
41947}
41948bool EvalEmitter::emitNegIntAPS(SourceInfo L) {
41949 if (!isActive()) return true;
41950 CurrentSource = L;
41951 return Neg<PT_IntAPS>(S, CodePtr());
41952}
41953bool EvalEmitter::emitNegBool(SourceInfo L) {
41954 if (!isActive()) return true;
41955 CurrentSource = L;
41956 return Neg<PT_Bool>(S, CodePtr());
41957}
41958bool EvalEmitter::emitNegFloat(SourceInfo L) {
41959 if (!isActive()) return true;
41960 CurrentSource = L;
41961 return Neg<PT_Float>(S, CodePtr());
41962}
41963bool EvalEmitter::emitNegFixedPoint(SourceInfo L) {
41964 if (!isActive()) return true;
41965 CurrentSource = L;
41966 return Neg<PT_FixedPoint>(S, CodePtr());
41967}
41968#endif
41969#ifdef GET_OPCODE_NAMES
41970OP_NoRet,
41971#endif
41972#ifdef GET_INTERPFN_LIST
41973&Interp_NoRet,
41974#endif
41975#ifdef GET_INTERPFN_DISPATCHERS
41976PRESERVE_NONE
41977static bool Interp_NoRet(InterpState &S) {
41978 if (!NoRet(S)) return false;
41979#if USE_TAILCALLS
41980 MUSTTAIL return InterpNext(S);
41981#else
41982 return true;
41983#endif
41984}
41985#endif
41986#ifdef GET_DISASM
41987case OP_NoRet:
41988 Text.Op = PrintName("NoRet");
41989 break;
41990#endif
41991#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
41992bool emitNoRet(SourceInfo);
41993#endif
41994#ifdef GET_LINK_IMPL
41995bool ByteCodeEmitter::emitNoRet(SourceInfo L) {
41996 return emitOp<>(OP_NoRet, L);
41997}
41998#endif
41999#ifdef GET_EVAL_IMPL
42000bool EvalEmitter::emitNoRet(SourceInfo L) {
42001 if (!isActive()) return true;
42002 CurrentSource = L;
42003 return NoRet(S);
42004}
42005#endif
42006#ifdef GET_OPCODE_NAMES
42007OP_NullPtr,
42008OP_NullMemberPtr,
42009#endif
42010#ifdef GET_INTERPFN_LIST
42011&Interp_NullPtr,
42012&Interp_NullMemberPtr,
42013#endif
42014#ifdef GET_INTERPFN_DISPATCHERS
42015PRESERVE_NONE
42016static bool Interp_NullPtr(InterpState &S) {
42017 {
42018 const auto V0 = ReadArg<uint64_t>(S, S.PC);
42019 const auto V1 = ReadArg<const Type *>(S, S.PC);
42020 Null<PT_Ptr>(S, V0, V1);
42021 }
42022#if USE_TAILCALLS
42023 MUSTTAIL return InterpNext(S);
42024#else
42025 return true;
42026#endif
42027}
42028PRESERVE_NONE
42029static bool Interp_NullMemberPtr(InterpState &S) {
42030 {
42031 const auto V0 = ReadArg<uint64_t>(S, S.PC);
42032 const auto V1 = ReadArg<const Type *>(S, S.PC);
42033 Null<PT_MemberPtr>(S, V0, V1);
42034 }
42035#if USE_TAILCALLS
42036 MUSTTAIL return InterpNext(S);
42037#else
42038 return true;
42039#endif
42040}
42041#endif
42042#ifdef GET_DISASM
42043case OP_NullPtr:
42044 Text.Op = PrintName("NullPtr");
42045 Text.Args.push_back(printArg<uint64_t>(PC));
42046 Text.Args.push_back(printArg<const Type *>(PC));
42047 break;
42048case OP_NullMemberPtr:
42049 Text.Op = PrintName("NullMemberPtr");
42050 Text.Args.push_back(printArg<uint64_t>(PC));
42051 Text.Args.push_back(printArg<const Type *>(PC));
42052 break;
42053#endif
42054#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42055bool emitNullPtr( uint64_t , const Type * , SourceInfo);
42056bool emitNullMemberPtr( uint64_t , const Type * , SourceInfo);
42057#endif
42058#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42059[[nodiscard]] bool emitNull(PrimType, uint64_t, const Type *, SourceInfo I);
42060#endif
42061#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
42062bool
42063#if defined(GET_EVAL_IMPL)
42064EvalEmitter
42065#else
42066ByteCodeEmitter
42067#endif
42068::emitNull(PrimType T0, uint64_t A0, const Type * A1, SourceInfo I) {
42069 switch (T0) {
42070 case PT_Ptr:
42071 return emitNullPtr(A0, A1, I);
42072 case PT_MemberPtr:
42073 return emitNullMemberPtr(A0, A1, I);
42074 default: llvm_unreachable("invalid type: emitNull");
42075 }
42076 llvm_unreachable("invalid enum value");
42077}
42078#endif
42079#ifdef GET_LINK_IMPL
42080bool ByteCodeEmitter::emitNullPtr( uint64_t A0, const Type * A1, SourceInfo L) {
42081 return emitOp<uint64_t, const Type *>(OP_NullPtr, A0, A1, L);
42082}
42083bool ByteCodeEmitter::emitNullMemberPtr( uint64_t A0, const Type * A1, SourceInfo L) {
42084 return emitOp<uint64_t, const Type *>(OP_NullMemberPtr, A0, A1, L);
42085}
42086#endif
42087#ifdef GET_EVAL_IMPL
42088bool EvalEmitter::emitNullPtr( uint64_t A0, const Type * A1, SourceInfo L) {
42089 if (!isActive()) return true;
42090 CurrentSource = L;
42091 return Null<PT_Ptr>(S, A0, A1);
42092}
42093bool EvalEmitter::emitNullMemberPtr( uint64_t A0, const Type * A1, SourceInfo L) {
42094 if (!isActive()) return true;
42095 CurrentSource = L;
42096 return Null<PT_MemberPtr>(S, A0, A1);
42097}
42098#endif
42099#ifdef GET_OPCODE_NAMES
42100OP_OffsetOfSint8,
42101OP_OffsetOfUint8,
42102OP_OffsetOfSint16,
42103OP_OffsetOfUint16,
42104OP_OffsetOfSint32,
42105OP_OffsetOfUint32,
42106OP_OffsetOfSint64,
42107OP_OffsetOfUint64,
42108OP_OffsetOfIntAP,
42109OP_OffsetOfIntAPS,
42110#endif
42111#ifdef GET_INTERPFN_LIST
42112&Interp_OffsetOfSint8,
42113&Interp_OffsetOfUint8,
42114&Interp_OffsetOfSint16,
42115&Interp_OffsetOfUint16,
42116&Interp_OffsetOfSint32,
42117&Interp_OffsetOfUint32,
42118&Interp_OffsetOfSint64,
42119&Interp_OffsetOfUint64,
42120&Interp_OffsetOfIntAP,
42121&Interp_OffsetOfIntAPS,
42122#endif
42123#ifdef GET_INTERPFN_DISPATCHERS
42124PRESERVE_NONE
42125static bool Interp_OffsetOfSint8(InterpState &S) {
42126 {
42127 CodePtr OpPC = S.PC;
42128 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42129 if (!OffsetOf<PT_Sint8>(S, OpPC, V0)) return false;
42130 }
42131#if USE_TAILCALLS
42132 MUSTTAIL return InterpNext(S);
42133#else
42134 return true;
42135#endif
42136}
42137PRESERVE_NONE
42138static bool Interp_OffsetOfUint8(InterpState &S) {
42139 {
42140 CodePtr OpPC = S.PC;
42141 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42142 if (!OffsetOf<PT_Uint8>(S, OpPC, V0)) return false;
42143 }
42144#if USE_TAILCALLS
42145 MUSTTAIL return InterpNext(S);
42146#else
42147 return true;
42148#endif
42149}
42150PRESERVE_NONE
42151static bool Interp_OffsetOfSint16(InterpState &S) {
42152 {
42153 CodePtr OpPC = S.PC;
42154 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42155 if (!OffsetOf<PT_Sint16>(S, OpPC, V0)) return false;
42156 }
42157#if USE_TAILCALLS
42158 MUSTTAIL return InterpNext(S);
42159#else
42160 return true;
42161#endif
42162}
42163PRESERVE_NONE
42164static bool Interp_OffsetOfUint16(InterpState &S) {
42165 {
42166 CodePtr OpPC = S.PC;
42167 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42168 if (!OffsetOf<PT_Uint16>(S, OpPC, V0)) return false;
42169 }
42170#if USE_TAILCALLS
42171 MUSTTAIL return InterpNext(S);
42172#else
42173 return true;
42174#endif
42175}
42176PRESERVE_NONE
42177static bool Interp_OffsetOfSint32(InterpState &S) {
42178 {
42179 CodePtr OpPC = S.PC;
42180 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42181 if (!OffsetOf<PT_Sint32>(S, OpPC, V0)) return false;
42182 }
42183#if USE_TAILCALLS
42184 MUSTTAIL return InterpNext(S);
42185#else
42186 return true;
42187#endif
42188}
42189PRESERVE_NONE
42190static bool Interp_OffsetOfUint32(InterpState &S) {
42191 {
42192 CodePtr OpPC = S.PC;
42193 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42194 if (!OffsetOf<PT_Uint32>(S, OpPC, V0)) return false;
42195 }
42196#if USE_TAILCALLS
42197 MUSTTAIL return InterpNext(S);
42198#else
42199 return true;
42200#endif
42201}
42202PRESERVE_NONE
42203static bool Interp_OffsetOfSint64(InterpState &S) {
42204 {
42205 CodePtr OpPC = S.PC;
42206 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42207 if (!OffsetOf<PT_Sint64>(S, OpPC, V0)) return false;
42208 }
42209#if USE_TAILCALLS
42210 MUSTTAIL return InterpNext(S);
42211#else
42212 return true;
42213#endif
42214}
42215PRESERVE_NONE
42216static bool Interp_OffsetOfUint64(InterpState &S) {
42217 {
42218 CodePtr OpPC = S.PC;
42219 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42220 if (!OffsetOf<PT_Uint64>(S, OpPC, V0)) return false;
42221 }
42222#if USE_TAILCALLS
42223 MUSTTAIL return InterpNext(S);
42224#else
42225 return true;
42226#endif
42227}
42228PRESERVE_NONE
42229static bool Interp_OffsetOfIntAP(InterpState &S) {
42230 {
42231 CodePtr OpPC = S.PC;
42232 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42233 if (!OffsetOf<PT_IntAP>(S, OpPC, V0)) return false;
42234 }
42235#if USE_TAILCALLS
42236 MUSTTAIL return InterpNext(S);
42237#else
42238 return true;
42239#endif
42240}
42241PRESERVE_NONE
42242static bool Interp_OffsetOfIntAPS(InterpState &S) {
42243 {
42244 CodePtr OpPC = S.PC;
42245 const auto V0 = ReadArg<const OffsetOfExpr *>(S, S.PC);
42246 if (!OffsetOf<PT_IntAPS>(S, OpPC, V0)) return false;
42247 }
42248#if USE_TAILCALLS
42249 MUSTTAIL return InterpNext(S);
42250#else
42251 return true;
42252#endif
42253}
42254#endif
42255#ifdef GET_DISASM
42256case OP_OffsetOfSint8:
42257 Text.Op = PrintName("OffsetOfSint8");
42258 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42259 break;
42260case OP_OffsetOfUint8:
42261 Text.Op = PrintName("OffsetOfUint8");
42262 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42263 break;
42264case OP_OffsetOfSint16:
42265 Text.Op = PrintName("OffsetOfSint16");
42266 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42267 break;
42268case OP_OffsetOfUint16:
42269 Text.Op = PrintName("OffsetOfUint16");
42270 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42271 break;
42272case OP_OffsetOfSint32:
42273 Text.Op = PrintName("OffsetOfSint32");
42274 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42275 break;
42276case OP_OffsetOfUint32:
42277 Text.Op = PrintName("OffsetOfUint32");
42278 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42279 break;
42280case OP_OffsetOfSint64:
42281 Text.Op = PrintName("OffsetOfSint64");
42282 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42283 break;
42284case OP_OffsetOfUint64:
42285 Text.Op = PrintName("OffsetOfUint64");
42286 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42287 break;
42288case OP_OffsetOfIntAP:
42289 Text.Op = PrintName("OffsetOfIntAP");
42290 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42291 break;
42292case OP_OffsetOfIntAPS:
42293 Text.Op = PrintName("OffsetOfIntAPS");
42294 Text.Args.push_back(printArg<const OffsetOfExpr *>(PC));
42295 break;
42296#endif
42297#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42298bool emitOffsetOfSint8( const OffsetOfExpr * , SourceInfo);
42299bool emitOffsetOfUint8( const OffsetOfExpr * , SourceInfo);
42300bool emitOffsetOfSint16( const OffsetOfExpr * , SourceInfo);
42301bool emitOffsetOfUint16( const OffsetOfExpr * , SourceInfo);
42302bool emitOffsetOfSint32( const OffsetOfExpr * , SourceInfo);
42303bool emitOffsetOfUint32( const OffsetOfExpr * , SourceInfo);
42304bool emitOffsetOfSint64( const OffsetOfExpr * , SourceInfo);
42305bool emitOffsetOfUint64( const OffsetOfExpr * , SourceInfo);
42306bool emitOffsetOfIntAP( const OffsetOfExpr * , SourceInfo);
42307bool emitOffsetOfIntAPS( const OffsetOfExpr * , SourceInfo);
42308#endif
42309#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42310[[nodiscard]] bool emitOffsetOf(PrimType, const OffsetOfExpr *, SourceInfo I);
42311#endif
42312#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
42313bool
42314#if defined(GET_EVAL_IMPL)
42315EvalEmitter
42316#else
42317ByteCodeEmitter
42318#endif
42319::emitOffsetOf(PrimType T0, const OffsetOfExpr * A0, SourceInfo I) {
42320 switch (T0) {
42321 case PT_Sint8:
42322 return emitOffsetOfSint8(A0, I);
42323 case PT_Uint8:
42324 return emitOffsetOfUint8(A0, I);
42325 case PT_Sint16:
42326 return emitOffsetOfSint16(A0, I);
42327 case PT_Uint16:
42328 return emitOffsetOfUint16(A0, I);
42329 case PT_Sint32:
42330 return emitOffsetOfSint32(A0, I);
42331 case PT_Uint32:
42332 return emitOffsetOfUint32(A0, I);
42333 case PT_Sint64:
42334 return emitOffsetOfSint64(A0, I);
42335 case PT_Uint64:
42336 return emitOffsetOfUint64(A0, I);
42337 case PT_IntAP:
42338 return emitOffsetOfIntAP(A0, I);
42339 case PT_IntAPS:
42340 return emitOffsetOfIntAPS(A0, I);
42341 default: llvm_unreachable("invalid type: emitOffsetOf");
42342 }
42343 llvm_unreachable("invalid enum value");
42344}
42345#endif
42346#ifdef GET_LINK_IMPL
42347bool ByteCodeEmitter::emitOffsetOfSint8( const OffsetOfExpr * A0, SourceInfo L) {
42348 return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint8, A0, L);
42349}
42350bool ByteCodeEmitter::emitOffsetOfUint8( const OffsetOfExpr * A0, SourceInfo L) {
42351 return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint8, A0, L);
42352}
42353bool ByteCodeEmitter::emitOffsetOfSint16( const OffsetOfExpr * A0, SourceInfo L) {
42354 return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint16, A0, L);
42355}
42356bool ByteCodeEmitter::emitOffsetOfUint16( const OffsetOfExpr * A0, SourceInfo L) {
42357 return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint16, A0, L);
42358}
42359bool ByteCodeEmitter::emitOffsetOfSint32( const OffsetOfExpr * A0, SourceInfo L) {
42360 return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint32, A0, L);
42361}
42362bool ByteCodeEmitter::emitOffsetOfUint32( const OffsetOfExpr * A0, SourceInfo L) {
42363 return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint32, A0, L);
42364}
42365bool ByteCodeEmitter::emitOffsetOfSint64( const OffsetOfExpr * A0, SourceInfo L) {
42366 return emitOp<const OffsetOfExpr *>(OP_OffsetOfSint64, A0, L);
42367}
42368bool ByteCodeEmitter::emitOffsetOfUint64( const OffsetOfExpr * A0, SourceInfo L) {
42369 return emitOp<const OffsetOfExpr *>(OP_OffsetOfUint64, A0, L);
42370}
42371bool ByteCodeEmitter::emitOffsetOfIntAP( const OffsetOfExpr * A0, SourceInfo L) {
42372 return emitOp<const OffsetOfExpr *>(OP_OffsetOfIntAP, A0, L);
42373}
42374bool ByteCodeEmitter::emitOffsetOfIntAPS( const OffsetOfExpr * A0, SourceInfo L) {
42375 return emitOp<const OffsetOfExpr *>(OP_OffsetOfIntAPS, A0, L);
42376}
42377#endif
42378#ifdef GET_EVAL_IMPL
42379bool EvalEmitter::emitOffsetOfSint8( const OffsetOfExpr * A0, SourceInfo L) {
42380 if (!isActive()) return true;
42381 CurrentSource = L;
42382 return OffsetOf<PT_Sint8>(S, CodePtr(), A0);
42383}
42384bool EvalEmitter::emitOffsetOfUint8( const OffsetOfExpr * A0, SourceInfo L) {
42385 if (!isActive()) return true;
42386 CurrentSource = L;
42387 return OffsetOf<PT_Uint8>(S, CodePtr(), A0);
42388}
42389bool EvalEmitter::emitOffsetOfSint16( const OffsetOfExpr * A0, SourceInfo L) {
42390 if (!isActive()) return true;
42391 CurrentSource = L;
42392 return OffsetOf<PT_Sint16>(S, CodePtr(), A0);
42393}
42394bool EvalEmitter::emitOffsetOfUint16( const OffsetOfExpr * A0, SourceInfo L) {
42395 if (!isActive()) return true;
42396 CurrentSource = L;
42397 return OffsetOf<PT_Uint16>(S, CodePtr(), A0);
42398}
42399bool EvalEmitter::emitOffsetOfSint32( const OffsetOfExpr * A0, SourceInfo L) {
42400 if (!isActive()) return true;
42401 CurrentSource = L;
42402 return OffsetOf<PT_Sint32>(S, CodePtr(), A0);
42403}
42404bool EvalEmitter::emitOffsetOfUint32( const OffsetOfExpr * A0, SourceInfo L) {
42405 if (!isActive()) return true;
42406 CurrentSource = L;
42407 return OffsetOf<PT_Uint32>(S, CodePtr(), A0);
42408}
42409bool EvalEmitter::emitOffsetOfSint64( const OffsetOfExpr * A0, SourceInfo L) {
42410 if (!isActive()) return true;
42411 CurrentSource = L;
42412 return OffsetOf<PT_Sint64>(S, CodePtr(), A0);
42413}
42414bool EvalEmitter::emitOffsetOfUint64( const OffsetOfExpr * A0, SourceInfo L) {
42415 if (!isActive()) return true;
42416 CurrentSource = L;
42417 return OffsetOf<PT_Uint64>(S, CodePtr(), A0);
42418}
42419bool EvalEmitter::emitOffsetOfIntAP( const OffsetOfExpr * A0, SourceInfo L) {
42420 if (!isActive()) return true;
42421 CurrentSource = L;
42422 return OffsetOf<PT_IntAP>(S, CodePtr(), A0);
42423}
42424bool EvalEmitter::emitOffsetOfIntAPS( const OffsetOfExpr * A0, SourceInfo L) {
42425 if (!isActive()) return true;
42426 CurrentSource = L;
42427 return OffsetOf<PT_IntAPS>(S, CodePtr(), A0);
42428}
42429#endif
42430#ifdef GET_OPCODE_NAMES
42431OP_PopSint8,
42432OP_PopUint8,
42433OP_PopSint16,
42434OP_PopUint16,
42435OP_PopSint32,
42436OP_PopUint32,
42437OP_PopSint64,
42438OP_PopUint64,
42439OP_PopIntAP,
42440OP_PopIntAPS,
42441OP_PopBool,
42442OP_PopFixedPoint,
42443OP_PopPtr,
42444OP_PopMemberPtr,
42445OP_PopFloat,
42446OP_PopReflect,
42447#endif
42448#ifdef GET_INTERPFN_LIST
42449&Interp_PopSint8,
42450&Interp_PopUint8,
42451&Interp_PopSint16,
42452&Interp_PopUint16,
42453&Interp_PopSint32,
42454&Interp_PopUint32,
42455&Interp_PopSint64,
42456&Interp_PopUint64,
42457&Interp_PopIntAP,
42458&Interp_PopIntAPS,
42459&Interp_PopBool,
42460&Interp_PopFixedPoint,
42461&Interp_PopPtr,
42462&Interp_PopMemberPtr,
42463&Interp_PopFloat,
42464&Interp_PopReflect,
42465#endif
42466#ifdef GET_INTERPFN_DISPATCHERS
42467PRESERVE_NONE
42468static bool Interp_PopSint8(InterpState &S) {
42469 Pop<PT_Sint8>(S);
42470#if USE_TAILCALLS
42471 MUSTTAIL return InterpNext(S);
42472#else
42473 return true;
42474#endif
42475}
42476PRESERVE_NONE
42477static bool Interp_PopUint8(InterpState &S) {
42478 Pop<PT_Uint8>(S);
42479#if USE_TAILCALLS
42480 MUSTTAIL return InterpNext(S);
42481#else
42482 return true;
42483#endif
42484}
42485PRESERVE_NONE
42486static bool Interp_PopSint16(InterpState &S) {
42487 Pop<PT_Sint16>(S);
42488#if USE_TAILCALLS
42489 MUSTTAIL return InterpNext(S);
42490#else
42491 return true;
42492#endif
42493}
42494PRESERVE_NONE
42495static bool Interp_PopUint16(InterpState &S) {
42496 Pop<PT_Uint16>(S);
42497#if USE_TAILCALLS
42498 MUSTTAIL return InterpNext(S);
42499#else
42500 return true;
42501#endif
42502}
42503PRESERVE_NONE
42504static bool Interp_PopSint32(InterpState &S) {
42505 Pop<PT_Sint32>(S);
42506#if USE_TAILCALLS
42507 MUSTTAIL return InterpNext(S);
42508#else
42509 return true;
42510#endif
42511}
42512PRESERVE_NONE
42513static bool Interp_PopUint32(InterpState &S) {
42514 Pop<PT_Uint32>(S);
42515#if USE_TAILCALLS
42516 MUSTTAIL return InterpNext(S);
42517#else
42518 return true;
42519#endif
42520}
42521PRESERVE_NONE
42522static bool Interp_PopSint64(InterpState &S) {
42523 Pop<PT_Sint64>(S);
42524#if USE_TAILCALLS
42525 MUSTTAIL return InterpNext(S);
42526#else
42527 return true;
42528#endif
42529}
42530PRESERVE_NONE
42531static bool Interp_PopUint64(InterpState &S) {
42532 Pop<PT_Uint64>(S);
42533#if USE_TAILCALLS
42534 MUSTTAIL return InterpNext(S);
42535#else
42536 return true;
42537#endif
42538}
42539PRESERVE_NONE
42540static bool Interp_PopIntAP(InterpState &S) {
42541 Pop<PT_IntAP>(S);
42542#if USE_TAILCALLS
42543 MUSTTAIL return InterpNext(S);
42544#else
42545 return true;
42546#endif
42547}
42548PRESERVE_NONE
42549static bool Interp_PopIntAPS(InterpState &S) {
42550 Pop<PT_IntAPS>(S);
42551#if USE_TAILCALLS
42552 MUSTTAIL return InterpNext(S);
42553#else
42554 return true;
42555#endif
42556}
42557PRESERVE_NONE
42558static bool Interp_PopBool(InterpState &S) {
42559 Pop<PT_Bool>(S);
42560#if USE_TAILCALLS
42561 MUSTTAIL return InterpNext(S);
42562#else
42563 return true;
42564#endif
42565}
42566PRESERVE_NONE
42567static bool Interp_PopFixedPoint(InterpState &S) {
42568 Pop<PT_FixedPoint>(S);
42569#if USE_TAILCALLS
42570 MUSTTAIL return InterpNext(S);
42571#else
42572 return true;
42573#endif
42574}
42575PRESERVE_NONE
42576static bool Interp_PopPtr(InterpState &S) {
42577 Pop<PT_Ptr>(S);
42578#if USE_TAILCALLS
42579 MUSTTAIL return InterpNext(S);
42580#else
42581 return true;
42582#endif
42583}
42584PRESERVE_NONE
42585static bool Interp_PopMemberPtr(InterpState &S) {
42586 Pop<PT_MemberPtr>(S);
42587#if USE_TAILCALLS
42588 MUSTTAIL return InterpNext(S);
42589#else
42590 return true;
42591#endif
42592}
42593PRESERVE_NONE
42594static bool Interp_PopFloat(InterpState &S) {
42595 Pop<PT_Float>(S);
42596#if USE_TAILCALLS
42597 MUSTTAIL return InterpNext(S);
42598#else
42599 return true;
42600#endif
42601}
42602PRESERVE_NONE
42603static bool Interp_PopReflect(InterpState &S) {
42604 Pop<PT_Reflect>(S);
42605#if USE_TAILCALLS
42606 MUSTTAIL return InterpNext(S);
42607#else
42608 return true;
42609#endif
42610}
42611#endif
42612#ifdef GET_DISASM
42613case OP_PopSint8:
42614 Text.Op = PrintName("PopSint8");
42615 break;
42616case OP_PopUint8:
42617 Text.Op = PrintName("PopUint8");
42618 break;
42619case OP_PopSint16:
42620 Text.Op = PrintName("PopSint16");
42621 break;
42622case OP_PopUint16:
42623 Text.Op = PrintName("PopUint16");
42624 break;
42625case OP_PopSint32:
42626 Text.Op = PrintName("PopSint32");
42627 break;
42628case OP_PopUint32:
42629 Text.Op = PrintName("PopUint32");
42630 break;
42631case OP_PopSint64:
42632 Text.Op = PrintName("PopSint64");
42633 break;
42634case OP_PopUint64:
42635 Text.Op = PrintName("PopUint64");
42636 break;
42637case OP_PopIntAP:
42638 Text.Op = PrintName("PopIntAP");
42639 break;
42640case OP_PopIntAPS:
42641 Text.Op = PrintName("PopIntAPS");
42642 break;
42643case OP_PopBool:
42644 Text.Op = PrintName("PopBool");
42645 break;
42646case OP_PopFixedPoint:
42647 Text.Op = PrintName("PopFixedPoint");
42648 break;
42649case OP_PopPtr:
42650 Text.Op = PrintName("PopPtr");
42651 break;
42652case OP_PopMemberPtr:
42653 Text.Op = PrintName("PopMemberPtr");
42654 break;
42655case OP_PopFloat:
42656 Text.Op = PrintName("PopFloat");
42657 break;
42658case OP_PopReflect:
42659 Text.Op = PrintName("PopReflect");
42660 break;
42661#endif
42662#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42663bool emitPopSint8(SourceInfo);
42664bool emitPopUint8(SourceInfo);
42665bool emitPopSint16(SourceInfo);
42666bool emitPopUint16(SourceInfo);
42667bool emitPopSint32(SourceInfo);
42668bool emitPopUint32(SourceInfo);
42669bool emitPopSint64(SourceInfo);
42670bool emitPopUint64(SourceInfo);
42671bool emitPopIntAP(SourceInfo);
42672bool emitPopIntAPS(SourceInfo);
42673bool emitPopBool(SourceInfo);
42674bool emitPopFixedPoint(SourceInfo);
42675bool emitPopPtr(SourceInfo);
42676bool emitPopMemberPtr(SourceInfo);
42677bool emitPopFloat(SourceInfo);
42678bool emitPopReflect(SourceInfo);
42679#endif
42680#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42681[[nodiscard]] bool emitPop(PrimType, SourceInfo I);
42682#endif
42683#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
42684bool
42685#if defined(GET_EVAL_IMPL)
42686EvalEmitter
42687#else
42688ByteCodeEmitter
42689#endif
42690::emitPop(PrimType T0, SourceInfo I) {
42691 switch (T0) {
42692 case PT_Sint8:
42693 return emitPopSint8(I);
42694 case PT_Uint8:
42695 return emitPopUint8(I);
42696 case PT_Sint16:
42697 return emitPopSint16(I);
42698 case PT_Uint16:
42699 return emitPopUint16(I);
42700 case PT_Sint32:
42701 return emitPopSint32(I);
42702 case PT_Uint32:
42703 return emitPopUint32(I);
42704 case PT_Sint64:
42705 return emitPopSint64(I);
42706 case PT_Uint64:
42707 return emitPopUint64(I);
42708 case PT_IntAP:
42709 return emitPopIntAP(I);
42710 case PT_IntAPS:
42711 return emitPopIntAPS(I);
42712 case PT_Bool:
42713 return emitPopBool(I);
42714 case PT_FixedPoint:
42715 return emitPopFixedPoint(I);
42716 case PT_Ptr:
42717 return emitPopPtr(I);
42718 case PT_MemberPtr:
42719 return emitPopMemberPtr(I);
42720 case PT_Float:
42721 return emitPopFloat(I);
42722 case PT_Reflect:
42723 return emitPopReflect(I);
42724 }
42725 llvm_unreachable("invalid enum value");
42726}
42727#endif
42728#ifdef GET_LINK_IMPL
42729bool ByteCodeEmitter::emitPopSint8(SourceInfo L) {
42730 return emitOp<>(OP_PopSint8, L);
42731}
42732bool ByteCodeEmitter::emitPopUint8(SourceInfo L) {
42733 return emitOp<>(OP_PopUint8, L);
42734}
42735bool ByteCodeEmitter::emitPopSint16(SourceInfo L) {
42736 return emitOp<>(OP_PopSint16, L);
42737}
42738bool ByteCodeEmitter::emitPopUint16(SourceInfo L) {
42739 return emitOp<>(OP_PopUint16, L);
42740}
42741bool ByteCodeEmitter::emitPopSint32(SourceInfo L) {
42742 return emitOp<>(OP_PopSint32, L);
42743}
42744bool ByteCodeEmitter::emitPopUint32(SourceInfo L) {
42745 return emitOp<>(OP_PopUint32, L);
42746}
42747bool ByteCodeEmitter::emitPopSint64(SourceInfo L) {
42748 return emitOp<>(OP_PopSint64, L);
42749}
42750bool ByteCodeEmitter::emitPopUint64(SourceInfo L) {
42751 return emitOp<>(OP_PopUint64, L);
42752}
42753bool ByteCodeEmitter::emitPopIntAP(SourceInfo L) {
42754 return emitOp<>(OP_PopIntAP, L);
42755}
42756bool ByteCodeEmitter::emitPopIntAPS(SourceInfo L) {
42757 return emitOp<>(OP_PopIntAPS, L);
42758}
42759bool ByteCodeEmitter::emitPopBool(SourceInfo L) {
42760 return emitOp<>(OP_PopBool, L);
42761}
42762bool ByteCodeEmitter::emitPopFixedPoint(SourceInfo L) {
42763 return emitOp<>(OP_PopFixedPoint, L);
42764}
42765bool ByteCodeEmitter::emitPopPtr(SourceInfo L) {
42766 return emitOp<>(OP_PopPtr, L);
42767}
42768bool ByteCodeEmitter::emitPopMemberPtr(SourceInfo L) {
42769 return emitOp<>(OP_PopMemberPtr, L);
42770}
42771bool ByteCodeEmitter::emitPopFloat(SourceInfo L) {
42772 return emitOp<>(OP_PopFloat, L);
42773}
42774bool ByteCodeEmitter::emitPopReflect(SourceInfo L) {
42775 return emitOp<>(OP_PopReflect, L);
42776}
42777#endif
42778#ifdef GET_EVAL_IMPL
42779bool EvalEmitter::emitPopSint8(SourceInfo L) {
42780 if (!isActive()) return true;
42781 CurrentSource = L;
42782 return Pop<PT_Sint8>(S);
42783}
42784bool EvalEmitter::emitPopUint8(SourceInfo L) {
42785 if (!isActive()) return true;
42786 CurrentSource = L;
42787 return Pop<PT_Uint8>(S);
42788}
42789bool EvalEmitter::emitPopSint16(SourceInfo L) {
42790 if (!isActive()) return true;
42791 CurrentSource = L;
42792 return Pop<PT_Sint16>(S);
42793}
42794bool EvalEmitter::emitPopUint16(SourceInfo L) {
42795 if (!isActive()) return true;
42796 CurrentSource = L;
42797 return Pop<PT_Uint16>(S);
42798}
42799bool EvalEmitter::emitPopSint32(SourceInfo L) {
42800 if (!isActive()) return true;
42801 CurrentSource = L;
42802 return Pop<PT_Sint32>(S);
42803}
42804bool EvalEmitter::emitPopUint32(SourceInfo L) {
42805 if (!isActive()) return true;
42806 CurrentSource = L;
42807 return Pop<PT_Uint32>(S);
42808}
42809bool EvalEmitter::emitPopSint64(SourceInfo L) {
42810 if (!isActive()) return true;
42811 CurrentSource = L;
42812 return Pop<PT_Sint64>(S);
42813}
42814bool EvalEmitter::emitPopUint64(SourceInfo L) {
42815 if (!isActive()) return true;
42816 CurrentSource = L;
42817 return Pop<PT_Uint64>(S);
42818}
42819bool EvalEmitter::emitPopIntAP(SourceInfo L) {
42820 if (!isActive()) return true;
42821 CurrentSource = L;
42822 return Pop<PT_IntAP>(S);
42823}
42824bool EvalEmitter::emitPopIntAPS(SourceInfo L) {
42825 if (!isActive()) return true;
42826 CurrentSource = L;
42827 return Pop<PT_IntAPS>(S);
42828}
42829bool EvalEmitter::emitPopBool(SourceInfo L) {
42830 if (!isActive()) return true;
42831 CurrentSource = L;
42832 return Pop<PT_Bool>(S);
42833}
42834bool EvalEmitter::emitPopFixedPoint(SourceInfo L) {
42835 if (!isActive()) return true;
42836 CurrentSource = L;
42837 return Pop<PT_FixedPoint>(S);
42838}
42839bool EvalEmitter::emitPopPtr(SourceInfo L) {
42840 if (!isActive()) return true;
42841 CurrentSource = L;
42842 return Pop<PT_Ptr>(S);
42843}
42844bool EvalEmitter::emitPopMemberPtr(SourceInfo L) {
42845 if (!isActive()) return true;
42846 CurrentSource = L;
42847 return Pop<PT_MemberPtr>(S);
42848}
42849bool EvalEmitter::emitPopFloat(SourceInfo L) {
42850 if (!isActive()) return true;
42851 CurrentSource = L;
42852 return Pop<PT_Float>(S);
42853}
42854bool EvalEmitter::emitPopReflect(SourceInfo L) {
42855 if (!isActive()) return true;
42856 CurrentSource = L;
42857 return Pop<PT_Reflect>(S);
42858}
42859#endif
42860#ifdef GET_OPCODE_NAMES
42861OP_PopCC,
42862#endif
42863#ifdef GET_INTERPFN_LIST
42864&Interp_PopCC,
42865#endif
42866#ifdef GET_INTERPFN_DISPATCHERS
42867PRESERVE_NONE
42868static bool Interp_PopCC(InterpState &S) {
42869 PopCC(S);
42870#if USE_TAILCALLS
42871 MUSTTAIL return InterpNext(S);
42872#else
42873 return true;
42874#endif
42875}
42876#endif
42877#ifdef GET_DISASM
42878case OP_PopCC:
42879 Text.Op = PrintName("PopCC");
42880 break;
42881#endif
42882#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42883bool emitPopCC(SourceInfo);
42884#endif
42885#ifdef GET_LINK_IMPL
42886bool ByteCodeEmitter::emitPopCC(SourceInfo L) {
42887 return emitOp<>(OP_PopCC, L);
42888}
42889#endif
42890#ifdef GET_EVAL_IMPL
42891bool EvalEmitter::emitPopCC(SourceInfo L) {
42892 if (!isActive()) return true;
42893 CurrentSource = L;
42894 return PopCC(S);
42895}
42896#endif
42897#ifdef GET_OPCODE_NAMES
42898OP_PopIgnoreDiags,
42899#endif
42900#ifdef GET_INTERPFN_LIST
42901&Interp_PopIgnoreDiags,
42902#endif
42903#ifdef GET_INTERPFN_DISPATCHERS
42904PRESERVE_NONE
42905static bool Interp_PopIgnoreDiags(InterpState &S) {
42906 PopIgnoreDiags(S);
42907#if USE_TAILCALLS
42908 MUSTTAIL return InterpNext(S);
42909#else
42910 return true;
42911#endif
42912}
42913#endif
42914#ifdef GET_DISASM
42915case OP_PopIgnoreDiags:
42916 Text.Op = PrintName("PopIgnoreDiags");
42917 break;
42918#endif
42919#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42920bool emitPopIgnoreDiags(SourceInfo);
42921#endif
42922#ifdef GET_LINK_IMPL
42923bool ByteCodeEmitter::emitPopIgnoreDiags(SourceInfo L) {
42924 return emitOp<>(OP_PopIgnoreDiags, L);
42925}
42926#endif
42927#ifdef GET_EVAL_IMPL
42928bool EvalEmitter::emitPopIgnoreDiags(SourceInfo L) {
42929 if (!isActive()) return true;
42930 CurrentSource = L;
42931 return PopIgnoreDiags(S);
42932}
42933#endif
42934#ifdef GET_OPCODE_NAMES
42935OP_PopMSVCCE,
42936#endif
42937#ifdef GET_INTERPFN_LIST
42938&Interp_PopMSVCCE,
42939#endif
42940#ifdef GET_INTERPFN_DISPATCHERS
42941PRESERVE_NONE
42942static bool Interp_PopMSVCCE(InterpState &S) {
42943 PopMSVCCE(S);
42944#if USE_TAILCALLS
42945 MUSTTAIL return InterpNext(S);
42946#else
42947 return true;
42948#endif
42949}
42950#endif
42951#ifdef GET_DISASM
42952case OP_PopMSVCCE:
42953 Text.Op = PrintName("PopMSVCCE");
42954 break;
42955#endif
42956#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
42957bool emitPopMSVCCE(SourceInfo);
42958#endif
42959#ifdef GET_LINK_IMPL
42960bool ByteCodeEmitter::emitPopMSVCCE(SourceInfo L) {
42961 return emitOp<>(OP_PopMSVCCE, L);
42962}
42963#endif
42964#ifdef GET_EVAL_IMPL
42965bool EvalEmitter::emitPopMSVCCE(SourceInfo L) {
42966 if (!isActive()) return true;
42967 CurrentSource = L;
42968 return PopMSVCCE(S);
42969}
42970#endif
42971#ifdef GET_OPCODE_NAMES
42972OP_PreDecSint8,
42973OP_PreDecUint8,
42974OP_PreDecSint16,
42975OP_PreDecUint16,
42976OP_PreDecSint32,
42977OP_PreDecUint32,
42978OP_PreDecSint64,
42979OP_PreDecUint64,
42980OP_PreDecIntAP,
42981OP_PreDecIntAPS,
42982OP_PreDecBool,
42983OP_PreDecFixedPoint,
42984#endif
42985#ifdef GET_INTERPFN_LIST
42986&Interp_PreDecSint8,
42987&Interp_PreDecUint8,
42988&Interp_PreDecSint16,
42989&Interp_PreDecUint16,
42990&Interp_PreDecSint32,
42991&Interp_PreDecUint32,
42992&Interp_PreDecSint64,
42993&Interp_PreDecUint64,
42994&Interp_PreDecIntAP,
42995&Interp_PreDecIntAPS,
42996&Interp_PreDecBool,
42997&Interp_PreDecFixedPoint,
42998#endif
42999#ifdef GET_INTERPFN_DISPATCHERS
43000PRESERVE_NONE
43001static bool Interp_PreDecSint8(InterpState &S) {
43002 {
43003 CodePtr OpPC = S.PC;
43004 const auto V0 = ReadArg<bool>(S, S.PC);
43005 if (!PreDec<PT_Sint8>(S, OpPC, V0)) return false;
43006 }
43007#if USE_TAILCALLS
43008 MUSTTAIL return InterpNext(S);
43009#else
43010 return true;
43011#endif
43012}
43013PRESERVE_NONE
43014static bool Interp_PreDecUint8(InterpState &S) {
43015 {
43016 CodePtr OpPC = S.PC;
43017 const auto V0 = ReadArg<bool>(S, S.PC);
43018 if (!PreDec<PT_Uint8>(S, OpPC, V0)) return false;
43019 }
43020#if USE_TAILCALLS
43021 MUSTTAIL return InterpNext(S);
43022#else
43023 return true;
43024#endif
43025}
43026PRESERVE_NONE
43027static bool Interp_PreDecSint16(InterpState &S) {
43028 {
43029 CodePtr OpPC = S.PC;
43030 const auto V0 = ReadArg<bool>(S, S.PC);
43031 if (!PreDec<PT_Sint16>(S, OpPC, V0)) return false;
43032 }
43033#if USE_TAILCALLS
43034 MUSTTAIL return InterpNext(S);
43035#else
43036 return true;
43037#endif
43038}
43039PRESERVE_NONE
43040static bool Interp_PreDecUint16(InterpState &S) {
43041 {
43042 CodePtr OpPC = S.PC;
43043 const auto V0 = ReadArg<bool>(S, S.PC);
43044 if (!PreDec<PT_Uint16>(S, OpPC, V0)) return false;
43045 }
43046#if USE_TAILCALLS
43047 MUSTTAIL return InterpNext(S);
43048#else
43049 return true;
43050#endif
43051}
43052PRESERVE_NONE
43053static bool Interp_PreDecSint32(InterpState &S) {
43054 {
43055 CodePtr OpPC = S.PC;
43056 const auto V0 = ReadArg<bool>(S, S.PC);
43057 if (!PreDec<PT_Sint32>(S, OpPC, V0)) return false;
43058 }
43059#if USE_TAILCALLS
43060 MUSTTAIL return InterpNext(S);
43061#else
43062 return true;
43063#endif
43064}
43065PRESERVE_NONE
43066static bool Interp_PreDecUint32(InterpState &S) {
43067 {
43068 CodePtr OpPC = S.PC;
43069 const auto V0 = ReadArg<bool>(S, S.PC);
43070 if (!PreDec<PT_Uint32>(S, OpPC, V0)) return false;
43071 }
43072#if USE_TAILCALLS
43073 MUSTTAIL return InterpNext(S);
43074#else
43075 return true;
43076#endif
43077}
43078PRESERVE_NONE
43079static bool Interp_PreDecSint64(InterpState &S) {
43080 {
43081 CodePtr OpPC = S.PC;
43082 const auto V0 = ReadArg<bool>(S, S.PC);
43083 if (!PreDec<PT_Sint64>(S, OpPC, V0)) return false;
43084 }
43085#if USE_TAILCALLS
43086 MUSTTAIL return InterpNext(S);
43087#else
43088 return true;
43089#endif
43090}
43091PRESERVE_NONE
43092static bool Interp_PreDecUint64(InterpState &S) {
43093 {
43094 CodePtr OpPC = S.PC;
43095 const auto V0 = ReadArg<bool>(S, S.PC);
43096 if (!PreDec<PT_Uint64>(S, OpPC, V0)) return false;
43097 }
43098#if USE_TAILCALLS
43099 MUSTTAIL return InterpNext(S);
43100#else
43101 return true;
43102#endif
43103}
43104PRESERVE_NONE
43105static bool Interp_PreDecIntAP(InterpState &S) {
43106 {
43107 CodePtr OpPC = S.PC;
43108 const auto V0 = ReadArg<bool>(S, S.PC);
43109 if (!PreDec<PT_IntAP>(S, OpPC, V0)) return false;
43110 }
43111#if USE_TAILCALLS
43112 MUSTTAIL return InterpNext(S);
43113#else
43114 return true;
43115#endif
43116}
43117PRESERVE_NONE
43118static bool Interp_PreDecIntAPS(InterpState &S) {
43119 {
43120 CodePtr OpPC = S.PC;
43121 const auto V0 = ReadArg<bool>(S, S.PC);
43122 if (!PreDec<PT_IntAPS>(S, OpPC, V0)) return false;
43123 }
43124#if USE_TAILCALLS
43125 MUSTTAIL return InterpNext(S);
43126#else
43127 return true;
43128#endif
43129}
43130PRESERVE_NONE
43131static bool Interp_PreDecBool(InterpState &S) {
43132 {
43133 CodePtr OpPC = S.PC;
43134 const auto V0 = ReadArg<bool>(S, S.PC);
43135 if (!PreDec<PT_Bool>(S, OpPC, V0)) return false;
43136 }
43137#if USE_TAILCALLS
43138 MUSTTAIL return InterpNext(S);
43139#else
43140 return true;
43141#endif
43142}
43143PRESERVE_NONE
43144static bool Interp_PreDecFixedPoint(InterpState &S) {
43145 {
43146 CodePtr OpPC = S.PC;
43147 const auto V0 = ReadArg<bool>(S, S.PC);
43148 if (!PreDec<PT_FixedPoint>(S, OpPC, V0)) return false;
43149 }
43150#if USE_TAILCALLS
43151 MUSTTAIL return InterpNext(S);
43152#else
43153 return true;
43154#endif
43155}
43156#endif
43157#ifdef GET_DISASM
43158case OP_PreDecSint8:
43159 Text.Op = PrintName("PreDecSint8");
43160 Text.Args.push_back(printArg<bool>(PC));
43161 break;
43162case OP_PreDecUint8:
43163 Text.Op = PrintName("PreDecUint8");
43164 Text.Args.push_back(printArg<bool>(PC));
43165 break;
43166case OP_PreDecSint16:
43167 Text.Op = PrintName("PreDecSint16");
43168 Text.Args.push_back(printArg<bool>(PC));
43169 break;
43170case OP_PreDecUint16:
43171 Text.Op = PrintName("PreDecUint16");
43172 Text.Args.push_back(printArg<bool>(PC));
43173 break;
43174case OP_PreDecSint32:
43175 Text.Op = PrintName("PreDecSint32");
43176 Text.Args.push_back(printArg<bool>(PC));
43177 break;
43178case OP_PreDecUint32:
43179 Text.Op = PrintName("PreDecUint32");
43180 Text.Args.push_back(printArg<bool>(PC));
43181 break;
43182case OP_PreDecSint64:
43183 Text.Op = PrintName("PreDecSint64");
43184 Text.Args.push_back(printArg<bool>(PC));
43185 break;
43186case OP_PreDecUint64:
43187 Text.Op = PrintName("PreDecUint64");
43188 Text.Args.push_back(printArg<bool>(PC));
43189 break;
43190case OP_PreDecIntAP:
43191 Text.Op = PrintName("PreDecIntAP");
43192 Text.Args.push_back(printArg<bool>(PC));
43193 break;
43194case OP_PreDecIntAPS:
43195 Text.Op = PrintName("PreDecIntAPS");
43196 Text.Args.push_back(printArg<bool>(PC));
43197 break;
43198case OP_PreDecBool:
43199 Text.Op = PrintName("PreDecBool");
43200 Text.Args.push_back(printArg<bool>(PC));
43201 break;
43202case OP_PreDecFixedPoint:
43203 Text.Op = PrintName("PreDecFixedPoint");
43204 Text.Args.push_back(printArg<bool>(PC));
43205 break;
43206#endif
43207#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
43208bool emitPreDecSint8( bool , SourceInfo);
43209bool emitPreDecUint8( bool , SourceInfo);
43210bool emitPreDecSint16( bool , SourceInfo);
43211bool emitPreDecUint16( bool , SourceInfo);
43212bool emitPreDecSint32( bool , SourceInfo);
43213bool emitPreDecUint32( bool , SourceInfo);
43214bool emitPreDecSint64( bool , SourceInfo);
43215bool emitPreDecUint64( bool , SourceInfo);
43216bool emitPreDecIntAP( bool , SourceInfo);
43217bool emitPreDecIntAPS( bool , SourceInfo);
43218bool emitPreDecBool( bool , SourceInfo);
43219bool emitPreDecFixedPoint( bool , SourceInfo);
43220#endif
43221#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
43222[[nodiscard]] bool emitPreDec(PrimType, bool, SourceInfo I);
43223#endif
43224#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
43225bool
43226#if defined(GET_EVAL_IMPL)
43227EvalEmitter
43228#else
43229ByteCodeEmitter
43230#endif
43231::emitPreDec(PrimType T0, bool A0, SourceInfo I) {
43232 switch (T0) {
43233 case PT_Sint8:
43234 return emitPreDecSint8(A0, I);
43235 case PT_Uint8:
43236 return emitPreDecUint8(A0, I);
43237 case PT_Sint16:
43238 return emitPreDecSint16(A0, I);
43239 case PT_Uint16:
43240 return emitPreDecUint16(A0, I);
43241 case PT_Sint32:
43242 return emitPreDecSint32(A0, I);
43243 case PT_Uint32:
43244 return emitPreDecUint32(A0, I);
43245 case PT_Sint64:
43246 return emitPreDecSint64(A0, I);
43247 case PT_Uint64:
43248 return emitPreDecUint64(A0, I);
43249 case PT_IntAP:
43250 return emitPreDecIntAP(A0, I);
43251 case PT_IntAPS:
43252 return emitPreDecIntAPS(A0, I);
43253 case PT_Bool:
43254 return emitPreDecBool(A0, I);
43255 case PT_FixedPoint:
43256 return emitPreDecFixedPoint(A0, I);
43257 default: llvm_unreachable("invalid type: emitPreDec");
43258 }
43259 llvm_unreachable("invalid enum value");
43260}
43261#endif
43262#ifdef GET_LINK_IMPL
43263bool ByteCodeEmitter::emitPreDecSint8( bool A0, SourceInfo L) {
43264 return emitOp<bool>(OP_PreDecSint8, A0, L);
43265}
43266bool ByteCodeEmitter::emitPreDecUint8( bool A0, SourceInfo L) {
43267 return emitOp<bool>(OP_PreDecUint8, A0, L);
43268}
43269bool ByteCodeEmitter::emitPreDecSint16( bool A0, SourceInfo L) {
43270 return emitOp<bool>(OP_PreDecSint16, A0, L);
43271}
43272bool ByteCodeEmitter::emitPreDecUint16( bool A0, SourceInfo L) {
43273 return emitOp<bool>(OP_PreDecUint16, A0, L);
43274}
43275bool ByteCodeEmitter::emitPreDecSint32( bool A0, SourceInfo L) {
43276 return emitOp<bool>(OP_PreDecSint32, A0, L);
43277}
43278bool ByteCodeEmitter::emitPreDecUint32( bool A0, SourceInfo L) {
43279 return emitOp<bool>(OP_PreDecUint32, A0, L);
43280}
43281bool ByteCodeEmitter::emitPreDecSint64( bool A0, SourceInfo L) {
43282 return emitOp<bool>(OP_PreDecSint64, A0, L);
43283}
43284bool ByteCodeEmitter::emitPreDecUint64( bool A0, SourceInfo L) {
43285 return emitOp<bool>(OP_PreDecUint64, A0, L);
43286}
43287bool ByteCodeEmitter::emitPreDecIntAP( bool A0, SourceInfo L) {
43288 return emitOp<bool>(OP_PreDecIntAP, A0, L);
43289}
43290bool ByteCodeEmitter::emitPreDecIntAPS( bool A0, SourceInfo L) {
43291 return emitOp<bool>(OP_PreDecIntAPS, A0, L);
43292}
43293bool ByteCodeEmitter::emitPreDecBool( bool A0, SourceInfo L) {
43294 return emitOp<bool>(OP_PreDecBool, A0, L);
43295}
43296bool ByteCodeEmitter::emitPreDecFixedPoint( bool A0, SourceInfo L) {
43297 return emitOp<bool>(OP_PreDecFixedPoint, A0, L);
43298}
43299#endif
43300#ifdef GET_EVAL_IMPL
43301bool EvalEmitter::emitPreDecSint8( bool A0, SourceInfo L) {
43302 if (!isActive()) return true;
43303 CurrentSource = L;
43304 return PreDec<PT_Sint8>(S, CodePtr(), A0);
43305}
43306bool EvalEmitter::emitPreDecUint8( bool A0, SourceInfo L) {
43307 if (!isActive()) return true;
43308 CurrentSource = L;
43309 return PreDec<PT_Uint8>(S, CodePtr(), A0);
43310}
43311bool EvalEmitter::emitPreDecSint16( bool A0, SourceInfo L) {
43312 if (!isActive()) return true;
43313 CurrentSource = L;
43314 return PreDec<PT_Sint16>(S, CodePtr(), A0);
43315}
43316bool EvalEmitter::emitPreDecUint16( bool A0, SourceInfo L) {
43317 if (!isActive()) return true;
43318 CurrentSource = L;
43319 return PreDec<PT_Uint16>(S, CodePtr(), A0);
43320}
43321bool EvalEmitter::emitPreDecSint32( bool A0, SourceInfo L) {
43322 if (!isActive()) return true;
43323 CurrentSource = L;
43324 return PreDec<PT_Sint32>(S, CodePtr(), A0);
43325}
43326bool EvalEmitter::emitPreDecUint32( bool A0, SourceInfo L) {
43327 if (!isActive()) return true;
43328 CurrentSource = L;
43329 return PreDec<PT_Uint32>(S, CodePtr(), A0);
43330}
43331bool EvalEmitter::emitPreDecSint64( bool A0, SourceInfo L) {
43332 if (!isActive()) return true;
43333 CurrentSource = L;
43334 return PreDec<PT_Sint64>(S, CodePtr(), A0);
43335}
43336bool EvalEmitter::emitPreDecUint64( bool A0, SourceInfo L) {
43337 if (!isActive()) return true;
43338 CurrentSource = L;
43339 return PreDec<PT_Uint64>(S, CodePtr(), A0);
43340}
43341bool EvalEmitter::emitPreDecIntAP( bool A0, SourceInfo L) {
43342 if (!isActive()) return true;
43343 CurrentSource = L;
43344 return PreDec<PT_IntAP>(S, CodePtr(), A0);
43345}
43346bool EvalEmitter::emitPreDecIntAPS( bool A0, SourceInfo L) {
43347 if (!isActive()) return true;
43348 CurrentSource = L;
43349 return PreDec<PT_IntAPS>(S, CodePtr(), A0);
43350}
43351bool EvalEmitter::emitPreDecBool( bool A0, SourceInfo L) {
43352 if (!isActive()) return true;
43353 CurrentSource = L;
43354 return PreDec<PT_Bool>(S, CodePtr(), A0);
43355}
43356bool EvalEmitter::emitPreDecFixedPoint( bool A0, SourceInfo L) {
43357 if (!isActive()) return true;
43358 CurrentSource = L;
43359 return PreDec<PT_FixedPoint>(S, CodePtr(), A0);
43360}
43361#endif
43362#ifdef GET_OPCODE_NAMES
43363OP_PreDecBitfieldSint8,
43364OP_PreDecBitfieldUint8,
43365OP_PreDecBitfieldSint16,
43366OP_PreDecBitfieldUint16,
43367OP_PreDecBitfieldSint32,
43368OP_PreDecBitfieldUint32,
43369OP_PreDecBitfieldSint64,
43370OP_PreDecBitfieldUint64,
43371OP_PreDecBitfieldIntAP,
43372OP_PreDecBitfieldIntAPS,
43373OP_PreDecBitfieldBool,
43374OP_PreDecBitfieldFixedPoint,
43375#endif
43376#ifdef GET_INTERPFN_LIST
43377&Interp_PreDecBitfieldSint8,
43378&Interp_PreDecBitfieldUint8,
43379&Interp_PreDecBitfieldSint16,
43380&Interp_PreDecBitfieldUint16,
43381&Interp_PreDecBitfieldSint32,
43382&Interp_PreDecBitfieldUint32,
43383&Interp_PreDecBitfieldSint64,
43384&Interp_PreDecBitfieldUint64,
43385&Interp_PreDecBitfieldIntAP,
43386&Interp_PreDecBitfieldIntAPS,
43387&Interp_PreDecBitfieldBool,
43388&Interp_PreDecBitfieldFixedPoint,
43389#endif
43390#ifdef GET_INTERPFN_DISPATCHERS
43391PRESERVE_NONE
43392static bool Interp_PreDecBitfieldSint8(InterpState &S) {
43393 {
43394 CodePtr OpPC = S.PC;
43395 const auto V0 = ReadArg<bool>(S, S.PC);
43396 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43397 if (!PreDecBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
43398 }
43399#if USE_TAILCALLS
43400 MUSTTAIL return InterpNext(S);
43401#else
43402 return true;
43403#endif
43404}
43405PRESERVE_NONE
43406static bool Interp_PreDecBitfieldUint8(InterpState &S) {
43407 {
43408 CodePtr OpPC = S.PC;
43409 const auto V0 = ReadArg<bool>(S, S.PC);
43410 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43411 if (!PreDecBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
43412 }
43413#if USE_TAILCALLS
43414 MUSTTAIL return InterpNext(S);
43415#else
43416 return true;
43417#endif
43418}
43419PRESERVE_NONE
43420static bool Interp_PreDecBitfieldSint16(InterpState &S) {
43421 {
43422 CodePtr OpPC = S.PC;
43423 const auto V0 = ReadArg<bool>(S, S.PC);
43424 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43425 if (!PreDecBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
43426 }
43427#if USE_TAILCALLS
43428 MUSTTAIL return InterpNext(S);
43429#else
43430 return true;
43431#endif
43432}
43433PRESERVE_NONE
43434static bool Interp_PreDecBitfieldUint16(InterpState &S) {
43435 {
43436 CodePtr OpPC = S.PC;
43437 const auto V0 = ReadArg<bool>(S, S.PC);
43438 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43439 if (!PreDecBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
43440 }
43441#if USE_TAILCALLS
43442 MUSTTAIL return InterpNext(S);
43443#else
43444 return true;
43445#endif
43446}
43447PRESERVE_NONE
43448static bool Interp_PreDecBitfieldSint32(InterpState &S) {
43449 {
43450 CodePtr OpPC = S.PC;
43451 const auto V0 = ReadArg<bool>(S, S.PC);
43452 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43453 if (!PreDecBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
43454 }
43455#if USE_TAILCALLS
43456 MUSTTAIL return InterpNext(S);
43457#else
43458 return true;
43459#endif
43460}
43461PRESERVE_NONE
43462static bool Interp_PreDecBitfieldUint32(InterpState &S) {
43463 {
43464 CodePtr OpPC = S.PC;
43465 const auto V0 = ReadArg<bool>(S, S.PC);
43466 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43467 if (!PreDecBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
43468 }
43469#if USE_TAILCALLS
43470 MUSTTAIL return InterpNext(S);
43471#else
43472 return true;
43473#endif
43474}
43475PRESERVE_NONE
43476static bool Interp_PreDecBitfieldSint64(InterpState &S) {
43477 {
43478 CodePtr OpPC = S.PC;
43479 const auto V0 = ReadArg<bool>(S, S.PC);
43480 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43481 if (!PreDecBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
43482 }
43483#if USE_TAILCALLS
43484 MUSTTAIL return InterpNext(S);
43485#else
43486 return true;
43487#endif
43488}
43489PRESERVE_NONE
43490static bool Interp_PreDecBitfieldUint64(InterpState &S) {
43491 {
43492 CodePtr OpPC = S.PC;
43493 const auto V0 = ReadArg<bool>(S, S.PC);
43494 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43495 if (!PreDecBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
43496 }
43497#if USE_TAILCALLS
43498 MUSTTAIL return InterpNext(S);
43499#else
43500 return true;
43501#endif
43502}
43503PRESERVE_NONE
43504static bool Interp_PreDecBitfieldIntAP(InterpState &S) {
43505 {
43506 CodePtr OpPC = S.PC;
43507 const auto V0 = ReadArg<bool>(S, S.PC);
43508 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43509 if (!PreDecBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
43510 }
43511#if USE_TAILCALLS
43512 MUSTTAIL return InterpNext(S);
43513#else
43514 return true;
43515#endif
43516}
43517PRESERVE_NONE
43518static bool Interp_PreDecBitfieldIntAPS(InterpState &S) {
43519 {
43520 CodePtr OpPC = S.PC;
43521 const auto V0 = ReadArg<bool>(S, S.PC);
43522 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43523 if (!PreDecBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
43524 }
43525#if USE_TAILCALLS
43526 MUSTTAIL return InterpNext(S);
43527#else
43528 return true;
43529#endif
43530}
43531PRESERVE_NONE
43532static bool Interp_PreDecBitfieldBool(InterpState &S) {
43533 {
43534 CodePtr OpPC = S.PC;
43535 const auto V0 = ReadArg<bool>(S, S.PC);
43536 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43537 if (!PreDecBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
43538 }
43539#if USE_TAILCALLS
43540 MUSTTAIL return InterpNext(S);
43541#else
43542 return true;
43543#endif
43544}
43545PRESERVE_NONE
43546static bool Interp_PreDecBitfieldFixedPoint(InterpState &S) {
43547 {
43548 CodePtr OpPC = S.PC;
43549 const auto V0 = ReadArg<bool>(S, S.PC);
43550 const auto V1 = ReadArg<uint32_t>(S, S.PC);
43551 if (!PreDecBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
43552 }
43553#if USE_TAILCALLS
43554 MUSTTAIL return InterpNext(S);
43555#else
43556 return true;
43557#endif
43558}
43559#endif
43560#ifdef GET_DISASM
43561case OP_PreDecBitfieldSint8:
43562 Text.Op = PrintName("PreDecBitfieldSint8");
43563 Text.Args.push_back(printArg<bool>(PC));
43564 Text.Args.push_back(printArg<uint32_t>(PC));
43565 break;
43566case OP_PreDecBitfieldUint8:
43567 Text.Op = PrintName("PreDecBitfieldUint8");
43568 Text.Args.push_back(printArg<bool>(PC));
43569 Text.Args.push_back(printArg<uint32_t>(PC));
43570 break;
43571case OP_PreDecBitfieldSint16:
43572 Text.Op = PrintName("PreDecBitfieldSint16");
43573 Text.Args.push_back(printArg<bool>(PC));
43574 Text.Args.push_back(printArg<uint32_t>(PC));
43575 break;
43576case OP_PreDecBitfieldUint16:
43577 Text.Op = PrintName("PreDecBitfieldUint16");
43578 Text.Args.push_back(printArg<bool>(PC));
43579 Text.Args.push_back(printArg<uint32_t>(PC));
43580 break;
43581case OP_PreDecBitfieldSint32:
43582 Text.Op = PrintName("PreDecBitfieldSint32");
43583 Text.Args.push_back(printArg<bool>(PC));
43584 Text.Args.push_back(printArg<uint32_t>(PC));
43585 break;
43586case OP_PreDecBitfieldUint32:
43587 Text.Op = PrintName("PreDecBitfieldUint32");
43588 Text.Args.push_back(printArg<bool>(PC));
43589 Text.Args.push_back(printArg<uint32_t>(PC));
43590 break;
43591case OP_PreDecBitfieldSint64:
43592 Text.Op = PrintName("PreDecBitfieldSint64");
43593 Text.Args.push_back(printArg<bool>(PC));
43594 Text.Args.push_back(printArg<uint32_t>(PC));
43595 break;
43596case OP_PreDecBitfieldUint64:
43597 Text.Op = PrintName("PreDecBitfieldUint64");
43598 Text.Args.push_back(printArg<bool>(PC));
43599 Text.Args.push_back(printArg<uint32_t>(PC));
43600 break;
43601case OP_PreDecBitfieldIntAP:
43602 Text.Op = PrintName("PreDecBitfieldIntAP");
43603 Text.Args.push_back(printArg<bool>(PC));
43604 Text.Args.push_back(printArg<uint32_t>(PC));
43605 break;
43606case OP_PreDecBitfieldIntAPS:
43607 Text.Op = PrintName("PreDecBitfieldIntAPS");
43608 Text.Args.push_back(printArg<bool>(PC));
43609 Text.Args.push_back(printArg<uint32_t>(PC));
43610 break;
43611case OP_PreDecBitfieldBool:
43612 Text.Op = PrintName("PreDecBitfieldBool");
43613 Text.Args.push_back(printArg<bool>(PC));
43614 Text.Args.push_back(printArg<uint32_t>(PC));
43615 break;
43616case OP_PreDecBitfieldFixedPoint:
43617 Text.Op = PrintName("PreDecBitfieldFixedPoint");
43618 Text.Args.push_back(printArg<bool>(PC));
43619 Text.Args.push_back(printArg<uint32_t>(PC));
43620 break;
43621#endif
43622#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
43623bool emitPreDecBitfieldSint8( bool , uint32_t , SourceInfo);
43624bool emitPreDecBitfieldUint8( bool , uint32_t , SourceInfo);
43625bool emitPreDecBitfieldSint16( bool , uint32_t , SourceInfo);
43626bool emitPreDecBitfieldUint16( bool , uint32_t , SourceInfo);
43627bool emitPreDecBitfieldSint32( bool , uint32_t , SourceInfo);
43628bool emitPreDecBitfieldUint32( bool , uint32_t , SourceInfo);
43629bool emitPreDecBitfieldSint64( bool , uint32_t , SourceInfo);
43630bool emitPreDecBitfieldUint64( bool , uint32_t , SourceInfo);
43631bool emitPreDecBitfieldIntAP( bool , uint32_t , SourceInfo);
43632bool emitPreDecBitfieldIntAPS( bool , uint32_t , SourceInfo);
43633bool emitPreDecBitfieldBool( bool , uint32_t , SourceInfo);
43634bool emitPreDecBitfieldFixedPoint( bool , uint32_t , SourceInfo);
43635#endif
43636#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
43637[[nodiscard]] bool emitPreDecBitfield(PrimType, bool, uint32_t, SourceInfo I);
43638#endif
43639#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
43640bool
43641#if defined(GET_EVAL_IMPL)
43642EvalEmitter
43643#else
43644ByteCodeEmitter
43645#endif
43646::emitPreDecBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
43647 switch (T0) {
43648 case PT_Sint8:
43649 return emitPreDecBitfieldSint8(A0, A1, I);
43650 case PT_Uint8:
43651 return emitPreDecBitfieldUint8(A0, A1, I);
43652 case PT_Sint16:
43653 return emitPreDecBitfieldSint16(A0, A1, I);
43654 case PT_Uint16:
43655 return emitPreDecBitfieldUint16(A0, A1, I);
43656 case PT_Sint32:
43657 return emitPreDecBitfieldSint32(A0, A1, I);
43658 case PT_Uint32:
43659 return emitPreDecBitfieldUint32(A0, A1, I);
43660 case PT_Sint64:
43661 return emitPreDecBitfieldSint64(A0, A1, I);
43662 case PT_Uint64:
43663 return emitPreDecBitfieldUint64(A0, A1, I);
43664 case PT_IntAP:
43665 return emitPreDecBitfieldIntAP(A0, A1, I);
43666 case PT_IntAPS:
43667 return emitPreDecBitfieldIntAPS(A0, A1, I);
43668 case PT_Bool:
43669 return emitPreDecBitfieldBool(A0, A1, I);
43670 case PT_FixedPoint:
43671 return emitPreDecBitfieldFixedPoint(A0, A1, I);
43672 default: llvm_unreachable("invalid type: emitPreDecBitfield");
43673 }
43674 llvm_unreachable("invalid enum value");
43675}
43676#endif
43677#ifdef GET_LINK_IMPL
43678bool ByteCodeEmitter::emitPreDecBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
43679 return emitOp<bool, uint32_t>(OP_PreDecBitfieldSint8, A0, A1, L);
43680}
43681bool ByteCodeEmitter::emitPreDecBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
43682 return emitOp<bool, uint32_t>(OP_PreDecBitfieldUint8, A0, A1, L);
43683}
43684bool ByteCodeEmitter::emitPreDecBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
43685 return emitOp<bool, uint32_t>(OP_PreDecBitfieldSint16, A0, A1, L);
43686}
43687bool ByteCodeEmitter::emitPreDecBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
43688 return emitOp<bool, uint32_t>(OP_PreDecBitfieldUint16, A0, A1, L);
43689}
43690bool ByteCodeEmitter::emitPreDecBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
43691 return emitOp<bool, uint32_t>(OP_PreDecBitfieldSint32, A0, A1, L);
43692}
43693bool ByteCodeEmitter::emitPreDecBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
43694 return emitOp<bool, uint32_t>(OP_PreDecBitfieldUint32, A0, A1, L);
43695}
43696bool ByteCodeEmitter::emitPreDecBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
43697 return emitOp<bool, uint32_t>(OP_PreDecBitfieldSint64, A0, A1, L);
43698}
43699bool ByteCodeEmitter::emitPreDecBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
43700 return emitOp<bool, uint32_t>(OP_PreDecBitfieldUint64, A0, A1, L);
43701}
43702bool ByteCodeEmitter::emitPreDecBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
43703 return emitOp<bool, uint32_t>(OP_PreDecBitfieldIntAP, A0, A1, L);
43704}
43705bool ByteCodeEmitter::emitPreDecBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
43706 return emitOp<bool, uint32_t>(OP_PreDecBitfieldIntAPS, A0, A1, L);
43707}
43708bool ByteCodeEmitter::emitPreDecBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
43709 return emitOp<bool, uint32_t>(OP_PreDecBitfieldBool, A0, A1, L);
43710}
43711bool ByteCodeEmitter::emitPreDecBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
43712 return emitOp<bool, uint32_t>(OP_PreDecBitfieldFixedPoint, A0, A1, L);
43713}
43714#endif
43715#ifdef GET_EVAL_IMPL
43716bool EvalEmitter::emitPreDecBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
43717 if (!isActive()) return true;
43718 CurrentSource = L;
43719 return PreDecBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
43720}
43721bool EvalEmitter::emitPreDecBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
43722 if (!isActive()) return true;
43723 CurrentSource = L;
43724 return PreDecBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
43725}
43726bool EvalEmitter::emitPreDecBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
43727 if (!isActive()) return true;
43728 CurrentSource = L;
43729 return PreDecBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
43730}
43731bool EvalEmitter::emitPreDecBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
43732 if (!isActive()) return true;
43733 CurrentSource = L;
43734 return PreDecBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
43735}
43736bool EvalEmitter::emitPreDecBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
43737 if (!isActive()) return true;
43738 CurrentSource = L;
43739 return PreDecBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
43740}
43741bool EvalEmitter::emitPreDecBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
43742 if (!isActive()) return true;
43743 CurrentSource = L;
43744 return PreDecBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
43745}
43746bool EvalEmitter::emitPreDecBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
43747 if (!isActive()) return true;
43748 CurrentSource = L;
43749 return PreDecBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
43750}
43751bool EvalEmitter::emitPreDecBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
43752 if (!isActive()) return true;
43753 CurrentSource = L;
43754 return PreDecBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
43755}
43756bool EvalEmitter::emitPreDecBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
43757 if (!isActive()) return true;
43758 CurrentSource = L;
43759 return PreDecBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
43760}
43761bool EvalEmitter::emitPreDecBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
43762 if (!isActive()) return true;
43763 CurrentSource = L;
43764 return PreDecBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
43765}
43766bool EvalEmitter::emitPreDecBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
43767 if (!isActive()) return true;
43768 CurrentSource = L;
43769 return PreDecBitfield<PT_Bool>(S, CodePtr(), A0, A1);
43770}
43771bool EvalEmitter::emitPreDecBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
43772 if (!isActive()) return true;
43773 CurrentSource = L;
43774 return PreDecBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
43775}
43776#endif
43777#ifdef GET_OPCODE_NAMES
43778OP_PreIncSint8,
43779OP_PreIncUint8,
43780OP_PreIncSint16,
43781OP_PreIncUint16,
43782OP_PreIncSint32,
43783OP_PreIncUint32,
43784OP_PreIncSint64,
43785OP_PreIncUint64,
43786OP_PreIncIntAP,
43787OP_PreIncIntAPS,
43788OP_PreIncBool,
43789OP_PreIncFixedPoint,
43790#endif
43791#ifdef GET_INTERPFN_LIST
43792&Interp_PreIncSint8,
43793&Interp_PreIncUint8,
43794&Interp_PreIncSint16,
43795&Interp_PreIncUint16,
43796&Interp_PreIncSint32,
43797&Interp_PreIncUint32,
43798&Interp_PreIncSint64,
43799&Interp_PreIncUint64,
43800&Interp_PreIncIntAP,
43801&Interp_PreIncIntAPS,
43802&Interp_PreIncBool,
43803&Interp_PreIncFixedPoint,
43804#endif
43805#ifdef GET_INTERPFN_DISPATCHERS
43806PRESERVE_NONE
43807static bool Interp_PreIncSint8(InterpState &S) {
43808 {
43809 CodePtr OpPC = S.PC;
43810 const auto V0 = ReadArg<bool>(S, S.PC);
43811 if (!PreInc<PT_Sint8>(S, OpPC, V0)) return false;
43812 }
43813#if USE_TAILCALLS
43814 MUSTTAIL return InterpNext(S);
43815#else
43816 return true;
43817#endif
43818}
43819PRESERVE_NONE
43820static bool Interp_PreIncUint8(InterpState &S) {
43821 {
43822 CodePtr OpPC = S.PC;
43823 const auto V0 = ReadArg<bool>(S, S.PC);
43824 if (!PreInc<PT_Uint8>(S, OpPC, V0)) return false;
43825 }
43826#if USE_TAILCALLS
43827 MUSTTAIL return InterpNext(S);
43828#else
43829 return true;
43830#endif
43831}
43832PRESERVE_NONE
43833static bool Interp_PreIncSint16(InterpState &S) {
43834 {
43835 CodePtr OpPC = S.PC;
43836 const auto V0 = ReadArg<bool>(S, S.PC);
43837 if (!PreInc<PT_Sint16>(S, OpPC, V0)) return false;
43838 }
43839#if USE_TAILCALLS
43840 MUSTTAIL return InterpNext(S);
43841#else
43842 return true;
43843#endif
43844}
43845PRESERVE_NONE
43846static bool Interp_PreIncUint16(InterpState &S) {
43847 {
43848 CodePtr OpPC = S.PC;
43849 const auto V0 = ReadArg<bool>(S, S.PC);
43850 if (!PreInc<PT_Uint16>(S, OpPC, V0)) return false;
43851 }
43852#if USE_TAILCALLS
43853 MUSTTAIL return InterpNext(S);
43854#else
43855 return true;
43856#endif
43857}
43858PRESERVE_NONE
43859static bool Interp_PreIncSint32(InterpState &S) {
43860 {
43861 CodePtr OpPC = S.PC;
43862 const auto V0 = ReadArg<bool>(S, S.PC);
43863 if (!PreInc<PT_Sint32>(S, OpPC, V0)) return false;
43864 }
43865#if USE_TAILCALLS
43866 MUSTTAIL return InterpNext(S);
43867#else
43868 return true;
43869#endif
43870}
43871PRESERVE_NONE
43872static bool Interp_PreIncUint32(InterpState &S) {
43873 {
43874 CodePtr OpPC = S.PC;
43875 const auto V0 = ReadArg<bool>(S, S.PC);
43876 if (!PreInc<PT_Uint32>(S, OpPC, V0)) return false;
43877 }
43878#if USE_TAILCALLS
43879 MUSTTAIL return InterpNext(S);
43880#else
43881 return true;
43882#endif
43883}
43884PRESERVE_NONE
43885static bool Interp_PreIncSint64(InterpState &S) {
43886 {
43887 CodePtr OpPC = S.PC;
43888 const auto V0 = ReadArg<bool>(S, S.PC);
43889 if (!PreInc<PT_Sint64>(S, OpPC, V0)) return false;
43890 }
43891#if USE_TAILCALLS
43892 MUSTTAIL return InterpNext(S);
43893#else
43894 return true;
43895#endif
43896}
43897PRESERVE_NONE
43898static bool Interp_PreIncUint64(InterpState &S) {
43899 {
43900 CodePtr OpPC = S.PC;
43901 const auto V0 = ReadArg<bool>(S, S.PC);
43902 if (!PreInc<PT_Uint64>(S, OpPC, V0)) return false;
43903 }
43904#if USE_TAILCALLS
43905 MUSTTAIL return InterpNext(S);
43906#else
43907 return true;
43908#endif
43909}
43910PRESERVE_NONE
43911static bool Interp_PreIncIntAP(InterpState &S) {
43912 {
43913 CodePtr OpPC = S.PC;
43914 const auto V0 = ReadArg<bool>(S, S.PC);
43915 if (!PreInc<PT_IntAP>(S, OpPC, V0)) return false;
43916 }
43917#if USE_TAILCALLS
43918 MUSTTAIL return InterpNext(S);
43919#else
43920 return true;
43921#endif
43922}
43923PRESERVE_NONE
43924static bool Interp_PreIncIntAPS(InterpState &S) {
43925 {
43926 CodePtr OpPC = S.PC;
43927 const auto V0 = ReadArg<bool>(S, S.PC);
43928 if (!PreInc<PT_IntAPS>(S, OpPC, V0)) return false;
43929 }
43930#if USE_TAILCALLS
43931 MUSTTAIL return InterpNext(S);
43932#else
43933 return true;
43934#endif
43935}
43936PRESERVE_NONE
43937static bool Interp_PreIncBool(InterpState &S) {
43938 {
43939 CodePtr OpPC = S.PC;
43940 const auto V0 = ReadArg<bool>(S, S.PC);
43941 if (!PreInc<PT_Bool>(S, OpPC, V0)) return false;
43942 }
43943#if USE_TAILCALLS
43944 MUSTTAIL return InterpNext(S);
43945#else
43946 return true;
43947#endif
43948}
43949PRESERVE_NONE
43950static bool Interp_PreIncFixedPoint(InterpState &S) {
43951 {
43952 CodePtr OpPC = S.PC;
43953 const auto V0 = ReadArg<bool>(S, S.PC);
43954 if (!PreInc<PT_FixedPoint>(S, OpPC, V0)) return false;
43955 }
43956#if USE_TAILCALLS
43957 MUSTTAIL return InterpNext(S);
43958#else
43959 return true;
43960#endif
43961}
43962#endif
43963#ifdef GET_DISASM
43964case OP_PreIncSint8:
43965 Text.Op = PrintName("PreIncSint8");
43966 Text.Args.push_back(printArg<bool>(PC));
43967 break;
43968case OP_PreIncUint8:
43969 Text.Op = PrintName("PreIncUint8");
43970 Text.Args.push_back(printArg<bool>(PC));
43971 break;
43972case OP_PreIncSint16:
43973 Text.Op = PrintName("PreIncSint16");
43974 Text.Args.push_back(printArg<bool>(PC));
43975 break;
43976case OP_PreIncUint16:
43977 Text.Op = PrintName("PreIncUint16");
43978 Text.Args.push_back(printArg<bool>(PC));
43979 break;
43980case OP_PreIncSint32:
43981 Text.Op = PrintName("PreIncSint32");
43982 Text.Args.push_back(printArg<bool>(PC));
43983 break;
43984case OP_PreIncUint32:
43985 Text.Op = PrintName("PreIncUint32");
43986 Text.Args.push_back(printArg<bool>(PC));
43987 break;
43988case OP_PreIncSint64:
43989 Text.Op = PrintName("PreIncSint64");
43990 Text.Args.push_back(printArg<bool>(PC));
43991 break;
43992case OP_PreIncUint64:
43993 Text.Op = PrintName("PreIncUint64");
43994 Text.Args.push_back(printArg<bool>(PC));
43995 break;
43996case OP_PreIncIntAP:
43997 Text.Op = PrintName("PreIncIntAP");
43998 Text.Args.push_back(printArg<bool>(PC));
43999 break;
44000case OP_PreIncIntAPS:
44001 Text.Op = PrintName("PreIncIntAPS");
44002 Text.Args.push_back(printArg<bool>(PC));
44003 break;
44004case OP_PreIncBool:
44005 Text.Op = PrintName("PreIncBool");
44006 Text.Args.push_back(printArg<bool>(PC));
44007 break;
44008case OP_PreIncFixedPoint:
44009 Text.Op = PrintName("PreIncFixedPoint");
44010 Text.Args.push_back(printArg<bool>(PC));
44011 break;
44012#endif
44013#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44014bool emitPreIncSint8( bool , SourceInfo);
44015bool emitPreIncUint8( bool , SourceInfo);
44016bool emitPreIncSint16( bool , SourceInfo);
44017bool emitPreIncUint16( bool , SourceInfo);
44018bool emitPreIncSint32( bool , SourceInfo);
44019bool emitPreIncUint32( bool , SourceInfo);
44020bool emitPreIncSint64( bool , SourceInfo);
44021bool emitPreIncUint64( bool , SourceInfo);
44022bool emitPreIncIntAP( bool , SourceInfo);
44023bool emitPreIncIntAPS( bool , SourceInfo);
44024bool emitPreIncBool( bool , SourceInfo);
44025bool emitPreIncFixedPoint( bool , SourceInfo);
44026#endif
44027#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44028[[nodiscard]] bool emitPreInc(PrimType, bool, SourceInfo I);
44029#endif
44030#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
44031bool
44032#if defined(GET_EVAL_IMPL)
44033EvalEmitter
44034#else
44035ByteCodeEmitter
44036#endif
44037::emitPreInc(PrimType T0, bool A0, SourceInfo I) {
44038 switch (T0) {
44039 case PT_Sint8:
44040 return emitPreIncSint8(A0, I);
44041 case PT_Uint8:
44042 return emitPreIncUint8(A0, I);
44043 case PT_Sint16:
44044 return emitPreIncSint16(A0, I);
44045 case PT_Uint16:
44046 return emitPreIncUint16(A0, I);
44047 case PT_Sint32:
44048 return emitPreIncSint32(A0, I);
44049 case PT_Uint32:
44050 return emitPreIncUint32(A0, I);
44051 case PT_Sint64:
44052 return emitPreIncSint64(A0, I);
44053 case PT_Uint64:
44054 return emitPreIncUint64(A0, I);
44055 case PT_IntAP:
44056 return emitPreIncIntAP(A0, I);
44057 case PT_IntAPS:
44058 return emitPreIncIntAPS(A0, I);
44059 case PT_Bool:
44060 return emitPreIncBool(A0, I);
44061 case PT_FixedPoint:
44062 return emitPreIncFixedPoint(A0, I);
44063 default: llvm_unreachable("invalid type: emitPreInc");
44064 }
44065 llvm_unreachable("invalid enum value");
44066}
44067#endif
44068#ifdef GET_LINK_IMPL
44069bool ByteCodeEmitter::emitPreIncSint8( bool A0, SourceInfo L) {
44070 return emitOp<bool>(OP_PreIncSint8, A0, L);
44071}
44072bool ByteCodeEmitter::emitPreIncUint8( bool A0, SourceInfo L) {
44073 return emitOp<bool>(OP_PreIncUint8, A0, L);
44074}
44075bool ByteCodeEmitter::emitPreIncSint16( bool A0, SourceInfo L) {
44076 return emitOp<bool>(OP_PreIncSint16, A0, L);
44077}
44078bool ByteCodeEmitter::emitPreIncUint16( bool A0, SourceInfo L) {
44079 return emitOp<bool>(OP_PreIncUint16, A0, L);
44080}
44081bool ByteCodeEmitter::emitPreIncSint32( bool A0, SourceInfo L) {
44082 return emitOp<bool>(OP_PreIncSint32, A0, L);
44083}
44084bool ByteCodeEmitter::emitPreIncUint32( bool A0, SourceInfo L) {
44085 return emitOp<bool>(OP_PreIncUint32, A0, L);
44086}
44087bool ByteCodeEmitter::emitPreIncSint64( bool A0, SourceInfo L) {
44088 return emitOp<bool>(OP_PreIncSint64, A0, L);
44089}
44090bool ByteCodeEmitter::emitPreIncUint64( bool A0, SourceInfo L) {
44091 return emitOp<bool>(OP_PreIncUint64, A0, L);
44092}
44093bool ByteCodeEmitter::emitPreIncIntAP( bool A0, SourceInfo L) {
44094 return emitOp<bool>(OP_PreIncIntAP, A0, L);
44095}
44096bool ByteCodeEmitter::emitPreIncIntAPS( bool A0, SourceInfo L) {
44097 return emitOp<bool>(OP_PreIncIntAPS, A0, L);
44098}
44099bool ByteCodeEmitter::emitPreIncBool( bool A0, SourceInfo L) {
44100 return emitOp<bool>(OP_PreIncBool, A0, L);
44101}
44102bool ByteCodeEmitter::emitPreIncFixedPoint( bool A0, SourceInfo L) {
44103 return emitOp<bool>(OP_PreIncFixedPoint, A0, L);
44104}
44105#endif
44106#ifdef GET_EVAL_IMPL
44107bool EvalEmitter::emitPreIncSint8( bool A0, SourceInfo L) {
44108 if (!isActive()) return true;
44109 CurrentSource = L;
44110 return PreInc<PT_Sint8>(S, CodePtr(), A0);
44111}
44112bool EvalEmitter::emitPreIncUint8( bool A0, SourceInfo L) {
44113 if (!isActive()) return true;
44114 CurrentSource = L;
44115 return PreInc<PT_Uint8>(S, CodePtr(), A0);
44116}
44117bool EvalEmitter::emitPreIncSint16( bool A0, SourceInfo L) {
44118 if (!isActive()) return true;
44119 CurrentSource = L;
44120 return PreInc<PT_Sint16>(S, CodePtr(), A0);
44121}
44122bool EvalEmitter::emitPreIncUint16( bool A0, SourceInfo L) {
44123 if (!isActive()) return true;
44124 CurrentSource = L;
44125 return PreInc<PT_Uint16>(S, CodePtr(), A0);
44126}
44127bool EvalEmitter::emitPreIncSint32( bool A0, SourceInfo L) {
44128 if (!isActive()) return true;
44129 CurrentSource = L;
44130 return PreInc<PT_Sint32>(S, CodePtr(), A0);
44131}
44132bool EvalEmitter::emitPreIncUint32( bool A0, SourceInfo L) {
44133 if (!isActive()) return true;
44134 CurrentSource = L;
44135 return PreInc<PT_Uint32>(S, CodePtr(), A0);
44136}
44137bool EvalEmitter::emitPreIncSint64( bool A0, SourceInfo L) {
44138 if (!isActive()) return true;
44139 CurrentSource = L;
44140 return PreInc<PT_Sint64>(S, CodePtr(), A0);
44141}
44142bool EvalEmitter::emitPreIncUint64( bool A0, SourceInfo L) {
44143 if (!isActive()) return true;
44144 CurrentSource = L;
44145 return PreInc<PT_Uint64>(S, CodePtr(), A0);
44146}
44147bool EvalEmitter::emitPreIncIntAP( bool A0, SourceInfo L) {
44148 if (!isActive()) return true;
44149 CurrentSource = L;
44150 return PreInc<PT_IntAP>(S, CodePtr(), A0);
44151}
44152bool EvalEmitter::emitPreIncIntAPS( bool A0, SourceInfo L) {
44153 if (!isActive()) return true;
44154 CurrentSource = L;
44155 return PreInc<PT_IntAPS>(S, CodePtr(), A0);
44156}
44157bool EvalEmitter::emitPreIncBool( bool A0, SourceInfo L) {
44158 if (!isActive()) return true;
44159 CurrentSource = L;
44160 return PreInc<PT_Bool>(S, CodePtr(), A0);
44161}
44162bool EvalEmitter::emitPreIncFixedPoint( bool A0, SourceInfo L) {
44163 if (!isActive()) return true;
44164 CurrentSource = L;
44165 return PreInc<PT_FixedPoint>(S, CodePtr(), A0);
44166}
44167#endif
44168#ifdef GET_OPCODE_NAMES
44169OP_PreIncBitfieldSint8,
44170OP_PreIncBitfieldUint8,
44171OP_PreIncBitfieldSint16,
44172OP_PreIncBitfieldUint16,
44173OP_PreIncBitfieldSint32,
44174OP_PreIncBitfieldUint32,
44175OP_PreIncBitfieldSint64,
44176OP_PreIncBitfieldUint64,
44177OP_PreIncBitfieldIntAP,
44178OP_PreIncBitfieldIntAPS,
44179OP_PreIncBitfieldBool,
44180OP_PreIncBitfieldFixedPoint,
44181#endif
44182#ifdef GET_INTERPFN_LIST
44183&Interp_PreIncBitfieldSint8,
44184&Interp_PreIncBitfieldUint8,
44185&Interp_PreIncBitfieldSint16,
44186&Interp_PreIncBitfieldUint16,
44187&Interp_PreIncBitfieldSint32,
44188&Interp_PreIncBitfieldUint32,
44189&Interp_PreIncBitfieldSint64,
44190&Interp_PreIncBitfieldUint64,
44191&Interp_PreIncBitfieldIntAP,
44192&Interp_PreIncBitfieldIntAPS,
44193&Interp_PreIncBitfieldBool,
44194&Interp_PreIncBitfieldFixedPoint,
44195#endif
44196#ifdef GET_INTERPFN_DISPATCHERS
44197PRESERVE_NONE
44198static bool Interp_PreIncBitfieldSint8(InterpState &S) {
44199 {
44200 CodePtr OpPC = S.PC;
44201 const auto V0 = ReadArg<bool>(S, S.PC);
44202 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44203 if (!PreIncBitfield<PT_Sint8>(S, OpPC, V0, V1)) return false;
44204 }
44205#if USE_TAILCALLS
44206 MUSTTAIL return InterpNext(S);
44207#else
44208 return true;
44209#endif
44210}
44211PRESERVE_NONE
44212static bool Interp_PreIncBitfieldUint8(InterpState &S) {
44213 {
44214 CodePtr OpPC = S.PC;
44215 const auto V0 = ReadArg<bool>(S, S.PC);
44216 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44217 if (!PreIncBitfield<PT_Uint8>(S, OpPC, V0, V1)) return false;
44218 }
44219#if USE_TAILCALLS
44220 MUSTTAIL return InterpNext(S);
44221#else
44222 return true;
44223#endif
44224}
44225PRESERVE_NONE
44226static bool Interp_PreIncBitfieldSint16(InterpState &S) {
44227 {
44228 CodePtr OpPC = S.PC;
44229 const auto V0 = ReadArg<bool>(S, S.PC);
44230 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44231 if (!PreIncBitfield<PT_Sint16>(S, OpPC, V0, V1)) return false;
44232 }
44233#if USE_TAILCALLS
44234 MUSTTAIL return InterpNext(S);
44235#else
44236 return true;
44237#endif
44238}
44239PRESERVE_NONE
44240static bool Interp_PreIncBitfieldUint16(InterpState &S) {
44241 {
44242 CodePtr OpPC = S.PC;
44243 const auto V0 = ReadArg<bool>(S, S.PC);
44244 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44245 if (!PreIncBitfield<PT_Uint16>(S, OpPC, V0, V1)) return false;
44246 }
44247#if USE_TAILCALLS
44248 MUSTTAIL return InterpNext(S);
44249#else
44250 return true;
44251#endif
44252}
44253PRESERVE_NONE
44254static bool Interp_PreIncBitfieldSint32(InterpState &S) {
44255 {
44256 CodePtr OpPC = S.PC;
44257 const auto V0 = ReadArg<bool>(S, S.PC);
44258 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44259 if (!PreIncBitfield<PT_Sint32>(S, OpPC, V0, V1)) return false;
44260 }
44261#if USE_TAILCALLS
44262 MUSTTAIL return InterpNext(S);
44263#else
44264 return true;
44265#endif
44266}
44267PRESERVE_NONE
44268static bool Interp_PreIncBitfieldUint32(InterpState &S) {
44269 {
44270 CodePtr OpPC = S.PC;
44271 const auto V0 = ReadArg<bool>(S, S.PC);
44272 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44273 if (!PreIncBitfield<PT_Uint32>(S, OpPC, V0, V1)) return false;
44274 }
44275#if USE_TAILCALLS
44276 MUSTTAIL return InterpNext(S);
44277#else
44278 return true;
44279#endif
44280}
44281PRESERVE_NONE
44282static bool Interp_PreIncBitfieldSint64(InterpState &S) {
44283 {
44284 CodePtr OpPC = S.PC;
44285 const auto V0 = ReadArg<bool>(S, S.PC);
44286 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44287 if (!PreIncBitfield<PT_Sint64>(S, OpPC, V0, V1)) return false;
44288 }
44289#if USE_TAILCALLS
44290 MUSTTAIL return InterpNext(S);
44291#else
44292 return true;
44293#endif
44294}
44295PRESERVE_NONE
44296static bool Interp_PreIncBitfieldUint64(InterpState &S) {
44297 {
44298 CodePtr OpPC = S.PC;
44299 const auto V0 = ReadArg<bool>(S, S.PC);
44300 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44301 if (!PreIncBitfield<PT_Uint64>(S, OpPC, V0, V1)) return false;
44302 }
44303#if USE_TAILCALLS
44304 MUSTTAIL return InterpNext(S);
44305#else
44306 return true;
44307#endif
44308}
44309PRESERVE_NONE
44310static bool Interp_PreIncBitfieldIntAP(InterpState &S) {
44311 {
44312 CodePtr OpPC = S.PC;
44313 const auto V0 = ReadArg<bool>(S, S.PC);
44314 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44315 if (!PreIncBitfield<PT_IntAP>(S, OpPC, V0, V1)) return false;
44316 }
44317#if USE_TAILCALLS
44318 MUSTTAIL return InterpNext(S);
44319#else
44320 return true;
44321#endif
44322}
44323PRESERVE_NONE
44324static bool Interp_PreIncBitfieldIntAPS(InterpState &S) {
44325 {
44326 CodePtr OpPC = S.PC;
44327 const auto V0 = ReadArg<bool>(S, S.PC);
44328 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44329 if (!PreIncBitfield<PT_IntAPS>(S, OpPC, V0, V1)) return false;
44330 }
44331#if USE_TAILCALLS
44332 MUSTTAIL return InterpNext(S);
44333#else
44334 return true;
44335#endif
44336}
44337PRESERVE_NONE
44338static bool Interp_PreIncBitfieldBool(InterpState &S) {
44339 {
44340 CodePtr OpPC = S.PC;
44341 const auto V0 = ReadArg<bool>(S, S.PC);
44342 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44343 if (!PreIncBitfield<PT_Bool>(S, OpPC, V0, V1)) return false;
44344 }
44345#if USE_TAILCALLS
44346 MUSTTAIL return InterpNext(S);
44347#else
44348 return true;
44349#endif
44350}
44351PRESERVE_NONE
44352static bool Interp_PreIncBitfieldFixedPoint(InterpState &S) {
44353 {
44354 CodePtr OpPC = S.PC;
44355 const auto V0 = ReadArg<bool>(S, S.PC);
44356 const auto V1 = ReadArg<uint32_t>(S, S.PC);
44357 if (!PreIncBitfield<PT_FixedPoint>(S, OpPC, V0, V1)) return false;
44358 }
44359#if USE_TAILCALLS
44360 MUSTTAIL return InterpNext(S);
44361#else
44362 return true;
44363#endif
44364}
44365#endif
44366#ifdef GET_DISASM
44367case OP_PreIncBitfieldSint8:
44368 Text.Op = PrintName("PreIncBitfieldSint8");
44369 Text.Args.push_back(printArg<bool>(PC));
44370 Text.Args.push_back(printArg<uint32_t>(PC));
44371 break;
44372case OP_PreIncBitfieldUint8:
44373 Text.Op = PrintName("PreIncBitfieldUint8");
44374 Text.Args.push_back(printArg<bool>(PC));
44375 Text.Args.push_back(printArg<uint32_t>(PC));
44376 break;
44377case OP_PreIncBitfieldSint16:
44378 Text.Op = PrintName("PreIncBitfieldSint16");
44379 Text.Args.push_back(printArg<bool>(PC));
44380 Text.Args.push_back(printArg<uint32_t>(PC));
44381 break;
44382case OP_PreIncBitfieldUint16:
44383 Text.Op = PrintName("PreIncBitfieldUint16");
44384 Text.Args.push_back(printArg<bool>(PC));
44385 Text.Args.push_back(printArg<uint32_t>(PC));
44386 break;
44387case OP_PreIncBitfieldSint32:
44388 Text.Op = PrintName("PreIncBitfieldSint32");
44389 Text.Args.push_back(printArg<bool>(PC));
44390 Text.Args.push_back(printArg<uint32_t>(PC));
44391 break;
44392case OP_PreIncBitfieldUint32:
44393 Text.Op = PrintName("PreIncBitfieldUint32");
44394 Text.Args.push_back(printArg<bool>(PC));
44395 Text.Args.push_back(printArg<uint32_t>(PC));
44396 break;
44397case OP_PreIncBitfieldSint64:
44398 Text.Op = PrintName("PreIncBitfieldSint64");
44399 Text.Args.push_back(printArg<bool>(PC));
44400 Text.Args.push_back(printArg<uint32_t>(PC));
44401 break;
44402case OP_PreIncBitfieldUint64:
44403 Text.Op = PrintName("PreIncBitfieldUint64");
44404 Text.Args.push_back(printArg<bool>(PC));
44405 Text.Args.push_back(printArg<uint32_t>(PC));
44406 break;
44407case OP_PreIncBitfieldIntAP:
44408 Text.Op = PrintName("PreIncBitfieldIntAP");
44409 Text.Args.push_back(printArg<bool>(PC));
44410 Text.Args.push_back(printArg<uint32_t>(PC));
44411 break;
44412case OP_PreIncBitfieldIntAPS:
44413 Text.Op = PrintName("PreIncBitfieldIntAPS");
44414 Text.Args.push_back(printArg<bool>(PC));
44415 Text.Args.push_back(printArg<uint32_t>(PC));
44416 break;
44417case OP_PreIncBitfieldBool:
44418 Text.Op = PrintName("PreIncBitfieldBool");
44419 Text.Args.push_back(printArg<bool>(PC));
44420 Text.Args.push_back(printArg<uint32_t>(PC));
44421 break;
44422case OP_PreIncBitfieldFixedPoint:
44423 Text.Op = PrintName("PreIncBitfieldFixedPoint");
44424 Text.Args.push_back(printArg<bool>(PC));
44425 Text.Args.push_back(printArg<uint32_t>(PC));
44426 break;
44427#endif
44428#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44429bool emitPreIncBitfieldSint8( bool , uint32_t , SourceInfo);
44430bool emitPreIncBitfieldUint8( bool , uint32_t , SourceInfo);
44431bool emitPreIncBitfieldSint16( bool , uint32_t , SourceInfo);
44432bool emitPreIncBitfieldUint16( bool , uint32_t , SourceInfo);
44433bool emitPreIncBitfieldSint32( bool , uint32_t , SourceInfo);
44434bool emitPreIncBitfieldUint32( bool , uint32_t , SourceInfo);
44435bool emitPreIncBitfieldSint64( bool , uint32_t , SourceInfo);
44436bool emitPreIncBitfieldUint64( bool , uint32_t , SourceInfo);
44437bool emitPreIncBitfieldIntAP( bool , uint32_t , SourceInfo);
44438bool emitPreIncBitfieldIntAPS( bool , uint32_t , SourceInfo);
44439bool emitPreIncBitfieldBool( bool , uint32_t , SourceInfo);
44440bool emitPreIncBitfieldFixedPoint( bool , uint32_t , SourceInfo);
44441#endif
44442#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44443[[nodiscard]] bool emitPreIncBitfield(PrimType, bool, uint32_t, SourceInfo I);
44444#endif
44445#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
44446bool
44447#if defined(GET_EVAL_IMPL)
44448EvalEmitter
44449#else
44450ByteCodeEmitter
44451#endif
44452::emitPreIncBitfield(PrimType T0, bool A0, uint32_t A1, SourceInfo I) {
44453 switch (T0) {
44454 case PT_Sint8:
44455 return emitPreIncBitfieldSint8(A0, A1, I);
44456 case PT_Uint8:
44457 return emitPreIncBitfieldUint8(A0, A1, I);
44458 case PT_Sint16:
44459 return emitPreIncBitfieldSint16(A0, A1, I);
44460 case PT_Uint16:
44461 return emitPreIncBitfieldUint16(A0, A1, I);
44462 case PT_Sint32:
44463 return emitPreIncBitfieldSint32(A0, A1, I);
44464 case PT_Uint32:
44465 return emitPreIncBitfieldUint32(A0, A1, I);
44466 case PT_Sint64:
44467 return emitPreIncBitfieldSint64(A0, A1, I);
44468 case PT_Uint64:
44469 return emitPreIncBitfieldUint64(A0, A1, I);
44470 case PT_IntAP:
44471 return emitPreIncBitfieldIntAP(A0, A1, I);
44472 case PT_IntAPS:
44473 return emitPreIncBitfieldIntAPS(A0, A1, I);
44474 case PT_Bool:
44475 return emitPreIncBitfieldBool(A0, A1, I);
44476 case PT_FixedPoint:
44477 return emitPreIncBitfieldFixedPoint(A0, A1, I);
44478 default: llvm_unreachable("invalid type: emitPreIncBitfield");
44479 }
44480 llvm_unreachable("invalid enum value");
44481}
44482#endif
44483#ifdef GET_LINK_IMPL
44484bool ByteCodeEmitter::emitPreIncBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
44485 return emitOp<bool, uint32_t>(OP_PreIncBitfieldSint8, A0, A1, L);
44486}
44487bool ByteCodeEmitter::emitPreIncBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
44488 return emitOp<bool, uint32_t>(OP_PreIncBitfieldUint8, A0, A1, L);
44489}
44490bool ByteCodeEmitter::emitPreIncBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
44491 return emitOp<bool, uint32_t>(OP_PreIncBitfieldSint16, A0, A1, L);
44492}
44493bool ByteCodeEmitter::emitPreIncBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
44494 return emitOp<bool, uint32_t>(OP_PreIncBitfieldUint16, A0, A1, L);
44495}
44496bool ByteCodeEmitter::emitPreIncBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
44497 return emitOp<bool, uint32_t>(OP_PreIncBitfieldSint32, A0, A1, L);
44498}
44499bool ByteCodeEmitter::emitPreIncBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
44500 return emitOp<bool, uint32_t>(OP_PreIncBitfieldUint32, A0, A1, L);
44501}
44502bool ByteCodeEmitter::emitPreIncBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
44503 return emitOp<bool, uint32_t>(OP_PreIncBitfieldSint64, A0, A1, L);
44504}
44505bool ByteCodeEmitter::emitPreIncBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
44506 return emitOp<bool, uint32_t>(OP_PreIncBitfieldUint64, A0, A1, L);
44507}
44508bool ByteCodeEmitter::emitPreIncBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
44509 return emitOp<bool, uint32_t>(OP_PreIncBitfieldIntAP, A0, A1, L);
44510}
44511bool ByteCodeEmitter::emitPreIncBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
44512 return emitOp<bool, uint32_t>(OP_PreIncBitfieldIntAPS, A0, A1, L);
44513}
44514bool ByteCodeEmitter::emitPreIncBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
44515 return emitOp<bool, uint32_t>(OP_PreIncBitfieldBool, A0, A1, L);
44516}
44517bool ByteCodeEmitter::emitPreIncBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
44518 return emitOp<bool, uint32_t>(OP_PreIncBitfieldFixedPoint, A0, A1, L);
44519}
44520#endif
44521#ifdef GET_EVAL_IMPL
44522bool EvalEmitter::emitPreIncBitfieldSint8( bool A0, uint32_t A1, SourceInfo L) {
44523 if (!isActive()) return true;
44524 CurrentSource = L;
44525 return PreIncBitfield<PT_Sint8>(S, CodePtr(), A0, A1);
44526}
44527bool EvalEmitter::emitPreIncBitfieldUint8( bool A0, uint32_t A1, SourceInfo L) {
44528 if (!isActive()) return true;
44529 CurrentSource = L;
44530 return PreIncBitfield<PT_Uint8>(S, CodePtr(), A0, A1);
44531}
44532bool EvalEmitter::emitPreIncBitfieldSint16( bool A0, uint32_t A1, SourceInfo L) {
44533 if (!isActive()) return true;
44534 CurrentSource = L;
44535 return PreIncBitfield<PT_Sint16>(S, CodePtr(), A0, A1);
44536}
44537bool EvalEmitter::emitPreIncBitfieldUint16( bool A0, uint32_t A1, SourceInfo L) {
44538 if (!isActive()) return true;
44539 CurrentSource = L;
44540 return PreIncBitfield<PT_Uint16>(S, CodePtr(), A0, A1);
44541}
44542bool EvalEmitter::emitPreIncBitfieldSint32( bool A0, uint32_t A1, SourceInfo L) {
44543 if (!isActive()) return true;
44544 CurrentSource = L;
44545 return PreIncBitfield<PT_Sint32>(S, CodePtr(), A0, A1);
44546}
44547bool EvalEmitter::emitPreIncBitfieldUint32( bool A0, uint32_t A1, SourceInfo L) {
44548 if (!isActive()) return true;
44549 CurrentSource = L;
44550 return PreIncBitfield<PT_Uint32>(S, CodePtr(), A0, A1);
44551}
44552bool EvalEmitter::emitPreIncBitfieldSint64( bool A0, uint32_t A1, SourceInfo L) {
44553 if (!isActive()) return true;
44554 CurrentSource = L;
44555 return PreIncBitfield<PT_Sint64>(S, CodePtr(), A0, A1);
44556}
44557bool EvalEmitter::emitPreIncBitfieldUint64( bool A0, uint32_t A1, SourceInfo L) {
44558 if (!isActive()) return true;
44559 CurrentSource = L;
44560 return PreIncBitfield<PT_Uint64>(S, CodePtr(), A0, A1);
44561}
44562bool EvalEmitter::emitPreIncBitfieldIntAP( bool A0, uint32_t A1, SourceInfo L) {
44563 if (!isActive()) return true;
44564 CurrentSource = L;
44565 return PreIncBitfield<PT_IntAP>(S, CodePtr(), A0, A1);
44566}
44567bool EvalEmitter::emitPreIncBitfieldIntAPS( bool A0, uint32_t A1, SourceInfo L) {
44568 if (!isActive()) return true;
44569 CurrentSource = L;
44570 return PreIncBitfield<PT_IntAPS>(S, CodePtr(), A0, A1);
44571}
44572bool EvalEmitter::emitPreIncBitfieldBool( bool A0, uint32_t A1, SourceInfo L) {
44573 if (!isActive()) return true;
44574 CurrentSource = L;
44575 return PreIncBitfield<PT_Bool>(S, CodePtr(), A0, A1);
44576}
44577bool EvalEmitter::emitPreIncBitfieldFixedPoint( bool A0, uint32_t A1, SourceInfo L) {
44578 if (!isActive()) return true;
44579 CurrentSource = L;
44580 return PreIncBitfield<PT_FixedPoint>(S, CodePtr(), A0, A1);
44581}
44582#endif
44583#ifdef GET_OPCODE_NAMES
44584OP_PseudoDtor,
44585#endif
44586#ifdef GET_INTERPFN_LIST
44587&Interp_PseudoDtor,
44588#endif
44589#ifdef GET_INTERPFN_DISPATCHERS
44590PRESERVE_NONE
44591static bool Interp_PseudoDtor(InterpState &S) {
44592 if (!PseudoDtor(S, S.PC)) return false;
44593#if USE_TAILCALLS
44594 MUSTTAIL return InterpNext(S);
44595#else
44596 return true;
44597#endif
44598}
44599#endif
44600#ifdef GET_DISASM
44601case OP_PseudoDtor:
44602 Text.Op = PrintName("PseudoDtor");
44603 break;
44604#endif
44605#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44606bool emitPseudoDtor(SourceInfo);
44607#endif
44608#ifdef GET_LINK_IMPL
44609bool ByteCodeEmitter::emitPseudoDtor(SourceInfo L) {
44610 return emitOp<>(OP_PseudoDtor, L);
44611}
44612#endif
44613#ifdef GET_EVAL_IMPL
44614bool EvalEmitter::emitPseudoDtor(SourceInfo L) {
44615 if (!isActive()) return true;
44616 CurrentSource = L;
44617 return PseudoDtor(S, CodePtr());
44618}
44619#endif
44620#ifdef GET_OPCODE_NAMES
44621OP_PtrPtrCast,
44622#endif
44623#ifdef GET_INTERPFN_LIST
44624&Interp_PtrPtrCast,
44625#endif
44626#ifdef GET_INTERPFN_DISPATCHERS
44627PRESERVE_NONE
44628static bool Interp_PtrPtrCast(InterpState &S) {
44629 {
44630 CodePtr OpPC = S.PC;
44631 const auto V0 = ReadArg<bool>(S, S.PC);
44632 const auto V1 = ReadArg<const Type *>(S, S.PC);
44633 if (!PtrPtrCast(S, OpPC, V0, V1)) return false;
44634 }
44635#if USE_TAILCALLS
44636 MUSTTAIL return InterpNext(S);
44637#else
44638 return true;
44639#endif
44640}
44641#endif
44642#ifdef GET_DISASM
44643case OP_PtrPtrCast:
44644 Text.Op = PrintName("PtrPtrCast");
44645 Text.Args.push_back(printArg<bool>(PC));
44646 Text.Args.push_back(printArg<const Type *>(PC));
44647 break;
44648#endif
44649#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44650bool emitPtrPtrCast( bool , const Type * , SourceInfo);
44651#endif
44652#ifdef GET_LINK_IMPL
44653bool ByteCodeEmitter::emitPtrPtrCast( bool A0, const Type * A1, SourceInfo L) {
44654 return emitOp<bool, const Type *>(OP_PtrPtrCast, A0, A1, L);
44655}
44656#endif
44657#ifdef GET_EVAL_IMPL
44658bool EvalEmitter::emitPtrPtrCast( bool A0, const Type * A1, SourceInfo L) {
44659 if (!isActive()) return true;
44660 CurrentSource = L;
44661 return PtrPtrCast(S, CodePtr(), A0, A1);
44662}
44663#endif
44664#ifdef GET_OPCODE_NAMES
44665OP_PushCC,
44666#endif
44667#ifdef GET_INTERPFN_LIST
44668&Interp_PushCC,
44669#endif
44670#ifdef GET_INTERPFN_DISPATCHERS
44671PRESERVE_NONE
44672static bool Interp_PushCC(InterpState &S) {
44673 {
44674 const auto V0 = ReadArg<bool>(S, S.PC);
44675 PushCC(S, V0);
44676 }
44677#if USE_TAILCALLS
44678 MUSTTAIL return InterpNext(S);
44679#else
44680 return true;
44681#endif
44682}
44683#endif
44684#ifdef GET_DISASM
44685case OP_PushCC:
44686 Text.Op = PrintName("PushCC");
44687 Text.Args.push_back(printArg<bool>(PC));
44688 break;
44689#endif
44690#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44691bool emitPushCC( bool , SourceInfo);
44692#endif
44693#ifdef GET_LINK_IMPL
44694bool ByteCodeEmitter::emitPushCC( bool A0, SourceInfo L) {
44695 return emitOp<bool>(OP_PushCC, A0, L);
44696}
44697#endif
44698#ifdef GET_EVAL_IMPL
44699bool EvalEmitter::emitPushCC( bool A0, SourceInfo L) {
44700 if (!isActive()) return true;
44701 CurrentSource = L;
44702 return PushCC(S, A0);
44703}
44704#endif
44705#ifdef GET_OPCODE_NAMES
44706OP_PushIgnoreDiags,
44707#endif
44708#ifdef GET_INTERPFN_LIST
44709&Interp_PushIgnoreDiags,
44710#endif
44711#ifdef GET_INTERPFN_DISPATCHERS
44712PRESERVE_NONE
44713static bool Interp_PushIgnoreDiags(InterpState &S) {
44714 PushIgnoreDiags(S);
44715#if USE_TAILCALLS
44716 MUSTTAIL return InterpNext(S);
44717#else
44718 return true;
44719#endif
44720}
44721#endif
44722#ifdef GET_DISASM
44723case OP_PushIgnoreDiags:
44724 Text.Op = PrintName("PushIgnoreDiags");
44725 break;
44726#endif
44727#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44728bool emitPushIgnoreDiags(SourceInfo);
44729#endif
44730#ifdef GET_LINK_IMPL
44731bool ByteCodeEmitter::emitPushIgnoreDiags(SourceInfo L) {
44732 return emitOp<>(OP_PushIgnoreDiags, L);
44733}
44734#endif
44735#ifdef GET_EVAL_IMPL
44736bool EvalEmitter::emitPushIgnoreDiags(SourceInfo L) {
44737 if (!isActive()) return true;
44738 CurrentSource = L;
44739 return PushIgnoreDiags(S);
44740}
44741#endif
44742#ifdef GET_OPCODE_NAMES
44743OP_PushMSVCCE,
44744#endif
44745#ifdef GET_INTERPFN_LIST
44746&Interp_PushMSVCCE,
44747#endif
44748#ifdef GET_INTERPFN_DISPATCHERS
44749PRESERVE_NONE
44750static bool Interp_PushMSVCCE(InterpState &S) {
44751 PushMSVCCE(S);
44752#if USE_TAILCALLS
44753 MUSTTAIL return InterpNext(S);
44754#else
44755 return true;
44756#endif
44757}
44758#endif
44759#ifdef GET_DISASM
44760case OP_PushMSVCCE:
44761 Text.Op = PrintName("PushMSVCCE");
44762 break;
44763#endif
44764#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44765bool emitPushMSVCCE(SourceInfo);
44766#endif
44767#ifdef GET_LINK_IMPL
44768bool ByteCodeEmitter::emitPushMSVCCE(SourceInfo L) {
44769 return emitOp<>(OP_PushMSVCCE, L);
44770}
44771#endif
44772#ifdef GET_EVAL_IMPL
44773bool EvalEmitter::emitPushMSVCCE(SourceInfo L) {
44774 if (!isActive()) return true;
44775 CurrentSource = L;
44776 return PushMSVCCE(S);
44777}
44778#endif
44779#ifdef GET_OPCODE_NAMES
44780OP_RVOPtr,
44781#endif
44782#ifdef GET_INTERPFN_LIST
44783&Interp_RVOPtr,
44784#endif
44785#ifdef GET_INTERPFN_DISPATCHERS
44786PRESERVE_NONE
44787static bool Interp_RVOPtr(InterpState &S) {
44788 if (!RVOPtr(S)) return false;
44789#if USE_TAILCALLS
44790 MUSTTAIL return InterpNext(S);
44791#else
44792 return true;
44793#endif
44794}
44795#endif
44796#ifdef GET_DISASM
44797case OP_RVOPtr:
44798 Text.Op = PrintName("RVOPtr");
44799 break;
44800#endif
44801#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44802bool emitRVOPtr(SourceInfo);
44803#endif
44804#ifdef GET_LINK_IMPL
44805bool ByteCodeEmitter::emitRVOPtr(SourceInfo L) {
44806 return emitOp<>(OP_RVOPtr, L);
44807}
44808#endif
44809#ifdef GET_EVAL_IMPL
44810bool EvalEmitter::emitRVOPtr(SourceInfo L) {
44811 if (!isActive()) return true;
44812 CurrentSource = L;
44813 return RVOPtr(S);
44814}
44815#endif
44816#ifdef GET_OPCODE_NAMES
44817OP_ReflectValue,
44818#endif
44819#ifdef GET_INTERPFN_LIST
44820&Interp_ReflectValue,
44821#endif
44822#ifdef GET_INTERPFN_DISPATCHERS
44823PRESERVE_NONE
44824static bool Interp_ReflectValue(InterpState &S) {
44825 {
44826 CodePtr OpPC = S.PC;
44827 const auto V0 = ReadArg<ReflectionKind>(S, S.PC);
44828 const auto V1 = ReadArg<const void *>(S, S.PC);
44829 if (!ReflectValue(S, OpPC, V0, V1)) return false;
44830 }
44831#if USE_TAILCALLS
44832 MUSTTAIL return InterpNext(S);
44833#else
44834 return true;
44835#endif
44836}
44837#endif
44838#ifdef GET_DISASM
44839case OP_ReflectValue:
44840 Text.Op = PrintName("ReflectValue");
44841 Text.Args.push_back(printArg<ReflectionKind>(PC));
44842 Text.Args.push_back(printArg<const void *>(PC));
44843 break;
44844#endif
44845#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
44846bool emitReflectValue( ReflectionKind , const void * , SourceInfo);
44847#endif
44848#ifdef GET_LINK_IMPL
44849bool ByteCodeEmitter::emitReflectValue( ReflectionKind A0, const void * A1, SourceInfo L) {
44850 return emitOp<ReflectionKind, const void *>(OP_ReflectValue, A0, A1, L);
44851}
44852#endif
44853#ifdef GET_EVAL_IMPL
44854bool EvalEmitter::emitReflectValue( ReflectionKind A0, const void * A1, SourceInfo L) {
44855 if (!isActive()) return true;
44856 CurrentSource = L;
44857 return ReflectValue(S, CodePtr(), A0, A1);
44858}
44859#endif
44860#ifdef GET_OPCODE_NAMES
44861OP_RemSint8,
44862OP_RemUint8,
44863OP_RemSint16,
44864OP_RemUint16,
44865OP_RemSint32,
44866OP_RemUint32,
44867OP_RemSint64,
44868OP_RemUint64,
44869OP_RemIntAP,
44870OP_RemIntAPS,
44871OP_RemFixedPoint,
44872#endif
44873#ifdef GET_INTERPFN_LIST
44874&Interp_RemSint8,
44875&Interp_RemUint8,
44876&Interp_RemSint16,
44877&Interp_RemUint16,
44878&Interp_RemSint32,
44879&Interp_RemUint32,
44880&Interp_RemSint64,
44881&Interp_RemUint64,
44882&Interp_RemIntAP,
44883&Interp_RemIntAPS,
44884&Interp_RemFixedPoint,
44885#endif
44886#ifdef GET_INTERPFN_DISPATCHERS
44887PRESERVE_NONE
44888static bool Interp_RemSint8(InterpState &S) {
44889 if (!Rem<PT_Sint8>(S, S.PC)) return false;
44890#if USE_TAILCALLS
44891 MUSTTAIL return InterpNext(S);
44892#else
44893 return true;
44894#endif
44895}
44896PRESERVE_NONE
44897static bool Interp_RemUint8(InterpState &S) {
44898 if (!Rem<PT_Uint8>(S, S.PC)) return false;
44899#if USE_TAILCALLS
44900 MUSTTAIL return InterpNext(S);
44901#else
44902 return true;
44903#endif
44904}
44905PRESERVE_NONE
44906static bool Interp_RemSint16(InterpState &S) {
44907 if (!Rem<PT_Sint16>(S, S.PC)) return false;
44908#if USE_TAILCALLS
44909 MUSTTAIL return InterpNext(S);
44910#else
44911 return true;
44912#endif
44913}
44914PRESERVE_NONE
44915static bool Interp_RemUint16(InterpState &S) {
44916 if (!Rem<PT_Uint16>(S, S.PC)) return false;
44917#if USE_TAILCALLS
44918 MUSTTAIL return InterpNext(S);
44919#else
44920 return true;
44921#endif
44922}
44923PRESERVE_NONE
44924static bool Interp_RemSint32(InterpState &S) {
44925 if (!Rem<PT_Sint32>(S, S.PC)) return false;
44926#if USE_TAILCALLS
44927 MUSTTAIL return InterpNext(S);
44928#else
44929 return true;
44930#endif
44931}
44932PRESERVE_NONE
44933static bool Interp_RemUint32(InterpState &S) {
44934 if (!Rem<PT_Uint32>(S, S.PC)) return false;
44935#if USE_TAILCALLS
44936 MUSTTAIL return InterpNext(S);
44937#else
44938 return true;
44939#endif
44940}
44941PRESERVE_NONE
44942static bool Interp_RemSint64(InterpState &S) {
44943 if (!Rem<PT_Sint64>(S, S.PC)) return false;
44944#if USE_TAILCALLS
44945 MUSTTAIL return InterpNext(S);
44946#else
44947 return true;
44948#endif
44949}
44950PRESERVE_NONE
44951static bool Interp_RemUint64(InterpState &S) {
44952 if (!Rem<PT_Uint64>(S, S.PC)) return false;
44953#if USE_TAILCALLS
44954 MUSTTAIL return InterpNext(S);
44955#else
44956 return true;
44957#endif
44958}
44959PRESERVE_NONE
44960static bool Interp_RemIntAP(InterpState &S) {
44961 if (!Rem<PT_IntAP>(S, S.PC)) return false;
44962#if USE_TAILCALLS
44963 MUSTTAIL return InterpNext(S);
44964#else
44965 return true;
44966#endif
44967}
44968PRESERVE_NONE
44969static bool Interp_RemIntAPS(InterpState &S) {
44970 if (!Rem<PT_IntAPS>(S, S.PC)) return false;
44971#if USE_TAILCALLS
44972 MUSTTAIL return InterpNext(S);
44973#else
44974 return true;
44975#endif
44976}
44977PRESERVE_NONE
44978static bool Interp_RemFixedPoint(InterpState &S) {
44979 if (!Rem<PT_FixedPoint>(S, S.PC)) return false;
44980#if USE_TAILCALLS
44981 MUSTTAIL return InterpNext(S);
44982#else
44983 return true;
44984#endif
44985}
44986#endif
44987#ifdef GET_DISASM
44988case OP_RemSint8:
44989 Text.Op = PrintName("RemSint8");
44990 break;
44991case OP_RemUint8:
44992 Text.Op = PrintName("RemUint8");
44993 break;
44994case OP_RemSint16:
44995 Text.Op = PrintName("RemSint16");
44996 break;
44997case OP_RemUint16:
44998 Text.Op = PrintName("RemUint16");
44999 break;
45000case OP_RemSint32:
45001 Text.Op = PrintName("RemSint32");
45002 break;
45003case OP_RemUint32:
45004 Text.Op = PrintName("RemUint32");
45005 break;
45006case OP_RemSint64:
45007 Text.Op = PrintName("RemSint64");
45008 break;
45009case OP_RemUint64:
45010 Text.Op = PrintName("RemUint64");
45011 break;
45012case OP_RemIntAP:
45013 Text.Op = PrintName("RemIntAP");
45014 break;
45015case OP_RemIntAPS:
45016 Text.Op = PrintName("RemIntAPS");
45017 break;
45018case OP_RemFixedPoint:
45019 Text.Op = PrintName("RemFixedPoint");
45020 break;
45021#endif
45022#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
45023bool emitRemSint8(SourceInfo);
45024bool emitRemUint8(SourceInfo);
45025bool emitRemSint16(SourceInfo);
45026bool emitRemUint16(SourceInfo);
45027bool emitRemSint32(SourceInfo);
45028bool emitRemUint32(SourceInfo);
45029bool emitRemSint64(SourceInfo);
45030bool emitRemUint64(SourceInfo);
45031bool emitRemIntAP(SourceInfo);
45032bool emitRemIntAPS(SourceInfo);
45033bool emitRemFixedPoint(SourceInfo);
45034#endif
45035#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
45036[[nodiscard]] bool emitRem(PrimType, SourceInfo I);
45037#endif
45038#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
45039bool
45040#if defined(GET_EVAL_IMPL)
45041EvalEmitter
45042#else
45043ByteCodeEmitter
45044#endif
45045::emitRem(PrimType T0, SourceInfo I) {
45046 switch (T0) {
45047 case PT_Sint8:
45048 return emitRemSint8(I);
45049 case PT_Uint8:
45050 return emitRemUint8(I);
45051 case PT_Sint16:
45052 return emitRemSint16(I);
45053 case PT_Uint16:
45054 return emitRemUint16(I);
45055 case PT_Sint32:
45056 return emitRemSint32(I);
45057 case PT_Uint32:
45058 return emitRemUint32(I);
45059 case PT_Sint64:
45060 return emitRemSint64(I);
45061 case PT_Uint64:
45062 return emitRemUint64(I);
45063 case PT_IntAP:
45064 return emitRemIntAP(I);
45065 case PT_IntAPS:
45066 return emitRemIntAPS(I);
45067 case PT_FixedPoint:
45068 return emitRemFixedPoint(I);
45069 default: llvm_unreachable("invalid type: emitRem");
45070 }
45071 llvm_unreachable("invalid enum value");
45072}
45073#endif
45074#ifdef GET_LINK_IMPL
45075bool ByteCodeEmitter::emitRemSint8(SourceInfo L) {
45076 return emitOp<>(OP_RemSint8, L);
45077}
45078bool ByteCodeEmitter::emitRemUint8(SourceInfo L) {
45079 return emitOp<>(OP_RemUint8, L);
45080}
45081bool ByteCodeEmitter::emitRemSint16(SourceInfo L) {
45082 return emitOp<>(OP_RemSint16, L);
45083}
45084bool ByteCodeEmitter::emitRemUint16(SourceInfo L) {
45085 return emitOp<>(OP_RemUint16, L);
45086}
45087bool ByteCodeEmitter::emitRemSint32(SourceInfo L) {
45088 return emitOp<>(OP_RemSint32, L);
45089}
45090bool ByteCodeEmitter::emitRemUint32(SourceInfo L) {
45091 return emitOp<>(OP_RemUint32, L);
45092}
45093bool ByteCodeEmitter::emitRemSint64(SourceInfo L) {
45094 return emitOp<>(OP_RemSint64, L);
45095}
45096bool ByteCodeEmitter::emitRemUint64(SourceInfo L) {
45097 return emitOp<>(OP_RemUint64, L);
45098}
45099bool ByteCodeEmitter::emitRemIntAP(SourceInfo L) {
45100 return emitOp<>(OP_RemIntAP, L);
45101}
45102bool ByteCodeEmitter::emitRemIntAPS(SourceInfo L) {
45103 return emitOp<>(OP_RemIntAPS, L);
45104}
45105bool ByteCodeEmitter::emitRemFixedPoint(SourceInfo L) {
45106 return emitOp<>(OP_RemFixedPoint, L);
45107}
45108#endif
45109#ifdef GET_EVAL_IMPL
45110bool EvalEmitter::emitRemSint8(SourceInfo L) {
45111 if (!isActive()) return true;
45112 CurrentSource = L;
45113 return Rem<PT_Sint8>(S, CodePtr());
45114}
45115bool EvalEmitter::emitRemUint8(SourceInfo L) {
45116 if (!isActive()) return true;
45117 CurrentSource = L;
45118 return Rem<PT_Uint8>(S, CodePtr());
45119}
45120bool EvalEmitter::emitRemSint16(SourceInfo L) {
45121 if (!isActive()) return true;
45122 CurrentSource = L;
45123 return Rem<PT_Sint16>(S, CodePtr());
45124}
45125bool EvalEmitter::emitRemUint16(SourceInfo L) {
45126 if (!isActive()) return true;
45127 CurrentSource = L;
45128 return Rem<PT_Uint16>(S, CodePtr());
45129}
45130bool EvalEmitter::emitRemSint32(SourceInfo L) {
45131 if (!isActive()) return true;
45132 CurrentSource = L;
45133 return Rem<PT_Sint32>(S, CodePtr());
45134}
45135bool EvalEmitter::emitRemUint32(SourceInfo L) {
45136 if (!isActive()) return true;
45137 CurrentSource = L;
45138 return Rem<PT_Uint32>(S, CodePtr());
45139}
45140bool EvalEmitter::emitRemSint64(SourceInfo L) {
45141 if (!isActive()) return true;
45142 CurrentSource = L;
45143 return Rem<PT_Sint64>(S, CodePtr());
45144}
45145bool EvalEmitter::emitRemUint64(SourceInfo L) {
45146 if (!isActive()) return true;
45147 CurrentSource = L;
45148 return Rem<PT_Uint64>(S, CodePtr());
45149}
45150bool EvalEmitter::emitRemIntAP(SourceInfo L) {
45151 if (!isActive()) return true;
45152 CurrentSource = L;
45153 return Rem<PT_IntAP>(S, CodePtr());
45154}
45155bool EvalEmitter::emitRemIntAPS(SourceInfo L) {
45156 if (!isActive()) return true;
45157 CurrentSource = L;
45158 return Rem<PT_IntAPS>(S, CodePtr());
45159}
45160bool EvalEmitter::emitRemFixedPoint(SourceInfo L) {
45161 if (!isActive()) return true;
45162 CurrentSource = L;
45163 return Rem<PT_FixedPoint>(S, CodePtr());
45164}
45165#endif
45166#ifdef GET_OPCODE_NAMES
45167OP_RetSint8,
45168OP_RetUint8,
45169OP_RetSint16,
45170OP_RetUint16,
45171OP_RetSint32,
45172OP_RetUint32,
45173OP_RetSint64,
45174OP_RetUint64,
45175OP_RetIntAP,
45176OP_RetIntAPS,
45177OP_RetBool,
45178OP_RetFixedPoint,
45179OP_RetPtr,
45180OP_RetMemberPtr,
45181OP_RetFloat,
45182OP_RetReflect,
45183#endif
45184#ifdef GET_INTERPFN_LIST
45185&Interp_RetSint8,
45186&Interp_RetUint8,
45187&Interp_RetSint16,
45188&Interp_RetUint16,
45189&Interp_RetSint32,
45190&Interp_RetUint32,
45191&Interp_RetSint64,
45192&Interp_RetUint64,
45193&Interp_RetIntAP,
45194&Interp_RetIntAPS,
45195&Interp_RetBool,
45196&Interp_RetFixedPoint,
45197&Interp_RetPtr,
45198&Interp_RetMemberPtr,
45199&Interp_RetFloat,
45200&Interp_RetReflect,
45201#endif
45202#ifdef GET_INTERPFN_DISPATCHERS
45203PRESERVE_NONE
45204static bool Interp_RetSint8(InterpState &S) {
45205 MUSTTAIL return Ret<PT_Sint8>(S);
45206}
45207PRESERVE_NONE
45208static bool Interp_RetUint8(InterpState &S) {
45209 MUSTTAIL return Ret<PT_Uint8>(S);
45210}
45211PRESERVE_NONE
45212static bool Interp_RetSint16(InterpState &S) {
45213 MUSTTAIL return Ret<PT_Sint16>(S);
45214}
45215PRESERVE_NONE
45216static bool Interp_RetUint16(InterpState &S) {
45217 MUSTTAIL return Ret<PT_Uint16>(S);
45218}
45219PRESERVE_NONE
45220static bool Interp_RetSint32(InterpState &S) {
45221 MUSTTAIL return Ret<PT_Sint32>(S);
45222}
45223PRESERVE_NONE
45224static bool Interp_RetUint32(InterpState &S) {
45225 MUSTTAIL return Ret<PT_Uint32>(S);
45226}
45227PRESERVE_NONE
45228static bool Interp_RetSint64(InterpState &S) {
45229 MUSTTAIL return Ret<PT_Sint64>(S);
45230}
45231PRESERVE_NONE
45232static bool Interp_RetUint64(InterpState &S) {
45233 MUSTTAIL return Ret<PT_Uint64>(S);
45234}
45235PRESERVE_NONE
45236static bool Interp_RetIntAP(InterpState &S) {
45237 MUSTTAIL return Ret<PT_IntAP>(S);
45238}
45239PRESERVE_NONE
45240static bool Interp_RetIntAPS(InterpState &S) {
45241 MUSTTAIL return Ret<PT_IntAPS>(S);
45242}
45243PRESERVE_NONE
45244static bool Interp_RetBool(InterpState &S) {
45245 MUSTTAIL return Ret<PT_Bool>(S);
45246}
45247PRESERVE_NONE
45248static bool Interp_RetFixedPoint(InterpState &S) {
45249 MUSTTAIL return Ret<PT_FixedPoint>(S);
45250}
45251PRESERVE_NONE
45252static bool Interp_RetPtr(InterpState &S) {
45253 MUSTTAIL return Ret<PT_Ptr>(S);
45254}
45255PRESERVE_NONE
45256static bool Interp_RetMemberPtr(InterpState &S) {
45257 MUSTTAIL return Ret<PT_MemberPtr>(S);
45258}
45259PRESERVE_NONE
45260static bool Interp_RetFloat(InterpState &S) {
45261 MUSTTAIL return Ret<PT_Float>(S);
45262}
45263PRESERVE_NONE
45264static bool Interp_RetReflect(InterpState &S) {
45265 MUSTTAIL return Ret<PT_Reflect>(S);
45266}
45267#endif
45268#ifdef GET_DISASM
45269case OP_RetSint8:
45270 Text.Op = PrintName("RetSint8");
45271 break;
45272case OP_RetUint8:
45273 Text.Op = PrintName("RetUint8");
45274 break;
45275case OP_RetSint16:
45276 Text.Op = PrintName("RetSint16");
45277 break;
45278case OP_RetUint16:
45279 Text.Op = PrintName("RetUint16");
45280 break;
45281case OP_RetSint32:
45282 Text.Op = PrintName("RetSint32");
45283 break;
45284case OP_RetUint32:
45285 Text.Op = PrintName("RetUint32");
45286 break;
45287case OP_RetSint64:
45288 Text.Op = PrintName("RetSint64");
45289 break;
45290case OP_RetUint64:
45291 Text.Op = PrintName("RetUint64");
45292 break;
45293case OP_RetIntAP:
45294 Text.Op = PrintName("RetIntAP");
45295 break;
45296case OP_RetIntAPS:
45297 Text.Op = PrintName("RetIntAPS");
45298 break;
45299case OP_RetBool:
45300 Text.Op = PrintName("RetBool");
45301 break;
45302case OP_RetFixedPoint:
45303 Text.Op = PrintName("RetFixedPoint");
45304 break;
45305case OP_RetPtr:
45306 Text.Op = PrintName("RetPtr");
45307 break;
45308case OP_RetMemberPtr:
45309 Text.Op = PrintName("RetMemberPtr");
45310 break;
45311case OP_RetFloat:
45312 Text.Op = PrintName("RetFloat");
45313 break;
45314case OP_RetReflect:
45315 Text.Op = PrintName("RetReflect");
45316 break;
45317#endif
45318#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
45319bool emitRetSint8(SourceInfo);
45320bool emitRetUint8(SourceInfo);
45321bool emitRetSint16(SourceInfo);
45322bool emitRetUint16(SourceInfo);
45323bool emitRetSint32(SourceInfo);
45324bool emitRetUint32(SourceInfo);
45325bool emitRetSint64(SourceInfo);
45326bool emitRetUint64(SourceInfo);
45327bool emitRetIntAP(SourceInfo);
45328bool emitRetIntAPS(SourceInfo);
45329bool emitRetBool(SourceInfo);
45330bool emitRetFixedPoint(SourceInfo);
45331bool emitRetPtr(SourceInfo);
45332bool emitRetMemberPtr(SourceInfo);
45333bool emitRetFloat(SourceInfo);
45334bool emitRetReflect(SourceInfo);
45335#if defined(GET_EVAL_PROTO)
45336template<PrimType>
45337bool emitRet(SourceInfo);
45338#endif
45339#endif
45340#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
45341[[nodiscard]] bool emitRet(PrimType, SourceInfo I);
45342#endif
45343#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
45344bool
45345#if defined(GET_EVAL_IMPL)
45346EvalEmitter
45347#else
45348ByteCodeEmitter
45349#endif
45350::emitRet(PrimType T0, SourceInfo I) {
45351 switch (T0) {
45352 case PT_Sint8:
45353#ifdef GET_LINK_IMPL
45354 return emitRetSint8
45355#else
45356 return emitRet<PT_Sint8>
45357#endif
45358 (I);
45359 case PT_Uint8:
45360#ifdef GET_LINK_IMPL
45361 return emitRetUint8
45362#else
45363 return emitRet<PT_Uint8>
45364#endif
45365 (I);
45366 case PT_Sint16:
45367#ifdef GET_LINK_IMPL
45368 return emitRetSint16
45369#else
45370 return emitRet<PT_Sint16>
45371#endif
45372 (I);
45373 case PT_Uint16:
45374#ifdef GET_LINK_IMPL
45375 return emitRetUint16
45376#else
45377 return emitRet<PT_Uint16>
45378#endif
45379 (I);
45380 case PT_Sint32:
45381#ifdef GET_LINK_IMPL
45382 return emitRetSint32
45383#else
45384 return emitRet<PT_Sint32>
45385#endif
45386 (I);
45387 case PT_Uint32:
45388#ifdef GET_LINK_IMPL
45389 return emitRetUint32
45390#else
45391 return emitRet<PT_Uint32>
45392#endif
45393 (I);
45394 case PT_Sint64:
45395#ifdef GET_LINK_IMPL
45396 return emitRetSint64
45397#else
45398 return emitRet<PT_Sint64>
45399#endif
45400 (I);
45401 case PT_Uint64:
45402#ifdef GET_LINK_IMPL
45403 return emitRetUint64
45404#else
45405 return emitRet<PT_Uint64>
45406#endif
45407 (I);
45408 case PT_IntAP:
45409#ifdef GET_LINK_IMPL
45410 return emitRetIntAP
45411#else
45412 return emitRet<PT_IntAP>
45413#endif
45414 (I);
45415 case PT_IntAPS:
45416#ifdef GET_LINK_IMPL
45417 return emitRetIntAPS
45418#else
45419 return emitRet<PT_IntAPS>
45420#endif
45421 (I);
45422 case PT_Bool:
45423#ifdef GET_LINK_IMPL
45424 return emitRetBool
45425#else
45426 return emitRet<PT_Bool>
45427#endif
45428 (I);
45429 case PT_FixedPoint:
45430#ifdef GET_LINK_IMPL
45431 return emitRetFixedPoint
45432#else
45433 return emitRet<PT_FixedPoint>
45434#endif
45435 (I);
45436 case PT_Ptr:
45437#ifdef GET_LINK_IMPL
45438 return emitRetPtr
45439#else
45440 return emitRet<PT_Ptr>
45441#endif
45442 (I);
45443 case PT_MemberPtr:
45444#ifdef GET_LINK_IMPL
45445 return emitRetMemberPtr
45446#else
45447 return emitRet<PT_MemberPtr>
45448#endif
45449 (I);
45450 case PT_Float:
45451#ifdef GET_LINK_IMPL
45452 return emitRetFloat
45453#else
45454 return emitRet<PT_Float>
45455#endif
45456 (I);
45457 case PT_Reflect:
45458#ifdef GET_LINK_IMPL
45459 return emitRetReflect
45460#else
45461 return emitRet<PT_Reflect>
45462#endif
45463 (I);
45464 }
45465 llvm_unreachable("invalid enum value");
45466}
45467#endif
45468#ifdef GET_LINK_IMPL
45469bool ByteCodeEmitter::emitRetSint8(SourceInfo L) {
45470 return emitOp<>(OP_RetSint8, L);
45471}
45472bool ByteCodeEmitter::emitRetUint8(SourceInfo L) {
45473 return emitOp<>(OP_RetUint8, L);
45474}
45475bool ByteCodeEmitter::emitRetSint16(SourceInfo L) {
45476 return emitOp<>(OP_RetSint16, L);
45477}
45478bool ByteCodeEmitter::emitRetUint16(SourceInfo L) {
45479 return emitOp<>(OP_RetUint16, L);
45480}
45481bool ByteCodeEmitter::emitRetSint32(SourceInfo L) {
45482 return emitOp<>(OP_RetSint32, L);
45483}
45484bool ByteCodeEmitter::emitRetUint32(SourceInfo L) {
45485 return emitOp<>(OP_RetUint32, L);
45486}
45487bool ByteCodeEmitter::emitRetSint64(SourceInfo L) {
45488 return emitOp<>(OP_RetSint64, L);
45489}
45490bool ByteCodeEmitter::emitRetUint64(SourceInfo L) {
45491 return emitOp<>(OP_RetUint64, L);
45492}
45493bool ByteCodeEmitter::emitRetIntAP(SourceInfo L) {
45494 return emitOp<>(OP_RetIntAP, L);
45495}
45496bool ByteCodeEmitter::emitRetIntAPS(SourceInfo L) {
45497 return emitOp<>(OP_RetIntAPS, L);
45498}
45499bool ByteCodeEmitter::emitRetBool(SourceInfo L) {
45500 return emitOp<>(OP_RetBool, L);
45501}
45502bool ByteCodeEmitter::emitRetFixedPoint(SourceInfo L) {
45503 return emitOp<>(OP_RetFixedPoint, L);
45504}
45505bool ByteCodeEmitter::emitRetPtr(SourceInfo L) {
45506 return emitOp<>(OP_RetPtr, L);
45507}
45508bool ByteCodeEmitter::emitRetMemberPtr(SourceInfo L) {
45509 return emitOp<>(OP_RetMemberPtr, L);
45510}
45511bool ByteCodeEmitter::emitRetFloat(SourceInfo L) {
45512 return emitOp<>(OP_RetFloat, L);
45513}
45514bool ByteCodeEmitter::emitRetReflect(SourceInfo L) {
45515 return emitOp<>(OP_RetReflect, L);
45516}
45517#endif
45518#ifdef GET_OPCODE_NAMES
45519OP_RetValue,
45520#endif
45521#ifdef GET_INTERPFN_LIST
45522&Interp_RetValue,
45523#endif
45524#ifdef GET_INTERPFN_DISPATCHERS
45525PRESERVE_NONE
45526static bool Interp_RetValue(InterpState &S) {
45527 MUSTTAIL return RetValue(S);
45528}
45529#endif
45530#ifdef GET_DISASM
45531case OP_RetValue:
45532 Text.Op = PrintName("RetValue");
45533 break;
45534#endif
45535#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
45536bool emitRetValue(SourceInfo);
45537#endif
45538#ifdef GET_LINK_IMPL
45539bool ByteCodeEmitter::emitRetValue(SourceInfo L) {
45540 return emitOp<>(OP_RetValue, L);
45541}
45542#endif
45543#ifdef GET_OPCODE_NAMES
45544OP_RetVoid,
45545#endif
45546#ifdef GET_INTERPFN_LIST
45547&Interp_RetVoid,
45548#endif
45549#ifdef GET_INTERPFN_DISPATCHERS
45550PRESERVE_NONE
45551static bool Interp_RetVoid(InterpState &S) {
45552 MUSTTAIL return RetVoid(S);
45553}
45554#endif
45555#ifdef GET_DISASM
45556case OP_RetVoid:
45557 Text.Op = PrintName("RetVoid");
45558 break;
45559#endif
45560#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
45561bool emitRetVoid(SourceInfo);
45562#endif
45563#ifdef GET_LINK_IMPL
45564bool ByteCodeEmitter::emitRetVoid(SourceInfo L) {
45565 return emitOp<>(OP_RetVoid, L);
45566}
45567#endif
45568#ifdef GET_OPCODE_NAMES
45569OP_SetGlobalSint8,
45570OP_SetGlobalUint8,
45571OP_SetGlobalSint16,
45572OP_SetGlobalUint16,
45573OP_SetGlobalSint32,
45574OP_SetGlobalUint32,
45575OP_SetGlobalSint64,
45576OP_SetGlobalUint64,
45577OP_SetGlobalIntAP,
45578OP_SetGlobalIntAPS,
45579OP_SetGlobalBool,
45580OP_SetGlobalFixedPoint,
45581OP_SetGlobalPtr,
45582OP_SetGlobalMemberPtr,
45583OP_SetGlobalFloat,
45584OP_SetGlobalReflect,
45585#endif
45586#ifdef GET_INTERPFN_LIST
45587&Interp_SetGlobalSint8,
45588&Interp_SetGlobalUint8,
45589&Interp_SetGlobalSint16,
45590&Interp_SetGlobalUint16,
45591&Interp_SetGlobalSint32,
45592&Interp_SetGlobalUint32,
45593&Interp_SetGlobalSint64,
45594&Interp_SetGlobalUint64,
45595&Interp_SetGlobalIntAP,
45596&Interp_SetGlobalIntAPS,
45597&Interp_SetGlobalBool,
45598&Interp_SetGlobalFixedPoint,
45599&Interp_SetGlobalPtr,
45600&Interp_SetGlobalMemberPtr,
45601&Interp_SetGlobalFloat,
45602&Interp_SetGlobalReflect,
45603#endif
45604#ifdef GET_INTERPFN_DISPATCHERS
45605PRESERVE_NONE
45606static bool Interp_SetGlobalSint8(InterpState &S) {
45607 {
45608 CodePtr OpPC = S.PC;
45609 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45610 if (!SetGlobal<PT_Sint8>(S, OpPC, V0)) return false;
45611 }
45612#if USE_TAILCALLS
45613 MUSTTAIL return InterpNext(S);
45614#else
45615 return true;
45616#endif
45617}
45618PRESERVE_NONE
45619static bool Interp_SetGlobalUint8(InterpState &S) {
45620 {
45621 CodePtr OpPC = S.PC;
45622 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45623 if (!SetGlobal<PT_Uint8>(S, OpPC, V0)) return false;
45624 }
45625#if USE_TAILCALLS
45626 MUSTTAIL return InterpNext(S);
45627#else
45628 return true;
45629#endif
45630}
45631PRESERVE_NONE
45632static bool Interp_SetGlobalSint16(InterpState &S) {
45633 {
45634 CodePtr OpPC = S.PC;
45635 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45636 if (!SetGlobal<PT_Sint16>(S, OpPC, V0)) return false;
45637 }
45638#if USE_TAILCALLS
45639 MUSTTAIL return InterpNext(S);
45640#else
45641 return true;
45642#endif
45643}
45644PRESERVE_NONE
45645static bool Interp_SetGlobalUint16(InterpState &S) {
45646 {
45647 CodePtr OpPC = S.PC;
45648 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45649 if (!SetGlobal<PT_Uint16>(S, OpPC, V0)) return false;
45650 }
45651#if USE_TAILCALLS
45652 MUSTTAIL return InterpNext(S);
45653#else
45654 return true;
45655#endif
45656}
45657PRESERVE_NONE
45658static bool Interp_SetGlobalSint32(InterpState &S) {
45659 {
45660 CodePtr OpPC = S.PC;
45661 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45662 if (!SetGlobal<PT_Sint32>(S, OpPC, V0)) return false;
45663 }
45664#if USE_TAILCALLS
45665 MUSTTAIL return InterpNext(S);
45666#else
45667 return true;
45668#endif
45669}
45670PRESERVE_NONE
45671static bool Interp_SetGlobalUint32(InterpState &S) {
45672 {
45673 CodePtr OpPC = S.PC;
45674 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45675 if (!SetGlobal<PT_Uint32>(S, OpPC, V0)) return false;
45676 }
45677#if USE_TAILCALLS
45678 MUSTTAIL return InterpNext(S);
45679#else
45680 return true;
45681#endif
45682}
45683PRESERVE_NONE
45684static bool Interp_SetGlobalSint64(InterpState &S) {
45685 {
45686 CodePtr OpPC = S.PC;
45687 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45688 if (!SetGlobal<PT_Sint64>(S, OpPC, V0)) return false;
45689 }
45690#if USE_TAILCALLS
45691 MUSTTAIL return InterpNext(S);
45692#else
45693 return true;
45694#endif
45695}
45696PRESERVE_NONE
45697static bool Interp_SetGlobalUint64(InterpState &S) {
45698 {
45699 CodePtr OpPC = S.PC;
45700 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45701 if (!SetGlobal<PT_Uint64>(S, OpPC, V0)) return false;
45702 }
45703#if USE_TAILCALLS
45704 MUSTTAIL return InterpNext(S);
45705#else
45706 return true;
45707#endif
45708}
45709PRESERVE_NONE
45710static bool Interp_SetGlobalIntAP(InterpState &S) {
45711 {
45712 CodePtr OpPC = S.PC;
45713 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45714 if (!SetGlobal<PT_IntAP>(S, OpPC, V0)) return false;
45715 }
45716#if USE_TAILCALLS
45717 MUSTTAIL return InterpNext(S);
45718#else
45719 return true;
45720#endif
45721}
45722PRESERVE_NONE
45723static bool Interp_SetGlobalIntAPS(InterpState &S) {
45724 {
45725 CodePtr OpPC = S.PC;
45726 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45727 if (!SetGlobal<PT_IntAPS>(S, OpPC, V0)) return false;
45728 }
45729#if USE_TAILCALLS
45730 MUSTTAIL return InterpNext(S);
45731#else
45732 return true;
45733#endif
45734}
45735PRESERVE_NONE
45736static bool Interp_SetGlobalBool(InterpState &S) {
45737 {
45738 CodePtr OpPC = S.PC;
45739 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45740 if (!SetGlobal<PT_Bool>(S, OpPC, V0)) return false;
45741 }
45742#if USE_TAILCALLS
45743 MUSTTAIL return InterpNext(S);
45744#else
45745 return true;
45746#endif
45747}
45748PRESERVE_NONE
45749static bool Interp_SetGlobalFixedPoint(InterpState &S) {
45750 {
45751 CodePtr OpPC = S.PC;
45752 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45753 if (!SetGlobal<PT_FixedPoint>(S, OpPC, V0)) return false;
45754 }
45755#if USE_TAILCALLS
45756 MUSTTAIL return InterpNext(S);
45757#else
45758 return true;
45759#endif
45760}
45761PRESERVE_NONE
45762static bool Interp_SetGlobalPtr(InterpState &S) {
45763 {
45764 CodePtr OpPC = S.PC;
45765 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45766 if (!SetGlobal<PT_Ptr>(S, OpPC, V0)) return false;
45767 }
45768#if USE_TAILCALLS
45769 MUSTTAIL return InterpNext(S);
45770#else
45771 return true;
45772#endif
45773}
45774PRESERVE_NONE
45775static bool Interp_SetGlobalMemberPtr(InterpState &S) {
45776 {
45777 CodePtr OpPC = S.PC;
45778 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45779 if (!SetGlobal<PT_MemberPtr>(S, OpPC, V0)) return false;
45780 }
45781#if USE_TAILCALLS
45782 MUSTTAIL return InterpNext(S);
45783#else
45784 return true;
45785#endif
45786}
45787PRESERVE_NONE
45788static bool Interp_SetGlobalFloat(InterpState &S) {
45789 {
45790 CodePtr OpPC = S.PC;
45791 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45792 if (!SetGlobal<PT_Float>(S, OpPC, V0)) return false;
45793 }
45794#if USE_TAILCALLS
45795 MUSTTAIL return InterpNext(S);
45796#else
45797 return true;
45798#endif
45799}
45800PRESERVE_NONE
45801static bool Interp_SetGlobalReflect(InterpState &S) {
45802 {
45803 CodePtr OpPC = S.PC;
45804 const auto V0 = ReadArg<uint32_t>(S, S.PC);
45805 if (!SetGlobal<PT_Reflect>(S, OpPC, V0)) return false;
45806 }
45807#if USE_TAILCALLS
45808 MUSTTAIL return InterpNext(S);
45809#else
45810 return true;
45811#endif
45812}
45813#endif
45814#ifdef GET_DISASM
45815case OP_SetGlobalSint8:
45816 Text.Op = PrintName("SetGlobalSint8");
45817 Text.Args.push_back(printArg<uint32_t>(PC));
45818 break;
45819case OP_SetGlobalUint8:
45820 Text.Op = PrintName("SetGlobalUint8");
45821 Text.Args.push_back(printArg<uint32_t>(PC));
45822 break;
45823case OP_SetGlobalSint16:
45824 Text.Op = PrintName("SetGlobalSint16");
45825 Text.Args.push_back(printArg<uint32_t>(PC));
45826 break;
45827case OP_SetGlobalUint16:
45828 Text.Op = PrintName("SetGlobalUint16");
45829 Text.Args.push_back(printArg<uint32_t>(PC));
45830 break;
45831case OP_SetGlobalSint32:
45832 Text.Op = PrintName("SetGlobalSint32");
45833 Text.Args.push_back(printArg<uint32_t>(PC));
45834 break;
45835case OP_SetGlobalUint32:
45836 Text.Op = PrintName("SetGlobalUint32");
45837 Text.Args.push_back(printArg<uint32_t>(PC));
45838 break;
45839case OP_SetGlobalSint64:
45840 Text.Op = PrintName("SetGlobalSint64");
45841 Text.Args.push_back(printArg<uint32_t>(PC));
45842 break;
45843case OP_SetGlobalUint64:
45844 Text.Op = PrintName("SetGlobalUint64");
45845 Text.Args.push_back(printArg<uint32_t>(PC));
45846 break;
45847case OP_SetGlobalIntAP:
45848 Text.Op = PrintName("SetGlobalIntAP");
45849 Text.Args.push_back(printArg<uint32_t>(PC));
45850 break;
45851case OP_SetGlobalIntAPS:
45852 Text.Op = PrintName("SetGlobalIntAPS");
45853 Text.Args.push_back(printArg<uint32_t>(PC));
45854 break;
45855case OP_SetGlobalBool:
45856 Text.Op = PrintName("SetGlobalBool");
45857 Text.Args.push_back(printArg<uint32_t>(PC));
45858 break;
45859case OP_SetGlobalFixedPoint:
45860 Text.Op = PrintName("SetGlobalFixedPoint");
45861 Text.Args.push_back(printArg<uint32_t>(PC));
45862 break;
45863case OP_SetGlobalPtr:
45864 Text.Op = PrintName("SetGlobalPtr");
45865 Text.Args.push_back(printArg<uint32_t>(PC));
45866 break;
45867case OP_SetGlobalMemberPtr:
45868 Text.Op = PrintName("SetGlobalMemberPtr");
45869 Text.Args.push_back(printArg<uint32_t>(PC));
45870 break;
45871case OP_SetGlobalFloat:
45872 Text.Op = PrintName("SetGlobalFloat");
45873 Text.Args.push_back(printArg<uint32_t>(PC));
45874 break;
45875case OP_SetGlobalReflect:
45876 Text.Op = PrintName("SetGlobalReflect");
45877 Text.Args.push_back(printArg<uint32_t>(PC));
45878 break;
45879#endif
45880#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
45881bool emitSetGlobalSint8( uint32_t , SourceInfo);
45882bool emitSetGlobalUint8( uint32_t , SourceInfo);
45883bool emitSetGlobalSint16( uint32_t , SourceInfo);
45884bool emitSetGlobalUint16( uint32_t , SourceInfo);
45885bool emitSetGlobalSint32( uint32_t , SourceInfo);
45886bool emitSetGlobalUint32( uint32_t , SourceInfo);
45887bool emitSetGlobalSint64( uint32_t , SourceInfo);
45888bool emitSetGlobalUint64( uint32_t , SourceInfo);
45889bool emitSetGlobalIntAP( uint32_t , SourceInfo);
45890bool emitSetGlobalIntAPS( uint32_t , SourceInfo);
45891bool emitSetGlobalBool( uint32_t , SourceInfo);
45892bool emitSetGlobalFixedPoint( uint32_t , SourceInfo);
45893bool emitSetGlobalPtr( uint32_t , SourceInfo);
45894bool emitSetGlobalMemberPtr( uint32_t , SourceInfo);
45895bool emitSetGlobalFloat( uint32_t , SourceInfo);
45896bool emitSetGlobalReflect( uint32_t , SourceInfo);
45897#endif
45898#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
45899[[nodiscard]] bool emitSetGlobal(PrimType, uint32_t, SourceInfo I);
45900#endif
45901#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
45902bool
45903#if defined(GET_EVAL_IMPL)
45904EvalEmitter
45905#else
45906ByteCodeEmitter
45907#endif
45908::emitSetGlobal(PrimType T0, uint32_t A0, SourceInfo I) {
45909 switch (T0) {
45910 case PT_Sint8:
45911 return emitSetGlobalSint8(A0, I);
45912 case PT_Uint8:
45913 return emitSetGlobalUint8(A0, I);
45914 case PT_Sint16:
45915 return emitSetGlobalSint16(A0, I);
45916 case PT_Uint16:
45917 return emitSetGlobalUint16(A0, I);
45918 case PT_Sint32:
45919 return emitSetGlobalSint32(A0, I);
45920 case PT_Uint32:
45921 return emitSetGlobalUint32(A0, I);
45922 case PT_Sint64:
45923 return emitSetGlobalSint64(A0, I);
45924 case PT_Uint64:
45925 return emitSetGlobalUint64(A0, I);
45926 case PT_IntAP:
45927 return emitSetGlobalIntAP(A0, I);
45928 case PT_IntAPS:
45929 return emitSetGlobalIntAPS(A0, I);
45930 case PT_Bool:
45931 return emitSetGlobalBool(A0, I);
45932 case PT_FixedPoint:
45933 return emitSetGlobalFixedPoint(A0, I);
45934 case PT_Ptr:
45935 return emitSetGlobalPtr(A0, I);
45936 case PT_MemberPtr:
45937 return emitSetGlobalMemberPtr(A0, I);
45938 case PT_Float:
45939 return emitSetGlobalFloat(A0, I);
45940 case PT_Reflect:
45941 return emitSetGlobalReflect(A0, I);
45942 }
45943 llvm_unreachable("invalid enum value");
45944}
45945#endif
45946#ifdef GET_LINK_IMPL
45947bool ByteCodeEmitter::emitSetGlobalSint8( uint32_t A0, SourceInfo L) {
45948 return emitOp<uint32_t>(OP_SetGlobalSint8, A0, L);
45949}
45950bool ByteCodeEmitter::emitSetGlobalUint8( uint32_t A0, SourceInfo L) {
45951 return emitOp<uint32_t>(OP_SetGlobalUint8, A0, L);
45952}
45953bool ByteCodeEmitter::emitSetGlobalSint16( uint32_t A0, SourceInfo L) {
45954 return emitOp<uint32_t>(OP_SetGlobalSint16, A0, L);
45955}
45956bool ByteCodeEmitter::emitSetGlobalUint16( uint32_t A0, SourceInfo L) {
45957 return emitOp<uint32_t>(OP_SetGlobalUint16, A0, L);
45958}
45959bool ByteCodeEmitter::emitSetGlobalSint32( uint32_t A0, SourceInfo L) {
45960 return emitOp<uint32_t>(OP_SetGlobalSint32, A0, L);
45961}
45962bool ByteCodeEmitter::emitSetGlobalUint32( uint32_t A0, SourceInfo L) {
45963 return emitOp<uint32_t>(OP_SetGlobalUint32, A0, L);
45964}
45965bool ByteCodeEmitter::emitSetGlobalSint64( uint32_t A0, SourceInfo L) {
45966 return emitOp<uint32_t>(OP_SetGlobalSint64, A0, L);
45967}
45968bool ByteCodeEmitter::emitSetGlobalUint64( uint32_t A0, SourceInfo L) {
45969 return emitOp<uint32_t>(OP_SetGlobalUint64, A0, L);
45970}
45971bool ByteCodeEmitter::emitSetGlobalIntAP( uint32_t A0, SourceInfo L) {
45972 return emitOp<uint32_t>(OP_SetGlobalIntAP, A0, L);
45973}
45974bool ByteCodeEmitter::emitSetGlobalIntAPS( uint32_t A0, SourceInfo L) {
45975 return emitOp<uint32_t>(OP_SetGlobalIntAPS, A0, L);
45976}
45977bool ByteCodeEmitter::emitSetGlobalBool( uint32_t A0, SourceInfo L) {
45978 return emitOp<uint32_t>(OP_SetGlobalBool, A0, L);
45979}
45980bool ByteCodeEmitter::emitSetGlobalFixedPoint( uint32_t A0, SourceInfo L) {
45981 return emitOp<uint32_t>(OP_SetGlobalFixedPoint, A0, L);
45982}
45983bool ByteCodeEmitter::emitSetGlobalPtr( uint32_t A0, SourceInfo L) {
45984 return emitOp<uint32_t>(OP_SetGlobalPtr, A0, L);
45985}
45986bool ByteCodeEmitter::emitSetGlobalMemberPtr( uint32_t A0, SourceInfo L) {
45987 return emitOp<uint32_t>(OP_SetGlobalMemberPtr, A0, L);
45988}
45989bool ByteCodeEmitter::emitSetGlobalFloat( uint32_t A0, SourceInfo L) {
45990 return emitOp<uint32_t>(OP_SetGlobalFloat, A0, L);
45991}
45992bool ByteCodeEmitter::emitSetGlobalReflect( uint32_t A0, SourceInfo L) {
45993 return emitOp<uint32_t>(OP_SetGlobalReflect, A0, L);
45994}
45995#endif
45996#ifdef GET_EVAL_IMPL
45997bool EvalEmitter::emitSetGlobalSint8( uint32_t A0, SourceInfo L) {
45998 if (!isActive()) return true;
45999 CurrentSource = L;
46000 return SetGlobal<PT_Sint8>(S, CodePtr(), A0);
46001}
46002bool EvalEmitter::emitSetGlobalUint8( uint32_t A0, SourceInfo L) {
46003 if (!isActive()) return true;
46004 CurrentSource = L;
46005 return SetGlobal<PT_Uint8>(S, CodePtr(), A0);
46006}
46007bool EvalEmitter::emitSetGlobalSint16( uint32_t A0, SourceInfo L) {
46008 if (!isActive()) return true;
46009 CurrentSource = L;
46010 return SetGlobal<PT_Sint16>(S, CodePtr(), A0);
46011}
46012bool EvalEmitter::emitSetGlobalUint16( uint32_t A0, SourceInfo L) {
46013 if (!isActive()) return true;
46014 CurrentSource = L;
46015 return SetGlobal<PT_Uint16>(S, CodePtr(), A0);
46016}
46017bool EvalEmitter::emitSetGlobalSint32( uint32_t A0, SourceInfo L) {
46018 if (!isActive()) return true;
46019 CurrentSource = L;
46020 return SetGlobal<PT_Sint32>(S, CodePtr(), A0);
46021}
46022bool EvalEmitter::emitSetGlobalUint32( uint32_t A0, SourceInfo L) {
46023 if (!isActive()) return true;
46024 CurrentSource = L;
46025 return SetGlobal<PT_Uint32>(S, CodePtr(), A0);
46026}
46027bool EvalEmitter::emitSetGlobalSint64( uint32_t A0, SourceInfo L) {
46028 if (!isActive()) return true;
46029 CurrentSource = L;
46030 return SetGlobal<PT_Sint64>(S, CodePtr(), A0);
46031}
46032bool EvalEmitter::emitSetGlobalUint64( uint32_t A0, SourceInfo L) {
46033 if (!isActive()) return true;
46034 CurrentSource = L;
46035 return SetGlobal<PT_Uint64>(S, CodePtr(), A0);
46036}
46037bool EvalEmitter::emitSetGlobalIntAP( uint32_t A0, SourceInfo L) {
46038 if (!isActive()) return true;
46039 CurrentSource = L;
46040 return SetGlobal<PT_IntAP>(S, CodePtr(), A0);
46041}
46042bool EvalEmitter::emitSetGlobalIntAPS( uint32_t A0, SourceInfo L) {
46043 if (!isActive()) return true;
46044 CurrentSource = L;
46045 return SetGlobal<PT_IntAPS>(S, CodePtr(), A0);
46046}
46047bool EvalEmitter::emitSetGlobalBool( uint32_t A0, SourceInfo L) {
46048 if (!isActive()) return true;
46049 CurrentSource = L;
46050 return SetGlobal<PT_Bool>(S, CodePtr(), A0);
46051}
46052bool EvalEmitter::emitSetGlobalFixedPoint( uint32_t A0, SourceInfo L) {
46053 if (!isActive()) return true;
46054 CurrentSource = L;
46055 return SetGlobal<PT_FixedPoint>(S, CodePtr(), A0);
46056}
46057bool EvalEmitter::emitSetGlobalPtr( uint32_t A0, SourceInfo L) {
46058 if (!isActive()) return true;
46059 CurrentSource = L;
46060 return SetGlobal<PT_Ptr>(S, CodePtr(), A0);
46061}
46062bool EvalEmitter::emitSetGlobalMemberPtr( uint32_t A0, SourceInfo L) {
46063 if (!isActive()) return true;
46064 CurrentSource = L;
46065 return SetGlobal<PT_MemberPtr>(S, CodePtr(), A0);
46066}
46067bool EvalEmitter::emitSetGlobalFloat( uint32_t A0, SourceInfo L) {
46068 if (!isActive()) return true;
46069 CurrentSource = L;
46070 return SetGlobal<PT_Float>(S, CodePtr(), A0);
46071}
46072bool EvalEmitter::emitSetGlobalReflect( uint32_t A0, SourceInfo L) {
46073 if (!isActive()) return true;
46074 CurrentSource = L;
46075 return SetGlobal<PT_Reflect>(S, CodePtr(), A0);
46076}
46077#endif
46078#ifdef GET_OPCODE_NAMES
46079OP_SetLocalSint8,
46080OP_SetLocalUint8,
46081OP_SetLocalSint16,
46082OP_SetLocalUint16,
46083OP_SetLocalSint32,
46084OP_SetLocalUint32,
46085OP_SetLocalSint64,
46086OP_SetLocalUint64,
46087OP_SetLocalIntAP,
46088OP_SetLocalIntAPS,
46089OP_SetLocalBool,
46090OP_SetLocalFixedPoint,
46091OP_SetLocalPtr,
46092OP_SetLocalMemberPtr,
46093OP_SetLocalFloat,
46094OP_SetLocalReflect,
46095#endif
46096#ifdef GET_INTERPFN_LIST
46097&Interp_SetLocalSint8,
46098&Interp_SetLocalUint8,
46099&Interp_SetLocalSint16,
46100&Interp_SetLocalUint16,
46101&Interp_SetLocalSint32,
46102&Interp_SetLocalUint32,
46103&Interp_SetLocalSint64,
46104&Interp_SetLocalUint64,
46105&Interp_SetLocalIntAP,
46106&Interp_SetLocalIntAPS,
46107&Interp_SetLocalBool,
46108&Interp_SetLocalFixedPoint,
46109&Interp_SetLocalPtr,
46110&Interp_SetLocalMemberPtr,
46111&Interp_SetLocalFloat,
46112&Interp_SetLocalReflect,
46113#endif
46114#ifdef GET_INTERPFN_DISPATCHERS
46115PRESERVE_NONE
46116static bool Interp_SetLocalSint8(InterpState &S) {
46117 {
46118 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46119 SetLocal<PT_Sint8>(S, V0);
46120 }
46121#if USE_TAILCALLS
46122 MUSTTAIL return InterpNext(S);
46123#else
46124 return true;
46125#endif
46126}
46127PRESERVE_NONE
46128static bool Interp_SetLocalUint8(InterpState &S) {
46129 {
46130 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46131 SetLocal<PT_Uint8>(S, V0);
46132 }
46133#if USE_TAILCALLS
46134 MUSTTAIL return InterpNext(S);
46135#else
46136 return true;
46137#endif
46138}
46139PRESERVE_NONE
46140static bool Interp_SetLocalSint16(InterpState &S) {
46141 {
46142 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46143 SetLocal<PT_Sint16>(S, V0);
46144 }
46145#if USE_TAILCALLS
46146 MUSTTAIL return InterpNext(S);
46147#else
46148 return true;
46149#endif
46150}
46151PRESERVE_NONE
46152static bool Interp_SetLocalUint16(InterpState &S) {
46153 {
46154 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46155 SetLocal<PT_Uint16>(S, V0);
46156 }
46157#if USE_TAILCALLS
46158 MUSTTAIL return InterpNext(S);
46159#else
46160 return true;
46161#endif
46162}
46163PRESERVE_NONE
46164static bool Interp_SetLocalSint32(InterpState &S) {
46165 {
46166 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46167 SetLocal<PT_Sint32>(S, V0);
46168 }
46169#if USE_TAILCALLS
46170 MUSTTAIL return InterpNext(S);
46171#else
46172 return true;
46173#endif
46174}
46175PRESERVE_NONE
46176static bool Interp_SetLocalUint32(InterpState &S) {
46177 {
46178 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46179 SetLocal<PT_Uint32>(S, V0);
46180 }
46181#if USE_TAILCALLS
46182 MUSTTAIL return InterpNext(S);
46183#else
46184 return true;
46185#endif
46186}
46187PRESERVE_NONE
46188static bool Interp_SetLocalSint64(InterpState &S) {
46189 {
46190 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46191 SetLocal<PT_Sint64>(S, V0);
46192 }
46193#if USE_TAILCALLS
46194 MUSTTAIL return InterpNext(S);
46195#else
46196 return true;
46197#endif
46198}
46199PRESERVE_NONE
46200static bool Interp_SetLocalUint64(InterpState &S) {
46201 {
46202 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46203 SetLocal<PT_Uint64>(S, V0);
46204 }
46205#if USE_TAILCALLS
46206 MUSTTAIL return InterpNext(S);
46207#else
46208 return true;
46209#endif
46210}
46211PRESERVE_NONE
46212static bool Interp_SetLocalIntAP(InterpState &S) {
46213 {
46214 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46215 SetLocal<PT_IntAP>(S, V0);
46216 }
46217#if USE_TAILCALLS
46218 MUSTTAIL return InterpNext(S);
46219#else
46220 return true;
46221#endif
46222}
46223PRESERVE_NONE
46224static bool Interp_SetLocalIntAPS(InterpState &S) {
46225 {
46226 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46227 SetLocal<PT_IntAPS>(S, V0);
46228 }
46229#if USE_TAILCALLS
46230 MUSTTAIL return InterpNext(S);
46231#else
46232 return true;
46233#endif
46234}
46235PRESERVE_NONE
46236static bool Interp_SetLocalBool(InterpState &S) {
46237 {
46238 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46239 SetLocal<PT_Bool>(S, V0);
46240 }
46241#if USE_TAILCALLS
46242 MUSTTAIL return InterpNext(S);
46243#else
46244 return true;
46245#endif
46246}
46247PRESERVE_NONE
46248static bool Interp_SetLocalFixedPoint(InterpState &S) {
46249 {
46250 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46251 SetLocal<PT_FixedPoint>(S, V0);
46252 }
46253#if USE_TAILCALLS
46254 MUSTTAIL return InterpNext(S);
46255#else
46256 return true;
46257#endif
46258}
46259PRESERVE_NONE
46260static bool Interp_SetLocalPtr(InterpState &S) {
46261 {
46262 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46263 SetLocal<PT_Ptr>(S, V0);
46264 }
46265#if USE_TAILCALLS
46266 MUSTTAIL return InterpNext(S);
46267#else
46268 return true;
46269#endif
46270}
46271PRESERVE_NONE
46272static bool Interp_SetLocalMemberPtr(InterpState &S) {
46273 {
46274 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46275 SetLocal<PT_MemberPtr>(S, V0);
46276 }
46277#if USE_TAILCALLS
46278 MUSTTAIL return InterpNext(S);
46279#else
46280 return true;
46281#endif
46282}
46283PRESERVE_NONE
46284static bool Interp_SetLocalFloat(InterpState &S) {
46285 {
46286 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46287 SetLocal<PT_Float>(S, V0);
46288 }
46289#if USE_TAILCALLS
46290 MUSTTAIL return InterpNext(S);
46291#else
46292 return true;
46293#endif
46294}
46295PRESERVE_NONE
46296static bool Interp_SetLocalReflect(InterpState &S) {
46297 {
46298 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46299 SetLocal<PT_Reflect>(S, V0);
46300 }
46301#if USE_TAILCALLS
46302 MUSTTAIL return InterpNext(S);
46303#else
46304 return true;
46305#endif
46306}
46307#endif
46308#ifdef GET_DISASM
46309case OP_SetLocalSint8:
46310 Text.Op = PrintName("SetLocalSint8");
46311 Text.Args.push_back(printArg<uint32_t>(PC));
46312 break;
46313case OP_SetLocalUint8:
46314 Text.Op = PrintName("SetLocalUint8");
46315 Text.Args.push_back(printArg<uint32_t>(PC));
46316 break;
46317case OP_SetLocalSint16:
46318 Text.Op = PrintName("SetLocalSint16");
46319 Text.Args.push_back(printArg<uint32_t>(PC));
46320 break;
46321case OP_SetLocalUint16:
46322 Text.Op = PrintName("SetLocalUint16");
46323 Text.Args.push_back(printArg<uint32_t>(PC));
46324 break;
46325case OP_SetLocalSint32:
46326 Text.Op = PrintName("SetLocalSint32");
46327 Text.Args.push_back(printArg<uint32_t>(PC));
46328 break;
46329case OP_SetLocalUint32:
46330 Text.Op = PrintName("SetLocalUint32");
46331 Text.Args.push_back(printArg<uint32_t>(PC));
46332 break;
46333case OP_SetLocalSint64:
46334 Text.Op = PrintName("SetLocalSint64");
46335 Text.Args.push_back(printArg<uint32_t>(PC));
46336 break;
46337case OP_SetLocalUint64:
46338 Text.Op = PrintName("SetLocalUint64");
46339 Text.Args.push_back(printArg<uint32_t>(PC));
46340 break;
46341case OP_SetLocalIntAP:
46342 Text.Op = PrintName("SetLocalIntAP");
46343 Text.Args.push_back(printArg<uint32_t>(PC));
46344 break;
46345case OP_SetLocalIntAPS:
46346 Text.Op = PrintName("SetLocalIntAPS");
46347 Text.Args.push_back(printArg<uint32_t>(PC));
46348 break;
46349case OP_SetLocalBool:
46350 Text.Op = PrintName("SetLocalBool");
46351 Text.Args.push_back(printArg<uint32_t>(PC));
46352 break;
46353case OP_SetLocalFixedPoint:
46354 Text.Op = PrintName("SetLocalFixedPoint");
46355 Text.Args.push_back(printArg<uint32_t>(PC));
46356 break;
46357case OP_SetLocalPtr:
46358 Text.Op = PrintName("SetLocalPtr");
46359 Text.Args.push_back(printArg<uint32_t>(PC));
46360 break;
46361case OP_SetLocalMemberPtr:
46362 Text.Op = PrintName("SetLocalMemberPtr");
46363 Text.Args.push_back(printArg<uint32_t>(PC));
46364 break;
46365case OP_SetLocalFloat:
46366 Text.Op = PrintName("SetLocalFloat");
46367 Text.Args.push_back(printArg<uint32_t>(PC));
46368 break;
46369case OP_SetLocalReflect:
46370 Text.Op = PrintName("SetLocalReflect");
46371 Text.Args.push_back(printArg<uint32_t>(PC));
46372 break;
46373#endif
46374#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
46375bool emitSetLocalSint8( uint32_t , SourceInfo);
46376bool emitSetLocalUint8( uint32_t , SourceInfo);
46377bool emitSetLocalSint16( uint32_t , SourceInfo);
46378bool emitSetLocalUint16( uint32_t , SourceInfo);
46379bool emitSetLocalSint32( uint32_t , SourceInfo);
46380bool emitSetLocalUint32( uint32_t , SourceInfo);
46381bool emitSetLocalSint64( uint32_t , SourceInfo);
46382bool emitSetLocalUint64( uint32_t , SourceInfo);
46383bool emitSetLocalIntAP( uint32_t , SourceInfo);
46384bool emitSetLocalIntAPS( uint32_t , SourceInfo);
46385bool emitSetLocalBool( uint32_t , SourceInfo);
46386bool emitSetLocalFixedPoint( uint32_t , SourceInfo);
46387bool emitSetLocalPtr( uint32_t , SourceInfo);
46388bool emitSetLocalMemberPtr( uint32_t , SourceInfo);
46389bool emitSetLocalFloat( uint32_t , SourceInfo);
46390bool emitSetLocalReflect( uint32_t , SourceInfo);
46391#if defined(GET_EVAL_PROTO)
46392template<PrimType>
46393bool emitSetLocal(uint32_t, SourceInfo);
46394#endif
46395#endif
46396#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
46397[[nodiscard]] bool emitSetLocal(PrimType, uint32_t, SourceInfo I);
46398#endif
46399#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
46400bool
46401#if defined(GET_EVAL_IMPL)
46402EvalEmitter
46403#else
46404ByteCodeEmitter
46405#endif
46406::emitSetLocal(PrimType T0, uint32_t A0, SourceInfo I) {
46407 switch (T0) {
46408 case PT_Sint8:
46409#ifdef GET_LINK_IMPL
46410 return emitSetLocalSint8
46411#else
46412 return emitSetLocal<PT_Sint8>
46413#endif
46414 (A0, I);
46415 case PT_Uint8:
46416#ifdef GET_LINK_IMPL
46417 return emitSetLocalUint8
46418#else
46419 return emitSetLocal<PT_Uint8>
46420#endif
46421 (A0, I);
46422 case PT_Sint16:
46423#ifdef GET_LINK_IMPL
46424 return emitSetLocalSint16
46425#else
46426 return emitSetLocal<PT_Sint16>
46427#endif
46428 (A0, I);
46429 case PT_Uint16:
46430#ifdef GET_LINK_IMPL
46431 return emitSetLocalUint16
46432#else
46433 return emitSetLocal<PT_Uint16>
46434#endif
46435 (A0, I);
46436 case PT_Sint32:
46437#ifdef GET_LINK_IMPL
46438 return emitSetLocalSint32
46439#else
46440 return emitSetLocal<PT_Sint32>
46441#endif
46442 (A0, I);
46443 case PT_Uint32:
46444#ifdef GET_LINK_IMPL
46445 return emitSetLocalUint32
46446#else
46447 return emitSetLocal<PT_Uint32>
46448#endif
46449 (A0, I);
46450 case PT_Sint64:
46451#ifdef GET_LINK_IMPL
46452 return emitSetLocalSint64
46453#else
46454 return emitSetLocal<PT_Sint64>
46455#endif
46456 (A0, I);
46457 case PT_Uint64:
46458#ifdef GET_LINK_IMPL
46459 return emitSetLocalUint64
46460#else
46461 return emitSetLocal<PT_Uint64>
46462#endif
46463 (A0, I);
46464 case PT_IntAP:
46465#ifdef GET_LINK_IMPL
46466 return emitSetLocalIntAP
46467#else
46468 return emitSetLocal<PT_IntAP>
46469#endif
46470 (A0, I);
46471 case PT_IntAPS:
46472#ifdef GET_LINK_IMPL
46473 return emitSetLocalIntAPS
46474#else
46475 return emitSetLocal<PT_IntAPS>
46476#endif
46477 (A0, I);
46478 case PT_Bool:
46479#ifdef GET_LINK_IMPL
46480 return emitSetLocalBool
46481#else
46482 return emitSetLocal<PT_Bool>
46483#endif
46484 (A0, I);
46485 case PT_FixedPoint:
46486#ifdef GET_LINK_IMPL
46487 return emitSetLocalFixedPoint
46488#else
46489 return emitSetLocal<PT_FixedPoint>
46490#endif
46491 (A0, I);
46492 case PT_Ptr:
46493#ifdef GET_LINK_IMPL
46494 return emitSetLocalPtr
46495#else
46496 return emitSetLocal<PT_Ptr>
46497#endif
46498 (A0, I);
46499 case PT_MemberPtr:
46500#ifdef GET_LINK_IMPL
46501 return emitSetLocalMemberPtr
46502#else
46503 return emitSetLocal<PT_MemberPtr>
46504#endif
46505 (A0, I);
46506 case PT_Float:
46507#ifdef GET_LINK_IMPL
46508 return emitSetLocalFloat
46509#else
46510 return emitSetLocal<PT_Float>
46511#endif
46512 (A0, I);
46513 case PT_Reflect:
46514#ifdef GET_LINK_IMPL
46515 return emitSetLocalReflect
46516#else
46517 return emitSetLocal<PT_Reflect>
46518#endif
46519 (A0, I);
46520 }
46521 llvm_unreachable("invalid enum value");
46522}
46523#endif
46524#ifdef GET_LINK_IMPL
46525bool ByteCodeEmitter::emitSetLocalSint8( uint32_t A0, SourceInfo L) {
46526 return emitOp<uint32_t>(OP_SetLocalSint8, A0, L);
46527}
46528bool ByteCodeEmitter::emitSetLocalUint8( uint32_t A0, SourceInfo L) {
46529 return emitOp<uint32_t>(OP_SetLocalUint8, A0, L);
46530}
46531bool ByteCodeEmitter::emitSetLocalSint16( uint32_t A0, SourceInfo L) {
46532 return emitOp<uint32_t>(OP_SetLocalSint16, A0, L);
46533}
46534bool ByteCodeEmitter::emitSetLocalUint16( uint32_t A0, SourceInfo L) {
46535 return emitOp<uint32_t>(OP_SetLocalUint16, A0, L);
46536}
46537bool ByteCodeEmitter::emitSetLocalSint32( uint32_t A0, SourceInfo L) {
46538 return emitOp<uint32_t>(OP_SetLocalSint32, A0, L);
46539}
46540bool ByteCodeEmitter::emitSetLocalUint32( uint32_t A0, SourceInfo L) {
46541 return emitOp<uint32_t>(OP_SetLocalUint32, A0, L);
46542}
46543bool ByteCodeEmitter::emitSetLocalSint64( uint32_t A0, SourceInfo L) {
46544 return emitOp<uint32_t>(OP_SetLocalSint64, A0, L);
46545}
46546bool ByteCodeEmitter::emitSetLocalUint64( uint32_t A0, SourceInfo L) {
46547 return emitOp<uint32_t>(OP_SetLocalUint64, A0, L);
46548}
46549bool ByteCodeEmitter::emitSetLocalIntAP( uint32_t A0, SourceInfo L) {
46550 return emitOp<uint32_t>(OP_SetLocalIntAP, A0, L);
46551}
46552bool ByteCodeEmitter::emitSetLocalIntAPS( uint32_t A0, SourceInfo L) {
46553 return emitOp<uint32_t>(OP_SetLocalIntAPS, A0, L);
46554}
46555bool ByteCodeEmitter::emitSetLocalBool( uint32_t A0, SourceInfo L) {
46556 return emitOp<uint32_t>(OP_SetLocalBool, A0, L);
46557}
46558bool ByteCodeEmitter::emitSetLocalFixedPoint( uint32_t A0, SourceInfo L) {
46559 return emitOp<uint32_t>(OP_SetLocalFixedPoint, A0, L);
46560}
46561bool ByteCodeEmitter::emitSetLocalPtr( uint32_t A0, SourceInfo L) {
46562 return emitOp<uint32_t>(OP_SetLocalPtr, A0, L);
46563}
46564bool ByteCodeEmitter::emitSetLocalMemberPtr( uint32_t A0, SourceInfo L) {
46565 return emitOp<uint32_t>(OP_SetLocalMemberPtr, A0, L);
46566}
46567bool ByteCodeEmitter::emitSetLocalFloat( uint32_t A0, SourceInfo L) {
46568 return emitOp<uint32_t>(OP_SetLocalFloat, A0, L);
46569}
46570bool ByteCodeEmitter::emitSetLocalReflect( uint32_t A0, SourceInfo L) {
46571 return emitOp<uint32_t>(OP_SetLocalReflect, A0, L);
46572}
46573#endif
46574#ifdef GET_OPCODE_NAMES
46575OP_SetParamSint8,
46576OP_SetParamUint8,
46577OP_SetParamSint16,
46578OP_SetParamUint16,
46579OP_SetParamSint32,
46580OP_SetParamUint32,
46581OP_SetParamSint64,
46582OP_SetParamUint64,
46583OP_SetParamIntAP,
46584OP_SetParamIntAPS,
46585OP_SetParamBool,
46586OP_SetParamFixedPoint,
46587OP_SetParamPtr,
46588OP_SetParamMemberPtr,
46589OP_SetParamFloat,
46590OP_SetParamReflect,
46591#endif
46592#ifdef GET_INTERPFN_LIST
46593&Interp_SetParamSint8,
46594&Interp_SetParamUint8,
46595&Interp_SetParamSint16,
46596&Interp_SetParamUint16,
46597&Interp_SetParamSint32,
46598&Interp_SetParamUint32,
46599&Interp_SetParamSint64,
46600&Interp_SetParamUint64,
46601&Interp_SetParamIntAP,
46602&Interp_SetParamIntAPS,
46603&Interp_SetParamBool,
46604&Interp_SetParamFixedPoint,
46605&Interp_SetParamPtr,
46606&Interp_SetParamMemberPtr,
46607&Interp_SetParamFloat,
46608&Interp_SetParamReflect,
46609#endif
46610#ifdef GET_INTERPFN_DISPATCHERS
46611PRESERVE_NONE
46612static bool Interp_SetParamSint8(InterpState &S) {
46613 {
46614 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46615 SetParam<PT_Sint8>(S, V0);
46616 }
46617#if USE_TAILCALLS
46618 MUSTTAIL return InterpNext(S);
46619#else
46620 return true;
46621#endif
46622}
46623PRESERVE_NONE
46624static bool Interp_SetParamUint8(InterpState &S) {
46625 {
46626 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46627 SetParam<PT_Uint8>(S, V0);
46628 }
46629#if USE_TAILCALLS
46630 MUSTTAIL return InterpNext(S);
46631#else
46632 return true;
46633#endif
46634}
46635PRESERVE_NONE
46636static bool Interp_SetParamSint16(InterpState &S) {
46637 {
46638 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46639 SetParam<PT_Sint16>(S, V0);
46640 }
46641#if USE_TAILCALLS
46642 MUSTTAIL return InterpNext(S);
46643#else
46644 return true;
46645#endif
46646}
46647PRESERVE_NONE
46648static bool Interp_SetParamUint16(InterpState &S) {
46649 {
46650 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46651 SetParam<PT_Uint16>(S, V0);
46652 }
46653#if USE_TAILCALLS
46654 MUSTTAIL return InterpNext(S);
46655#else
46656 return true;
46657#endif
46658}
46659PRESERVE_NONE
46660static bool Interp_SetParamSint32(InterpState &S) {
46661 {
46662 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46663 SetParam<PT_Sint32>(S, V0);
46664 }
46665#if USE_TAILCALLS
46666 MUSTTAIL return InterpNext(S);
46667#else
46668 return true;
46669#endif
46670}
46671PRESERVE_NONE
46672static bool Interp_SetParamUint32(InterpState &S) {
46673 {
46674 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46675 SetParam<PT_Uint32>(S, V0);
46676 }
46677#if USE_TAILCALLS
46678 MUSTTAIL return InterpNext(S);
46679#else
46680 return true;
46681#endif
46682}
46683PRESERVE_NONE
46684static bool Interp_SetParamSint64(InterpState &S) {
46685 {
46686 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46687 SetParam<PT_Sint64>(S, V0);
46688 }
46689#if USE_TAILCALLS
46690 MUSTTAIL return InterpNext(S);
46691#else
46692 return true;
46693#endif
46694}
46695PRESERVE_NONE
46696static bool Interp_SetParamUint64(InterpState &S) {
46697 {
46698 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46699 SetParam<PT_Uint64>(S, V0);
46700 }
46701#if USE_TAILCALLS
46702 MUSTTAIL return InterpNext(S);
46703#else
46704 return true;
46705#endif
46706}
46707PRESERVE_NONE
46708static bool Interp_SetParamIntAP(InterpState &S) {
46709 {
46710 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46711 SetParam<PT_IntAP>(S, V0);
46712 }
46713#if USE_TAILCALLS
46714 MUSTTAIL return InterpNext(S);
46715#else
46716 return true;
46717#endif
46718}
46719PRESERVE_NONE
46720static bool Interp_SetParamIntAPS(InterpState &S) {
46721 {
46722 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46723 SetParam<PT_IntAPS>(S, V0);
46724 }
46725#if USE_TAILCALLS
46726 MUSTTAIL return InterpNext(S);
46727#else
46728 return true;
46729#endif
46730}
46731PRESERVE_NONE
46732static bool Interp_SetParamBool(InterpState &S) {
46733 {
46734 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46735 SetParam<PT_Bool>(S, V0);
46736 }
46737#if USE_TAILCALLS
46738 MUSTTAIL return InterpNext(S);
46739#else
46740 return true;
46741#endif
46742}
46743PRESERVE_NONE
46744static bool Interp_SetParamFixedPoint(InterpState &S) {
46745 {
46746 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46747 SetParam<PT_FixedPoint>(S, V0);
46748 }
46749#if USE_TAILCALLS
46750 MUSTTAIL return InterpNext(S);
46751#else
46752 return true;
46753#endif
46754}
46755PRESERVE_NONE
46756static bool Interp_SetParamPtr(InterpState &S) {
46757 {
46758 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46759 SetParam<PT_Ptr>(S, V0);
46760 }
46761#if USE_TAILCALLS
46762 MUSTTAIL return InterpNext(S);
46763#else
46764 return true;
46765#endif
46766}
46767PRESERVE_NONE
46768static bool Interp_SetParamMemberPtr(InterpState &S) {
46769 {
46770 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46771 SetParam<PT_MemberPtr>(S, V0);
46772 }
46773#if USE_TAILCALLS
46774 MUSTTAIL return InterpNext(S);
46775#else
46776 return true;
46777#endif
46778}
46779PRESERVE_NONE
46780static bool Interp_SetParamFloat(InterpState &S) {
46781 {
46782 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46783 SetParam<PT_Float>(S, V0);
46784 }
46785#if USE_TAILCALLS
46786 MUSTTAIL return InterpNext(S);
46787#else
46788 return true;
46789#endif
46790}
46791PRESERVE_NONE
46792static bool Interp_SetParamReflect(InterpState &S) {
46793 {
46794 const auto V0 = ReadArg<uint32_t>(S, S.PC);
46795 SetParam<PT_Reflect>(S, V0);
46796 }
46797#if USE_TAILCALLS
46798 MUSTTAIL return InterpNext(S);
46799#else
46800 return true;
46801#endif
46802}
46803#endif
46804#ifdef GET_DISASM
46805case OP_SetParamSint8:
46806 Text.Op = PrintName("SetParamSint8");
46807 Text.Args.push_back(printArg<uint32_t>(PC));
46808 break;
46809case OP_SetParamUint8:
46810 Text.Op = PrintName("SetParamUint8");
46811 Text.Args.push_back(printArg<uint32_t>(PC));
46812 break;
46813case OP_SetParamSint16:
46814 Text.Op = PrintName("SetParamSint16");
46815 Text.Args.push_back(printArg<uint32_t>(PC));
46816 break;
46817case OP_SetParamUint16:
46818 Text.Op = PrintName("SetParamUint16");
46819 Text.Args.push_back(printArg<uint32_t>(PC));
46820 break;
46821case OP_SetParamSint32:
46822 Text.Op = PrintName("SetParamSint32");
46823 Text.Args.push_back(printArg<uint32_t>(PC));
46824 break;
46825case OP_SetParamUint32:
46826 Text.Op = PrintName("SetParamUint32");
46827 Text.Args.push_back(printArg<uint32_t>(PC));
46828 break;
46829case OP_SetParamSint64:
46830 Text.Op = PrintName("SetParamSint64");
46831 Text.Args.push_back(printArg<uint32_t>(PC));
46832 break;
46833case OP_SetParamUint64:
46834 Text.Op = PrintName("SetParamUint64");
46835 Text.Args.push_back(printArg<uint32_t>(PC));
46836 break;
46837case OP_SetParamIntAP:
46838 Text.Op = PrintName("SetParamIntAP");
46839 Text.Args.push_back(printArg<uint32_t>(PC));
46840 break;
46841case OP_SetParamIntAPS:
46842 Text.Op = PrintName("SetParamIntAPS");
46843 Text.Args.push_back(printArg<uint32_t>(PC));
46844 break;
46845case OP_SetParamBool:
46846 Text.Op = PrintName("SetParamBool");
46847 Text.Args.push_back(printArg<uint32_t>(PC));
46848 break;
46849case OP_SetParamFixedPoint:
46850 Text.Op = PrintName("SetParamFixedPoint");
46851 Text.Args.push_back(printArg<uint32_t>(PC));
46852 break;
46853case OP_SetParamPtr:
46854 Text.Op = PrintName("SetParamPtr");
46855 Text.Args.push_back(printArg<uint32_t>(PC));
46856 break;
46857case OP_SetParamMemberPtr:
46858 Text.Op = PrintName("SetParamMemberPtr");
46859 Text.Args.push_back(printArg<uint32_t>(PC));
46860 break;
46861case OP_SetParamFloat:
46862 Text.Op = PrintName("SetParamFloat");
46863 Text.Args.push_back(printArg<uint32_t>(PC));
46864 break;
46865case OP_SetParamReflect:
46866 Text.Op = PrintName("SetParamReflect");
46867 Text.Args.push_back(printArg<uint32_t>(PC));
46868 break;
46869#endif
46870#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
46871bool emitSetParamSint8( uint32_t , SourceInfo);
46872bool emitSetParamUint8( uint32_t , SourceInfo);
46873bool emitSetParamSint16( uint32_t , SourceInfo);
46874bool emitSetParamUint16( uint32_t , SourceInfo);
46875bool emitSetParamSint32( uint32_t , SourceInfo);
46876bool emitSetParamUint32( uint32_t , SourceInfo);
46877bool emitSetParamSint64( uint32_t , SourceInfo);
46878bool emitSetParamUint64( uint32_t , SourceInfo);
46879bool emitSetParamIntAP( uint32_t , SourceInfo);
46880bool emitSetParamIntAPS( uint32_t , SourceInfo);
46881bool emitSetParamBool( uint32_t , SourceInfo);
46882bool emitSetParamFixedPoint( uint32_t , SourceInfo);
46883bool emitSetParamPtr( uint32_t , SourceInfo);
46884bool emitSetParamMemberPtr( uint32_t , SourceInfo);
46885bool emitSetParamFloat( uint32_t , SourceInfo);
46886bool emitSetParamReflect( uint32_t , SourceInfo);
46887#endif
46888#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
46889[[nodiscard]] bool emitSetParam(PrimType, uint32_t, SourceInfo I);
46890#endif
46891#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
46892bool
46893#if defined(GET_EVAL_IMPL)
46894EvalEmitter
46895#else
46896ByteCodeEmitter
46897#endif
46898::emitSetParam(PrimType T0, uint32_t A0, SourceInfo I) {
46899 switch (T0) {
46900 case PT_Sint8:
46901 return emitSetParamSint8(A0, I);
46902 case PT_Uint8:
46903 return emitSetParamUint8(A0, I);
46904 case PT_Sint16:
46905 return emitSetParamSint16(A0, I);
46906 case PT_Uint16:
46907 return emitSetParamUint16(A0, I);
46908 case PT_Sint32:
46909 return emitSetParamSint32(A0, I);
46910 case PT_Uint32:
46911 return emitSetParamUint32(A0, I);
46912 case PT_Sint64:
46913 return emitSetParamSint64(A0, I);
46914 case PT_Uint64:
46915 return emitSetParamUint64(A0, I);
46916 case PT_IntAP:
46917 return emitSetParamIntAP(A0, I);
46918 case PT_IntAPS:
46919 return emitSetParamIntAPS(A0, I);
46920 case PT_Bool:
46921 return emitSetParamBool(A0, I);
46922 case PT_FixedPoint:
46923 return emitSetParamFixedPoint(A0, I);
46924 case PT_Ptr:
46925 return emitSetParamPtr(A0, I);
46926 case PT_MemberPtr:
46927 return emitSetParamMemberPtr(A0, I);
46928 case PT_Float:
46929 return emitSetParamFloat(A0, I);
46930 case PT_Reflect:
46931 return emitSetParamReflect(A0, I);
46932 }
46933 llvm_unreachable("invalid enum value");
46934}
46935#endif
46936#ifdef GET_LINK_IMPL
46937bool ByteCodeEmitter::emitSetParamSint8( uint32_t A0, SourceInfo L) {
46938 return emitOp<uint32_t>(OP_SetParamSint8, A0, L);
46939}
46940bool ByteCodeEmitter::emitSetParamUint8( uint32_t A0, SourceInfo L) {
46941 return emitOp<uint32_t>(OP_SetParamUint8, A0, L);
46942}
46943bool ByteCodeEmitter::emitSetParamSint16( uint32_t A0, SourceInfo L) {
46944 return emitOp<uint32_t>(OP_SetParamSint16, A0, L);
46945}
46946bool ByteCodeEmitter::emitSetParamUint16( uint32_t A0, SourceInfo L) {
46947 return emitOp<uint32_t>(OP_SetParamUint16, A0, L);
46948}
46949bool ByteCodeEmitter::emitSetParamSint32( uint32_t A0, SourceInfo L) {
46950 return emitOp<uint32_t>(OP_SetParamSint32, A0, L);
46951}
46952bool ByteCodeEmitter::emitSetParamUint32( uint32_t A0, SourceInfo L) {
46953 return emitOp<uint32_t>(OP_SetParamUint32, A0, L);
46954}
46955bool ByteCodeEmitter::emitSetParamSint64( uint32_t A0, SourceInfo L) {
46956 return emitOp<uint32_t>(OP_SetParamSint64, A0, L);
46957}
46958bool ByteCodeEmitter::emitSetParamUint64( uint32_t A0, SourceInfo L) {
46959 return emitOp<uint32_t>(OP_SetParamUint64, A0, L);
46960}
46961bool ByteCodeEmitter::emitSetParamIntAP( uint32_t A0, SourceInfo L) {
46962 return emitOp<uint32_t>(OP_SetParamIntAP, A0, L);
46963}
46964bool ByteCodeEmitter::emitSetParamIntAPS( uint32_t A0, SourceInfo L) {
46965 return emitOp<uint32_t>(OP_SetParamIntAPS, A0, L);
46966}
46967bool ByteCodeEmitter::emitSetParamBool( uint32_t A0, SourceInfo L) {
46968 return emitOp<uint32_t>(OP_SetParamBool, A0, L);
46969}
46970bool ByteCodeEmitter::emitSetParamFixedPoint( uint32_t A0, SourceInfo L) {
46971 return emitOp<uint32_t>(OP_SetParamFixedPoint, A0, L);
46972}
46973bool ByteCodeEmitter::emitSetParamPtr( uint32_t A0, SourceInfo L) {
46974 return emitOp<uint32_t>(OP_SetParamPtr, A0, L);
46975}
46976bool ByteCodeEmitter::emitSetParamMemberPtr( uint32_t A0, SourceInfo L) {
46977 return emitOp<uint32_t>(OP_SetParamMemberPtr, A0, L);
46978}
46979bool ByteCodeEmitter::emitSetParamFloat( uint32_t A0, SourceInfo L) {
46980 return emitOp<uint32_t>(OP_SetParamFloat, A0, L);
46981}
46982bool ByteCodeEmitter::emitSetParamReflect( uint32_t A0, SourceInfo L) {
46983 return emitOp<uint32_t>(OP_SetParamReflect, A0, L);
46984}
46985#endif
46986#ifdef GET_EVAL_IMPL
46987bool EvalEmitter::emitSetParamSint8( uint32_t A0, SourceInfo L) {
46988 if (!isActive()) return true;
46989 CurrentSource = L;
46990 return SetParam<PT_Sint8>(S, A0);
46991}
46992bool EvalEmitter::emitSetParamUint8( uint32_t A0, SourceInfo L) {
46993 if (!isActive()) return true;
46994 CurrentSource = L;
46995 return SetParam<PT_Uint8>(S, A0);
46996}
46997bool EvalEmitter::emitSetParamSint16( uint32_t A0, SourceInfo L) {
46998 if (!isActive()) return true;
46999 CurrentSource = L;
47000 return SetParam<PT_Sint16>(S, A0);
47001}
47002bool EvalEmitter::emitSetParamUint16( uint32_t A0, SourceInfo L) {
47003 if (!isActive()) return true;
47004 CurrentSource = L;
47005 return SetParam<PT_Uint16>(S, A0);
47006}
47007bool EvalEmitter::emitSetParamSint32( uint32_t A0, SourceInfo L) {
47008 if (!isActive()) return true;
47009 CurrentSource = L;
47010 return SetParam<PT_Sint32>(S, A0);
47011}
47012bool EvalEmitter::emitSetParamUint32( uint32_t A0, SourceInfo L) {
47013 if (!isActive()) return true;
47014 CurrentSource = L;
47015 return SetParam<PT_Uint32>(S, A0);
47016}
47017bool EvalEmitter::emitSetParamSint64( uint32_t A0, SourceInfo L) {
47018 if (!isActive()) return true;
47019 CurrentSource = L;
47020 return SetParam<PT_Sint64>(S, A0);
47021}
47022bool EvalEmitter::emitSetParamUint64( uint32_t A0, SourceInfo L) {
47023 if (!isActive()) return true;
47024 CurrentSource = L;
47025 return SetParam<PT_Uint64>(S, A0);
47026}
47027bool EvalEmitter::emitSetParamIntAP( uint32_t A0, SourceInfo L) {
47028 if (!isActive()) return true;
47029 CurrentSource = L;
47030 return SetParam<PT_IntAP>(S, A0);
47031}
47032bool EvalEmitter::emitSetParamIntAPS( uint32_t A0, SourceInfo L) {
47033 if (!isActive()) return true;
47034 CurrentSource = L;
47035 return SetParam<PT_IntAPS>(S, A0);
47036}
47037bool EvalEmitter::emitSetParamBool( uint32_t A0, SourceInfo L) {
47038 if (!isActive()) return true;
47039 CurrentSource = L;
47040 return SetParam<PT_Bool>(S, A0);
47041}
47042bool EvalEmitter::emitSetParamFixedPoint( uint32_t A0, SourceInfo L) {
47043 if (!isActive()) return true;
47044 CurrentSource = L;
47045 return SetParam<PT_FixedPoint>(S, A0);
47046}
47047bool EvalEmitter::emitSetParamPtr( uint32_t A0, SourceInfo L) {
47048 if (!isActive()) return true;
47049 CurrentSource = L;
47050 return SetParam<PT_Ptr>(S, A0);
47051}
47052bool EvalEmitter::emitSetParamMemberPtr( uint32_t A0, SourceInfo L) {
47053 if (!isActive()) return true;
47054 CurrentSource = L;
47055 return SetParam<PT_MemberPtr>(S, A0);
47056}
47057bool EvalEmitter::emitSetParamFloat( uint32_t A0, SourceInfo L) {
47058 if (!isActive()) return true;
47059 CurrentSource = L;
47060 return SetParam<PT_Float>(S, A0);
47061}
47062bool EvalEmitter::emitSetParamReflect( uint32_t A0, SourceInfo L) {
47063 if (!isActive()) return true;
47064 CurrentSource = L;
47065 return SetParam<PT_Reflect>(S, A0);
47066}
47067#endif
47068#ifdef GET_OPCODE_NAMES
47069OP_ShiftFixedPoint,
47070#endif
47071#ifdef GET_INTERPFN_LIST
47072&Interp_ShiftFixedPoint,
47073#endif
47074#ifdef GET_INTERPFN_DISPATCHERS
47075PRESERVE_NONE
47076static bool Interp_ShiftFixedPoint(InterpState &S) {
47077 {
47078 CodePtr OpPC = S.PC;
47079 const auto V0 = ReadArg<bool>(S, S.PC);
47080 if (!ShiftFixedPoint(S, OpPC, V0)) return false;
47081 }
47082#if USE_TAILCALLS
47083 MUSTTAIL return InterpNext(S);
47084#else
47085 return true;
47086#endif
47087}
47088#endif
47089#ifdef GET_DISASM
47090case OP_ShiftFixedPoint:
47091 Text.Op = PrintName("ShiftFixedPoint");
47092 Text.Args.push_back(printArg<bool>(PC));
47093 break;
47094#endif
47095#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
47096bool emitShiftFixedPoint( bool , SourceInfo);
47097#endif
47098#ifdef GET_LINK_IMPL
47099bool ByteCodeEmitter::emitShiftFixedPoint( bool A0, SourceInfo L) {
47100 return emitOp<bool>(OP_ShiftFixedPoint, A0, L);
47101}
47102#endif
47103#ifdef GET_EVAL_IMPL
47104bool EvalEmitter::emitShiftFixedPoint( bool A0, SourceInfo L) {
47105 if (!isActive()) return true;
47106 CurrentSource = L;
47107 return ShiftFixedPoint(S, CodePtr(), A0);
47108}
47109#endif
47110#ifdef GET_OPCODE_NAMES
47111OP_ShlSint8Sint8,
47112OP_ShlSint8Uint8,
47113OP_ShlSint8Sint16,
47114OP_ShlSint8Uint16,
47115OP_ShlSint8Sint32,
47116OP_ShlSint8Uint32,
47117OP_ShlSint8Sint64,
47118OP_ShlSint8Uint64,
47119OP_ShlSint8IntAP,
47120OP_ShlSint8IntAPS,
47121OP_ShlUint8Sint8,
47122OP_ShlUint8Uint8,
47123OP_ShlUint8Sint16,
47124OP_ShlUint8Uint16,
47125OP_ShlUint8Sint32,
47126OP_ShlUint8Uint32,
47127OP_ShlUint8Sint64,
47128OP_ShlUint8Uint64,
47129OP_ShlUint8IntAP,
47130OP_ShlUint8IntAPS,
47131OP_ShlSint16Sint8,
47132OP_ShlSint16Uint8,
47133OP_ShlSint16Sint16,
47134OP_ShlSint16Uint16,
47135OP_ShlSint16Sint32,
47136OP_ShlSint16Uint32,
47137OP_ShlSint16Sint64,
47138OP_ShlSint16Uint64,
47139OP_ShlSint16IntAP,
47140OP_ShlSint16IntAPS,
47141OP_ShlUint16Sint8,
47142OP_ShlUint16Uint8,
47143OP_ShlUint16Sint16,
47144OP_ShlUint16Uint16,
47145OP_ShlUint16Sint32,
47146OP_ShlUint16Uint32,
47147OP_ShlUint16Sint64,
47148OP_ShlUint16Uint64,
47149OP_ShlUint16IntAP,
47150OP_ShlUint16IntAPS,
47151OP_ShlSint32Sint8,
47152OP_ShlSint32Uint8,
47153OP_ShlSint32Sint16,
47154OP_ShlSint32Uint16,
47155OP_ShlSint32Sint32,
47156OP_ShlSint32Uint32,
47157OP_ShlSint32Sint64,
47158OP_ShlSint32Uint64,
47159OP_ShlSint32IntAP,
47160OP_ShlSint32IntAPS,
47161OP_ShlUint32Sint8,
47162OP_ShlUint32Uint8,
47163OP_ShlUint32Sint16,
47164OP_ShlUint32Uint16,
47165OP_ShlUint32Sint32,
47166OP_ShlUint32Uint32,
47167OP_ShlUint32Sint64,
47168OP_ShlUint32Uint64,
47169OP_ShlUint32IntAP,
47170OP_ShlUint32IntAPS,
47171OP_ShlSint64Sint8,
47172OP_ShlSint64Uint8,
47173OP_ShlSint64Sint16,
47174OP_ShlSint64Uint16,
47175OP_ShlSint64Sint32,
47176OP_ShlSint64Uint32,
47177OP_ShlSint64Sint64,
47178OP_ShlSint64Uint64,
47179OP_ShlSint64IntAP,
47180OP_ShlSint64IntAPS,
47181OP_ShlUint64Sint8,
47182OP_ShlUint64Uint8,
47183OP_ShlUint64Sint16,
47184OP_ShlUint64Uint16,
47185OP_ShlUint64Sint32,
47186OP_ShlUint64Uint32,
47187OP_ShlUint64Sint64,
47188OP_ShlUint64Uint64,
47189OP_ShlUint64IntAP,
47190OP_ShlUint64IntAPS,
47191OP_ShlIntAPSint8,
47192OP_ShlIntAPUint8,
47193OP_ShlIntAPSint16,
47194OP_ShlIntAPUint16,
47195OP_ShlIntAPSint32,
47196OP_ShlIntAPUint32,
47197OP_ShlIntAPSint64,
47198OP_ShlIntAPUint64,
47199OP_ShlIntAPIntAP,
47200OP_ShlIntAPIntAPS,
47201OP_ShlIntAPSSint8,
47202OP_ShlIntAPSUint8,
47203OP_ShlIntAPSSint16,
47204OP_ShlIntAPSUint16,
47205OP_ShlIntAPSSint32,
47206OP_ShlIntAPSUint32,
47207OP_ShlIntAPSSint64,
47208OP_ShlIntAPSUint64,
47209OP_ShlIntAPSIntAP,
47210OP_ShlIntAPSIntAPS,
47211#endif
47212#ifdef GET_INTERPFN_LIST
47213&Interp_ShlSint8Sint8,
47214&Interp_ShlSint8Uint8,
47215&Interp_ShlSint8Sint16,
47216&Interp_ShlSint8Uint16,
47217&Interp_ShlSint8Sint32,
47218&Interp_ShlSint8Uint32,
47219&Interp_ShlSint8Sint64,
47220&Interp_ShlSint8Uint64,
47221&Interp_ShlSint8IntAP,
47222&Interp_ShlSint8IntAPS,
47223&Interp_ShlUint8Sint8,
47224&Interp_ShlUint8Uint8,
47225&Interp_ShlUint8Sint16,
47226&Interp_ShlUint8Uint16,
47227&Interp_ShlUint8Sint32,
47228&Interp_ShlUint8Uint32,
47229&Interp_ShlUint8Sint64,
47230&Interp_ShlUint8Uint64,
47231&Interp_ShlUint8IntAP,
47232&Interp_ShlUint8IntAPS,
47233&Interp_ShlSint16Sint8,
47234&Interp_ShlSint16Uint8,
47235&Interp_ShlSint16Sint16,
47236&Interp_ShlSint16Uint16,
47237&Interp_ShlSint16Sint32,
47238&Interp_ShlSint16Uint32,
47239&Interp_ShlSint16Sint64,
47240&Interp_ShlSint16Uint64,
47241&Interp_ShlSint16IntAP,
47242&Interp_ShlSint16IntAPS,
47243&Interp_ShlUint16Sint8,
47244&Interp_ShlUint16Uint8,
47245&Interp_ShlUint16Sint16,
47246&Interp_ShlUint16Uint16,
47247&Interp_ShlUint16Sint32,
47248&Interp_ShlUint16Uint32,
47249&Interp_ShlUint16Sint64,
47250&Interp_ShlUint16Uint64,
47251&Interp_ShlUint16IntAP,
47252&Interp_ShlUint16IntAPS,
47253&Interp_ShlSint32Sint8,
47254&Interp_ShlSint32Uint8,
47255&Interp_ShlSint32Sint16,
47256&Interp_ShlSint32Uint16,
47257&Interp_ShlSint32Sint32,
47258&Interp_ShlSint32Uint32,
47259&Interp_ShlSint32Sint64,
47260&Interp_ShlSint32Uint64,
47261&Interp_ShlSint32IntAP,
47262&Interp_ShlSint32IntAPS,
47263&Interp_ShlUint32Sint8,
47264&Interp_ShlUint32Uint8,
47265&Interp_ShlUint32Sint16,
47266&Interp_ShlUint32Uint16,
47267&Interp_ShlUint32Sint32,
47268&Interp_ShlUint32Uint32,
47269&Interp_ShlUint32Sint64,
47270&Interp_ShlUint32Uint64,
47271&Interp_ShlUint32IntAP,
47272&Interp_ShlUint32IntAPS,
47273&Interp_ShlSint64Sint8,
47274&Interp_ShlSint64Uint8,
47275&Interp_ShlSint64Sint16,
47276&Interp_ShlSint64Uint16,
47277&Interp_ShlSint64Sint32,
47278&Interp_ShlSint64Uint32,
47279&Interp_ShlSint64Sint64,
47280&Interp_ShlSint64Uint64,
47281&Interp_ShlSint64IntAP,
47282&Interp_ShlSint64IntAPS,
47283&Interp_ShlUint64Sint8,
47284&Interp_ShlUint64Uint8,
47285&Interp_ShlUint64Sint16,
47286&Interp_ShlUint64Uint16,
47287&Interp_ShlUint64Sint32,
47288&Interp_ShlUint64Uint32,
47289&Interp_ShlUint64Sint64,
47290&Interp_ShlUint64Uint64,
47291&Interp_ShlUint64IntAP,
47292&Interp_ShlUint64IntAPS,
47293&Interp_ShlIntAPSint8,
47294&Interp_ShlIntAPUint8,
47295&Interp_ShlIntAPSint16,
47296&Interp_ShlIntAPUint16,
47297&Interp_ShlIntAPSint32,
47298&Interp_ShlIntAPUint32,
47299&Interp_ShlIntAPSint64,
47300&Interp_ShlIntAPUint64,
47301&Interp_ShlIntAPIntAP,
47302&Interp_ShlIntAPIntAPS,
47303&Interp_ShlIntAPSSint8,
47304&Interp_ShlIntAPSUint8,
47305&Interp_ShlIntAPSSint16,
47306&Interp_ShlIntAPSUint16,
47307&Interp_ShlIntAPSSint32,
47308&Interp_ShlIntAPSUint32,
47309&Interp_ShlIntAPSSint64,
47310&Interp_ShlIntAPSUint64,
47311&Interp_ShlIntAPSIntAP,
47312&Interp_ShlIntAPSIntAPS,
47313#endif
47314#ifdef GET_INTERPFN_DISPATCHERS
47315PRESERVE_NONE
47316static bool Interp_ShlSint8Sint8(InterpState &S) {
47317 if (!Shl<PT_Sint8, PT_Sint8>(S, S.PC)) return false;
47318#if USE_TAILCALLS
47319 MUSTTAIL return InterpNext(S);
47320#else
47321 return true;
47322#endif
47323}
47324PRESERVE_NONE
47325static bool Interp_ShlSint8Uint8(InterpState &S) {
47326 if (!Shl<PT_Sint8, PT_Uint8>(S, S.PC)) return false;
47327#if USE_TAILCALLS
47328 MUSTTAIL return InterpNext(S);
47329#else
47330 return true;
47331#endif
47332}
47333PRESERVE_NONE
47334static bool Interp_ShlSint8Sint16(InterpState &S) {
47335 if (!Shl<PT_Sint8, PT_Sint16>(S, S.PC)) return false;
47336#if USE_TAILCALLS
47337 MUSTTAIL return InterpNext(S);
47338#else
47339 return true;
47340#endif
47341}
47342PRESERVE_NONE
47343static bool Interp_ShlSint8Uint16(InterpState &S) {
47344 if (!Shl<PT_Sint8, PT_Uint16>(S, S.PC)) return false;
47345#if USE_TAILCALLS
47346 MUSTTAIL return InterpNext(S);
47347#else
47348 return true;
47349#endif
47350}
47351PRESERVE_NONE
47352static bool Interp_ShlSint8Sint32(InterpState &S) {
47353 if (!Shl<PT_Sint8, PT_Sint32>(S, S.PC)) return false;
47354#if USE_TAILCALLS
47355 MUSTTAIL return InterpNext(S);
47356#else
47357 return true;
47358#endif
47359}
47360PRESERVE_NONE
47361static bool Interp_ShlSint8Uint32(InterpState &S) {
47362 if (!Shl<PT_Sint8, PT_Uint32>(S, S.PC)) return false;
47363#if USE_TAILCALLS
47364 MUSTTAIL return InterpNext(S);
47365#else
47366 return true;
47367#endif
47368}
47369PRESERVE_NONE
47370static bool Interp_ShlSint8Sint64(InterpState &S) {
47371 if (!Shl<PT_Sint8, PT_Sint64>(S, S.PC)) return false;
47372#if USE_TAILCALLS
47373 MUSTTAIL return InterpNext(S);
47374#else
47375 return true;
47376#endif
47377}
47378PRESERVE_NONE
47379static bool Interp_ShlSint8Uint64(InterpState &S) {
47380 if (!Shl<PT_Sint8, PT_Uint64>(S, S.PC)) return false;
47381#if USE_TAILCALLS
47382 MUSTTAIL return InterpNext(S);
47383#else
47384 return true;
47385#endif
47386}
47387PRESERVE_NONE
47388static bool Interp_ShlSint8IntAP(InterpState &S) {
47389 if (!Shl<PT_Sint8, PT_IntAP>(S, S.PC)) return false;
47390#if USE_TAILCALLS
47391 MUSTTAIL return InterpNext(S);
47392#else
47393 return true;
47394#endif
47395}
47396PRESERVE_NONE
47397static bool Interp_ShlSint8IntAPS(InterpState &S) {
47398 if (!Shl<PT_Sint8, PT_IntAPS>(S, S.PC)) return false;
47399#if USE_TAILCALLS
47400 MUSTTAIL return InterpNext(S);
47401#else
47402 return true;
47403#endif
47404}
47405PRESERVE_NONE
47406static bool Interp_ShlUint8Sint8(InterpState &S) {
47407 if (!Shl<PT_Uint8, PT_Sint8>(S, S.PC)) return false;
47408#if USE_TAILCALLS
47409 MUSTTAIL return InterpNext(S);
47410#else
47411 return true;
47412#endif
47413}
47414PRESERVE_NONE
47415static bool Interp_ShlUint8Uint8(InterpState &S) {
47416 if (!Shl<PT_Uint8, PT_Uint8>(S, S.PC)) return false;
47417#if USE_TAILCALLS
47418 MUSTTAIL return InterpNext(S);
47419#else
47420 return true;
47421#endif
47422}
47423PRESERVE_NONE
47424static bool Interp_ShlUint8Sint16(InterpState &S) {
47425 if (!Shl<PT_Uint8, PT_Sint16>(S, S.PC)) return false;
47426#if USE_TAILCALLS
47427 MUSTTAIL return InterpNext(S);
47428#else
47429 return true;
47430#endif
47431}
47432PRESERVE_NONE
47433static bool Interp_ShlUint8Uint16(InterpState &S) {
47434 if (!Shl<PT_Uint8, PT_Uint16>(S, S.PC)) return false;
47435#if USE_TAILCALLS
47436 MUSTTAIL return InterpNext(S);
47437#else
47438 return true;
47439#endif
47440}
47441PRESERVE_NONE
47442static bool Interp_ShlUint8Sint32(InterpState &S) {
47443 if (!Shl<PT_Uint8, PT_Sint32>(S, S.PC)) return false;
47444#if USE_TAILCALLS
47445 MUSTTAIL return InterpNext(S);
47446#else
47447 return true;
47448#endif
47449}
47450PRESERVE_NONE
47451static bool Interp_ShlUint8Uint32(InterpState &S) {
47452 if (!Shl<PT_Uint8, PT_Uint32>(S, S.PC)) return false;
47453#if USE_TAILCALLS
47454 MUSTTAIL return InterpNext(S);
47455#else
47456 return true;
47457#endif
47458}
47459PRESERVE_NONE
47460static bool Interp_ShlUint8Sint64(InterpState &S) {
47461 if (!Shl<PT_Uint8, PT_Sint64>(S, S.PC)) return false;
47462#if USE_TAILCALLS
47463 MUSTTAIL return InterpNext(S);
47464#else
47465 return true;
47466#endif
47467}
47468PRESERVE_NONE
47469static bool Interp_ShlUint8Uint64(InterpState &S) {
47470 if (!Shl<PT_Uint8, PT_Uint64>(S, S.PC)) return false;
47471#if USE_TAILCALLS
47472 MUSTTAIL return InterpNext(S);
47473#else
47474 return true;
47475#endif
47476}
47477PRESERVE_NONE
47478static bool Interp_ShlUint8IntAP(InterpState &S) {
47479 if (!Shl<PT_Uint8, PT_IntAP>(S, S.PC)) return false;
47480#if USE_TAILCALLS
47481 MUSTTAIL return InterpNext(S);
47482#else
47483 return true;
47484#endif
47485}
47486PRESERVE_NONE
47487static bool Interp_ShlUint8IntAPS(InterpState &S) {
47488 if (!Shl<PT_Uint8, PT_IntAPS>(S, S.PC)) return false;
47489#if USE_TAILCALLS
47490 MUSTTAIL return InterpNext(S);
47491#else
47492 return true;
47493#endif
47494}
47495PRESERVE_NONE
47496static bool Interp_ShlSint16Sint8(InterpState &S) {
47497 if (!Shl<PT_Sint16, PT_Sint8>(S, S.PC)) return false;
47498#if USE_TAILCALLS
47499 MUSTTAIL return InterpNext(S);
47500#else
47501 return true;
47502#endif
47503}
47504PRESERVE_NONE
47505static bool Interp_ShlSint16Uint8(InterpState &S) {
47506 if (!Shl<PT_Sint16, PT_Uint8>(S, S.PC)) return false;
47507#if USE_TAILCALLS
47508 MUSTTAIL return InterpNext(S);
47509#else
47510 return true;
47511#endif
47512}
47513PRESERVE_NONE
47514static bool Interp_ShlSint16Sint16(InterpState &S) {
47515 if (!Shl<PT_Sint16, PT_Sint16>(S, S.PC)) return false;
47516#if USE_TAILCALLS
47517 MUSTTAIL return InterpNext(S);
47518#else
47519 return true;
47520#endif
47521}
47522PRESERVE_NONE
47523static bool Interp_ShlSint16Uint16(InterpState &S) {
47524 if (!Shl<PT_Sint16, PT_Uint16>(S, S.PC)) return false;
47525#if USE_TAILCALLS
47526 MUSTTAIL return InterpNext(S);
47527#else
47528 return true;
47529#endif
47530}
47531PRESERVE_NONE
47532static bool Interp_ShlSint16Sint32(InterpState &S) {
47533 if (!Shl<PT_Sint16, PT_Sint32>(S, S.PC)) return false;
47534#if USE_TAILCALLS
47535 MUSTTAIL return InterpNext(S);
47536#else
47537 return true;
47538#endif
47539}
47540PRESERVE_NONE
47541static bool Interp_ShlSint16Uint32(InterpState &S) {
47542 if (!Shl<PT_Sint16, PT_Uint32>(S, S.PC)) return false;
47543#if USE_TAILCALLS
47544 MUSTTAIL return InterpNext(S);
47545#else
47546 return true;
47547#endif
47548}
47549PRESERVE_NONE
47550static bool Interp_ShlSint16Sint64(InterpState &S) {
47551 if (!Shl<PT_Sint16, PT_Sint64>(S, S.PC)) return false;
47552#if USE_TAILCALLS
47553 MUSTTAIL return InterpNext(S);
47554#else
47555 return true;
47556#endif
47557}
47558PRESERVE_NONE
47559static bool Interp_ShlSint16Uint64(InterpState &S) {
47560 if (!Shl<PT_Sint16, PT_Uint64>(S, S.PC)) return false;
47561#if USE_TAILCALLS
47562 MUSTTAIL return InterpNext(S);
47563#else
47564 return true;
47565#endif
47566}
47567PRESERVE_NONE
47568static bool Interp_ShlSint16IntAP(InterpState &S) {
47569 if (!Shl<PT_Sint16, PT_IntAP>(S, S.PC)) return false;
47570#if USE_TAILCALLS
47571 MUSTTAIL return InterpNext(S);
47572#else
47573 return true;
47574#endif
47575}
47576PRESERVE_NONE
47577static bool Interp_ShlSint16IntAPS(InterpState &S) {
47578 if (!Shl<PT_Sint16, PT_IntAPS>(S, S.PC)) return false;
47579#if USE_TAILCALLS
47580 MUSTTAIL return InterpNext(S);
47581#else
47582 return true;
47583#endif
47584}
47585PRESERVE_NONE
47586static bool Interp_ShlUint16Sint8(InterpState &S) {
47587 if (!Shl<PT_Uint16, PT_Sint8>(S, S.PC)) return false;
47588#if USE_TAILCALLS
47589 MUSTTAIL return InterpNext(S);
47590#else
47591 return true;
47592#endif
47593}
47594PRESERVE_NONE
47595static bool Interp_ShlUint16Uint8(InterpState &S) {
47596 if (!Shl<PT_Uint16, PT_Uint8>(S, S.PC)) return false;
47597#if USE_TAILCALLS
47598 MUSTTAIL return InterpNext(S);
47599#else
47600 return true;
47601#endif
47602}
47603PRESERVE_NONE
47604static bool Interp_ShlUint16Sint16(InterpState &S) {
47605 if (!Shl<PT_Uint16, PT_Sint16>(S, S.PC)) return false;
47606#if USE_TAILCALLS
47607 MUSTTAIL return InterpNext(S);
47608#else
47609 return true;
47610#endif
47611}
47612PRESERVE_NONE
47613static bool Interp_ShlUint16Uint16(InterpState &S) {
47614 if (!Shl<PT_Uint16, PT_Uint16>(S, S.PC)) return false;
47615#if USE_TAILCALLS
47616 MUSTTAIL return InterpNext(S);
47617#else
47618 return true;
47619#endif
47620}
47621PRESERVE_NONE
47622static bool Interp_ShlUint16Sint32(InterpState &S) {
47623 if (!Shl<PT_Uint16, PT_Sint32>(S, S.PC)) return false;
47624#if USE_TAILCALLS
47625 MUSTTAIL return InterpNext(S);
47626#else
47627 return true;
47628#endif
47629}
47630PRESERVE_NONE
47631static bool Interp_ShlUint16Uint32(InterpState &S) {
47632 if (!Shl<PT_Uint16, PT_Uint32>(S, S.PC)) return false;
47633#if USE_TAILCALLS
47634 MUSTTAIL return InterpNext(S);
47635#else
47636 return true;
47637#endif
47638}
47639PRESERVE_NONE
47640static bool Interp_ShlUint16Sint64(InterpState &S) {
47641 if (!Shl<PT_Uint16, PT_Sint64>(S, S.PC)) return false;
47642#if USE_TAILCALLS
47643 MUSTTAIL return InterpNext(S);
47644#else
47645 return true;
47646#endif
47647}
47648PRESERVE_NONE
47649static bool Interp_ShlUint16Uint64(InterpState &S) {
47650 if (!Shl<PT_Uint16, PT_Uint64>(S, S.PC)) return false;
47651#if USE_TAILCALLS
47652 MUSTTAIL return InterpNext(S);
47653#else
47654 return true;
47655#endif
47656}
47657PRESERVE_NONE
47658static bool Interp_ShlUint16IntAP(InterpState &S) {
47659 if (!Shl<PT_Uint16, PT_IntAP>(S, S.PC)) return false;
47660#if USE_TAILCALLS
47661 MUSTTAIL return InterpNext(S);
47662#else
47663 return true;
47664#endif
47665}
47666PRESERVE_NONE
47667static bool Interp_ShlUint16IntAPS(InterpState &S) {
47668 if (!Shl<PT_Uint16, PT_IntAPS>(S, S.PC)) return false;
47669#if USE_TAILCALLS
47670 MUSTTAIL return InterpNext(S);
47671#else
47672 return true;
47673#endif
47674}
47675PRESERVE_NONE
47676static bool Interp_ShlSint32Sint8(InterpState &S) {
47677 if (!Shl<PT_Sint32, PT_Sint8>(S, S.PC)) return false;
47678#if USE_TAILCALLS
47679 MUSTTAIL return InterpNext(S);
47680#else
47681 return true;
47682#endif
47683}
47684PRESERVE_NONE
47685static bool Interp_ShlSint32Uint8(InterpState &S) {
47686 if (!Shl<PT_Sint32, PT_Uint8>(S, S.PC)) return false;
47687#if USE_TAILCALLS
47688 MUSTTAIL return InterpNext(S);
47689#else
47690 return true;
47691#endif
47692}
47693PRESERVE_NONE
47694static bool Interp_ShlSint32Sint16(InterpState &S) {
47695 if (!Shl<PT_Sint32, PT_Sint16>(S, S.PC)) return false;
47696#if USE_TAILCALLS
47697 MUSTTAIL return InterpNext(S);
47698#else
47699 return true;
47700#endif
47701}
47702PRESERVE_NONE
47703static bool Interp_ShlSint32Uint16(InterpState &S) {
47704 if (!Shl<PT_Sint32, PT_Uint16>(S, S.PC)) return false;
47705#if USE_TAILCALLS
47706 MUSTTAIL return InterpNext(S);
47707#else
47708 return true;
47709#endif
47710}
47711PRESERVE_NONE
47712static bool Interp_ShlSint32Sint32(InterpState &S) {
47713 if (!Shl<PT_Sint32, PT_Sint32>(S, S.PC)) return false;
47714#if USE_TAILCALLS
47715 MUSTTAIL return InterpNext(S);
47716#else
47717 return true;
47718#endif
47719}
47720PRESERVE_NONE
47721static bool Interp_ShlSint32Uint32(InterpState &S) {
47722 if (!Shl<PT_Sint32, PT_Uint32>(S, S.PC)) return false;
47723#if USE_TAILCALLS
47724 MUSTTAIL return InterpNext(S);
47725#else
47726 return true;
47727#endif
47728}
47729PRESERVE_NONE
47730static bool Interp_ShlSint32Sint64(InterpState &S) {
47731 if (!Shl<PT_Sint32, PT_Sint64>(S, S.PC)) return false;
47732#if USE_TAILCALLS
47733 MUSTTAIL return InterpNext(S);
47734#else
47735 return true;
47736#endif
47737}
47738PRESERVE_NONE
47739static bool Interp_ShlSint32Uint64(InterpState &S) {
47740 if (!Shl<PT_Sint32, PT_Uint64>(S, S.PC)) return false;
47741#if USE_TAILCALLS
47742 MUSTTAIL return InterpNext(S);
47743#else
47744 return true;
47745#endif
47746}
47747PRESERVE_NONE
47748static bool Interp_ShlSint32IntAP(InterpState &S) {
47749 if (!Shl<PT_Sint32, PT_IntAP>(S, S.PC)) return false;
47750#if USE_TAILCALLS
47751 MUSTTAIL return InterpNext(S);
47752#else
47753 return true;
47754#endif
47755}
47756PRESERVE_NONE
47757static bool Interp_ShlSint32IntAPS(InterpState &S) {
47758 if (!Shl<PT_Sint32, PT_IntAPS>(S, S.PC)) return false;
47759#if USE_TAILCALLS
47760 MUSTTAIL return InterpNext(S);
47761#else
47762 return true;
47763#endif
47764}
47765PRESERVE_NONE
47766static bool Interp_ShlUint32Sint8(InterpState &S) {
47767 if (!Shl<PT_Uint32, PT_Sint8>(S, S.PC)) return false;
47768#if USE_TAILCALLS
47769 MUSTTAIL return InterpNext(S);
47770#else
47771 return true;
47772#endif
47773}
47774PRESERVE_NONE
47775static bool Interp_ShlUint32Uint8(InterpState &S) {
47776 if (!Shl<PT_Uint32, PT_Uint8>(S, S.PC)) return false;
47777#if USE_TAILCALLS
47778 MUSTTAIL return InterpNext(S);
47779#else
47780 return true;
47781#endif
47782}
47783PRESERVE_NONE
47784static bool Interp_ShlUint32Sint16(InterpState &S) {
47785 if (!Shl<PT_Uint32, PT_Sint16>(S, S.PC)) return false;
47786#if USE_TAILCALLS
47787 MUSTTAIL return InterpNext(S);
47788#else
47789 return true;
47790#endif
47791}
47792PRESERVE_NONE
47793static bool Interp_ShlUint32Uint16(InterpState &S) {
47794 if (!Shl<PT_Uint32, PT_Uint16>(S, S.PC)) return false;
47795#if USE_TAILCALLS
47796 MUSTTAIL return InterpNext(S);
47797#else
47798 return true;
47799#endif
47800}
47801PRESERVE_NONE
47802static bool Interp_ShlUint32Sint32(InterpState &S) {
47803 if (!Shl<PT_Uint32, PT_Sint32>(S, S.PC)) return false;
47804#if USE_TAILCALLS
47805 MUSTTAIL return InterpNext(S);
47806#else
47807 return true;
47808#endif
47809}
47810PRESERVE_NONE
47811static bool Interp_ShlUint32Uint32(InterpState &S) {
47812 if (!Shl<PT_Uint32, PT_Uint32>(S, S.PC)) return false;
47813#if USE_TAILCALLS
47814 MUSTTAIL return InterpNext(S);
47815#else
47816 return true;
47817#endif
47818}
47819PRESERVE_NONE
47820static bool Interp_ShlUint32Sint64(InterpState &S) {
47821 if (!Shl<PT_Uint32, PT_Sint64>(S, S.PC)) return false;
47822#if USE_TAILCALLS
47823 MUSTTAIL return InterpNext(S);
47824#else
47825 return true;
47826#endif
47827}
47828PRESERVE_NONE
47829static bool Interp_ShlUint32Uint64(InterpState &S) {
47830 if (!Shl<PT_Uint32, PT_Uint64>(S, S.PC)) return false;
47831#if USE_TAILCALLS
47832 MUSTTAIL return InterpNext(S);
47833#else
47834 return true;
47835#endif
47836}
47837PRESERVE_NONE
47838static bool Interp_ShlUint32IntAP(InterpState &S) {
47839 if (!Shl<PT_Uint32, PT_IntAP>(S, S.PC)) return false;
47840#if USE_TAILCALLS
47841 MUSTTAIL return InterpNext(S);
47842#else
47843 return true;
47844#endif
47845}
47846PRESERVE_NONE
47847static bool Interp_ShlUint32IntAPS(InterpState &S) {
47848 if (!Shl<PT_Uint32, PT_IntAPS>(S, S.PC)) return false;
47849#if USE_TAILCALLS
47850 MUSTTAIL return InterpNext(S);
47851#else
47852 return true;
47853#endif
47854}
47855PRESERVE_NONE
47856static bool Interp_ShlSint64Sint8(InterpState &S) {
47857 if (!Shl<PT_Sint64, PT_Sint8>(S, S.PC)) return false;
47858#if USE_TAILCALLS
47859 MUSTTAIL return InterpNext(S);
47860#else
47861 return true;
47862#endif
47863}
47864PRESERVE_NONE
47865static bool Interp_ShlSint64Uint8(InterpState &S) {
47866 if (!Shl<PT_Sint64, PT_Uint8>(S, S.PC)) return false;
47867#if USE_TAILCALLS
47868 MUSTTAIL return InterpNext(S);
47869#else
47870 return true;
47871#endif
47872}
47873PRESERVE_NONE
47874static bool Interp_ShlSint64Sint16(InterpState &S) {
47875 if (!Shl<PT_Sint64, PT_Sint16>(S, S.PC)) return false;
47876#if USE_TAILCALLS
47877 MUSTTAIL return InterpNext(S);
47878#else
47879 return true;
47880#endif
47881}
47882PRESERVE_NONE
47883static bool Interp_ShlSint64Uint16(InterpState &S) {
47884 if (!Shl<PT_Sint64, PT_Uint16>(S, S.PC)) return false;
47885#if USE_TAILCALLS
47886 MUSTTAIL return InterpNext(S);
47887#else
47888 return true;
47889#endif
47890}
47891PRESERVE_NONE
47892static bool Interp_ShlSint64Sint32(InterpState &S) {
47893 if (!Shl<PT_Sint64, PT_Sint32>(S, S.PC)) return false;
47894#if USE_TAILCALLS
47895 MUSTTAIL return InterpNext(S);
47896#else
47897 return true;
47898#endif
47899}
47900PRESERVE_NONE
47901static bool Interp_ShlSint64Uint32(InterpState &S) {
47902 if (!Shl<PT_Sint64, PT_Uint32>(S, S.PC)) return false;
47903#if USE_TAILCALLS
47904 MUSTTAIL return InterpNext(S);
47905#else
47906 return true;
47907#endif
47908}
47909PRESERVE_NONE
47910static bool Interp_ShlSint64Sint64(InterpState &S) {
47911 if (!Shl<PT_Sint64, PT_Sint64>(S, S.PC)) return false;
47912#if USE_TAILCALLS
47913 MUSTTAIL return InterpNext(S);
47914#else
47915 return true;
47916#endif
47917}
47918PRESERVE_NONE
47919static bool Interp_ShlSint64Uint64(InterpState &S) {
47920 if (!Shl<PT_Sint64, PT_Uint64>(S, S.PC)) return false;
47921#if USE_TAILCALLS
47922 MUSTTAIL return InterpNext(S);
47923#else
47924 return true;
47925#endif
47926}
47927PRESERVE_NONE
47928static bool Interp_ShlSint64IntAP(InterpState &S) {
47929 if (!Shl<PT_Sint64, PT_IntAP>(S, S.PC)) return false;
47930#if USE_TAILCALLS
47931 MUSTTAIL return InterpNext(S);
47932#else
47933 return true;
47934#endif
47935}
47936PRESERVE_NONE
47937static bool Interp_ShlSint64IntAPS(InterpState &S) {
47938 if (!Shl<PT_Sint64, PT_IntAPS>(S, S.PC)) return false;
47939#if USE_TAILCALLS
47940 MUSTTAIL return InterpNext(S);
47941#else
47942 return true;
47943#endif
47944}
47945PRESERVE_NONE
47946static bool Interp_ShlUint64Sint8(InterpState &S) {
47947 if (!Shl<PT_Uint64, PT_Sint8>(S, S.PC)) return false;
47948#if USE_TAILCALLS
47949 MUSTTAIL return InterpNext(S);
47950#else
47951 return true;
47952#endif
47953}
47954PRESERVE_NONE
47955static bool Interp_ShlUint64Uint8(InterpState &S) {
47956 if (!Shl<PT_Uint64, PT_Uint8>(S, S.PC)) return false;
47957#if USE_TAILCALLS
47958 MUSTTAIL return InterpNext(S);
47959#else
47960 return true;
47961#endif
47962}
47963PRESERVE_NONE
47964static bool Interp_ShlUint64Sint16(InterpState &S) {
47965 if (!Shl<PT_Uint64, PT_Sint16>(S, S.PC)) return false;
47966#if USE_TAILCALLS
47967 MUSTTAIL return InterpNext(S);
47968#else
47969 return true;
47970#endif
47971}
47972PRESERVE_NONE
47973static bool Interp_ShlUint64Uint16(InterpState &S) {
47974 if (!Shl<PT_Uint64, PT_Uint16>(S, S.PC)) return false;
47975#if USE_TAILCALLS
47976 MUSTTAIL return InterpNext(S);
47977#else
47978 return true;
47979#endif
47980}
47981PRESERVE_NONE
47982static bool Interp_ShlUint64Sint32(InterpState &S) {
47983 if (!Shl<PT_Uint64, PT_Sint32>(S, S.PC)) return false;
47984#if USE_TAILCALLS
47985 MUSTTAIL return InterpNext(S);
47986#else
47987 return true;
47988#endif
47989}
47990PRESERVE_NONE
47991static bool Interp_ShlUint64Uint32(InterpState &S) {
47992 if (!Shl<PT_Uint64, PT_Uint32>(S, S.PC)) return false;
47993#if USE_TAILCALLS
47994 MUSTTAIL return InterpNext(S);
47995#else
47996 return true;
47997#endif
47998}
47999PRESERVE_NONE
48000static bool Interp_ShlUint64Sint64(InterpState &S) {
48001 if (!Shl<PT_Uint64, PT_Sint64>(S, S.PC)) return false;
48002#if USE_TAILCALLS
48003 MUSTTAIL return InterpNext(S);
48004#else
48005 return true;
48006#endif
48007}
48008PRESERVE_NONE
48009static bool Interp_ShlUint64Uint64(InterpState &S) {
48010 if (!Shl<PT_Uint64, PT_Uint64>(S, S.PC)) return false;
48011#if USE_TAILCALLS
48012 MUSTTAIL return InterpNext(S);
48013#else
48014 return true;
48015#endif
48016}
48017PRESERVE_NONE
48018static bool Interp_ShlUint64IntAP(InterpState &S) {
48019 if (!Shl<PT_Uint64, PT_IntAP>(S, S.PC)) return false;
48020#if USE_TAILCALLS
48021 MUSTTAIL return InterpNext(S);
48022#else
48023 return true;
48024#endif
48025}
48026PRESERVE_NONE
48027static bool Interp_ShlUint64IntAPS(InterpState &S) {
48028 if (!Shl<PT_Uint64, PT_IntAPS>(S, S.PC)) return false;
48029#if USE_TAILCALLS
48030 MUSTTAIL return InterpNext(S);
48031#else
48032 return true;
48033#endif
48034}
48035PRESERVE_NONE
48036static bool Interp_ShlIntAPSint8(InterpState &S) {
48037 if (!Shl<PT_IntAP, PT_Sint8>(S, S.PC)) return false;
48038#if USE_TAILCALLS
48039 MUSTTAIL return InterpNext(S);
48040#else
48041 return true;
48042#endif
48043}
48044PRESERVE_NONE
48045static bool Interp_ShlIntAPUint8(InterpState &S) {
48046 if (!Shl<PT_IntAP, PT_Uint8>(S, S.PC)) return false;
48047#if USE_TAILCALLS
48048 MUSTTAIL return InterpNext(S);
48049#else
48050 return true;
48051#endif
48052}
48053PRESERVE_NONE
48054static bool Interp_ShlIntAPSint16(InterpState &S) {
48055 if (!Shl<PT_IntAP, PT_Sint16>(S, S.PC)) return false;
48056#if USE_TAILCALLS
48057 MUSTTAIL return InterpNext(S);
48058#else
48059 return true;
48060#endif
48061}
48062PRESERVE_NONE
48063static bool Interp_ShlIntAPUint16(InterpState &S) {
48064 if (!Shl<PT_IntAP, PT_Uint16>(S, S.PC)) return false;
48065#if USE_TAILCALLS
48066 MUSTTAIL return InterpNext(S);
48067#else
48068 return true;
48069#endif
48070}
48071PRESERVE_NONE
48072static bool Interp_ShlIntAPSint32(InterpState &S) {
48073 if (!Shl<PT_IntAP, PT_Sint32>(S, S.PC)) return false;
48074#if USE_TAILCALLS
48075 MUSTTAIL return InterpNext(S);
48076#else
48077 return true;
48078#endif
48079}
48080PRESERVE_NONE
48081static bool Interp_ShlIntAPUint32(InterpState &S) {
48082 if (!Shl<PT_IntAP, PT_Uint32>(S, S.PC)) return false;
48083#if USE_TAILCALLS
48084 MUSTTAIL return InterpNext(S);
48085#else
48086 return true;
48087#endif
48088}
48089PRESERVE_NONE
48090static bool Interp_ShlIntAPSint64(InterpState &S) {
48091 if (!Shl<PT_IntAP, PT_Sint64>(S, S.PC)) return false;
48092#if USE_TAILCALLS
48093 MUSTTAIL return InterpNext(S);
48094#else
48095 return true;
48096#endif
48097}
48098PRESERVE_NONE
48099static bool Interp_ShlIntAPUint64(InterpState &S) {
48100 if (!Shl<PT_IntAP, PT_Uint64>(S, S.PC)) return false;
48101#if USE_TAILCALLS
48102 MUSTTAIL return InterpNext(S);
48103#else
48104 return true;
48105#endif
48106}
48107PRESERVE_NONE
48108static bool Interp_ShlIntAPIntAP(InterpState &S) {
48109 if (!Shl<PT_IntAP, PT_IntAP>(S, S.PC)) return false;
48110#if USE_TAILCALLS
48111 MUSTTAIL return InterpNext(S);
48112#else
48113 return true;
48114#endif
48115}
48116PRESERVE_NONE
48117static bool Interp_ShlIntAPIntAPS(InterpState &S) {
48118 if (!Shl<PT_IntAP, PT_IntAPS>(S, S.PC)) return false;
48119#if USE_TAILCALLS
48120 MUSTTAIL return InterpNext(S);
48121#else
48122 return true;
48123#endif
48124}
48125PRESERVE_NONE
48126static bool Interp_ShlIntAPSSint8(InterpState &S) {
48127 if (!Shl<PT_IntAPS, PT_Sint8>(S, S.PC)) return false;
48128#if USE_TAILCALLS
48129 MUSTTAIL return InterpNext(S);
48130#else
48131 return true;
48132#endif
48133}
48134PRESERVE_NONE
48135static bool Interp_ShlIntAPSUint8(InterpState &S) {
48136 if (!Shl<PT_IntAPS, PT_Uint8>(S, S.PC)) return false;
48137#if USE_TAILCALLS
48138 MUSTTAIL return InterpNext(S);
48139#else
48140 return true;
48141#endif
48142}
48143PRESERVE_NONE
48144static bool Interp_ShlIntAPSSint16(InterpState &S) {
48145 if (!Shl<PT_IntAPS, PT_Sint16>(S, S.PC)) return false;
48146#if USE_TAILCALLS
48147 MUSTTAIL return InterpNext(S);
48148#else
48149 return true;
48150#endif
48151}
48152PRESERVE_NONE
48153static bool Interp_ShlIntAPSUint16(InterpState &S) {
48154 if (!Shl<PT_IntAPS, PT_Uint16>(S, S.PC)) return false;
48155#if USE_TAILCALLS
48156 MUSTTAIL return InterpNext(S);
48157#else
48158 return true;
48159#endif
48160}
48161PRESERVE_NONE
48162static bool Interp_ShlIntAPSSint32(InterpState &S) {
48163 if (!Shl<PT_IntAPS, PT_Sint32>(S, S.PC)) return false;
48164#if USE_TAILCALLS
48165 MUSTTAIL return InterpNext(S);
48166#else
48167 return true;
48168#endif
48169}
48170PRESERVE_NONE
48171static bool Interp_ShlIntAPSUint32(InterpState &S) {
48172 if (!Shl<PT_IntAPS, PT_Uint32>(S, S.PC)) return false;
48173#if USE_TAILCALLS
48174 MUSTTAIL return InterpNext(S);
48175#else
48176 return true;
48177#endif
48178}
48179PRESERVE_NONE
48180static bool Interp_ShlIntAPSSint64(InterpState &S) {
48181 if (!Shl<PT_IntAPS, PT_Sint64>(S, S.PC)) return false;
48182#if USE_TAILCALLS
48183 MUSTTAIL return InterpNext(S);
48184#else
48185 return true;
48186#endif
48187}
48188PRESERVE_NONE
48189static bool Interp_ShlIntAPSUint64(InterpState &S) {
48190 if (!Shl<PT_IntAPS, PT_Uint64>(S, S.PC)) return false;
48191#if USE_TAILCALLS
48192 MUSTTAIL return InterpNext(S);
48193#else
48194 return true;
48195#endif
48196}
48197PRESERVE_NONE
48198static bool Interp_ShlIntAPSIntAP(InterpState &S) {
48199 if (!Shl<PT_IntAPS, PT_IntAP>(S, S.PC)) return false;
48200#if USE_TAILCALLS
48201 MUSTTAIL return InterpNext(S);
48202#else
48203 return true;
48204#endif
48205}
48206PRESERVE_NONE
48207static bool Interp_ShlIntAPSIntAPS(InterpState &S) {
48208 if (!Shl<PT_IntAPS, PT_IntAPS>(S, S.PC)) return false;
48209#if USE_TAILCALLS
48210 MUSTTAIL return InterpNext(S);
48211#else
48212 return true;
48213#endif
48214}
48215#endif
48216#ifdef GET_DISASM
48217case OP_ShlSint8Sint8:
48218 Text.Op = PrintName("ShlSint8Sint8");
48219 break;
48220case OP_ShlSint8Uint8:
48221 Text.Op = PrintName("ShlSint8Uint8");
48222 break;
48223case OP_ShlSint8Sint16:
48224 Text.Op = PrintName("ShlSint8Sint16");
48225 break;
48226case OP_ShlSint8Uint16:
48227 Text.Op = PrintName("ShlSint8Uint16");
48228 break;
48229case OP_ShlSint8Sint32:
48230 Text.Op = PrintName("ShlSint8Sint32");
48231 break;
48232case OP_ShlSint8Uint32:
48233 Text.Op = PrintName("ShlSint8Uint32");
48234 break;
48235case OP_ShlSint8Sint64:
48236 Text.Op = PrintName("ShlSint8Sint64");
48237 break;
48238case OP_ShlSint8Uint64:
48239 Text.Op = PrintName("ShlSint8Uint64");
48240 break;
48241case OP_ShlSint8IntAP:
48242 Text.Op = PrintName("ShlSint8IntAP");
48243 break;
48244case OP_ShlSint8IntAPS:
48245 Text.Op = PrintName("ShlSint8IntAPS");
48246 break;
48247case OP_ShlUint8Sint8:
48248 Text.Op = PrintName("ShlUint8Sint8");
48249 break;
48250case OP_ShlUint8Uint8:
48251 Text.Op = PrintName("ShlUint8Uint8");
48252 break;
48253case OP_ShlUint8Sint16:
48254 Text.Op = PrintName("ShlUint8Sint16");
48255 break;
48256case OP_ShlUint8Uint16:
48257 Text.Op = PrintName("ShlUint8Uint16");
48258 break;
48259case OP_ShlUint8Sint32:
48260 Text.Op = PrintName("ShlUint8Sint32");
48261 break;
48262case OP_ShlUint8Uint32:
48263 Text.Op = PrintName("ShlUint8Uint32");
48264 break;
48265case OP_ShlUint8Sint64:
48266 Text.Op = PrintName("ShlUint8Sint64");
48267 break;
48268case OP_ShlUint8Uint64:
48269 Text.Op = PrintName("ShlUint8Uint64");
48270 break;
48271case OP_ShlUint8IntAP:
48272 Text.Op = PrintName("ShlUint8IntAP");
48273 break;
48274case OP_ShlUint8IntAPS:
48275 Text.Op = PrintName("ShlUint8IntAPS");
48276 break;
48277case OP_ShlSint16Sint8:
48278 Text.Op = PrintName("ShlSint16Sint8");
48279 break;
48280case OP_ShlSint16Uint8:
48281 Text.Op = PrintName("ShlSint16Uint8");
48282 break;
48283case OP_ShlSint16Sint16:
48284 Text.Op = PrintName("ShlSint16Sint16");
48285 break;
48286case OP_ShlSint16Uint16:
48287 Text.Op = PrintName("ShlSint16Uint16");
48288 break;
48289case OP_ShlSint16Sint32:
48290 Text.Op = PrintName("ShlSint16Sint32");
48291 break;
48292case OP_ShlSint16Uint32:
48293 Text.Op = PrintName("ShlSint16Uint32");
48294 break;
48295case OP_ShlSint16Sint64:
48296 Text.Op = PrintName("ShlSint16Sint64");
48297 break;
48298case OP_ShlSint16Uint64:
48299 Text.Op = PrintName("ShlSint16Uint64");
48300 break;
48301case OP_ShlSint16IntAP:
48302 Text.Op = PrintName("ShlSint16IntAP");
48303 break;
48304case OP_ShlSint16IntAPS:
48305 Text.Op = PrintName("ShlSint16IntAPS");
48306 break;
48307case OP_ShlUint16Sint8:
48308 Text.Op = PrintName("ShlUint16Sint8");
48309 break;
48310case OP_ShlUint16Uint8:
48311 Text.Op = PrintName("ShlUint16Uint8");
48312 break;
48313case OP_ShlUint16Sint16:
48314 Text.Op = PrintName("ShlUint16Sint16");
48315 break;
48316case OP_ShlUint16Uint16:
48317 Text.Op = PrintName("ShlUint16Uint16");
48318 break;
48319case OP_ShlUint16Sint32:
48320 Text.Op = PrintName("ShlUint16Sint32");
48321 break;
48322case OP_ShlUint16Uint32:
48323 Text.Op = PrintName("ShlUint16Uint32");
48324 break;
48325case OP_ShlUint16Sint64:
48326 Text.Op = PrintName("ShlUint16Sint64");
48327 break;
48328case OP_ShlUint16Uint64:
48329 Text.Op = PrintName("ShlUint16Uint64");
48330 break;
48331case OP_ShlUint16IntAP:
48332 Text.Op = PrintName("ShlUint16IntAP");
48333 break;
48334case OP_ShlUint16IntAPS:
48335 Text.Op = PrintName("ShlUint16IntAPS");
48336 break;
48337case OP_ShlSint32Sint8:
48338 Text.Op = PrintName("ShlSint32Sint8");
48339 break;
48340case OP_ShlSint32Uint8:
48341 Text.Op = PrintName("ShlSint32Uint8");
48342 break;
48343case OP_ShlSint32Sint16:
48344 Text.Op = PrintName("ShlSint32Sint16");
48345 break;
48346case OP_ShlSint32Uint16:
48347 Text.Op = PrintName("ShlSint32Uint16");
48348 break;
48349case OP_ShlSint32Sint32:
48350 Text.Op = PrintName("ShlSint32Sint32");
48351 break;
48352case OP_ShlSint32Uint32:
48353 Text.Op = PrintName("ShlSint32Uint32");
48354 break;
48355case OP_ShlSint32Sint64:
48356 Text.Op = PrintName("ShlSint32Sint64");
48357 break;
48358case OP_ShlSint32Uint64:
48359 Text.Op = PrintName("ShlSint32Uint64");
48360 break;
48361case OP_ShlSint32IntAP:
48362 Text.Op = PrintName("ShlSint32IntAP");
48363 break;
48364case OP_ShlSint32IntAPS:
48365 Text.Op = PrintName("ShlSint32IntAPS");
48366 break;
48367case OP_ShlUint32Sint8:
48368 Text.Op = PrintName("ShlUint32Sint8");
48369 break;
48370case OP_ShlUint32Uint8:
48371 Text.Op = PrintName("ShlUint32Uint8");
48372 break;
48373case OP_ShlUint32Sint16:
48374 Text.Op = PrintName("ShlUint32Sint16");
48375 break;
48376case OP_ShlUint32Uint16:
48377 Text.Op = PrintName("ShlUint32Uint16");
48378 break;
48379case OP_ShlUint32Sint32:
48380 Text.Op = PrintName("ShlUint32Sint32");
48381 break;
48382case OP_ShlUint32Uint32:
48383 Text.Op = PrintName("ShlUint32Uint32");
48384 break;
48385case OP_ShlUint32Sint64:
48386 Text.Op = PrintName("ShlUint32Sint64");
48387 break;
48388case OP_ShlUint32Uint64:
48389 Text.Op = PrintName("ShlUint32Uint64");
48390 break;
48391case OP_ShlUint32IntAP:
48392 Text.Op = PrintName("ShlUint32IntAP");
48393 break;
48394case OP_ShlUint32IntAPS:
48395 Text.Op = PrintName("ShlUint32IntAPS");
48396 break;
48397case OP_ShlSint64Sint8:
48398 Text.Op = PrintName("ShlSint64Sint8");
48399 break;
48400case OP_ShlSint64Uint8:
48401 Text.Op = PrintName("ShlSint64Uint8");
48402 break;
48403case OP_ShlSint64Sint16:
48404 Text.Op = PrintName("ShlSint64Sint16");
48405 break;
48406case OP_ShlSint64Uint16:
48407 Text.Op = PrintName("ShlSint64Uint16");
48408 break;
48409case OP_ShlSint64Sint32:
48410 Text.Op = PrintName("ShlSint64Sint32");
48411 break;
48412case OP_ShlSint64Uint32:
48413 Text.Op = PrintName("ShlSint64Uint32");
48414 break;
48415case OP_ShlSint64Sint64:
48416 Text.Op = PrintName("ShlSint64Sint64");
48417 break;
48418case OP_ShlSint64Uint64:
48419 Text.Op = PrintName("ShlSint64Uint64");
48420 break;
48421case OP_ShlSint64IntAP:
48422 Text.Op = PrintName("ShlSint64IntAP");
48423 break;
48424case OP_ShlSint64IntAPS:
48425 Text.Op = PrintName("ShlSint64IntAPS");
48426 break;
48427case OP_ShlUint64Sint8:
48428 Text.Op = PrintName("ShlUint64Sint8");
48429 break;
48430case OP_ShlUint64Uint8:
48431 Text.Op = PrintName("ShlUint64Uint8");
48432 break;
48433case OP_ShlUint64Sint16:
48434 Text.Op = PrintName("ShlUint64Sint16");
48435 break;
48436case OP_ShlUint64Uint16:
48437 Text.Op = PrintName("ShlUint64Uint16");
48438 break;
48439case OP_ShlUint64Sint32:
48440 Text.Op = PrintName("ShlUint64Sint32");
48441 break;
48442case OP_ShlUint64Uint32:
48443 Text.Op = PrintName("ShlUint64Uint32");
48444 break;
48445case OP_ShlUint64Sint64:
48446 Text.Op = PrintName("ShlUint64Sint64");
48447 break;
48448case OP_ShlUint64Uint64:
48449 Text.Op = PrintName("ShlUint64Uint64");
48450 break;
48451case OP_ShlUint64IntAP:
48452 Text.Op = PrintName("ShlUint64IntAP");
48453 break;
48454case OP_ShlUint64IntAPS:
48455 Text.Op = PrintName("ShlUint64IntAPS");
48456 break;
48457case OP_ShlIntAPSint8:
48458 Text.Op = PrintName("ShlIntAPSint8");
48459 break;
48460case OP_ShlIntAPUint8:
48461 Text.Op = PrintName("ShlIntAPUint8");
48462 break;
48463case OP_ShlIntAPSint16:
48464 Text.Op = PrintName("ShlIntAPSint16");
48465 break;
48466case OP_ShlIntAPUint16:
48467 Text.Op = PrintName("ShlIntAPUint16");
48468 break;
48469case OP_ShlIntAPSint32:
48470 Text.Op = PrintName("ShlIntAPSint32");
48471 break;
48472case OP_ShlIntAPUint32:
48473 Text.Op = PrintName("ShlIntAPUint32");
48474 break;
48475case OP_ShlIntAPSint64:
48476 Text.Op = PrintName("ShlIntAPSint64");
48477 break;
48478case OP_ShlIntAPUint64:
48479 Text.Op = PrintName("ShlIntAPUint64");
48480 break;
48481case OP_ShlIntAPIntAP:
48482 Text.Op = PrintName("ShlIntAPIntAP");
48483 break;
48484case OP_ShlIntAPIntAPS:
48485 Text.Op = PrintName("ShlIntAPIntAPS");
48486 break;
48487case OP_ShlIntAPSSint8:
48488 Text.Op = PrintName("ShlIntAPSSint8");
48489 break;
48490case OP_ShlIntAPSUint8:
48491 Text.Op = PrintName("ShlIntAPSUint8");
48492 break;
48493case OP_ShlIntAPSSint16:
48494 Text.Op = PrintName("ShlIntAPSSint16");
48495 break;
48496case OP_ShlIntAPSUint16:
48497 Text.Op = PrintName("ShlIntAPSUint16");
48498 break;
48499case OP_ShlIntAPSSint32:
48500 Text.Op = PrintName("ShlIntAPSSint32");
48501 break;
48502case OP_ShlIntAPSUint32:
48503 Text.Op = PrintName("ShlIntAPSUint32");
48504 break;
48505case OP_ShlIntAPSSint64:
48506 Text.Op = PrintName("ShlIntAPSSint64");
48507 break;
48508case OP_ShlIntAPSUint64:
48509 Text.Op = PrintName("ShlIntAPSUint64");
48510 break;
48511case OP_ShlIntAPSIntAP:
48512 Text.Op = PrintName("ShlIntAPSIntAP");
48513 break;
48514case OP_ShlIntAPSIntAPS:
48515 Text.Op = PrintName("ShlIntAPSIntAPS");
48516 break;
48517#endif
48518#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
48519bool emitShlSint8Sint8(SourceInfo);
48520bool emitShlSint8Uint8(SourceInfo);
48521bool emitShlSint8Sint16(SourceInfo);
48522bool emitShlSint8Uint16(SourceInfo);
48523bool emitShlSint8Sint32(SourceInfo);
48524bool emitShlSint8Uint32(SourceInfo);
48525bool emitShlSint8Sint64(SourceInfo);
48526bool emitShlSint8Uint64(SourceInfo);
48527bool emitShlSint8IntAP(SourceInfo);
48528bool emitShlSint8IntAPS(SourceInfo);
48529bool emitShlUint8Sint8(SourceInfo);
48530bool emitShlUint8Uint8(SourceInfo);
48531bool emitShlUint8Sint16(SourceInfo);
48532bool emitShlUint8Uint16(SourceInfo);
48533bool emitShlUint8Sint32(SourceInfo);
48534bool emitShlUint8Uint32(SourceInfo);
48535bool emitShlUint8Sint64(SourceInfo);
48536bool emitShlUint8Uint64(SourceInfo);
48537bool emitShlUint8IntAP(SourceInfo);
48538bool emitShlUint8IntAPS(SourceInfo);
48539bool emitShlSint16Sint8(SourceInfo);
48540bool emitShlSint16Uint8(SourceInfo);
48541bool emitShlSint16Sint16(SourceInfo);
48542bool emitShlSint16Uint16(SourceInfo);
48543bool emitShlSint16Sint32(SourceInfo);
48544bool emitShlSint16Uint32(SourceInfo);
48545bool emitShlSint16Sint64(SourceInfo);
48546bool emitShlSint16Uint64(SourceInfo);
48547bool emitShlSint16IntAP(SourceInfo);
48548bool emitShlSint16IntAPS(SourceInfo);
48549bool emitShlUint16Sint8(SourceInfo);
48550bool emitShlUint16Uint8(SourceInfo);
48551bool emitShlUint16Sint16(SourceInfo);
48552bool emitShlUint16Uint16(SourceInfo);
48553bool emitShlUint16Sint32(SourceInfo);
48554bool emitShlUint16Uint32(SourceInfo);
48555bool emitShlUint16Sint64(SourceInfo);
48556bool emitShlUint16Uint64(SourceInfo);
48557bool emitShlUint16IntAP(SourceInfo);
48558bool emitShlUint16IntAPS(SourceInfo);
48559bool emitShlSint32Sint8(SourceInfo);
48560bool emitShlSint32Uint8(SourceInfo);
48561bool emitShlSint32Sint16(SourceInfo);
48562bool emitShlSint32Uint16(SourceInfo);
48563bool emitShlSint32Sint32(SourceInfo);
48564bool emitShlSint32Uint32(SourceInfo);
48565bool emitShlSint32Sint64(SourceInfo);
48566bool emitShlSint32Uint64(SourceInfo);
48567bool emitShlSint32IntAP(SourceInfo);
48568bool emitShlSint32IntAPS(SourceInfo);
48569bool emitShlUint32Sint8(SourceInfo);
48570bool emitShlUint32Uint8(SourceInfo);
48571bool emitShlUint32Sint16(SourceInfo);
48572bool emitShlUint32Uint16(SourceInfo);
48573bool emitShlUint32Sint32(SourceInfo);
48574bool emitShlUint32Uint32(SourceInfo);
48575bool emitShlUint32Sint64(SourceInfo);
48576bool emitShlUint32Uint64(SourceInfo);
48577bool emitShlUint32IntAP(SourceInfo);
48578bool emitShlUint32IntAPS(SourceInfo);
48579bool emitShlSint64Sint8(SourceInfo);
48580bool emitShlSint64Uint8(SourceInfo);
48581bool emitShlSint64Sint16(SourceInfo);
48582bool emitShlSint64Uint16(SourceInfo);
48583bool emitShlSint64Sint32(SourceInfo);
48584bool emitShlSint64Uint32(SourceInfo);
48585bool emitShlSint64Sint64(SourceInfo);
48586bool emitShlSint64Uint64(SourceInfo);
48587bool emitShlSint64IntAP(SourceInfo);
48588bool emitShlSint64IntAPS(SourceInfo);
48589bool emitShlUint64Sint8(SourceInfo);
48590bool emitShlUint64Uint8(SourceInfo);
48591bool emitShlUint64Sint16(SourceInfo);
48592bool emitShlUint64Uint16(SourceInfo);
48593bool emitShlUint64Sint32(SourceInfo);
48594bool emitShlUint64Uint32(SourceInfo);
48595bool emitShlUint64Sint64(SourceInfo);
48596bool emitShlUint64Uint64(SourceInfo);
48597bool emitShlUint64IntAP(SourceInfo);
48598bool emitShlUint64IntAPS(SourceInfo);
48599bool emitShlIntAPSint8(SourceInfo);
48600bool emitShlIntAPUint8(SourceInfo);
48601bool emitShlIntAPSint16(SourceInfo);
48602bool emitShlIntAPUint16(SourceInfo);
48603bool emitShlIntAPSint32(SourceInfo);
48604bool emitShlIntAPUint32(SourceInfo);
48605bool emitShlIntAPSint64(SourceInfo);
48606bool emitShlIntAPUint64(SourceInfo);
48607bool emitShlIntAPIntAP(SourceInfo);
48608bool emitShlIntAPIntAPS(SourceInfo);
48609bool emitShlIntAPSSint8(SourceInfo);
48610bool emitShlIntAPSUint8(SourceInfo);
48611bool emitShlIntAPSSint16(SourceInfo);
48612bool emitShlIntAPSUint16(SourceInfo);
48613bool emitShlIntAPSSint32(SourceInfo);
48614bool emitShlIntAPSUint32(SourceInfo);
48615bool emitShlIntAPSSint64(SourceInfo);
48616bool emitShlIntAPSUint64(SourceInfo);
48617bool emitShlIntAPSIntAP(SourceInfo);
48618bool emitShlIntAPSIntAPS(SourceInfo);
48619#endif
48620#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
48621[[nodiscard]] bool emitShl(PrimType, PrimType, SourceInfo I);
48622#endif
48623#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
48624bool
48625#if defined(GET_EVAL_IMPL)
48626EvalEmitter
48627#else
48628ByteCodeEmitter
48629#endif
48630::emitShl(PrimType T0, PrimType T1, SourceInfo I) {
48631 switch (T0) {
48632 case PT_Sint8:
48633 switch (T1) {
48634 case PT_Sint8:
48635 return emitShlSint8Sint8(I);
48636 case PT_Uint8:
48637 return emitShlSint8Uint8(I);
48638 case PT_Sint16:
48639 return emitShlSint8Sint16(I);
48640 case PT_Uint16:
48641 return emitShlSint8Uint16(I);
48642 case PT_Sint32:
48643 return emitShlSint8Sint32(I);
48644 case PT_Uint32:
48645 return emitShlSint8Uint32(I);
48646 case PT_Sint64:
48647 return emitShlSint8Sint64(I);
48648 case PT_Uint64:
48649 return emitShlSint8Uint64(I);
48650 case PT_IntAP:
48651 return emitShlSint8IntAP(I);
48652 case PT_IntAPS:
48653 return emitShlSint8IntAPS(I);
48654 default: llvm_unreachable("invalid type: emitShl");
48655 }
48656 llvm_unreachable("invalid enum value");
48657 case PT_Uint8:
48658 switch (T1) {
48659 case PT_Sint8:
48660 return emitShlUint8Sint8(I);
48661 case PT_Uint8:
48662 return emitShlUint8Uint8(I);
48663 case PT_Sint16:
48664 return emitShlUint8Sint16(I);
48665 case PT_Uint16:
48666 return emitShlUint8Uint16(I);
48667 case PT_Sint32:
48668 return emitShlUint8Sint32(I);
48669 case PT_Uint32:
48670 return emitShlUint8Uint32(I);
48671 case PT_Sint64:
48672 return emitShlUint8Sint64(I);
48673 case PT_Uint64:
48674 return emitShlUint8Uint64(I);
48675 case PT_IntAP:
48676 return emitShlUint8IntAP(I);
48677 case PT_IntAPS:
48678 return emitShlUint8IntAPS(I);
48679 default: llvm_unreachable("invalid type: emitShl");
48680 }
48681 llvm_unreachable("invalid enum value");
48682 case PT_Sint16:
48683 switch (T1) {
48684 case PT_Sint8:
48685 return emitShlSint16Sint8(I);
48686 case PT_Uint8:
48687 return emitShlSint16Uint8(I);
48688 case PT_Sint16:
48689 return emitShlSint16Sint16(I);
48690 case PT_Uint16:
48691 return emitShlSint16Uint16(I);
48692 case PT_Sint32:
48693 return emitShlSint16Sint32(I);
48694 case PT_Uint32:
48695 return emitShlSint16Uint32(I);
48696 case PT_Sint64:
48697 return emitShlSint16Sint64(I);
48698 case PT_Uint64:
48699 return emitShlSint16Uint64(I);
48700 case PT_IntAP:
48701 return emitShlSint16IntAP(I);
48702 case PT_IntAPS:
48703 return emitShlSint16IntAPS(I);
48704 default: llvm_unreachable("invalid type: emitShl");
48705 }
48706 llvm_unreachable("invalid enum value");
48707 case PT_Uint16:
48708 switch (T1) {
48709 case PT_Sint8:
48710 return emitShlUint16Sint8(I);
48711 case PT_Uint8:
48712 return emitShlUint16Uint8(I);
48713 case PT_Sint16:
48714 return emitShlUint16Sint16(I);
48715 case PT_Uint16:
48716 return emitShlUint16Uint16(I);
48717 case PT_Sint32:
48718 return emitShlUint16Sint32(I);
48719 case PT_Uint32:
48720 return emitShlUint16Uint32(I);
48721 case PT_Sint64:
48722 return emitShlUint16Sint64(I);
48723 case PT_Uint64:
48724 return emitShlUint16Uint64(I);
48725 case PT_IntAP:
48726 return emitShlUint16IntAP(I);
48727 case PT_IntAPS:
48728 return emitShlUint16IntAPS(I);
48729 default: llvm_unreachable("invalid type: emitShl");
48730 }
48731 llvm_unreachable("invalid enum value");
48732 case PT_Sint32:
48733 switch (T1) {
48734 case PT_Sint8:
48735 return emitShlSint32Sint8(I);
48736 case PT_Uint8:
48737 return emitShlSint32Uint8(I);
48738 case PT_Sint16:
48739 return emitShlSint32Sint16(I);
48740 case PT_Uint16:
48741 return emitShlSint32Uint16(I);
48742 case PT_Sint32:
48743 return emitShlSint32Sint32(I);
48744 case PT_Uint32:
48745 return emitShlSint32Uint32(I);
48746 case PT_Sint64:
48747 return emitShlSint32Sint64(I);
48748 case PT_Uint64:
48749 return emitShlSint32Uint64(I);
48750 case PT_IntAP:
48751 return emitShlSint32IntAP(I);
48752 case PT_IntAPS:
48753 return emitShlSint32IntAPS(I);
48754 default: llvm_unreachable("invalid type: emitShl");
48755 }
48756 llvm_unreachable("invalid enum value");
48757 case PT_Uint32:
48758 switch (T1) {
48759 case PT_Sint8:
48760 return emitShlUint32Sint8(I);
48761 case PT_Uint8:
48762 return emitShlUint32Uint8(I);
48763 case PT_Sint16:
48764 return emitShlUint32Sint16(I);
48765 case PT_Uint16:
48766 return emitShlUint32Uint16(I);
48767 case PT_Sint32:
48768 return emitShlUint32Sint32(I);
48769 case PT_Uint32:
48770 return emitShlUint32Uint32(I);
48771 case PT_Sint64:
48772 return emitShlUint32Sint64(I);
48773 case PT_Uint64:
48774 return emitShlUint32Uint64(I);
48775 case PT_IntAP:
48776 return emitShlUint32IntAP(I);
48777 case PT_IntAPS:
48778 return emitShlUint32IntAPS(I);
48779 default: llvm_unreachable("invalid type: emitShl");
48780 }
48781 llvm_unreachable("invalid enum value");
48782 case PT_Sint64:
48783 switch (T1) {
48784 case PT_Sint8:
48785 return emitShlSint64Sint8(I);
48786 case PT_Uint8:
48787 return emitShlSint64Uint8(I);
48788 case PT_Sint16:
48789 return emitShlSint64Sint16(I);
48790 case PT_Uint16:
48791 return emitShlSint64Uint16(I);
48792 case PT_Sint32:
48793 return emitShlSint64Sint32(I);
48794 case PT_Uint32:
48795 return emitShlSint64Uint32(I);
48796 case PT_Sint64:
48797 return emitShlSint64Sint64(I);
48798 case PT_Uint64:
48799 return emitShlSint64Uint64(I);
48800 case PT_IntAP:
48801 return emitShlSint64IntAP(I);
48802 case PT_IntAPS:
48803 return emitShlSint64IntAPS(I);
48804 default: llvm_unreachable("invalid type: emitShl");
48805 }
48806 llvm_unreachable("invalid enum value");
48807 case PT_Uint64:
48808 switch (T1) {
48809 case PT_Sint8:
48810 return emitShlUint64Sint8(I);
48811 case PT_Uint8:
48812 return emitShlUint64Uint8(I);
48813 case PT_Sint16:
48814 return emitShlUint64Sint16(I);
48815 case PT_Uint16:
48816 return emitShlUint64Uint16(I);
48817 case PT_Sint32:
48818 return emitShlUint64Sint32(I);
48819 case PT_Uint32:
48820 return emitShlUint64Uint32(I);
48821 case PT_Sint64:
48822 return emitShlUint64Sint64(I);
48823 case PT_Uint64:
48824 return emitShlUint64Uint64(I);
48825 case PT_IntAP:
48826 return emitShlUint64IntAP(I);
48827 case PT_IntAPS:
48828 return emitShlUint64IntAPS(I);
48829 default: llvm_unreachable("invalid type: emitShl");
48830 }
48831 llvm_unreachable("invalid enum value");
48832 case PT_IntAP:
48833 switch (T1) {
48834 case PT_Sint8:
48835 return emitShlIntAPSint8(I);
48836 case PT_Uint8:
48837 return emitShlIntAPUint8(I);
48838 case PT_Sint16:
48839 return emitShlIntAPSint16(I);
48840 case PT_Uint16:
48841 return emitShlIntAPUint16(I);
48842 case PT_Sint32:
48843 return emitShlIntAPSint32(I);
48844 case PT_Uint32:
48845 return emitShlIntAPUint32(I);
48846 case PT_Sint64:
48847 return emitShlIntAPSint64(I);
48848 case PT_Uint64:
48849 return emitShlIntAPUint64(I);
48850 case PT_IntAP:
48851 return emitShlIntAPIntAP(I);
48852 case PT_IntAPS:
48853 return emitShlIntAPIntAPS(I);
48854 default: llvm_unreachable("invalid type: emitShl");
48855 }
48856 llvm_unreachable("invalid enum value");
48857 case PT_IntAPS:
48858 switch (T1) {
48859 case PT_Sint8:
48860 return emitShlIntAPSSint8(I);
48861 case PT_Uint8:
48862 return emitShlIntAPSUint8(I);
48863 case PT_Sint16:
48864 return emitShlIntAPSSint16(I);
48865 case PT_Uint16:
48866 return emitShlIntAPSUint16(I);
48867 case PT_Sint32:
48868 return emitShlIntAPSSint32(I);
48869 case PT_Uint32:
48870 return emitShlIntAPSUint32(I);
48871 case PT_Sint64:
48872 return emitShlIntAPSSint64(I);
48873 case PT_Uint64:
48874 return emitShlIntAPSUint64(I);
48875 case PT_IntAP:
48876 return emitShlIntAPSIntAP(I);
48877 case PT_IntAPS:
48878 return emitShlIntAPSIntAPS(I);
48879 default: llvm_unreachable("invalid type: emitShl");
48880 }
48881 llvm_unreachable("invalid enum value");
48882 default: llvm_unreachable("invalid type: emitShl");
48883 }
48884 llvm_unreachable("invalid enum value");
48885}
48886#endif
48887#ifdef GET_LINK_IMPL
48888bool ByteCodeEmitter::emitShlSint8Sint8(SourceInfo L) {
48889 return emitOp<>(OP_ShlSint8Sint8, L);
48890}
48891bool ByteCodeEmitter::emitShlSint8Uint8(SourceInfo L) {
48892 return emitOp<>(OP_ShlSint8Uint8, L);
48893}
48894bool ByteCodeEmitter::emitShlSint8Sint16(SourceInfo L) {
48895 return emitOp<>(OP_ShlSint8Sint16, L);
48896}
48897bool ByteCodeEmitter::emitShlSint8Uint16(SourceInfo L) {
48898 return emitOp<>(OP_ShlSint8Uint16, L);
48899}
48900bool ByteCodeEmitter::emitShlSint8Sint32(SourceInfo L) {
48901 return emitOp<>(OP_ShlSint8Sint32, L);
48902}
48903bool ByteCodeEmitter::emitShlSint8Uint32(SourceInfo L) {
48904 return emitOp<>(OP_ShlSint8Uint32, L);
48905}
48906bool ByteCodeEmitter::emitShlSint8Sint64(SourceInfo L) {
48907 return emitOp<>(OP_ShlSint8Sint64, L);
48908}
48909bool ByteCodeEmitter::emitShlSint8Uint64(SourceInfo L) {
48910 return emitOp<>(OP_ShlSint8Uint64, L);
48911}
48912bool ByteCodeEmitter::emitShlSint8IntAP(SourceInfo L) {
48913 return emitOp<>(OP_ShlSint8IntAP, L);
48914}
48915bool ByteCodeEmitter::emitShlSint8IntAPS(SourceInfo L) {
48916 return emitOp<>(OP_ShlSint8IntAPS, L);
48917}
48918bool ByteCodeEmitter::emitShlUint8Sint8(SourceInfo L) {
48919 return emitOp<>(OP_ShlUint8Sint8, L);
48920}
48921bool ByteCodeEmitter::emitShlUint8Uint8(SourceInfo L) {
48922 return emitOp<>(OP_ShlUint8Uint8, L);
48923}
48924bool ByteCodeEmitter::emitShlUint8Sint16(SourceInfo L) {
48925 return emitOp<>(OP_ShlUint8Sint16, L);
48926}
48927bool ByteCodeEmitter::emitShlUint8Uint16(SourceInfo L) {
48928 return emitOp<>(OP_ShlUint8Uint16, L);
48929}
48930bool ByteCodeEmitter::emitShlUint8Sint32(SourceInfo L) {
48931 return emitOp<>(OP_ShlUint8Sint32, L);
48932}
48933bool ByteCodeEmitter::emitShlUint8Uint32(SourceInfo L) {
48934 return emitOp<>(OP_ShlUint8Uint32, L);
48935}
48936bool ByteCodeEmitter::emitShlUint8Sint64(SourceInfo L) {
48937 return emitOp<>(OP_ShlUint8Sint64, L);
48938}
48939bool ByteCodeEmitter::emitShlUint8Uint64(SourceInfo L) {
48940 return emitOp<>(OP_ShlUint8Uint64, L);
48941}
48942bool ByteCodeEmitter::emitShlUint8IntAP(SourceInfo L) {
48943 return emitOp<>(OP_ShlUint8IntAP, L);
48944}
48945bool ByteCodeEmitter::emitShlUint8IntAPS(SourceInfo L) {
48946 return emitOp<>(OP_ShlUint8IntAPS, L);
48947}
48948bool ByteCodeEmitter::emitShlSint16Sint8(SourceInfo L) {
48949 return emitOp<>(OP_ShlSint16Sint8, L);
48950}
48951bool ByteCodeEmitter::emitShlSint16Uint8(SourceInfo L) {
48952 return emitOp<>(OP_ShlSint16Uint8, L);
48953}
48954bool ByteCodeEmitter::emitShlSint16Sint16(SourceInfo L) {
48955 return emitOp<>(OP_ShlSint16Sint16, L);
48956}
48957bool ByteCodeEmitter::emitShlSint16Uint16(SourceInfo L) {
48958 return emitOp<>(OP_ShlSint16Uint16, L);
48959}
48960bool ByteCodeEmitter::emitShlSint16Sint32(SourceInfo L) {
48961 return emitOp<>(OP_ShlSint16Sint32, L);
48962}
48963bool ByteCodeEmitter::emitShlSint16Uint32(SourceInfo L) {
48964 return emitOp<>(OP_ShlSint16Uint32, L);
48965}
48966bool ByteCodeEmitter::emitShlSint16Sint64(SourceInfo L) {
48967 return emitOp<>(OP_ShlSint16Sint64, L);
48968}
48969bool ByteCodeEmitter::emitShlSint16Uint64(SourceInfo L) {
48970 return emitOp<>(OP_ShlSint16Uint64, L);
48971}
48972bool ByteCodeEmitter::emitShlSint16IntAP(SourceInfo L) {
48973 return emitOp<>(OP_ShlSint16IntAP, L);
48974}
48975bool ByteCodeEmitter::emitShlSint16IntAPS(SourceInfo L) {
48976 return emitOp<>(OP_ShlSint16IntAPS, L);
48977}
48978bool ByteCodeEmitter::emitShlUint16Sint8(SourceInfo L) {
48979 return emitOp<>(OP_ShlUint16Sint8, L);
48980}
48981bool ByteCodeEmitter::emitShlUint16Uint8(SourceInfo L) {
48982 return emitOp<>(OP_ShlUint16Uint8, L);
48983}
48984bool ByteCodeEmitter::emitShlUint16Sint16(SourceInfo L) {
48985 return emitOp<>(OP_ShlUint16Sint16, L);
48986}
48987bool ByteCodeEmitter::emitShlUint16Uint16(SourceInfo L) {
48988 return emitOp<>(OP_ShlUint16Uint16, L);
48989}
48990bool ByteCodeEmitter::emitShlUint16Sint32(SourceInfo L) {
48991 return emitOp<>(OP_ShlUint16Sint32, L);
48992}
48993bool ByteCodeEmitter::emitShlUint16Uint32(SourceInfo L) {
48994 return emitOp<>(OP_ShlUint16Uint32, L);
48995}
48996bool ByteCodeEmitter::emitShlUint16Sint64(SourceInfo L) {
48997 return emitOp<>(OP_ShlUint16Sint64, L);
48998}
48999bool ByteCodeEmitter::emitShlUint16Uint64(SourceInfo L) {
49000 return emitOp<>(OP_ShlUint16Uint64, L);
49001}
49002bool ByteCodeEmitter::emitShlUint16IntAP(SourceInfo L) {
49003 return emitOp<>(OP_ShlUint16IntAP, L);
49004}
49005bool ByteCodeEmitter::emitShlUint16IntAPS(SourceInfo L) {
49006 return emitOp<>(OP_ShlUint16IntAPS, L);
49007}
49008bool ByteCodeEmitter::emitShlSint32Sint8(SourceInfo L) {
49009 return emitOp<>(OP_ShlSint32Sint8, L);
49010}
49011bool ByteCodeEmitter::emitShlSint32Uint8(SourceInfo L) {
49012 return emitOp<>(OP_ShlSint32Uint8, L);
49013}
49014bool ByteCodeEmitter::emitShlSint32Sint16(SourceInfo L) {
49015 return emitOp<>(OP_ShlSint32Sint16, L);
49016}
49017bool ByteCodeEmitter::emitShlSint32Uint16(SourceInfo L) {
49018 return emitOp<>(OP_ShlSint32Uint16, L);
49019}
49020bool ByteCodeEmitter::emitShlSint32Sint32(SourceInfo L) {
49021 return emitOp<>(OP_ShlSint32Sint32, L);
49022}
49023bool ByteCodeEmitter::emitShlSint32Uint32(SourceInfo L) {
49024 return emitOp<>(OP_ShlSint32Uint32, L);
49025}
49026bool ByteCodeEmitter::emitShlSint32Sint64(SourceInfo L) {
49027 return emitOp<>(OP_ShlSint32Sint64, L);
49028}
49029bool ByteCodeEmitter::emitShlSint32Uint64(SourceInfo L) {
49030 return emitOp<>(OP_ShlSint32Uint64, L);
49031}
49032bool ByteCodeEmitter::emitShlSint32IntAP(SourceInfo L) {
49033 return emitOp<>(OP_ShlSint32IntAP, L);
49034}
49035bool ByteCodeEmitter::emitShlSint32IntAPS(SourceInfo L) {
49036 return emitOp<>(OP_ShlSint32IntAPS, L);
49037}
49038bool ByteCodeEmitter::emitShlUint32Sint8(SourceInfo L) {
49039 return emitOp<>(OP_ShlUint32Sint8, L);
49040}
49041bool ByteCodeEmitter::emitShlUint32Uint8(SourceInfo L) {
49042 return emitOp<>(OP_ShlUint32Uint8, L);
49043}
49044bool ByteCodeEmitter::emitShlUint32Sint16(SourceInfo L) {
49045 return emitOp<>(OP_ShlUint32Sint16, L);
49046}
49047bool ByteCodeEmitter::emitShlUint32Uint16(SourceInfo L) {
49048 return emitOp<>(OP_ShlUint32Uint16, L);
49049}
49050bool ByteCodeEmitter::emitShlUint32Sint32(SourceInfo L) {
49051 return emitOp<>(OP_ShlUint32Sint32, L);
49052}
49053bool ByteCodeEmitter::emitShlUint32Uint32(SourceInfo L) {
49054 return emitOp<>(OP_ShlUint32Uint32, L);
49055}
49056bool ByteCodeEmitter::emitShlUint32Sint64(SourceInfo L) {
49057 return emitOp<>(OP_ShlUint32Sint64, L);
49058}
49059bool ByteCodeEmitter::emitShlUint32Uint64(SourceInfo L) {
49060 return emitOp<>(OP_ShlUint32Uint64, L);
49061}
49062bool ByteCodeEmitter::emitShlUint32IntAP(SourceInfo L) {
49063 return emitOp<>(OP_ShlUint32IntAP, L);
49064}
49065bool ByteCodeEmitter::emitShlUint32IntAPS(SourceInfo L) {
49066 return emitOp<>(OP_ShlUint32IntAPS, L);
49067}
49068bool ByteCodeEmitter::emitShlSint64Sint8(SourceInfo L) {
49069 return emitOp<>(OP_ShlSint64Sint8, L);
49070}
49071bool ByteCodeEmitter::emitShlSint64Uint8(SourceInfo L) {
49072 return emitOp<>(OP_ShlSint64Uint8, L);
49073}
49074bool ByteCodeEmitter::emitShlSint64Sint16(SourceInfo L) {
49075 return emitOp<>(OP_ShlSint64Sint16, L);
49076}
49077bool ByteCodeEmitter::emitShlSint64Uint16(SourceInfo L) {
49078 return emitOp<>(OP_ShlSint64Uint16, L);
49079}
49080bool ByteCodeEmitter::emitShlSint64Sint32(SourceInfo L) {
49081 return emitOp<>(OP_ShlSint64Sint32, L);
49082}
49083bool ByteCodeEmitter::emitShlSint64Uint32(SourceInfo L) {
49084 return emitOp<>(OP_ShlSint64Uint32, L);
49085}
49086bool ByteCodeEmitter::emitShlSint64Sint64(SourceInfo L) {
49087 return emitOp<>(OP_ShlSint64Sint64, L);
49088}
49089bool ByteCodeEmitter::emitShlSint64Uint64(SourceInfo L) {
49090 return emitOp<>(OP_ShlSint64Uint64, L);
49091}
49092bool ByteCodeEmitter::emitShlSint64IntAP(SourceInfo L) {
49093 return emitOp<>(OP_ShlSint64IntAP, L);
49094}
49095bool ByteCodeEmitter::emitShlSint64IntAPS(SourceInfo L) {
49096 return emitOp<>(OP_ShlSint64IntAPS, L);
49097}
49098bool ByteCodeEmitter::emitShlUint64Sint8(SourceInfo L) {
49099 return emitOp<>(OP_ShlUint64Sint8, L);
49100}
49101bool ByteCodeEmitter::emitShlUint64Uint8(SourceInfo L) {
49102 return emitOp<>(OP_ShlUint64Uint8, L);
49103}
49104bool ByteCodeEmitter::emitShlUint64Sint16(SourceInfo L) {
49105 return emitOp<>(OP_ShlUint64Sint16, L);
49106}
49107bool ByteCodeEmitter::emitShlUint64Uint16(SourceInfo L) {
49108 return emitOp<>(OP_ShlUint64Uint16, L);
49109}
49110bool ByteCodeEmitter::emitShlUint64Sint32(SourceInfo L) {
49111 return emitOp<>(OP_ShlUint64Sint32, L);
49112}
49113bool ByteCodeEmitter::emitShlUint64Uint32(SourceInfo L) {
49114 return emitOp<>(OP_ShlUint64Uint32, L);
49115}
49116bool ByteCodeEmitter::emitShlUint64Sint64(SourceInfo L) {
49117 return emitOp<>(OP_ShlUint64Sint64, L);
49118}
49119bool ByteCodeEmitter::emitShlUint64Uint64(SourceInfo L) {
49120 return emitOp<>(OP_ShlUint64Uint64, L);
49121}
49122bool ByteCodeEmitter::emitShlUint64IntAP(SourceInfo L) {
49123 return emitOp<>(OP_ShlUint64IntAP, L);
49124}
49125bool ByteCodeEmitter::emitShlUint64IntAPS(SourceInfo L) {
49126 return emitOp<>(OP_ShlUint64IntAPS, L);
49127}
49128bool ByteCodeEmitter::emitShlIntAPSint8(SourceInfo L) {
49129 return emitOp<>(OP_ShlIntAPSint8, L);
49130}
49131bool ByteCodeEmitter::emitShlIntAPUint8(SourceInfo L) {
49132 return emitOp<>(OP_ShlIntAPUint8, L);
49133}
49134bool ByteCodeEmitter::emitShlIntAPSint16(SourceInfo L) {
49135 return emitOp<>(OP_ShlIntAPSint16, L);
49136}
49137bool ByteCodeEmitter::emitShlIntAPUint16(SourceInfo L) {
49138 return emitOp<>(OP_ShlIntAPUint16, L);
49139}
49140bool ByteCodeEmitter::emitShlIntAPSint32(SourceInfo L) {
49141 return emitOp<>(OP_ShlIntAPSint32, L);
49142}
49143bool ByteCodeEmitter::emitShlIntAPUint32(SourceInfo L) {
49144 return emitOp<>(OP_ShlIntAPUint32, L);
49145}
49146bool ByteCodeEmitter::emitShlIntAPSint64(SourceInfo L) {
49147 return emitOp<>(OP_ShlIntAPSint64, L);
49148}
49149bool ByteCodeEmitter::emitShlIntAPUint64(SourceInfo L) {
49150 return emitOp<>(OP_ShlIntAPUint64, L);
49151}
49152bool ByteCodeEmitter::emitShlIntAPIntAP(SourceInfo L) {
49153 return emitOp<>(OP_ShlIntAPIntAP, L);
49154}
49155bool ByteCodeEmitter::emitShlIntAPIntAPS(SourceInfo L) {
49156 return emitOp<>(OP_ShlIntAPIntAPS, L);
49157}
49158bool ByteCodeEmitter::emitShlIntAPSSint8(SourceInfo L) {
49159 return emitOp<>(OP_ShlIntAPSSint8, L);
49160}
49161bool ByteCodeEmitter::emitShlIntAPSUint8(SourceInfo L) {
49162 return emitOp<>(OP_ShlIntAPSUint8, L);
49163}
49164bool ByteCodeEmitter::emitShlIntAPSSint16(SourceInfo L) {
49165 return emitOp<>(OP_ShlIntAPSSint16, L);
49166}
49167bool ByteCodeEmitter::emitShlIntAPSUint16(SourceInfo L) {
49168 return emitOp<>(OP_ShlIntAPSUint16, L);
49169}
49170bool ByteCodeEmitter::emitShlIntAPSSint32(SourceInfo L) {
49171 return emitOp<>(OP_ShlIntAPSSint32, L);
49172}
49173bool ByteCodeEmitter::emitShlIntAPSUint32(SourceInfo L) {
49174 return emitOp<>(OP_ShlIntAPSUint32, L);
49175}
49176bool ByteCodeEmitter::emitShlIntAPSSint64(SourceInfo L) {
49177 return emitOp<>(OP_ShlIntAPSSint64, L);
49178}
49179bool ByteCodeEmitter::emitShlIntAPSUint64(SourceInfo L) {
49180 return emitOp<>(OP_ShlIntAPSUint64, L);
49181}
49182bool ByteCodeEmitter::emitShlIntAPSIntAP(SourceInfo L) {
49183 return emitOp<>(OP_ShlIntAPSIntAP, L);
49184}
49185bool ByteCodeEmitter::emitShlIntAPSIntAPS(SourceInfo L) {
49186 return emitOp<>(OP_ShlIntAPSIntAPS, L);
49187}
49188#endif
49189#ifdef GET_EVAL_IMPL
49190bool EvalEmitter::emitShlSint8Sint8(SourceInfo L) {
49191 if (!isActive()) return true;
49192 CurrentSource = L;
49193 return Shl<PT_Sint8, PT_Sint8>(S, CodePtr());
49194}
49195bool EvalEmitter::emitShlSint8Uint8(SourceInfo L) {
49196 if (!isActive()) return true;
49197 CurrentSource = L;
49198 return Shl<PT_Sint8, PT_Uint8>(S, CodePtr());
49199}
49200bool EvalEmitter::emitShlSint8Sint16(SourceInfo L) {
49201 if (!isActive()) return true;
49202 CurrentSource = L;
49203 return Shl<PT_Sint8, PT_Sint16>(S, CodePtr());
49204}
49205bool EvalEmitter::emitShlSint8Uint16(SourceInfo L) {
49206 if (!isActive()) return true;
49207 CurrentSource = L;
49208 return Shl<PT_Sint8, PT_Uint16>(S, CodePtr());
49209}
49210bool EvalEmitter::emitShlSint8Sint32(SourceInfo L) {
49211 if (!isActive()) return true;
49212 CurrentSource = L;
49213 return Shl<PT_Sint8, PT_Sint32>(S, CodePtr());
49214}
49215bool EvalEmitter::emitShlSint8Uint32(SourceInfo L) {
49216 if (!isActive()) return true;
49217 CurrentSource = L;
49218 return Shl<PT_Sint8, PT_Uint32>(S, CodePtr());
49219}
49220bool EvalEmitter::emitShlSint8Sint64(SourceInfo L) {
49221 if (!isActive()) return true;
49222 CurrentSource = L;
49223 return Shl<PT_Sint8, PT_Sint64>(S, CodePtr());
49224}
49225bool EvalEmitter::emitShlSint8Uint64(SourceInfo L) {
49226 if (!isActive()) return true;
49227 CurrentSource = L;
49228 return Shl<PT_Sint8, PT_Uint64>(S, CodePtr());
49229}
49230bool EvalEmitter::emitShlSint8IntAP(SourceInfo L) {
49231 if (!isActive()) return true;
49232 CurrentSource = L;
49233 return Shl<PT_Sint8, PT_IntAP>(S, CodePtr());
49234}
49235bool EvalEmitter::emitShlSint8IntAPS(SourceInfo L) {
49236 if (!isActive()) return true;
49237 CurrentSource = L;
49238 return Shl<PT_Sint8, PT_IntAPS>(S, CodePtr());
49239}
49240bool EvalEmitter::emitShlUint8Sint8(SourceInfo L) {
49241 if (!isActive()) return true;
49242 CurrentSource = L;
49243 return Shl<PT_Uint8, PT_Sint8>(S, CodePtr());
49244}
49245bool EvalEmitter::emitShlUint8Uint8(SourceInfo L) {
49246 if (!isActive()) return true;
49247 CurrentSource = L;
49248 return Shl<PT_Uint8, PT_Uint8>(S, CodePtr());
49249}
49250bool EvalEmitter::emitShlUint8Sint16(SourceInfo L) {
49251 if (!isActive()) return true;
49252 CurrentSource = L;
49253 return Shl<PT_Uint8, PT_Sint16>(S, CodePtr());
49254}
49255bool EvalEmitter::emitShlUint8Uint16(SourceInfo L) {
49256 if (!isActive()) return true;
49257 CurrentSource = L;
49258 return Shl<PT_Uint8, PT_Uint16>(S, CodePtr());
49259}
49260bool EvalEmitter::emitShlUint8Sint32(SourceInfo L) {
49261 if (!isActive()) return true;
49262 CurrentSource = L;
49263 return Shl<PT_Uint8, PT_Sint32>(S, CodePtr());
49264}
49265bool EvalEmitter::emitShlUint8Uint32(SourceInfo L) {
49266 if (!isActive()) return true;
49267 CurrentSource = L;
49268 return Shl<PT_Uint8, PT_Uint32>(S, CodePtr());
49269}
49270bool EvalEmitter::emitShlUint8Sint64(SourceInfo L) {
49271 if (!isActive()) return true;
49272 CurrentSource = L;
49273 return Shl<PT_Uint8, PT_Sint64>(S, CodePtr());
49274}
49275bool EvalEmitter::emitShlUint8Uint64(SourceInfo L) {
49276 if (!isActive()) return true;
49277 CurrentSource = L;
49278 return Shl<PT_Uint8, PT_Uint64>(S, CodePtr());
49279}
49280bool EvalEmitter::emitShlUint8IntAP(SourceInfo L) {
49281 if (!isActive()) return true;
49282 CurrentSource = L;
49283 return Shl<PT_Uint8, PT_IntAP>(S, CodePtr());
49284}
49285bool EvalEmitter::emitShlUint8IntAPS(SourceInfo L) {
49286 if (!isActive()) return true;
49287 CurrentSource = L;
49288 return Shl<PT_Uint8, PT_IntAPS>(S, CodePtr());
49289}
49290bool EvalEmitter::emitShlSint16Sint8(SourceInfo L) {
49291 if (!isActive()) return true;
49292 CurrentSource = L;
49293 return Shl<PT_Sint16, PT_Sint8>(S, CodePtr());
49294}
49295bool EvalEmitter::emitShlSint16Uint8(SourceInfo L) {
49296 if (!isActive()) return true;
49297 CurrentSource = L;
49298 return Shl<PT_Sint16, PT_Uint8>(S, CodePtr());
49299}
49300bool EvalEmitter::emitShlSint16Sint16(SourceInfo L) {
49301 if (!isActive()) return true;
49302 CurrentSource = L;
49303 return Shl<PT_Sint16, PT_Sint16>(S, CodePtr());
49304}
49305bool EvalEmitter::emitShlSint16Uint16(SourceInfo L) {
49306 if (!isActive()) return true;
49307 CurrentSource = L;
49308 return Shl<PT_Sint16, PT_Uint16>(S, CodePtr());
49309}
49310bool EvalEmitter::emitShlSint16Sint32(SourceInfo L) {
49311 if (!isActive()) return true;
49312 CurrentSource = L;
49313 return Shl<PT_Sint16, PT_Sint32>(S, CodePtr());
49314}
49315bool EvalEmitter::emitShlSint16Uint32(SourceInfo L) {
49316 if (!isActive()) return true;
49317 CurrentSource = L;
49318 return Shl<PT_Sint16, PT_Uint32>(S, CodePtr());
49319}
49320bool EvalEmitter::emitShlSint16Sint64(SourceInfo L) {
49321 if (!isActive()) return true;
49322 CurrentSource = L;
49323 return Shl<PT_Sint16, PT_Sint64>(S, CodePtr());
49324}
49325bool EvalEmitter::emitShlSint16Uint64(SourceInfo L) {
49326 if (!isActive()) return true;
49327 CurrentSource = L;
49328 return Shl<PT_Sint16, PT_Uint64>(S, CodePtr());
49329}
49330bool EvalEmitter::emitShlSint16IntAP(SourceInfo L) {
49331 if (!isActive()) return true;
49332 CurrentSource = L;
49333 return Shl<PT_Sint16, PT_IntAP>(S, CodePtr());
49334}
49335bool EvalEmitter::emitShlSint16IntAPS(SourceInfo L) {
49336 if (!isActive()) return true;
49337 CurrentSource = L;
49338 return Shl<PT_Sint16, PT_IntAPS>(S, CodePtr());
49339}
49340bool EvalEmitter::emitShlUint16Sint8(SourceInfo L) {
49341 if (!isActive()) return true;
49342 CurrentSource = L;
49343 return Shl<PT_Uint16, PT_Sint8>(S, CodePtr());
49344}
49345bool EvalEmitter::emitShlUint16Uint8(SourceInfo L) {
49346 if (!isActive()) return true;
49347 CurrentSource = L;
49348 return Shl<PT_Uint16, PT_Uint8>(S, CodePtr());
49349}
49350bool EvalEmitter::emitShlUint16Sint16(SourceInfo L) {
49351 if (!isActive()) return true;
49352 CurrentSource = L;
49353 return Shl<PT_Uint16, PT_Sint16>(S, CodePtr());
49354}
49355bool EvalEmitter::emitShlUint16Uint16(SourceInfo L) {
49356 if (!isActive()) return true;
49357 CurrentSource = L;
49358 return Shl<PT_Uint16, PT_Uint16>(S, CodePtr());
49359}
49360bool EvalEmitter::emitShlUint16Sint32(SourceInfo L) {
49361 if (!isActive()) return true;
49362 CurrentSource = L;
49363 return Shl<PT_Uint16, PT_Sint32>(S, CodePtr());
49364}
49365bool EvalEmitter::emitShlUint16Uint32(SourceInfo L) {
49366 if (!isActive()) return true;
49367 CurrentSource = L;
49368 return Shl<PT_Uint16, PT_Uint32>(S, CodePtr());
49369}
49370bool EvalEmitter::emitShlUint16Sint64(SourceInfo L) {
49371 if (!isActive()) return true;
49372 CurrentSource = L;
49373 return Shl<PT_Uint16, PT_Sint64>(S, CodePtr());
49374}
49375bool EvalEmitter::emitShlUint16Uint64(SourceInfo L) {
49376 if (!isActive()) return true;
49377 CurrentSource = L;
49378 return Shl<PT_Uint16, PT_Uint64>(S, CodePtr());
49379}
49380bool EvalEmitter::emitShlUint16IntAP(SourceInfo L) {
49381 if (!isActive()) return true;
49382 CurrentSource = L;
49383 return Shl<PT_Uint16, PT_IntAP>(S, CodePtr());
49384}
49385bool EvalEmitter::emitShlUint16IntAPS(SourceInfo L) {
49386 if (!isActive()) return true;
49387 CurrentSource = L;
49388 return Shl<PT_Uint16, PT_IntAPS>(S, CodePtr());
49389}
49390bool EvalEmitter::emitShlSint32Sint8(SourceInfo L) {
49391 if (!isActive()) return true;
49392 CurrentSource = L;
49393 return Shl<PT_Sint32, PT_Sint8>(S, CodePtr());
49394}
49395bool EvalEmitter::emitShlSint32Uint8(SourceInfo L) {
49396 if (!isActive()) return true;
49397 CurrentSource = L;
49398 return Shl<PT_Sint32, PT_Uint8>(S, CodePtr());
49399}
49400bool EvalEmitter::emitShlSint32Sint16(SourceInfo L) {
49401 if (!isActive()) return true;
49402 CurrentSource = L;
49403 return Shl<PT_Sint32, PT_Sint16>(S, CodePtr());
49404}
49405bool EvalEmitter::emitShlSint32Uint16(SourceInfo L) {
49406 if (!isActive()) return true;
49407 CurrentSource = L;
49408 return Shl<PT_Sint32, PT_Uint16>(S, CodePtr());
49409}
49410bool EvalEmitter::emitShlSint32Sint32(SourceInfo L) {
49411 if (!isActive()) return true;
49412 CurrentSource = L;
49413 return Shl<PT_Sint32, PT_Sint32>(S, CodePtr());
49414}
49415bool EvalEmitter::emitShlSint32Uint32(SourceInfo L) {
49416 if (!isActive()) return true;
49417 CurrentSource = L;
49418 return Shl<PT_Sint32, PT_Uint32>(S, CodePtr());
49419}
49420bool EvalEmitter::emitShlSint32Sint64(SourceInfo L) {
49421 if (!isActive()) return true;
49422 CurrentSource = L;
49423 return Shl<PT_Sint32, PT_Sint64>(S, CodePtr());
49424}
49425bool EvalEmitter::emitShlSint32Uint64(SourceInfo L) {
49426 if (!isActive()) return true;
49427 CurrentSource = L;
49428 return Shl<PT_Sint32, PT_Uint64>(S, CodePtr());
49429}
49430bool EvalEmitter::emitShlSint32IntAP(SourceInfo L) {
49431 if (!isActive()) return true;
49432 CurrentSource = L;
49433 return Shl<PT_Sint32, PT_IntAP>(S, CodePtr());
49434}
49435bool EvalEmitter::emitShlSint32IntAPS(SourceInfo L) {
49436 if (!isActive()) return true;
49437 CurrentSource = L;
49438 return Shl<PT_Sint32, PT_IntAPS>(S, CodePtr());
49439}
49440bool EvalEmitter::emitShlUint32Sint8(SourceInfo L) {
49441 if (!isActive()) return true;
49442 CurrentSource = L;
49443 return Shl<PT_Uint32, PT_Sint8>(S, CodePtr());
49444}
49445bool EvalEmitter::emitShlUint32Uint8(SourceInfo L) {
49446 if (!isActive()) return true;
49447 CurrentSource = L;
49448 return Shl<PT_Uint32, PT_Uint8>(S, CodePtr());
49449}
49450bool EvalEmitter::emitShlUint32Sint16(SourceInfo L) {
49451 if (!isActive()) return true;
49452 CurrentSource = L;
49453 return Shl<PT_Uint32, PT_Sint16>(S, CodePtr());
49454}
49455bool EvalEmitter::emitShlUint32Uint16(SourceInfo L) {
49456 if (!isActive()) return true;
49457 CurrentSource = L;
49458 return Shl<PT_Uint32, PT_Uint16>(S, CodePtr());
49459}
49460bool EvalEmitter::emitShlUint32Sint32(SourceInfo L) {
49461 if (!isActive()) return true;
49462 CurrentSource = L;
49463 return Shl<PT_Uint32, PT_Sint32>(S, CodePtr());
49464}
49465bool EvalEmitter::emitShlUint32Uint32(SourceInfo L) {
49466 if (!isActive()) return true;
49467 CurrentSource = L;
49468 return Shl<PT_Uint32, PT_Uint32>(S, CodePtr());
49469}
49470bool EvalEmitter::emitShlUint32Sint64(SourceInfo L) {
49471 if (!isActive()) return true;
49472 CurrentSource = L;
49473 return Shl<PT_Uint32, PT_Sint64>(S, CodePtr());
49474}
49475bool EvalEmitter::emitShlUint32Uint64(SourceInfo L) {
49476 if (!isActive()) return true;
49477 CurrentSource = L;
49478 return Shl<PT_Uint32, PT_Uint64>(S, CodePtr());
49479}
49480bool EvalEmitter::emitShlUint32IntAP(SourceInfo L) {
49481 if (!isActive()) return true;
49482 CurrentSource = L;
49483 return Shl<PT_Uint32, PT_IntAP>(S, CodePtr());
49484}
49485bool EvalEmitter::emitShlUint32IntAPS(SourceInfo L) {
49486 if (!isActive()) return true;
49487 CurrentSource = L;
49488 return Shl<PT_Uint32, PT_IntAPS>(S, CodePtr());
49489}
49490bool EvalEmitter::emitShlSint64Sint8(SourceInfo L) {
49491 if (!isActive()) return true;
49492 CurrentSource = L;
49493 return Shl<PT_Sint64, PT_Sint8>(S, CodePtr());
49494}
49495bool EvalEmitter::emitShlSint64Uint8(SourceInfo L) {
49496 if (!isActive()) return true;
49497 CurrentSource = L;
49498 return Shl<PT_Sint64, PT_Uint8>(S, CodePtr());
49499}
49500bool EvalEmitter::emitShlSint64Sint16(SourceInfo L) {
49501 if (!isActive()) return true;
49502 CurrentSource = L;
49503 return Shl<PT_Sint64, PT_Sint16>(S, CodePtr());
49504}
49505bool EvalEmitter::emitShlSint64Uint16(SourceInfo L) {
49506 if (!isActive()) return true;
49507 CurrentSource = L;
49508 return Shl<PT_Sint64, PT_Uint16>(S, CodePtr());
49509}
49510bool EvalEmitter::emitShlSint64Sint32(SourceInfo L) {
49511 if (!isActive()) return true;
49512 CurrentSource = L;
49513 return Shl<PT_Sint64, PT_Sint32>(S, CodePtr());
49514}
49515bool EvalEmitter::emitShlSint64Uint32(SourceInfo L) {
49516 if (!isActive()) return true;
49517 CurrentSource = L;
49518 return Shl<PT_Sint64, PT_Uint32>(S, CodePtr());
49519}
49520bool EvalEmitter::emitShlSint64Sint64(SourceInfo L) {
49521 if (!isActive()) return true;
49522 CurrentSource = L;
49523 return Shl<PT_Sint64, PT_Sint64>(S, CodePtr());
49524}
49525bool EvalEmitter::emitShlSint64Uint64(SourceInfo L) {
49526 if (!isActive()) return true;
49527 CurrentSource = L;
49528 return Shl<PT_Sint64, PT_Uint64>(S, CodePtr());
49529}
49530bool EvalEmitter::emitShlSint64IntAP(SourceInfo L) {
49531 if (!isActive()) return true;
49532 CurrentSource = L;
49533 return Shl<PT_Sint64, PT_IntAP>(S, CodePtr());
49534}
49535bool EvalEmitter::emitShlSint64IntAPS(SourceInfo L) {
49536 if (!isActive()) return true;
49537 CurrentSource = L;
49538 return Shl<PT_Sint64, PT_IntAPS>(S, CodePtr());
49539}
49540bool EvalEmitter::emitShlUint64Sint8(SourceInfo L) {
49541 if (!isActive()) return true;
49542 CurrentSource = L;
49543 return Shl<PT_Uint64, PT_Sint8>(S, CodePtr());
49544}
49545bool EvalEmitter::emitShlUint64Uint8(SourceInfo L) {
49546 if (!isActive()) return true;
49547 CurrentSource = L;
49548 return Shl<PT_Uint64, PT_Uint8>(S, CodePtr());
49549}
49550bool EvalEmitter::emitShlUint64Sint16(SourceInfo L) {
49551 if (!isActive()) return true;
49552 CurrentSource = L;
49553 return Shl<PT_Uint64, PT_Sint16>(S, CodePtr());
49554}
49555bool EvalEmitter::emitShlUint64Uint16(SourceInfo L) {
49556 if (!isActive()) return true;
49557 CurrentSource = L;
49558 return Shl<PT_Uint64, PT_Uint16>(S, CodePtr());
49559}
49560bool EvalEmitter::emitShlUint64Sint32(SourceInfo L) {
49561 if (!isActive()) return true;
49562 CurrentSource = L;
49563 return Shl<PT_Uint64, PT_Sint32>(S, CodePtr());
49564}
49565bool EvalEmitter::emitShlUint64Uint32(SourceInfo L) {
49566 if (!isActive()) return true;
49567 CurrentSource = L;
49568 return Shl<PT_Uint64, PT_Uint32>(S, CodePtr());
49569}
49570bool EvalEmitter::emitShlUint64Sint64(SourceInfo L) {
49571 if (!isActive()) return true;
49572 CurrentSource = L;
49573 return Shl<PT_Uint64, PT_Sint64>(S, CodePtr());
49574}
49575bool EvalEmitter::emitShlUint64Uint64(SourceInfo L) {
49576 if (!isActive()) return true;
49577 CurrentSource = L;
49578 return Shl<PT_Uint64, PT_Uint64>(S, CodePtr());
49579}
49580bool EvalEmitter::emitShlUint64IntAP(SourceInfo L) {
49581 if (!isActive()) return true;
49582 CurrentSource = L;
49583 return Shl<PT_Uint64, PT_IntAP>(S, CodePtr());
49584}
49585bool EvalEmitter::emitShlUint64IntAPS(SourceInfo L) {
49586 if (!isActive()) return true;
49587 CurrentSource = L;
49588 return Shl<PT_Uint64, PT_IntAPS>(S, CodePtr());
49589}
49590bool EvalEmitter::emitShlIntAPSint8(SourceInfo L) {
49591 if (!isActive()) return true;
49592 CurrentSource = L;
49593 return Shl<PT_IntAP, PT_Sint8>(S, CodePtr());
49594}
49595bool EvalEmitter::emitShlIntAPUint8(SourceInfo L) {
49596 if (!isActive()) return true;
49597 CurrentSource = L;
49598 return Shl<PT_IntAP, PT_Uint8>(S, CodePtr());
49599}
49600bool EvalEmitter::emitShlIntAPSint16(SourceInfo L) {
49601 if (!isActive()) return true;
49602 CurrentSource = L;
49603 return Shl<PT_IntAP, PT_Sint16>(S, CodePtr());
49604}
49605bool EvalEmitter::emitShlIntAPUint16(SourceInfo L) {
49606 if (!isActive()) return true;
49607 CurrentSource = L;
49608 return Shl<PT_IntAP, PT_Uint16>(S, CodePtr());
49609}
49610bool EvalEmitter::emitShlIntAPSint32(SourceInfo L) {
49611 if (!isActive()) return true;
49612 CurrentSource = L;
49613 return Shl<PT_IntAP, PT_Sint32>(S, CodePtr());
49614}
49615bool EvalEmitter::emitShlIntAPUint32(SourceInfo L) {
49616 if (!isActive()) return true;
49617 CurrentSource = L;
49618 return Shl<PT_IntAP, PT_Uint32>(S, CodePtr());
49619}
49620bool EvalEmitter::emitShlIntAPSint64(SourceInfo L) {
49621 if (!isActive()) return true;
49622 CurrentSource = L;
49623 return Shl<PT_IntAP, PT_Sint64>(S, CodePtr());
49624}
49625bool EvalEmitter::emitShlIntAPUint64(SourceInfo L) {
49626 if (!isActive()) return true;
49627 CurrentSource = L;
49628 return Shl<PT_IntAP, PT_Uint64>(S, CodePtr());
49629}
49630bool EvalEmitter::emitShlIntAPIntAP(SourceInfo L) {
49631 if (!isActive()) return true;
49632 CurrentSource = L;
49633 return Shl<PT_IntAP, PT_IntAP>(S, CodePtr());
49634}
49635bool EvalEmitter::emitShlIntAPIntAPS(SourceInfo L) {
49636 if (!isActive()) return true;
49637 CurrentSource = L;
49638 return Shl<PT_IntAP, PT_IntAPS>(S, CodePtr());
49639}
49640bool EvalEmitter::emitShlIntAPSSint8(SourceInfo L) {
49641 if (!isActive()) return true;
49642 CurrentSource = L;
49643 return Shl<PT_IntAPS, PT_Sint8>(S, CodePtr());
49644}
49645bool EvalEmitter::emitShlIntAPSUint8(SourceInfo L) {
49646 if (!isActive()) return true;
49647 CurrentSource = L;
49648 return Shl<PT_IntAPS, PT_Uint8>(S, CodePtr());
49649}
49650bool EvalEmitter::emitShlIntAPSSint16(SourceInfo L) {
49651 if (!isActive()) return true;
49652 CurrentSource = L;
49653 return Shl<PT_IntAPS, PT_Sint16>(S, CodePtr());
49654}
49655bool EvalEmitter::emitShlIntAPSUint16(SourceInfo L) {
49656 if (!isActive()) return true;
49657 CurrentSource = L;
49658 return Shl<PT_IntAPS, PT_Uint16>(S, CodePtr());
49659}
49660bool EvalEmitter::emitShlIntAPSSint32(SourceInfo L) {
49661 if (!isActive()) return true;
49662 CurrentSource = L;
49663 return Shl<PT_IntAPS, PT_Sint32>(S, CodePtr());
49664}
49665bool EvalEmitter::emitShlIntAPSUint32(SourceInfo L) {
49666 if (!isActive()) return true;
49667 CurrentSource = L;
49668 return Shl<PT_IntAPS, PT_Uint32>(S, CodePtr());
49669}
49670bool EvalEmitter::emitShlIntAPSSint64(SourceInfo L) {
49671 if (!isActive()) return true;
49672 CurrentSource = L;
49673 return Shl<PT_IntAPS, PT_Sint64>(S, CodePtr());
49674}
49675bool EvalEmitter::emitShlIntAPSUint64(SourceInfo L) {
49676 if (!isActive()) return true;
49677 CurrentSource = L;
49678 return Shl<PT_IntAPS, PT_Uint64>(S, CodePtr());
49679}
49680bool EvalEmitter::emitShlIntAPSIntAP(SourceInfo L) {
49681 if (!isActive()) return true;
49682 CurrentSource = L;
49683 return Shl<PT_IntAPS, PT_IntAP>(S, CodePtr());
49684}
49685bool EvalEmitter::emitShlIntAPSIntAPS(SourceInfo L) {
49686 if (!isActive()) return true;
49687 CurrentSource = L;
49688 return Shl<PT_IntAPS, PT_IntAPS>(S, CodePtr());
49689}
49690#endif
49691#ifdef GET_OPCODE_NAMES
49692OP_ShrSint8Sint8,
49693OP_ShrSint8Uint8,
49694OP_ShrSint8Sint16,
49695OP_ShrSint8Uint16,
49696OP_ShrSint8Sint32,
49697OP_ShrSint8Uint32,
49698OP_ShrSint8Sint64,
49699OP_ShrSint8Uint64,
49700OP_ShrSint8IntAP,
49701OP_ShrSint8IntAPS,
49702OP_ShrUint8Sint8,
49703OP_ShrUint8Uint8,
49704OP_ShrUint8Sint16,
49705OP_ShrUint8Uint16,
49706OP_ShrUint8Sint32,
49707OP_ShrUint8Uint32,
49708OP_ShrUint8Sint64,
49709OP_ShrUint8Uint64,
49710OP_ShrUint8IntAP,
49711OP_ShrUint8IntAPS,
49712OP_ShrSint16Sint8,
49713OP_ShrSint16Uint8,
49714OP_ShrSint16Sint16,
49715OP_ShrSint16Uint16,
49716OP_ShrSint16Sint32,
49717OP_ShrSint16Uint32,
49718OP_ShrSint16Sint64,
49719OP_ShrSint16Uint64,
49720OP_ShrSint16IntAP,
49721OP_ShrSint16IntAPS,
49722OP_ShrUint16Sint8,
49723OP_ShrUint16Uint8,
49724OP_ShrUint16Sint16,
49725OP_ShrUint16Uint16,
49726OP_ShrUint16Sint32,
49727OP_ShrUint16Uint32,
49728OP_ShrUint16Sint64,
49729OP_ShrUint16Uint64,
49730OP_ShrUint16IntAP,
49731OP_ShrUint16IntAPS,
49732OP_ShrSint32Sint8,
49733OP_ShrSint32Uint8,
49734OP_ShrSint32Sint16,
49735OP_ShrSint32Uint16,
49736OP_ShrSint32Sint32,
49737OP_ShrSint32Uint32,
49738OP_ShrSint32Sint64,
49739OP_ShrSint32Uint64,
49740OP_ShrSint32IntAP,
49741OP_ShrSint32IntAPS,
49742OP_ShrUint32Sint8,
49743OP_ShrUint32Uint8,
49744OP_ShrUint32Sint16,
49745OP_ShrUint32Uint16,
49746OP_ShrUint32Sint32,
49747OP_ShrUint32Uint32,
49748OP_ShrUint32Sint64,
49749OP_ShrUint32Uint64,
49750OP_ShrUint32IntAP,
49751OP_ShrUint32IntAPS,
49752OP_ShrSint64Sint8,
49753OP_ShrSint64Uint8,
49754OP_ShrSint64Sint16,
49755OP_ShrSint64Uint16,
49756OP_ShrSint64Sint32,
49757OP_ShrSint64Uint32,
49758OP_ShrSint64Sint64,
49759OP_ShrSint64Uint64,
49760OP_ShrSint64IntAP,
49761OP_ShrSint64IntAPS,
49762OP_ShrUint64Sint8,
49763OP_ShrUint64Uint8,
49764OP_ShrUint64Sint16,
49765OP_ShrUint64Uint16,
49766OP_ShrUint64Sint32,
49767OP_ShrUint64Uint32,
49768OP_ShrUint64Sint64,
49769OP_ShrUint64Uint64,
49770OP_ShrUint64IntAP,
49771OP_ShrUint64IntAPS,
49772OP_ShrIntAPSint8,
49773OP_ShrIntAPUint8,
49774OP_ShrIntAPSint16,
49775OP_ShrIntAPUint16,
49776OP_ShrIntAPSint32,
49777OP_ShrIntAPUint32,
49778OP_ShrIntAPSint64,
49779OP_ShrIntAPUint64,
49780OP_ShrIntAPIntAP,
49781OP_ShrIntAPIntAPS,
49782OP_ShrIntAPSSint8,
49783OP_ShrIntAPSUint8,
49784OP_ShrIntAPSSint16,
49785OP_ShrIntAPSUint16,
49786OP_ShrIntAPSSint32,
49787OP_ShrIntAPSUint32,
49788OP_ShrIntAPSSint64,
49789OP_ShrIntAPSUint64,
49790OP_ShrIntAPSIntAP,
49791OP_ShrIntAPSIntAPS,
49792#endif
49793#ifdef GET_INTERPFN_LIST
49794&Interp_ShrSint8Sint8,
49795&Interp_ShrSint8Uint8,
49796&Interp_ShrSint8Sint16,
49797&Interp_ShrSint8Uint16,
49798&Interp_ShrSint8Sint32,
49799&Interp_ShrSint8Uint32,
49800&Interp_ShrSint8Sint64,
49801&Interp_ShrSint8Uint64,
49802&Interp_ShrSint8IntAP,
49803&Interp_ShrSint8IntAPS,
49804&Interp_ShrUint8Sint8,
49805&Interp_ShrUint8Uint8,
49806&Interp_ShrUint8Sint16,
49807&Interp_ShrUint8Uint16,
49808&Interp_ShrUint8Sint32,
49809&Interp_ShrUint8Uint32,
49810&Interp_ShrUint8Sint64,
49811&Interp_ShrUint8Uint64,
49812&Interp_ShrUint8IntAP,
49813&Interp_ShrUint8IntAPS,
49814&Interp_ShrSint16Sint8,
49815&Interp_ShrSint16Uint8,
49816&Interp_ShrSint16Sint16,
49817&Interp_ShrSint16Uint16,
49818&Interp_ShrSint16Sint32,
49819&Interp_ShrSint16Uint32,
49820&Interp_ShrSint16Sint64,
49821&Interp_ShrSint16Uint64,
49822&Interp_ShrSint16IntAP,
49823&Interp_ShrSint16IntAPS,
49824&Interp_ShrUint16Sint8,
49825&Interp_ShrUint16Uint8,
49826&Interp_ShrUint16Sint16,
49827&Interp_ShrUint16Uint16,
49828&Interp_ShrUint16Sint32,
49829&Interp_ShrUint16Uint32,
49830&Interp_ShrUint16Sint64,
49831&Interp_ShrUint16Uint64,
49832&Interp_ShrUint16IntAP,
49833&Interp_ShrUint16IntAPS,
49834&Interp_ShrSint32Sint8,
49835&Interp_ShrSint32Uint8,
49836&Interp_ShrSint32Sint16,
49837&Interp_ShrSint32Uint16,
49838&Interp_ShrSint32Sint32,
49839&Interp_ShrSint32Uint32,
49840&Interp_ShrSint32Sint64,
49841&Interp_ShrSint32Uint64,
49842&Interp_ShrSint32IntAP,
49843&Interp_ShrSint32IntAPS,
49844&Interp_ShrUint32Sint8,
49845&Interp_ShrUint32Uint8,
49846&Interp_ShrUint32Sint16,
49847&Interp_ShrUint32Uint16,
49848&Interp_ShrUint32Sint32,
49849&Interp_ShrUint32Uint32,
49850&Interp_ShrUint32Sint64,
49851&Interp_ShrUint32Uint64,
49852&Interp_ShrUint32IntAP,
49853&Interp_ShrUint32IntAPS,
49854&Interp_ShrSint64Sint8,
49855&Interp_ShrSint64Uint8,
49856&Interp_ShrSint64Sint16,
49857&Interp_ShrSint64Uint16,
49858&Interp_ShrSint64Sint32,
49859&Interp_ShrSint64Uint32,
49860&Interp_ShrSint64Sint64,
49861&Interp_ShrSint64Uint64,
49862&Interp_ShrSint64IntAP,
49863&Interp_ShrSint64IntAPS,
49864&Interp_ShrUint64Sint8,
49865&Interp_ShrUint64Uint8,
49866&Interp_ShrUint64Sint16,
49867&Interp_ShrUint64Uint16,
49868&Interp_ShrUint64Sint32,
49869&Interp_ShrUint64Uint32,
49870&Interp_ShrUint64Sint64,
49871&Interp_ShrUint64Uint64,
49872&Interp_ShrUint64IntAP,
49873&Interp_ShrUint64IntAPS,
49874&Interp_ShrIntAPSint8,
49875&Interp_ShrIntAPUint8,
49876&Interp_ShrIntAPSint16,
49877&Interp_ShrIntAPUint16,
49878&Interp_ShrIntAPSint32,
49879&Interp_ShrIntAPUint32,
49880&Interp_ShrIntAPSint64,
49881&Interp_ShrIntAPUint64,
49882&Interp_ShrIntAPIntAP,
49883&Interp_ShrIntAPIntAPS,
49884&Interp_ShrIntAPSSint8,
49885&Interp_ShrIntAPSUint8,
49886&Interp_ShrIntAPSSint16,
49887&Interp_ShrIntAPSUint16,
49888&Interp_ShrIntAPSSint32,
49889&Interp_ShrIntAPSUint32,
49890&Interp_ShrIntAPSSint64,
49891&Interp_ShrIntAPSUint64,
49892&Interp_ShrIntAPSIntAP,
49893&Interp_ShrIntAPSIntAPS,
49894#endif
49895#ifdef GET_INTERPFN_DISPATCHERS
49896PRESERVE_NONE
49897static bool Interp_ShrSint8Sint8(InterpState &S) {
49898 if (!Shr<PT_Sint8, PT_Sint8>(S, S.PC)) return false;
49899#if USE_TAILCALLS
49900 MUSTTAIL return InterpNext(S);
49901#else
49902 return true;
49903#endif
49904}
49905PRESERVE_NONE
49906static bool Interp_ShrSint8Uint8(InterpState &S) {
49907 if (!Shr<PT_Sint8, PT_Uint8>(S, S.PC)) return false;
49908#if USE_TAILCALLS
49909 MUSTTAIL return InterpNext(S);
49910#else
49911 return true;
49912#endif
49913}
49914PRESERVE_NONE
49915static bool Interp_ShrSint8Sint16(InterpState &S) {
49916 if (!Shr<PT_Sint8, PT_Sint16>(S, S.PC)) return false;
49917#if USE_TAILCALLS
49918 MUSTTAIL return InterpNext(S);
49919#else
49920 return true;
49921#endif
49922}
49923PRESERVE_NONE
49924static bool Interp_ShrSint8Uint16(InterpState &S) {
49925 if (!Shr<PT_Sint8, PT_Uint16>(S, S.PC)) return false;
49926#if USE_TAILCALLS
49927 MUSTTAIL return InterpNext(S);
49928#else
49929 return true;
49930#endif
49931}
49932PRESERVE_NONE
49933static bool Interp_ShrSint8Sint32(InterpState &S) {
49934 if (!Shr<PT_Sint8, PT_Sint32>(S, S.PC)) return false;
49935#if USE_TAILCALLS
49936 MUSTTAIL return InterpNext(S);
49937#else
49938 return true;
49939#endif
49940}
49941PRESERVE_NONE
49942static bool Interp_ShrSint8Uint32(InterpState &S) {
49943 if (!Shr<PT_Sint8, PT_Uint32>(S, S.PC)) return false;
49944#if USE_TAILCALLS
49945 MUSTTAIL return InterpNext(S);
49946#else
49947 return true;
49948#endif
49949}
49950PRESERVE_NONE
49951static bool Interp_ShrSint8Sint64(InterpState &S) {
49952 if (!Shr<PT_Sint8, PT_Sint64>(S, S.PC)) return false;
49953#if USE_TAILCALLS
49954 MUSTTAIL return InterpNext(S);
49955#else
49956 return true;
49957#endif
49958}
49959PRESERVE_NONE
49960static bool Interp_ShrSint8Uint64(InterpState &S) {
49961 if (!Shr<PT_Sint8, PT_Uint64>(S, S.PC)) return false;
49962#if USE_TAILCALLS
49963 MUSTTAIL return InterpNext(S);
49964#else
49965 return true;
49966#endif
49967}
49968PRESERVE_NONE
49969static bool Interp_ShrSint8IntAP(InterpState &S) {
49970 if (!Shr<PT_Sint8, PT_IntAP>(S, S.PC)) return false;
49971#if USE_TAILCALLS
49972 MUSTTAIL return InterpNext(S);
49973#else
49974 return true;
49975#endif
49976}
49977PRESERVE_NONE
49978static bool Interp_ShrSint8IntAPS(InterpState &S) {
49979 if (!Shr<PT_Sint8, PT_IntAPS>(S, S.PC)) return false;
49980#if USE_TAILCALLS
49981 MUSTTAIL return InterpNext(S);
49982#else
49983 return true;
49984#endif
49985}
49986PRESERVE_NONE
49987static bool Interp_ShrUint8Sint8(InterpState &S) {
49988 if (!Shr<PT_Uint8, PT_Sint8>(S, S.PC)) return false;
49989#if USE_TAILCALLS
49990 MUSTTAIL return InterpNext(S);
49991#else
49992 return true;
49993#endif
49994}
49995PRESERVE_NONE
49996static bool Interp_ShrUint8Uint8(InterpState &S) {
49997 if (!Shr<PT_Uint8, PT_Uint8>(S, S.PC)) return false;
49998#if USE_TAILCALLS
49999 MUSTTAIL return InterpNext(S);
50000#else
50001 return true;
50002#endif
50003}
50004PRESERVE_NONE
50005static bool Interp_ShrUint8Sint16(InterpState &S) {
50006 if (!Shr<PT_Uint8, PT_Sint16>(S, S.PC)) return false;
50007#if USE_TAILCALLS
50008 MUSTTAIL return InterpNext(S);
50009#else
50010 return true;
50011#endif
50012}
50013PRESERVE_NONE
50014static bool Interp_ShrUint8Uint16(InterpState &S) {
50015 if (!Shr<PT_Uint8, PT_Uint16>(S, S.PC)) return false;
50016#if USE_TAILCALLS
50017 MUSTTAIL return InterpNext(S);
50018#else
50019 return true;
50020#endif
50021}
50022PRESERVE_NONE
50023static bool Interp_ShrUint8Sint32(InterpState &S) {
50024 if (!Shr<PT_Uint8, PT_Sint32>(S, S.PC)) return false;
50025#if USE_TAILCALLS
50026 MUSTTAIL return InterpNext(S);
50027#else
50028 return true;
50029#endif
50030}
50031PRESERVE_NONE
50032static bool Interp_ShrUint8Uint32(InterpState &S) {
50033 if (!Shr<PT_Uint8, PT_Uint32>(S, S.PC)) return false;
50034#if USE_TAILCALLS
50035 MUSTTAIL return InterpNext(S);
50036#else
50037 return true;
50038#endif
50039}
50040PRESERVE_NONE
50041static bool Interp_ShrUint8Sint64(InterpState &S) {
50042 if (!Shr<PT_Uint8, PT_Sint64>(S, S.PC)) return false;
50043#if USE_TAILCALLS
50044 MUSTTAIL return InterpNext(S);
50045#else
50046 return true;
50047#endif
50048}
50049PRESERVE_NONE
50050static bool Interp_ShrUint8Uint64(InterpState &S) {
50051 if (!Shr<PT_Uint8, PT_Uint64>(S, S.PC)) return false;
50052#if USE_TAILCALLS
50053 MUSTTAIL return InterpNext(S);
50054#else
50055 return true;
50056#endif
50057}
50058PRESERVE_NONE
50059static bool Interp_ShrUint8IntAP(InterpState &S) {
50060 if (!Shr<PT_Uint8, PT_IntAP>(S, S.PC)) return false;
50061#if USE_TAILCALLS
50062 MUSTTAIL return InterpNext(S);
50063#else
50064 return true;
50065#endif
50066}
50067PRESERVE_NONE
50068static bool Interp_ShrUint8IntAPS(InterpState &S) {
50069 if (!Shr<PT_Uint8, PT_IntAPS>(S, S.PC)) return false;
50070#if USE_TAILCALLS
50071 MUSTTAIL return InterpNext(S);
50072#else
50073 return true;
50074#endif
50075}
50076PRESERVE_NONE
50077static bool Interp_ShrSint16Sint8(InterpState &S) {
50078 if (!Shr<PT_Sint16, PT_Sint8>(S, S.PC)) return false;
50079#if USE_TAILCALLS
50080 MUSTTAIL return InterpNext(S);
50081#else
50082 return true;
50083#endif
50084}
50085PRESERVE_NONE
50086static bool Interp_ShrSint16Uint8(InterpState &S) {
50087 if (!Shr<PT_Sint16, PT_Uint8>(S, S.PC)) return false;
50088#if USE_TAILCALLS
50089 MUSTTAIL return InterpNext(S);
50090#else
50091 return true;
50092#endif
50093}
50094PRESERVE_NONE
50095static bool Interp_ShrSint16Sint16(InterpState &S) {
50096 if (!Shr<PT_Sint16, PT_Sint16>(S, S.PC)) return false;
50097#if USE_TAILCALLS
50098 MUSTTAIL return InterpNext(S);
50099#else
50100 return true;
50101#endif
50102}
50103PRESERVE_NONE
50104static bool Interp_ShrSint16Uint16(InterpState &S) {
50105 if (!Shr<PT_Sint16, PT_Uint16>(S, S.PC)) return false;
50106#if USE_TAILCALLS
50107 MUSTTAIL return InterpNext(S);
50108#else
50109 return true;
50110#endif
50111}
50112PRESERVE_NONE
50113static bool Interp_ShrSint16Sint32(InterpState &S) {
50114 if (!Shr<PT_Sint16, PT_Sint32>(S, S.PC)) return false;
50115#if USE_TAILCALLS
50116 MUSTTAIL return InterpNext(S);
50117#else
50118 return true;
50119#endif
50120}
50121PRESERVE_NONE
50122static bool Interp_ShrSint16Uint32(InterpState &S) {
50123 if (!Shr<PT_Sint16, PT_Uint32>(S, S.PC)) return false;
50124#if USE_TAILCALLS
50125 MUSTTAIL return InterpNext(S);
50126#else
50127 return true;
50128#endif
50129}
50130PRESERVE_NONE
50131static bool Interp_ShrSint16Sint64(InterpState &S) {
50132 if (!Shr<PT_Sint16, PT_Sint64>(S, S.PC)) return false;
50133#if USE_TAILCALLS
50134 MUSTTAIL return InterpNext(S);
50135#else
50136 return true;
50137#endif
50138}
50139PRESERVE_NONE
50140static bool Interp_ShrSint16Uint64(InterpState &S) {
50141 if (!Shr<PT_Sint16, PT_Uint64>(S, S.PC)) return false;
50142#if USE_TAILCALLS
50143 MUSTTAIL return InterpNext(S);
50144#else
50145 return true;
50146#endif
50147}
50148PRESERVE_NONE
50149static bool Interp_ShrSint16IntAP(InterpState &S) {
50150 if (!Shr<PT_Sint16, PT_IntAP>(S, S.PC)) return false;
50151#if USE_TAILCALLS
50152 MUSTTAIL return InterpNext(S);
50153#else
50154 return true;
50155#endif
50156}
50157PRESERVE_NONE
50158static bool Interp_ShrSint16IntAPS(InterpState &S) {
50159 if (!Shr<PT_Sint16, PT_IntAPS>(S, S.PC)) return false;
50160#if USE_TAILCALLS
50161 MUSTTAIL return InterpNext(S);
50162#else
50163 return true;
50164#endif
50165}
50166PRESERVE_NONE
50167static bool Interp_ShrUint16Sint8(InterpState &S) {
50168 if (!Shr<PT_Uint16, PT_Sint8>(S, S.PC)) return false;
50169#if USE_TAILCALLS
50170 MUSTTAIL return InterpNext(S);
50171#else
50172 return true;
50173#endif
50174}
50175PRESERVE_NONE
50176static bool Interp_ShrUint16Uint8(InterpState &S) {
50177 if (!Shr<PT_Uint16, PT_Uint8>(S, S.PC)) return false;
50178#if USE_TAILCALLS
50179 MUSTTAIL return InterpNext(S);
50180#else
50181 return true;
50182#endif
50183}
50184PRESERVE_NONE
50185static bool Interp_ShrUint16Sint16(InterpState &S) {
50186 if (!Shr<PT_Uint16, PT_Sint16>(S, S.PC)) return false;
50187#if USE_TAILCALLS
50188 MUSTTAIL return InterpNext(S);
50189#else
50190 return true;
50191#endif
50192}
50193PRESERVE_NONE
50194static bool Interp_ShrUint16Uint16(InterpState &S) {
50195 if (!Shr<PT_Uint16, PT_Uint16>(S, S.PC)) return false;
50196#if USE_TAILCALLS
50197 MUSTTAIL return InterpNext(S);
50198#else
50199 return true;
50200#endif
50201}
50202PRESERVE_NONE
50203static bool Interp_ShrUint16Sint32(InterpState &S) {
50204 if (!Shr<PT_Uint16, PT_Sint32>(S, S.PC)) return false;
50205#if USE_TAILCALLS
50206 MUSTTAIL return InterpNext(S);
50207#else
50208 return true;
50209#endif
50210}
50211PRESERVE_NONE
50212static bool Interp_ShrUint16Uint32(InterpState &S) {
50213 if (!Shr<PT_Uint16, PT_Uint32>(S, S.PC)) return false;
50214#if USE_TAILCALLS
50215 MUSTTAIL return InterpNext(S);
50216#else
50217 return true;
50218#endif
50219}
50220PRESERVE_NONE
50221static bool Interp_ShrUint16Sint64(InterpState &S) {
50222 if (!Shr<PT_Uint16, PT_Sint64>(S, S.PC)) return false;
50223#if USE_TAILCALLS
50224 MUSTTAIL return InterpNext(S);
50225#else
50226 return true;
50227#endif
50228}
50229PRESERVE_NONE
50230static bool Interp_ShrUint16Uint64(InterpState &S) {
50231 if (!Shr<PT_Uint16, PT_Uint64>(S, S.PC)) return false;
50232#if USE_TAILCALLS
50233 MUSTTAIL return InterpNext(S);
50234#else
50235 return true;
50236#endif
50237}
50238PRESERVE_NONE
50239static bool Interp_ShrUint16IntAP(InterpState &S) {
50240 if (!Shr<PT_Uint16, PT_IntAP>(S, S.PC)) return false;
50241#if USE_TAILCALLS
50242 MUSTTAIL return InterpNext(S);
50243#else
50244 return true;
50245#endif
50246}
50247PRESERVE_NONE
50248static bool Interp_ShrUint16IntAPS(InterpState &S) {
50249 if (!Shr<PT_Uint16, PT_IntAPS>(S, S.PC)) return false;
50250#if USE_TAILCALLS
50251 MUSTTAIL return InterpNext(S);
50252#else
50253 return true;
50254#endif
50255}
50256PRESERVE_NONE
50257static bool Interp_ShrSint32Sint8(InterpState &S) {
50258 if (!Shr<PT_Sint32, PT_Sint8>(S, S.PC)) return false;
50259#if USE_TAILCALLS
50260 MUSTTAIL return InterpNext(S);
50261#else
50262 return true;
50263#endif
50264}
50265PRESERVE_NONE
50266static bool Interp_ShrSint32Uint8(InterpState &S) {
50267 if (!Shr<PT_Sint32, PT_Uint8>(S, S.PC)) return false;
50268#if USE_TAILCALLS
50269 MUSTTAIL return InterpNext(S);
50270#else
50271 return true;
50272#endif
50273}
50274PRESERVE_NONE
50275static bool Interp_ShrSint32Sint16(InterpState &S) {
50276 if (!Shr<PT_Sint32, PT_Sint16>(S, S.PC)) return false;
50277#if USE_TAILCALLS
50278 MUSTTAIL return InterpNext(S);
50279#else
50280 return true;
50281#endif
50282}
50283PRESERVE_NONE
50284static bool Interp_ShrSint32Uint16(InterpState &S) {
50285 if (!Shr<PT_Sint32, PT_Uint16>(S, S.PC)) return false;
50286#if USE_TAILCALLS
50287 MUSTTAIL return InterpNext(S);
50288#else
50289 return true;
50290#endif
50291}
50292PRESERVE_NONE
50293static bool Interp_ShrSint32Sint32(InterpState &S) {
50294 if (!Shr<PT_Sint32, PT_Sint32>(S, S.PC)) return false;
50295#if USE_TAILCALLS
50296 MUSTTAIL return InterpNext(S);
50297#else
50298 return true;
50299#endif
50300}
50301PRESERVE_NONE
50302static bool Interp_ShrSint32Uint32(InterpState &S) {
50303 if (!Shr<PT_Sint32, PT_Uint32>(S, S.PC)) return false;
50304#if USE_TAILCALLS
50305 MUSTTAIL return InterpNext(S);
50306#else
50307 return true;
50308#endif
50309}
50310PRESERVE_NONE
50311static bool Interp_ShrSint32Sint64(InterpState &S) {
50312 if (!Shr<PT_Sint32, PT_Sint64>(S, S.PC)) return false;
50313#if USE_TAILCALLS
50314 MUSTTAIL return InterpNext(S);
50315#else
50316 return true;
50317#endif
50318}
50319PRESERVE_NONE
50320static bool Interp_ShrSint32Uint64(InterpState &S) {
50321 if (!Shr<PT_Sint32, PT_Uint64>(S, S.PC)) return false;
50322#if USE_TAILCALLS
50323 MUSTTAIL return InterpNext(S);
50324#else
50325 return true;
50326#endif
50327}
50328PRESERVE_NONE
50329static bool Interp_ShrSint32IntAP(InterpState &S) {
50330 if (!Shr<PT_Sint32, PT_IntAP>(S, S.PC)) return false;
50331#if USE_TAILCALLS
50332 MUSTTAIL return InterpNext(S);
50333#else
50334 return true;
50335#endif
50336}
50337PRESERVE_NONE
50338static bool Interp_ShrSint32IntAPS(InterpState &S) {
50339 if (!Shr<PT_Sint32, PT_IntAPS>(S, S.PC)) return false;
50340#if USE_TAILCALLS
50341 MUSTTAIL return InterpNext(S);
50342#else
50343 return true;
50344#endif
50345}
50346PRESERVE_NONE
50347static bool Interp_ShrUint32Sint8(InterpState &S) {
50348 if (!Shr<PT_Uint32, PT_Sint8>(S, S.PC)) return false;
50349#if USE_TAILCALLS
50350 MUSTTAIL return InterpNext(S);
50351#else
50352 return true;
50353#endif
50354}
50355PRESERVE_NONE
50356static bool Interp_ShrUint32Uint8(InterpState &S) {
50357 if (!Shr<PT_Uint32, PT_Uint8>(S, S.PC)) return false;
50358#if USE_TAILCALLS
50359 MUSTTAIL return InterpNext(S);
50360#else
50361 return true;
50362#endif
50363}
50364PRESERVE_NONE
50365static bool Interp_ShrUint32Sint16(InterpState &S) {
50366 if (!Shr<PT_Uint32, PT_Sint16>(S, S.PC)) return false;
50367#if USE_TAILCALLS
50368 MUSTTAIL return InterpNext(S);
50369#else
50370 return true;
50371#endif
50372}
50373PRESERVE_NONE
50374static bool Interp_ShrUint32Uint16(InterpState &S) {
50375 if (!Shr<PT_Uint32, PT_Uint16>(S, S.PC)) return false;
50376#if USE_TAILCALLS
50377 MUSTTAIL return InterpNext(S);
50378#else
50379 return true;
50380#endif
50381}
50382PRESERVE_NONE
50383static bool Interp_ShrUint32Sint32(InterpState &S) {
50384 if (!Shr<PT_Uint32, PT_Sint32>(S, S.PC)) return false;
50385#if USE_TAILCALLS
50386 MUSTTAIL return InterpNext(S);
50387#else
50388 return true;
50389#endif
50390}
50391PRESERVE_NONE
50392static bool Interp_ShrUint32Uint32(InterpState &S) {
50393 if (!Shr<PT_Uint32, PT_Uint32>(S, S.PC)) return false;
50394#if USE_TAILCALLS
50395 MUSTTAIL return InterpNext(S);
50396#else
50397 return true;
50398#endif
50399}
50400PRESERVE_NONE
50401static bool Interp_ShrUint32Sint64(InterpState &S) {
50402 if (!Shr<PT_Uint32, PT_Sint64>(S, S.PC)) return false;
50403#if USE_TAILCALLS
50404 MUSTTAIL return InterpNext(S);
50405#else
50406 return true;
50407#endif
50408}
50409PRESERVE_NONE
50410static bool Interp_ShrUint32Uint64(InterpState &S) {
50411 if (!Shr<PT_Uint32, PT_Uint64>(S, S.PC)) return false;
50412#if USE_TAILCALLS
50413 MUSTTAIL return InterpNext(S);
50414#else
50415 return true;
50416#endif
50417}
50418PRESERVE_NONE
50419static bool Interp_ShrUint32IntAP(InterpState &S) {
50420 if (!Shr<PT_Uint32, PT_IntAP>(S, S.PC)) return false;
50421#if USE_TAILCALLS
50422 MUSTTAIL return InterpNext(S);
50423#else
50424 return true;
50425#endif
50426}
50427PRESERVE_NONE
50428static bool Interp_ShrUint32IntAPS(InterpState &S) {
50429 if (!Shr<PT_Uint32, PT_IntAPS>(S, S.PC)) return false;
50430#if USE_TAILCALLS
50431 MUSTTAIL return InterpNext(S);
50432#else
50433 return true;
50434#endif
50435}
50436PRESERVE_NONE
50437static bool Interp_ShrSint64Sint8(InterpState &S) {
50438 if (!Shr<PT_Sint64, PT_Sint8>(S, S.PC)) return false;
50439#if USE_TAILCALLS
50440 MUSTTAIL return InterpNext(S);
50441#else
50442 return true;
50443#endif
50444}
50445PRESERVE_NONE
50446static bool Interp_ShrSint64Uint8(InterpState &S) {
50447 if (!Shr<PT_Sint64, PT_Uint8>(S, S.PC)) return false;
50448#if USE_TAILCALLS
50449 MUSTTAIL return InterpNext(S);
50450#else
50451 return true;
50452#endif
50453}
50454PRESERVE_NONE
50455static bool Interp_ShrSint64Sint16(InterpState &S) {
50456 if (!Shr<PT_Sint64, PT_Sint16>(S, S.PC)) return false;
50457#if USE_TAILCALLS
50458 MUSTTAIL return InterpNext(S);
50459#else
50460 return true;
50461#endif
50462}
50463PRESERVE_NONE
50464static bool Interp_ShrSint64Uint16(InterpState &S) {
50465 if (!Shr<PT_Sint64, PT_Uint16>(S, S.PC)) return false;
50466#if USE_TAILCALLS
50467 MUSTTAIL return InterpNext(S);
50468#else
50469 return true;
50470#endif
50471}
50472PRESERVE_NONE
50473static bool Interp_ShrSint64Sint32(InterpState &S) {
50474 if (!Shr<PT_Sint64, PT_Sint32>(S, S.PC)) return false;
50475#if USE_TAILCALLS
50476 MUSTTAIL return InterpNext(S);
50477#else
50478 return true;
50479#endif
50480}
50481PRESERVE_NONE
50482static bool Interp_ShrSint64Uint32(InterpState &S) {
50483 if (!Shr<PT_Sint64, PT_Uint32>(S, S.PC)) return false;
50484#if USE_TAILCALLS
50485 MUSTTAIL return InterpNext(S);
50486#else
50487 return true;
50488#endif
50489}
50490PRESERVE_NONE
50491static bool Interp_ShrSint64Sint64(InterpState &S) {
50492 if (!Shr<PT_Sint64, PT_Sint64>(S, S.PC)) return false;
50493#if USE_TAILCALLS
50494 MUSTTAIL return InterpNext(S);
50495#else
50496 return true;
50497#endif
50498}
50499PRESERVE_NONE
50500static bool Interp_ShrSint64Uint64(InterpState &S) {
50501 if (!Shr<PT_Sint64, PT_Uint64>(S, S.PC)) return false;
50502#if USE_TAILCALLS
50503 MUSTTAIL return InterpNext(S);
50504#else
50505 return true;
50506#endif
50507}
50508PRESERVE_NONE
50509static bool Interp_ShrSint64IntAP(InterpState &S) {
50510 if (!Shr<PT_Sint64, PT_IntAP>(S, S.PC)) return false;
50511#if USE_TAILCALLS
50512 MUSTTAIL return InterpNext(S);
50513#else
50514 return true;
50515#endif
50516}
50517PRESERVE_NONE
50518static bool Interp_ShrSint64IntAPS(InterpState &S) {
50519 if (!Shr<PT_Sint64, PT_IntAPS>(S, S.PC)) return false;
50520#if USE_TAILCALLS
50521 MUSTTAIL return InterpNext(S);
50522#else
50523 return true;
50524#endif
50525}
50526PRESERVE_NONE
50527static bool Interp_ShrUint64Sint8(InterpState &S) {
50528 if (!Shr<PT_Uint64, PT_Sint8>(S, S.PC)) return false;
50529#if USE_TAILCALLS
50530 MUSTTAIL return InterpNext(S);
50531#else
50532 return true;
50533#endif
50534}
50535PRESERVE_NONE
50536static bool Interp_ShrUint64Uint8(InterpState &S) {
50537 if (!Shr<PT_Uint64, PT_Uint8>(S, S.PC)) return false;
50538#if USE_TAILCALLS
50539 MUSTTAIL return InterpNext(S);
50540#else
50541 return true;
50542#endif
50543}
50544PRESERVE_NONE
50545static bool Interp_ShrUint64Sint16(InterpState &S) {
50546 if (!Shr<PT_Uint64, PT_Sint16>(S, S.PC)) return false;
50547#if USE_TAILCALLS
50548 MUSTTAIL return InterpNext(S);
50549#else
50550 return true;
50551#endif
50552}
50553PRESERVE_NONE
50554static bool Interp_ShrUint64Uint16(InterpState &S) {
50555 if (!Shr<PT_Uint64, PT_Uint16>(S, S.PC)) return false;
50556#if USE_TAILCALLS
50557 MUSTTAIL return InterpNext(S);
50558#else
50559 return true;
50560#endif
50561}
50562PRESERVE_NONE
50563static bool Interp_ShrUint64Sint32(InterpState &S) {
50564 if (!Shr<PT_Uint64, PT_Sint32>(S, S.PC)) return false;
50565#if USE_TAILCALLS
50566 MUSTTAIL return InterpNext(S);
50567#else
50568 return true;
50569#endif
50570}
50571PRESERVE_NONE
50572static bool Interp_ShrUint64Uint32(InterpState &S) {
50573 if (!Shr<PT_Uint64, PT_Uint32>(S, S.PC)) return false;
50574#if USE_TAILCALLS
50575 MUSTTAIL return InterpNext(S);
50576#else
50577 return true;
50578#endif
50579}
50580PRESERVE_NONE
50581static bool Interp_ShrUint64Sint64(InterpState &S) {
50582 if (!Shr<PT_Uint64, PT_Sint64>(S, S.PC)) return false;
50583#if USE_TAILCALLS
50584 MUSTTAIL return InterpNext(S);
50585#else
50586 return true;
50587#endif
50588}
50589PRESERVE_NONE
50590static bool Interp_ShrUint64Uint64(InterpState &S) {
50591 if (!Shr<PT_Uint64, PT_Uint64>(S, S.PC)) return false;
50592#if USE_TAILCALLS
50593 MUSTTAIL return InterpNext(S);
50594#else
50595 return true;
50596#endif
50597}
50598PRESERVE_NONE
50599static bool Interp_ShrUint64IntAP(InterpState &S) {
50600 if (!Shr<PT_Uint64, PT_IntAP>(S, S.PC)) return false;
50601#if USE_TAILCALLS
50602 MUSTTAIL return InterpNext(S);
50603#else
50604 return true;
50605#endif
50606}
50607PRESERVE_NONE
50608static bool Interp_ShrUint64IntAPS(InterpState &S) {
50609 if (!Shr<PT_Uint64, PT_IntAPS>(S, S.PC)) return false;
50610#if USE_TAILCALLS
50611 MUSTTAIL return InterpNext(S);
50612#else
50613 return true;
50614#endif
50615}
50616PRESERVE_NONE
50617static bool Interp_ShrIntAPSint8(InterpState &S) {
50618 if (!Shr<PT_IntAP, PT_Sint8>(S, S.PC)) return false;
50619#if USE_TAILCALLS
50620 MUSTTAIL return InterpNext(S);
50621#else
50622 return true;
50623#endif
50624}
50625PRESERVE_NONE
50626static bool Interp_ShrIntAPUint8(InterpState &S) {
50627 if (!Shr<PT_IntAP, PT_Uint8>(S, S.PC)) return false;
50628#if USE_TAILCALLS
50629 MUSTTAIL return InterpNext(S);
50630#else
50631 return true;
50632#endif
50633}
50634PRESERVE_NONE
50635static bool Interp_ShrIntAPSint16(InterpState &S) {
50636 if (!Shr<PT_IntAP, PT_Sint16>(S, S.PC)) return false;
50637#if USE_TAILCALLS
50638 MUSTTAIL return InterpNext(S);
50639#else
50640 return true;
50641#endif
50642}
50643PRESERVE_NONE
50644static bool Interp_ShrIntAPUint16(InterpState &S) {
50645 if (!Shr<PT_IntAP, PT_Uint16>(S, S.PC)) return false;
50646#if USE_TAILCALLS
50647 MUSTTAIL return InterpNext(S);
50648#else
50649 return true;
50650#endif
50651}
50652PRESERVE_NONE
50653static bool Interp_ShrIntAPSint32(InterpState &S) {
50654 if (!Shr<PT_IntAP, PT_Sint32>(S, S.PC)) return false;
50655#if USE_TAILCALLS
50656 MUSTTAIL return InterpNext(S);
50657#else
50658 return true;
50659#endif
50660}
50661PRESERVE_NONE
50662static bool Interp_ShrIntAPUint32(InterpState &S) {
50663 if (!Shr<PT_IntAP, PT_Uint32>(S, S.PC)) return false;
50664#if USE_TAILCALLS
50665 MUSTTAIL return InterpNext(S);
50666#else
50667 return true;
50668#endif
50669}
50670PRESERVE_NONE
50671static bool Interp_ShrIntAPSint64(InterpState &S) {
50672 if (!Shr<PT_IntAP, PT_Sint64>(S, S.PC)) return false;
50673#if USE_TAILCALLS
50674 MUSTTAIL return InterpNext(S);
50675#else
50676 return true;
50677#endif
50678}
50679PRESERVE_NONE
50680static bool Interp_ShrIntAPUint64(InterpState &S) {
50681 if (!Shr<PT_IntAP, PT_Uint64>(S, S.PC)) return false;
50682#if USE_TAILCALLS
50683 MUSTTAIL return InterpNext(S);
50684#else
50685 return true;
50686#endif
50687}
50688PRESERVE_NONE
50689static bool Interp_ShrIntAPIntAP(InterpState &S) {
50690 if (!Shr<PT_IntAP, PT_IntAP>(S, S.PC)) return false;
50691#if USE_TAILCALLS
50692 MUSTTAIL return InterpNext(S);
50693#else
50694 return true;
50695#endif
50696}
50697PRESERVE_NONE
50698static bool Interp_ShrIntAPIntAPS(InterpState &S) {
50699 if (!Shr<PT_IntAP, PT_IntAPS>(S, S.PC)) return false;
50700#if USE_TAILCALLS
50701 MUSTTAIL return InterpNext(S);
50702#else
50703 return true;
50704#endif
50705}
50706PRESERVE_NONE
50707static bool Interp_ShrIntAPSSint8(InterpState &S) {
50708 if (!Shr<PT_IntAPS, PT_Sint8>(S, S.PC)) return false;
50709#if USE_TAILCALLS
50710 MUSTTAIL return InterpNext(S);
50711#else
50712 return true;
50713#endif
50714}
50715PRESERVE_NONE
50716static bool Interp_ShrIntAPSUint8(InterpState &S) {
50717 if (!Shr<PT_IntAPS, PT_Uint8>(S, S.PC)) return false;
50718#if USE_TAILCALLS
50719 MUSTTAIL return InterpNext(S);
50720#else
50721 return true;
50722#endif
50723}
50724PRESERVE_NONE
50725static bool Interp_ShrIntAPSSint16(InterpState &S) {
50726 if (!Shr<PT_IntAPS, PT_Sint16>(S, S.PC)) return false;
50727#if USE_TAILCALLS
50728 MUSTTAIL return InterpNext(S);
50729#else
50730 return true;
50731#endif
50732}
50733PRESERVE_NONE
50734static bool Interp_ShrIntAPSUint16(InterpState &S) {
50735 if (!Shr<PT_IntAPS, PT_Uint16>(S, S.PC)) return false;
50736#if USE_TAILCALLS
50737 MUSTTAIL return InterpNext(S);
50738#else
50739 return true;
50740#endif
50741}
50742PRESERVE_NONE
50743static bool Interp_ShrIntAPSSint32(InterpState &S) {
50744 if (!Shr<PT_IntAPS, PT_Sint32>(S, S.PC)) return false;
50745#if USE_TAILCALLS
50746 MUSTTAIL return InterpNext(S);
50747#else
50748 return true;
50749#endif
50750}
50751PRESERVE_NONE
50752static bool Interp_ShrIntAPSUint32(InterpState &S) {
50753 if (!Shr<PT_IntAPS, PT_Uint32>(S, S.PC)) return false;
50754#if USE_TAILCALLS
50755 MUSTTAIL return InterpNext(S);
50756#else
50757 return true;
50758#endif
50759}
50760PRESERVE_NONE
50761static bool Interp_ShrIntAPSSint64(InterpState &S) {
50762 if (!Shr<PT_IntAPS, PT_Sint64>(S, S.PC)) return false;
50763#if USE_TAILCALLS
50764 MUSTTAIL return InterpNext(S);
50765#else
50766 return true;
50767#endif
50768}
50769PRESERVE_NONE
50770static bool Interp_ShrIntAPSUint64(InterpState &S) {
50771 if (!Shr<PT_IntAPS, PT_Uint64>(S, S.PC)) return false;
50772#if USE_TAILCALLS
50773 MUSTTAIL return InterpNext(S);
50774#else
50775 return true;
50776#endif
50777}
50778PRESERVE_NONE
50779static bool Interp_ShrIntAPSIntAP(InterpState &S) {
50780 if (!Shr<PT_IntAPS, PT_IntAP>(S, S.PC)) return false;
50781#if USE_TAILCALLS
50782 MUSTTAIL return InterpNext(S);
50783#else
50784 return true;
50785#endif
50786}
50787PRESERVE_NONE
50788static bool Interp_ShrIntAPSIntAPS(InterpState &S) {
50789 if (!Shr<PT_IntAPS, PT_IntAPS>(S, S.PC)) return false;
50790#if USE_TAILCALLS
50791 MUSTTAIL return InterpNext(S);
50792#else
50793 return true;
50794#endif
50795}
50796#endif
50797#ifdef GET_DISASM
50798case OP_ShrSint8Sint8:
50799 Text.Op = PrintName("ShrSint8Sint8");
50800 break;
50801case OP_ShrSint8Uint8:
50802 Text.Op = PrintName("ShrSint8Uint8");
50803 break;
50804case OP_ShrSint8Sint16:
50805 Text.Op = PrintName("ShrSint8Sint16");
50806 break;
50807case OP_ShrSint8Uint16:
50808 Text.Op = PrintName("ShrSint8Uint16");
50809 break;
50810case OP_ShrSint8Sint32:
50811 Text.Op = PrintName("ShrSint8Sint32");
50812 break;
50813case OP_ShrSint8Uint32:
50814 Text.Op = PrintName("ShrSint8Uint32");
50815 break;
50816case OP_ShrSint8Sint64:
50817 Text.Op = PrintName("ShrSint8Sint64");
50818 break;
50819case OP_ShrSint8Uint64:
50820 Text.Op = PrintName("ShrSint8Uint64");
50821 break;
50822case OP_ShrSint8IntAP:
50823 Text.Op = PrintName("ShrSint8IntAP");
50824 break;
50825case OP_ShrSint8IntAPS:
50826 Text.Op = PrintName("ShrSint8IntAPS");
50827 break;
50828case OP_ShrUint8Sint8:
50829 Text.Op = PrintName("ShrUint8Sint8");
50830 break;
50831case OP_ShrUint8Uint8:
50832 Text.Op = PrintName("ShrUint8Uint8");
50833 break;
50834case OP_ShrUint8Sint16:
50835 Text.Op = PrintName("ShrUint8Sint16");
50836 break;
50837case OP_ShrUint8Uint16:
50838 Text.Op = PrintName("ShrUint8Uint16");
50839 break;
50840case OP_ShrUint8Sint32:
50841 Text.Op = PrintName("ShrUint8Sint32");
50842 break;
50843case OP_ShrUint8Uint32:
50844 Text.Op = PrintName("ShrUint8Uint32");
50845 break;
50846case OP_ShrUint8Sint64:
50847 Text.Op = PrintName("ShrUint8Sint64");
50848 break;
50849case OP_ShrUint8Uint64:
50850 Text.Op = PrintName("ShrUint8Uint64");
50851 break;
50852case OP_ShrUint8IntAP:
50853 Text.Op = PrintName("ShrUint8IntAP");
50854 break;
50855case OP_ShrUint8IntAPS:
50856 Text.Op = PrintName("ShrUint8IntAPS");
50857 break;
50858case OP_ShrSint16Sint8:
50859 Text.Op = PrintName("ShrSint16Sint8");
50860 break;
50861case OP_ShrSint16Uint8:
50862 Text.Op = PrintName("ShrSint16Uint8");
50863 break;
50864case OP_ShrSint16Sint16:
50865 Text.Op = PrintName("ShrSint16Sint16");
50866 break;
50867case OP_ShrSint16Uint16:
50868 Text.Op = PrintName("ShrSint16Uint16");
50869 break;
50870case OP_ShrSint16Sint32:
50871 Text.Op = PrintName("ShrSint16Sint32");
50872 break;
50873case OP_ShrSint16Uint32:
50874 Text.Op = PrintName("ShrSint16Uint32");
50875 break;
50876case OP_ShrSint16Sint64:
50877 Text.Op = PrintName("ShrSint16Sint64");
50878 break;
50879case OP_ShrSint16Uint64:
50880 Text.Op = PrintName("ShrSint16Uint64");
50881 break;
50882case OP_ShrSint16IntAP:
50883 Text.Op = PrintName("ShrSint16IntAP");
50884 break;
50885case OP_ShrSint16IntAPS:
50886 Text.Op = PrintName("ShrSint16IntAPS");
50887 break;
50888case OP_ShrUint16Sint8:
50889 Text.Op = PrintName("ShrUint16Sint8");
50890 break;
50891case OP_ShrUint16Uint8:
50892 Text.Op = PrintName("ShrUint16Uint8");
50893 break;
50894case OP_ShrUint16Sint16:
50895 Text.Op = PrintName("ShrUint16Sint16");
50896 break;
50897case OP_ShrUint16Uint16:
50898 Text.Op = PrintName("ShrUint16Uint16");
50899 break;
50900case OP_ShrUint16Sint32:
50901 Text.Op = PrintName("ShrUint16Sint32");
50902 break;
50903case OP_ShrUint16Uint32:
50904 Text.Op = PrintName("ShrUint16Uint32");
50905 break;
50906case OP_ShrUint16Sint64:
50907 Text.Op = PrintName("ShrUint16Sint64");
50908 break;
50909case OP_ShrUint16Uint64:
50910 Text.Op = PrintName("ShrUint16Uint64");
50911 break;
50912case OP_ShrUint16IntAP:
50913 Text.Op = PrintName("ShrUint16IntAP");
50914 break;
50915case OP_ShrUint16IntAPS:
50916 Text.Op = PrintName("ShrUint16IntAPS");
50917 break;
50918case OP_ShrSint32Sint8:
50919 Text.Op = PrintName("ShrSint32Sint8");
50920 break;
50921case OP_ShrSint32Uint8:
50922 Text.Op = PrintName("ShrSint32Uint8");
50923 break;
50924case OP_ShrSint32Sint16:
50925 Text.Op = PrintName("ShrSint32Sint16");
50926 break;
50927case OP_ShrSint32Uint16:
50928 Text.Op = PrintName("ShrSint32Uint16");
50929 break;
50930case OP_ShrSint32Sint32:
50931 Text.Op = PrintName("ShrSint32Sint32");
50932 break;
50933case OP_ShrSint32Uint32:
50934 Text.Op = PrintName("ShrSint32Uint32");
50935 break;
50936case OP_ShrSint32Sint64:
50937 Text.Op = PrintName("ShrSint32Sint64");
50938 break;
50939case OP_ShrSint32Uint64:
50940 Text.Op = PrintName("ShrSint32Uint64");
50941 break;
50942case OP_ShrSint32IntAP:
50943 Text.Op = PrintName("ShrSint32IntAP");
50944 break;
50945case OP_ShrSint32IntAPS:
50946 Text.Op = PrintName("ShrSint32IntAPS");
50947 break;
50948case OP_ShrUint32Sint8:
50949 Text.Op = PrintName("ShrUint32Sint8");
50950 break;
50951case OP_ShrUint32Uint8:
50952 Text.Op = PrintName("ShrUint32Uint8");
50953 break;
50954case OP_ShrUint32Sint16:
50955 Text.Op = PrintName("ShrUint32Sint16");
50956 break;
50957case OP_ShrUint32Uint16:
50958 Text.Op = PrintName("ShrUint32Uint16");
50959 break;
50960case OP_ShrUint32Sint32:
50961 Text.Op = PrintName("ShrUint32Sint32");
50962 break;
50963case OP_ShrUint32Uint32:
50964 Text.Op = PrintName("ShrUint32Uint32");
50965 break;
50966case OP_ShrUint32Sint64:
50967 Text.Op = PrintName("ShrUint32Sint64");
50968 break;
50969case OP_ShrUint32Uint64:
50970 Text.Op = PrintName("ShrUint32Uint64");
50971 break;
50972case OP_ShrUint32IntAP:
50973 Text.Op = PrintName("ShrUint32IntAP");
50974 break;
50975case OP_ShrUint32IntAPS:
50976 Text.Op = PrintName("ShrUint32IntAPS");
50977 break;
50978case OP_ShrSint64Sint8:
50979 Text.Op = PrintName("ShrSint64Sint8");
50980 break;
50981case OP_ShrSint64Uint8:
50982 Text.Op = PrintName("ShrSint64Uint8");
50983 break;
50984case OP_ShrSint64Sint16:
50985 Text.Op = PrintName("ShrSint64Sint16");
50986 break;
50987case OP_ShrSint64Uint16:
50988 Text.Op = PrintName("ShrSint64Uint16");
50989 break;
50990case OP_ShrSint64Sint32:
50991 Text.Op = PrintName("ShrSint64Sint32");
50992 break;
50993case OP_ShrSint64Uint32:
50994 Text.Op = PrintName("ShrSint64Uint32");
50995 break;
50996case OP_ShrSint64Sint64:
50997 Text.Op = PrintName("ShrSint64Sint64");
50998 break;
50999case OP_ShrSint64Uint64:
51000 Text.Op = PrintName("ShrSint64Uint64");
51001 break;
51002case OP_ShrSint64IntAP:
51003 Text.Op = PrintName("ShrSint64IntAP");
51004 break;
51005case OP_ShrSint64IntAPS:
51006 Text.Op = PrintName("ShrSint64IntAPS");
51007 break;
51008case OP_ShrUint64Sint8:
51009 Text.Op = PrintName("ShrUint64Sint8");
51010 break;
51011case OP_ShrUint64Uint8:
51012 Text.Op = PrintName("ShrUint64Uint8");
51013 break;
51014case OP_ShrUint64Sint16:
51015 Text.Op = PrintName("ShrUint64Sint16");
51016 break;
51017case OP_ShrUint64Uint16:
51018 Text.Op = PrintName("ShrUint64Uint16");
51019 break;
51020case OP_ShrUint64Sint32:
51021 Text.Op = PrintName("ShrUint64Sint32");
51022 break;
51023case OP_ShrUint64Uint32:
51024 Text.Op = PrintName("ShrUint64Uint32");
51025 break;
51026case OP_ShrUint64Sint64:
51027 Text.Op = PrintName("ShrUint64Sint64");
51028 break;
51029case OP_ShrUint64Uint64:
51030 Text.Op = PrintName("ShrUint64Uint64");
51031 break;
51032case OP_ShrUint64IntAP:
51033 Text.Op = PrintName("ShrUint64IntAP");
51034 break;
51035case OP_ShrUint64IntAPS:
51036 Text.Op = PrintName("ShrUint64IntAPS");
51037 break;
51038case OP_ShrIntAPSint8:
51039 Text.Op = PrintName("ShrIntAPSint8");
51040 break;
51041case OP_ShrIntAPUint8:
51042 Text.Op = PrintName("ShrIntAPUint8");
51043 break;
51044case OP_ShrIntAPSint16:
51045 Text.Op = PrintName("ShrIntAPSint16");
51046 break;
51047case OP_ShrIntAPUint16:
51048 Text.Op = PrintName("ShrIntAPUint16");
51049 break;
51050case OP_ShrIntAPSint32:
51051 Text.Op = PrintName("ShrIntAPSint32");
51052 break;
51053case OP_ShrIntAPUint32:
51054 Text.Op = PrintName("ShrIntAPUint32");
51055 break;
51056case OP_ShrIntAPSint64:
51057 Text.Op = PrintName("ShrIntAPSint64");
51058 break;
51059case OP_ShrIntAPUint64:
51060 Text.Op = PrintName("ShrIntAPUint64");
51061 break;
51062case OP_ShrIntAPIntAP:
51063 Text.Op = PrintName("ShrIntAPIntAP");
51064 break;
51065case OP_ShrIntAPIntAPS:
51066 Text.Op = PrintName("ShrIntAPIntAPS");
51067 break;
51068case OP_ShrIntAPSSint8:
51069 Text.Op = PrintName("ShrIntAPSSint8");
51070 break;
51071case OP_ShrIntAPSUint8:
51072 Text.Op = PrintName("ShrIntAPSUint8");
51073 break;
51074case OP_ShrIntAPSSint16:
51075 Text.Op = PrintName("ShrIntAPSSint16");
51076 break;
51077case OP_ShrIntAPSUint16:
51078 Text.Op = PrintName("ShrIntAPSUint16");
51079 break;
51080case OP_ShrIntAPSSint32:
51081 Text.Op = PrintName("ShrIntAPSSint32");
51082 break;
51083case OP_ShrIntAPSUint32:
51084 Text.Op = PrintName("ShrIntAPSUint32");
51085 break;
51086case OP_ShrIntAPSSint64:
51087 Text.Op = PrintName("ShrIntAPSSint64");
51088 break;
51089case OP_ShrIntAPSUint64:
51090 Text.Op = PrintName("ShrIntAPSUint64");
51091 break;
51092case OP_ShrIntAPSIntAP:
51093 Text.Op = PrintName("ShrIntAPSIntAP");
51094 break;
51095case OP_ShrIntAPSIntAPS:
51096 Text.Op = PrintName("ShrIntAPSIntAPS");
51097 break;
51098#endif
51099#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
51100bool emitShrSint8Sint8(SourceInfo);
51101bool emitShrSint8Uint8(SourceInfo);
51102bool emitShrSint8Sint16(SourceInfo);
51103bool emitShrSint8Uint16(SourceInfo);
51104bool emitShrSint8Sint32(SourceInfo);
51105bool emitShrSint8Uint32(SourceInfo);
51106bool emitShrSint8Sint64(SourceInfo);
51107bool emitShrSint8Uint64(SourceInfo);
51108bool emitShrSint8IntAP(SourceInfo);
51109bool emitShrSint8IntAPS(SourceInfo);
51110bool emitShrUint8Sint8(SourceInfo);
51111bool emitShrUint8Uint8(SourceInfo);
51112bool emitShrUint8Sint16(SourceInfo);
51113bool emitShrUint8Uint16(SourceInfo);
51114bool emitShrUint8Sint32(SourceInfo);
51115bool emitShrUint8Uint32(SourceInfo);
51116bool emitShrUint8Sint64(SourceInfo);
51117bool emitShrUint8Uint64(SourceInfo);
51118bool emitShrUint8IntAP(SourceInfo);
51119bool emitShrUint8IntAPS(SourceInfo);
51120bool emitShrSint16Sint8(SourceInfo);
51121bool emitShrSint16Uint8(SourceInfo);
51122bool emitShrSint16Sint16(SourceInfo);
51123bool emitShrSint16Uint16(SourceInfo);
51124bool emitShrSint16Sint32(SourceInfo);
51125bool emitShrSint16Uint32(SourceInfo);
51126bool emitShrSint16Sint64(SourceInfo);
51127bool emitShrSint16Uint64(SourceInfo);
51128bool emitShrSint16IntAP(SourceInfo);
51129bool emitShrSint16IntAPS(SourceInfo);
51130bool emitShrUint16Sint8(SourceInfo);
51131bool emitShrUint16Uint8(SourceInfo);
51132bool emitShrUint16Sint16(SourceInfo);
51133bool emitShrUint16Uint16(SourceInfo);
51134bool emitShrUint16Sint32(SourceInfo);
51135bool emitShrUint16Uint32(SourceInfo);
51136bool emitShrUint16Sint64(SourceInfo);
51137bool emitShrUint16Uint64(SourceInfo);
51138bool emitShrUint16IntAP(SourceInfo);
51139bool emitShrUint16IntAPS(SourceInfo);
51140bool emitShrSint32Sint8(SourceInfo);
51141bool emitShrSint32Uint8(SourceInfo);
51142bool emitShrSint32Sint16(SourceInfo);
51143bool emitShrSint32Uint16(SourceInfo);
51144bool emitShrSint32Sint32(SourceInfo);
51145bool emitShrSint32Uint32(SourceInfo);
51146bool emitShrSint32Sint64(SourceInfo);
51147bool emitShrSint32Uint64(SourceInfo);
51148bool emitShrSint32IntAP(SourceInfo);
51149bool emitShrSint32IntAPS(SourceInfo);
51150bool emitShrUint32Sint8(SourceInfo);
51151bool emitShrUint32Uint8(SourceInfo);
51152bool emitShrUint32Sint16(SourceInfo);
51153bool emitShrUint32Uint16(SourceInfo);
51154bool emitShrUint32Sint32(SourceInfo);
51155bool emitShrUint32Uint32(SourceInfo);
51156bool emitShrUint32Sint64(SourceInfo);
51157bool emitShrUint32Uint64(SourceInfo);
51158bool emitShrUint32IntAP(SourceInfo);
51159bool emitShrUint32IntAPS(SourceInfo);
51160bool emitShrSint64Sint8(SourceInfo);
51161bool emitShrSint64Uint8(SourceInfo);
51162bool emitShrSint64Sint16(SourceInfo);
51163bool emitShrSint64Uint16(SourceInfo);
51164bool emitShrSint64Sint32(SourceInfo);
51165bool emitShrSint64Uint32(SourceInfo);
51166bool emitShrSint64Sint64(SourceInfo);
51167bool emitShrSint64Uint64(SourceInfo);
51168bool emitShrSint64IntAP(SourceInfo);
51169bool emitShrSint64IntAPS(SourceInfo);
51170bool emitShrUint64Sint8(SourceInfo);
51171bool emitShrUint64Uint8(SourceInfo);
51172bool emitShrUint64Sint16(SourceInfo);
51173bool emitShrUint64Uint16(SourceInfo);
51174bool emitShrUint64Sint32(SourceInfo);
51175bool emitShrUint64Uint32(SourceInfo);
51176bool emitShrUint64Sint64(SourceInfo);
51177bool emitShrUint64Uint64(SourceInfo);
51178bool emitShrUint64IntAP(SourceInfo);
51179bool emitShrUint64IntAPS(SourceInfo);
51180bool emitShrIntAPSint8(SourceInfo);
51181bool emitShrIntAPUint8(SourceInfo);
51182bool emitShrIntAPSint16(SourceInfo);
51183bool emitShrIntAPUint16(SourceInfo);
51184bool emitShrIntAPSint32(SourceInfo);
51185bool emitShrIntAPUint32(SourceInfo);
51186bool emitShrIntAPSint64(SourceInfo);
51187bool emitShrIntAPUint64(SourceInfo);
51188bool emitShrIntAPIntAP(SourceInfo);
51189bool emitShrIntAPIntAPS(SourceInfo);
51190bool emitShrIntAPSSint8(SourceInfo);
51191bool emitShrIntAPSUint8(SourceInfo);
51192bool emitShrIntAPSSint16(SourceInfo);
51193bool emitShrIntAPSUint16(SourceInfo);
51194bool emitShrIntAPSSint32(SourceInfo);
51195bool emitShrIntAPSUint32(SourceInfo);
51196bool emitShrIntAPSSint64(SourceInfo);
51197bool emitShrIntAPSUint64(SourceInfo);
51198bool emitShrIntAPSIntAP(SourceInfo);
51199bool emitShrIntAPSIntAPS(SourceInfo);
51200#endif
51201#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
51202[[nodiscard]] bool emitShr(PrimType, PrimType, SourceInfo I);
51203#endif
51204#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
51205bool
51206#if defined(GET_EVAL_IMPL)
51207EvalEmitter
51208#else
51209ByteCodeEmitter
51210#endif
51211::emitShr(PrimType T0, PrimType T1, SourceInfo I) {
51212 switch (T0) {
51213 case PT_Sint8:
51214 switch (T1) {
51215 case PT_Sint8:
51216 return emitShrSint8Sint8(I);
51217 case PT_Uint8:
51218 return emitShrSint8Uint8(I);
51219 case PT_Sint16:
51220 return emitShrSint8Sint16(I);
51221 case PT_Uint16:
51222 return emitShrSint8Uint16(I);
51223 case PT_Sint32:
51224 return emitShrSint8Sint32(I);
51225 case PT_Uint32:
51226 return emitShrSint8Uint32(I);
51227 case PT_Sint64:
51228 return emitShrSint8Sint64(I);
51229 case PT_Uint64:
51230 return emitShrSint8Uint64(I);
51231 case PT_IntAP:
51232 return emitShrSint8IntAP(I);
51233 case PT_IntAPS:
51234 return emitShrSint8IntAPS(I);
51235 default: llvm_unreachable("invalid type: emitShr");
51236 }
51237 llvm_unreachable("invalid enum value");
51238 case PT_Uint8:
51239 switch (T1) {
51240 case PT_Sint8:
51241 return emitShrUint8Sint8(I);
51242 case PT_Uint8:
51243 return emitShrUint8Uint8(I);
51244 case PT_Sint16:
51245 return emitShrUint8Sint16(I);
51246 case PT_Uint16:
51247 return emitShrUint8Uint16(I);
51248 case PT_Sint32:
51249 return emitShrUint8Sint32(I);
51250 case PT_Uint32:
51251 return emitShrUint8Uint32(I);
51252 case PT_Sint64:
51253 return emitShrUint8Sint64(I);
51254 case PT_Uint64:
51255 return emitShrUint8Uint64(I);
51256 case PT_IntAP:
51257 return emitShrUint8IntAP(I);
51258 case PT_IntAPS:
51259 return emitShrUint8IntAPS(I);
51260 default: llvm_unreachable("invalid type: emitShr");
51261 }
51262 llvm_unreachable("invalid enum value");
51263 case PT_Sint16:
51264 switch (T1) {
51265 case PT_Sint8:
51266 return emitShrSint16Sint8(I);
51267 case PT_Uint8:
51268 return emitShrSint16Uint8(I);
51269 case PT_Sint16:
51270 return emitShrSint16Sint16(I);
51271 case PT_Uint16:
51272 return emitShrSint16Uint16(I);
51273 case PT_Sint32:
51274 return emitShrSint16Sint32(I);
51275 case PT_Uint32:
51276 return emitShrSint16Uint32(I);
51277 case PT_Sint64:
51278 return emitShrSint16Sint64(I);
51279 case PT_Uint64:
51280 return emitShrSint16Uint64(I);
51281 case PT_IntAP:
51282 return emitShrSint16IntAP(I);
51283 case PT_IntAPS:
51284 return emitShrSint16IntAPS(I);
51285 default: llvm_unreachable("invalid type: emitShr");
51286 }
51287 llvm_unreachable("invalid enum value");
51288 case PT_Uint16:
51289 switch (T1) {
51290 case PT_Sint8:
51291 return emitShrUint16Sint8(I);
51292 case PT_Uint8:
51293 return emitShrUint16Uint8(I);
51294 case PT_Sint16:
51295 return emitShrUint16Sint16(I);
51296 case PT_Uint16:
51297 return emitShrUint16Uint16(I);
51298 case PT_Sint32:
51299 return emitShrUint16Sint32(I);
51300 case PT_Uint32:
51301 return emitShrUint16Uint32(I);
51302 case PT_Sint64:
51303 return emitShrUint16Sint64(I);
51304 case PT_Uint64:
51305 return emitShrUint16Uint64(I);
51306 case PT_IntAP:
51307 return emitShrUint16IntAP(I);
51308 case PT_IntAPS:
51309 return emitShrUint16IntAPS(I);
51310 default: llvm_unreachable("invalid type: emitShr");
51311 }
51312 llvm_unreachable("invalid enum value");
51313 case PT_Sint32:
51314 switch (T1) {
51315 case PT_Sint8:
51316 return emitShrSint32Sint8(I);
51317 case PT_Uint8:
51318 return emitShrSint32Uint8(I);
51319 case PT_Sint16:
51320 return emitShrSint32Sint16(I);
51321 case PT_Uint16:
51322 return emitShrSint32Uint16(I);
51323 case PT_Sint32:
51324 return emitShrSint32Sint32(I);
51325 case PT_Uint32:
51326 return emitShrSint32Uint32(I);
51327 case PT_Sint64:
51328 return emitShrSint32Sint64(I);
51329 case PT_Uint64:
51330 return emitShrSint32Uint64(I);
51331 case PT_IntAP:
51332 return emitShrSint32IntAP(I);
51333 case PT_IntAPS:
51334 return emitShrSint32IntAPS(I);
51335 default: llvm_unreachable("invalid type: emitShr");
51336 }
51337 llvm_unreachable("invalid enum value");
51338 case PT_Uint32:
51339 switch (T1) {
51340 case PT_Sint8:
51341 return emitShrUint32Sint8(I);
51342 case PT_Uint8:
51343 return emitShrUint32Uint8(I);
51344 case PT_Sint16:
51345 return emitShrUint32Sint16(I);
51346 case PT_Uint16:
51347 return emitShrUint32Uint16(I);
51348 case PT_Sint32:
51349 return emitShrUint32Sint32(I);
51350 case PT_Uint32:
51351 return emitShrUint32Uint32(I);
51352 case PT_Sint64:
51353 return emitShrUint32Sint64(I);
51354 case PT_Uint64:
51355 return emitShrUint32Uint64(I);
51356 case PT_IntAP:
51357 return emitShrUint32IntAP(I);
51358 case PT_IntAPS:
51359 return emitShrUint32IntAPS(I);
51360 default: llvm_unreachable("invalid type: emitShr");
51361 }
51362 llvm_unreachable("invalid enum value");
51363 case PT_Sint64:
51364 switch (T1) {
51365 case PT_Sint8:
51366 return emitShrSint64Sint8(I);
51367 case PT_Uint8:
51368 return emitShrSint64Uint8(I);
51369 case PT_Sint16:
51370 return emitShrSint64Sint16(I);
51371 case PT_Uint16:
51372 return emitShrSint64Uint16(I);
51373 case PT_Sint32:
51374 return emitShrSint64Sint32(I);
51375 case PT_Uint32:
51376 return emitShrSint64Uint32(I);
51377 case PT_Sint64:
51378 return emitShrSint64Sint64(I);
51379 case PT_Uint64:
51380 return emitShrSint64Uint64(I);
51381 case PT_IntAP:
51382 return emitShrSint64IntAP(I);
51383 case PT_IntAPS:
51384 return emitShrSint64IntAPS(I);
51385 default: llvm_unreachable("invalid type: emitShr");
51386 }
51387 llvm_unreachable("invalid enum value");
51388 case PT_Uint64:
51389 switch (T1) {
51390 case PT_Sint8:
51391 return emitShrUint64Sint8(I);
51392 case PT_Uint8:
51393 return emitShrUint64Uint8(I);
51394 case PT_Sint16:
51395 return emitShrUint64Sint16(I);
51396 case PT_Uint16:
51397 return emitShrUint64Uint16(I);
51398 case PT_Sint32:
51399 return emitShrUint64Sint32(I);
51400 case PT_Uint32:
51401 return emitShrUint64Uint32(I);
51402 case PT_Sint64:
51403 return emitShrUint64Sint64(I);
51404 case PT_Uint64:
51405 return emitShrUint64Uint64(I);
51406 case PT_IntAP:
51407 return emitShrUint64IntAP(I);
51408 case PT_IntAPS:
51409 return emitShrUint64IntAPS(I);
51410 default: llvm_unreachable("invalid type: emitShr");
51411 }
51412 llvm_unreachable("invalid enum value");
51413 case PT_IntAP:
51414 switch (T1) {
51415 case PT_Sint8:
51416 return emitShrIntAPSint8(I);
51417 case PT_Uint8:
51418 return emitShrIntAPUint8(I);
51419 case PT_Sint16:
51420 return emitShrIntAPSint16(I);
51421 case PT_Uint16:
51422 return emitShrIntAPUint16(I);
51423 case PT_Sint32:
51424 return emitShrIntAPSint32(I);
51425 case PT_Uint32:
51426 return emitShrIntAPUint32(I);
51427 case PT_Sint64:
51428 return emitShrIntAPSint64(I);
51429 case PT_Uint64:
51430 return emitShrIntAPUint64(I);
51431 case PT_IntAP:
51432 return emitShrIntAPIntAP(I);
51433 case PT_IntAPS:
51434 return emitShrIntAPIntAPS(I);
51435 default: llvm_unreachable("invalid type: emitShr");
51436 }
51437 llvm_unreachable("invalid enum value");
51438 case PT_IntAPS:
51439 switch (T1) {
51440 case PT_Sint8:
51441 return emitShrIntAPSSint8(I);
51442 case PT_Uint8:
51443 return emitShrIntAPSUint8(I);
51444 case PT_Sint16:
51445 return emitShrIntAPSSint16(I);
51446 case PT_Uint16:
51447 return emitShrIntAPSUint16(I);
51448 case PT_Sint32:
51449 return emitShrIntAPSSint32(I);
51450 case PT_Uint32:
51451 return emitShrIntAPSUint32(I);
51452 case PT_Sint64:
51453 return emitShrIntAPSSint64(I);
51454 case PT_Uint64:
51455 return emitShrIntAPSUint64(I);
51456 case PT_IntAP:
51457 return emitShrIntAPSIntAP(I);
51458 case PT_IntAPS:
51459 return emitShrIntAPSIntAPS(I);
51460 default: llvm_unreachable("invalid type: emitShr");
51461 }
51462 llvm_unreachable("invalid enum value");
51463 default: llvm_unreachable("invalid type: emitShr");
51464 }
51465 llvm_unreachable("invalid enum value");
51466}
51467#endif
51468#ifdef GET_LINK_IMPL
51469bool ByteCodeEmitter::emitShrSint8Sint8(SourceInfo L) {
51470 return emitOp<>(OP_ShrSint8Sint8, L);
51471}
51472bool ByteCodeEmitter::emitShrSint8Uint8(SourceInfo L) {
51473 return emitOp<>(OP_ShrSint8Uint8, L);
51474}
51475bool ByteCodeEmitter::emitShrSint8Sint16(SourceInfo L) {
51476 return emitOp<>(OP_ShrSint8Sint16, L);
51477}
51478bool ByteCodeEmitter::emitShrSint8Uint16(SourceInfo L) {
51479 return emitOp<>(OP_ShrSint8Uint16, L);
51480}
51481bool ByteCodeEmitter::emitShrSint8Sint32(SourceInfo L) {
51482 return emitOp<>(OP_ShrSint8Sint32, L);
51483}
51484bool ByteCodeEmitter::emitShrSint8Uint32(SourceInfo L) {
51485 return emitOp<>(OP_ShrSint8Uint32, L);
51486}
51487bool ByteCodeEmitter::emitShrSint8Sint64(SourceInfo L) {
51488 return emitOp<>(OP_ShrSint8Sint64, L);
51489}
51490bool ByteCodeEmitter::emitShrSint8Uint64(SourceInfo L) {
51491 return emitOp<>(OP_ShrSint8Uint64, L);
51492}
51493bool ByteCodeEmitter::emitShrSint8IntAP(SourceInfo L) {
51494 return emitOp<>(OP_ShrSint8IntAP, L);
51495}
51496bool ByteCodeEmitter::emitShrSint8IntAPS(SourceInfo L) {
51497 return emitOp<>(OP_ShrSint8IntAPS, L);
51498}
51499bool ByteCodeEmitter::emitShrUint8Sint8(SourceInfo L) {
51500 return emitOp<>(OP_ShrUint8Sint8, L);
51501}
51502bool ByteCodeEmitter::emitShrUint8Uint8(SourceInfo L) {
51503 return emitOp<>(OP_ShrUint8Uint8, L);
51504}
51505bool ByteCodeEmitter::emitShrUint8Sint16(SourceInfo L) {
51506 return emitOp<>(OP_ShrUint8Sint16, L);
51507}
51508bool ByteCodeEmitter::emitShrUint8Uint16(SourceInfo L) {
51509 return emitOp<>(OP_ShrUint8Uint16, L);
51510}
51511bool ByteCodeEmitter::emitShrUint8Sint32(SourceInfo L) {
51512 return emitOp<>(OP_ShrUint8Sint32, L);
51513}
51514bool ByteCodeEmitter::emitShrUint8Uint32(SourceInfo L) {
51515 return emitOp<>(OP_ShrUint8Uint32, L);
51516}
51517bool ByteCodeEmitter::emitShrUint8Sint64(SourceInfo L) {
51518 return emitOp<>(OP_ShrUint8Sint64, L);
51519}
51520bool ByteCodeEmitter::emitShrUint8Uint64(SourceInfo L) {
51521 return emitOp<>(OP_ShrUint8Uint64, L);
51522}
51523bool ByteCodeEmitter::emitShrUint8IntAP(SourceInfo L) {
51524 return emitOp<>(OP_ShrUint8IntAP, L);
51525}
51526bool ByteCodeEmitter::emitShrUint8IntAPS(SourceInfo L) {
51527 return emitOp<>(OP_ShrUint8IntAPS, L);
51528}
51529bool ByteCodeEmitter::emitShrSint16Sint8(SourceInfo L) {
51530 return emitOp<>(OP_ShrSint16Sint8, L);
51531}
51532bool ByteCodeEmitter::emitShrSint16Uint8(SourceInfo L) {
51533 return emitOp<>(OP_ShrSint16Uint8, L);
51534}
51535bool ByteCodeEmitter::emitShrSint16Sint16(SourceInfo L) {
51536 return emitOp<>(OP_ShrSint16Sint16, L);
51537}
51538bool ByteCodeEmitter::emitShrSint16Uint16(SourceInfo L) {
51539 return emitOp<>(OP_ShrSint16Uint16, L);
51540}
51541bool ByteCodeEmitter::emitShrSint16Sint32(SourceInfo L) {
51542 return emitOp<>(OP_ShrSint16Sint32, L);
51543}
51544bool ByteCodeEmitter::emitShrSint16Uint32(SourceInfo L) {
51545 return emitOp<>(OP_ShrSint16Uint32, L);
51546}
51547bool ByteCodeEmitter::emitShrSint16Sint64(SourceInfo L) {
51548 return emitOp<>(OP_ShrSint16Sint64, L);
51549}
51550bool ByteCodeEmitter::emitShrSint16Uint64(SourceInfo L) {
51551 return emitOp<>(OP_ShrSint16Uint64, L);
51552}
51553bool ByteCodeEmitter::emitShrSint16IntAP(SourceInfo L) {
51554 return emitOp<>(OP_ShrSint16IntAP, L);
51555}
51556bool ByteCodeEmitter::emitShrSint16IntAPS(SourceInfo L) {
51557 return emitOp<>(OP_ShrSint16IntAPS, L);
51558}
51559bool ByteCodeEmitter::emitShrUint16Sint8(SourceInfo L) {
51560 return emitOp<>(OP_ShrUint16Sint8, L);
51561}
51562bool ByteCodeEmitter::emitShrUint16Uint8(SourceInfo L) {
51563 return emitOp<>(OP_ShrUint16Uint8, L);
51564}
51565bool ByteCodeEmitter::emitShrUint16Sint16(SourceInfo L) {
51566 return emitOp<>(OP_ShrUint16Sint16, L);
51567}
51568bool ByteCodeEmitter::emitShrUint16Uint16(SourceInfo L) {
51569 return emitOp<>(OP_ShrUint16Uint16, L);
51570}
51571bool ByteCodeEmitter::emitShrUint16Sint32(SourceInfo L) {
51572 return emitOp<>(OP_ShrUint16Sint32, L);
51573}
51574bool ByteCodeEmitter::emitShrUint16Uint32(SourceInfo L) {
51575 return emitOp<>(OP_ShrUint16Uint32, L);
51576}
51577bool ByteCodeEmitter::emitShrUint16Sint64(SourceInfo L) {
51578 return emitOp<>(OP_ShrUint16Sint64, L);
51579}
51580bool ByteCodeEmitter::emitShrUint16Uint64(SourceInfo L) {
51581 return emitOp<>(OP_ShrUint16Uint64, L);
51582}
51583bool ByteCodeEmitter::emitShrUint16IntAP(SourceInfo L) {
51584 return emitOp<>(OP_ShrUint16IntAP, L);
51585}
51586bool ByteCodeEmitter::emitShrUint16IntAPS(SourceInfo L) {
51587 return emitOp<>(OP_ShrUint16IntAPS, L);
51588}
51589bool ByteCodeEmitter::emitShrSint32Sint8(SourceInfo L) {
51590 return emitOp<>(OP_ShrSint32Sint8, L);
51591}
51592bool ByteCodeEmitter::emitShrSint32Uint8(SourceInfo L) {
51593 return emitOp<>(OP_ShrSint32Uint8, L);
51594}
51595bool ByteCodeEmitter::emitShrSint32Sint16(SourceInfo L) {
51596 return emitOp<>(OP_ShrSint32Sint16, L);
51597}
51598bool ByteCodeEmitter::emitShrSint32Uint16(SourceInfo L) {
51599 return emitOp<>(OP_ShrSint32Uint16, L);
51600}
51601bool ByteCodeEmitter::emitShrSint32Sint32(SourceInfo L) {
51602 return emitOp<>(OP_ShrSint32Sint32, L);
51603}
51604bool ByteCodeEmitter::emitShrSint32Uint32(SourceInfo L) {
51605 return emitOp<>(OP_ShrSint32Uint32, L);
51606}
51607bool ByteCodeEmitter::emitShrSint32Sint64(SourceInfo L) {
51608 return emitOp<>(OP_ShrSint32Sint64, L);
51609}
51610bool ByteCodeEmitter::emitShrSint32Uint64(SourceInfo L) {
51611 return emitOp<>(OP_ShrSint32Uint64, L);
51612}
51613bool ByteCodeEmitter::emitShrSint32IntAP(SourceInfo L) {
51614 return emitOp<>(OP_ShrSint32IntAP, L);
51615}
51616bool ByteCodeEmitter::emitShrSint32IntAPS(SourceInfo L) {
51617 return emitOp<>(OP_ShrSint32IntAPS, L);
51618}
51619bool ByteCodeEmitter::emitShrUint32Sint8(SourceInfo L) {
51620 return emitOp<>(OP_ShrUint32Sint8, L);
51621}
51622bool ByteCodeEmitter::emitShrUint32Uint8(SourceInfo L) {
51623 return emitOp<>(OP_ShrUint32Uint8, L);
51624}
51625bool ByteCodeEmitter::emitShrUint32Sint16(SourceInfo L) {
51626 return emitOp<>(OP_ShrUint32Sint16, L);
51627}
51628bool ByteCodeEmitter::emitShrUint32Uint16(SourceInfo L) {
51629 return emitOp<>(OP_ShrUint32Uint16, L);
51630}
51631bool ByteCodeEmitter::emitShrUint32Sint32(SourceInfo L) {
51632 return emitOp<>(OP_ShrUint32Sint32, L);
51633}
51634bool ByteCodeEmitter::emitShrUint32Uint32(SourceInfo L) {
51635 return emitOp<>(OP_ShrUint32Uint32, L);
51636}
51637bool ByteCodeEmitter::emitShrUint32Sint64(SourceInfo L) {
51638 return emitOp<>(OP_ShrUint32Sint64, L);
51639}
51640bool ByteCodeEmitter::emitShrUint32Uint64(SourceInfo L) {
51641 return emitOp<>(OP_ShrUint32Uint64, L);
51642}
51643bool ByteCodeEmitter::emitShrUint32IntAP(SourceInfo L) {
51644 return emitOp<>(OP_ShrUint32IntAP, L);
51645}
51646bool ByteCodeEmitter::emitShrUint32IntAPS(SourceInfo L) {
51647 return emitOp<>(OP_ShrUint32IntAPS, L);
51648}
51649bool ByteCodeEmitter::emitShrSint64Sint8(SourceInfo L) {
51650 return emitOp<>(OP_ShrSint64Sint8, L);
51651}
51652bool ByteCodeEmitter::emitShrSint64Uint8(SourceInfo L) {
51653 return emitOp<>(OP_ShrSint64Uint8, L);
51654}
51655bool ByteCodeEmitter::emitShrSint64Sint16(SourceInfo L) {
51656 return emitOp<>(OP_ShrSint64Sint16, L);
51657}
51658bool ByteCodeEmitter::emitShrSint64Uint16(SourceInfo L) {
51659 return emitOp<>(OP_ShrSint64Uint16, L);
51660}
51661bool ByteCodeEmitter::emitShrSint64Sint32(SourceInfo L) {
51662 return emitOp<>(OP_ShrSint64Sint32, L);
51663}
51664bool ByteCodeEmitter::emitShrSint64Uint32(SourceInfo L) {
51665 return emitOp<>(OP_ShrSint64Uint32, L);
51666}
51667bool ByteCodeEmitter::emitShrSint64Sint64(SourceInfo L) {
51668 return emitOp<>(OP_ShrSint64Sint64, L);
51669}
51670bool ByteCodeEmitter::emitShrSint64Uint64(SourceInfo L) {
51671 return emitOp<>(OP_ShrSint64Uint64, L);
51672}
51673bool ByteCodeEmitter::emitShrSint64IntAP(SourceInfo L) {
51674 return emitOp<>(OP_ShrSint64IntAP, L);
51675}
51676bool ByteCodeEmitter::emitShrSint64IntAPS(SourceInfo L) {
51677 return emitOp<>(OP_ShrSint64IntAPS, L);
51678}
51679bool ByteCodeEmitter::emitShrUint64Sint8(SourceInfo L) {
51680 return emitOp<>(OP_ShrUint64Sint8, L);
51681}
51682bool ByteCodeEmitter::emitShrUint64Uint8(SourceInfo L) {
51683 return emitOp<>(OP_ShrUint64Uint8, L);
51684}
51685bool ByteCodeEmitter::emitShrUint64Sint16(SourceInfo L) {
51686 return emitOp<>(OP_ShrUint64Sint16, L);
51687}
51688bool ByteCodeEmitter::emitShrUint64Uint16(SourceInfo L) {
51689 return emitOp<>(OP_ShrUint64Uint16, L);
51690}
51691bool ByteCodeEmitter::emitShrUint64Sint32(SourceInfo L) {
51692 return emitOp<>(OP_ShrUint64Sint32, L);
51693}
51694bool ByteCodeEmitter::emitShrUint64Uint32(SourceInfo L) {
51695 return emitOp<>(OP_ShrUint64Uint32, L);
51696}
51697bool ByteCodeEmitter::emitShrUint64Sint64(SourceInfo L) {
51698 return emitOp<>(OP_ShrUint64Sint64, L);
51699}
51700bool ByteCodeEmitter::emitShrUint64Uint64(SourceInfo L) {
51701 return emitOp<>(OP_ShrUint64Uint64, L);
51702}
51703bool ByteCodeEmitter::emitShrUint64IntAP(SourceInfo L) {
51704 return emitOp<>(OP_ShrUint64IntAP, L);
51705}
51706bool ByteCodeEmitter::emitShrUint64IntAPS(SourceInfo L) {
51707 return emitOp<>(OP_ShrUint64IntAPS, L);
51708}
51709bool ByteCodeEmitter::emitShrIntAPSint8(SourceInfo L) {
51710 return emitOp<>(OP_ShrIntAPSint8, L);
51711}
51712bool ByteCodeEmitter::emitShrIntAPUint8(SourceInfo L) {
51713 return emitOp<>(OP_ShrIntAPUint8, L);
51714}
51715bool ByteCodeEmitter::emitShrIntAPSint16(SourceInfo L) {
51716 return emitOp<>(OP_ShrIntAPSint16, L);
51717}
51718bool ByteCodeEmitter::emitShrIntAPUint16(SourceInfo L) {
51719 return emitOp<>(OP_ShrIntAPUint16, L);
51720}
51721bool ByteCodeEmitter::emitShrIntAPSint32(SourceInfo L) {
51722 return emitOp<>(OP_ShrIntAPSint32, L);
51723}
51724bool ByteCodeEmitter::emitShrIntAPUint32(SourceInfo L) {
51725 return emitOp<>(OP_ShrIntAPUint32, L);
51726}
51727bool ByteCodeEmitter::emitShrIntAPSint64(SourceInfo L) {
51728 return emitOp<>(OP_ShrIntAPSint64, L);
51729}
51730bool ByteCodeEmitter::emitShrIntAPUint64(SourceInfo L) {
51731 return emitOp<>(OP_ShrIntAPUint64, L);
51732}
51733bool ByteCodeEmitter::emitShrIntAPIntAP(SourceInfo L) {
51734 return emitOp<>(OP_ShrIntAPIntAP, L);
51735}
51736bool ByteCodeEmitter::emitShrIntAPIntAPS(SourceInfo L) {
51737 return emitOp<>(OP_ShrIntAPIntAPS, L);
51738}
51739bool ByteCodeEmitter::emitShrIntAPSSint8(SourceInfo L) {
51740 return emitOp<>(OP_ShrIntAPSSint8, L);
51741}
51742bool ByteCodeEmitter::emitShrIntAPSUint8(SourceInfo L) {
51743 return emitOp<>(OP_ShrIntAPSUint8, L);
51744}
51745bool ByteCodeEmitter::emitShrIntAPSSint16(SourceInfo L) {
51746 return emitOp<>(OP_ShrIntAPSSint16, L);
51747}
51748bool ByteCodeEmitter::emitShrIntAPSUint16(SourceInfo L) {
51749 return emitOp<>(OP_ShrIntAPSUint16, L);
51750}
51751bool ByteCodeEmitter::emitShrIntAPSSint32(SourceInfo L) {
51752 return emitOp<>(OP_ShrIntAPSSint32, L);
51753}
51754bool ByteCodeEmitter::emitShrIntAPSUint32(SourceInfo L) {
51755 return emitOp<>(OP_ShrIntAPSUint32, L);
51756}
51757bool ByteCodeEmitter::emitShrIntAPSSint64(SourceInfo L) {
51758 return emitOp<>(OP_ShrIntAPSSint64, L);
51759}
51760bool ByteCodeEmitter::emitShrIntAPSUint64(SourceInfo L) {
51761 return emitOp<>(OP_ShrIntAPSUint64, L);
51762}
51763bool ByteCodeEmitter::emitShrIntAPSIntAP(SourceInfo L) {
51764 return emitOp<>(OP_ShrIntAPSIntAP, L);
51765}
51766bool ByteCodeEmitter::emitShrIntAPSIntAPS(SourceInfo L) {
51767 return emitOp<>(OP_ShrIntAPSIntAPS, L);
51768}
51769#endif
51770#ifdef GET_EVAL_IMPL
51771bool EvalEmitter::emitShrSint8Sint8(SourceInfo L) {
51772 if (!isActive()) return true;
51773 CurrentSource = L;
51774 return Shr<PT_Sint8, PT_Sint8>(S, CodePtr());
51775}
51776bool EvalEmitter::emitShrSint8Uint8(SourceInfo L) {
51777 if (!isActive()) return true;
51778 CurrentSource = L;
51779 return Shr<PT_Sint8, PT_Uint8>(S, CodePtr());
51780}
51781bool EvalEmitter::emitShrSint8Sint16(SourceInfo L) {
51782 if (!isActive()) return true;
51783 CurrentSource = L;
51784 return Shr<PT_Sint8, PT_Sint16>(S, CodePtr());
51785}
51786bool EvalEmitter::emitShrSint8Uint16(SourceInfo L) {
51787 if (!isActive()) return true;
51788 CurrentSource = L;
51789 return Shr<PT_Sint8, PT_Uint16>(S, CodePtr());
51790}
51791bool EvalEmitter::emitShrSint8Sint32(SourceInfo L) {
51792 if (!isActive()) return true;
51793 CurrentSource = L;
51794 return Shr<PT_Sint8, PT_Sint32>(S, CodePtr());
51795}
51796bool EvalEmitter::emitShrSint8Uint32(SourceInfo L) {
51797 if (!isActive()) return true;
51798 CurrentSource = L;
51799 return Shr<PT_Sint8, PT_Uint32>(S, CodePtr());
51800}
51801bool EvalEmitter::emitShrSint8Sint64(SourceInfo L) {
51802 if (!isActive()) return true;
51803 CurrentSource = L;
51804 return Shr<PT_Sint8, PT_Sint64>(S, CodePtr());
51805}
51806bool EvalEmitter::emitShrSint8Uint64(SourceInfo L) {
51807 if (!isActive()) return true;
51808 CurrentSource = L;
51809 return Shr<PT_Sint8, PT_Uint64>(S, CodePtr());
51810}
51811bool EvalEmitter::emitShrSint8IntAP(SourceInfo L) {
51812 if (!isActive()) return true;
51813 CurrentSource = L;
51814 return Shr<PT_Sint8, PT_IntAP>(S, CodePtr());
51815}
51816bool EvalEmitter::emitShrSint8IntAPS(SourceInfo L) {
51817 if (!isActive()) return true;
51818 CurrentSource = L;
51819 return Shr<PT_Sint8, PT_IntAPS>(S, CodePtr());
51820}
51821bool EvalEmitter::emitShrUint8Sint8(SourceInfo L) {
51822 if (!isActive()) return true;
51823 CurrentSource = L;
51824 return Shr<PT_Uint8, PT_Sint8>(S, CodePtr());
51825}
51826bool EvalEmitter::emitShrUint8Uint8(SourceInfo L) {
51827 if (!isActive()) return true;
51828 CurrentSource = L;
51829 return Shr<PT_Uint8, PT_Uint8>(S, CodePtr());
51830}
51831bool EvalEmitter::emitShrUint8Sint16(SourceInfo L) {
51832 if (!isActive()) return true;
51833 CurrentSource = L;
51834 return Shr<PT_Uint8, PT_Sint16>(S, CodePtr());
51835}
51836bool EvalEmitter::emitShrUint8Uint16(SourceInfo L) {
51837 if (!isActive()) return true;
51838 CurrentSource = L;
51839 return Shr<PT_Uint8, PT_Uint16>(S, CodePtr());
51840}
51841bool EvalEmitter::emitShrUint8Sint32(SourceInfo L) {
51842 if (!isActive()) return true;
51843 CurrentSource = L;
51844 return Shr<PT_Uint8, PT_Sint32>(S, CodePtr());
51845}
51846bool EvalEmitter::emitShrUint8Uint32(SourceInfo L) {
51847 if (!isActive()) return true;
51848 CurrentSource = L;
51849 return Shr<PT_Uint8, PT_Uint32>(S, CodePtr());
51850}
51851bool EvalEmitter::emitShrUint8Sint64(SourceInfo L) {
51852 if (!isActive()) return true;
51853 CurrentSource = L;
51854 return Shr<PT_Uint8, PT_Sint64>(S, CodePtr());
51855}
51856bool EvalEmitter::emitShrUint8Uint64(SourceInfo L) {
51857 if (!isActive()) return true;
51858 CurrentSource = L;
51859 return Shr<PT_Uint8, PT_Uint64>(S, CodePtr());
51860}
51861bool EvalEmitter::emitShrUint8IntAP(SourceInfo L) {
51862 if (!isActive()) return true;
51863 CurrentSource = L;
51864 return Shr<PT_Uint8, PT_IntAP>(S, CodePtr());
51865}
51866bool EvalEmitter::emitShrUint8IntAPS(SourceInfo L) {
51867 if (!isActive()) return true;
51868 CurrentSource = L;
51869 return Shr<PT_Uint8, PT_IntAPS>(S, CodePtr());
51870}
51871bool EvalEmitter::emitShrSint16Sint8(SourceInfo L) {
51872 if (!isActive()) return true;
51873 CurrentSource = L;
51874 return Shr<PT_Sint16, PT_Sint8>(S, CodePtr());
51875}
51876bool EvalEmitter::emitShrSint16Uint8(SourceInfo L) {
51877 if (!isActive()) return true;
51878 CurrentSource = L;
51879 return Shr<PT_Sint16, PT_Uint8>(S, CodePtr());
51880}
51881bool EvalEmitter::emitShrSint16Sint16(SourceInfo L) {
51882 if (!isActive()) return true;
51883 CurrentSource = L;
51884 return Shr<PT_Sint16, PT_Sint16>(S, CodePtr());
51885}
51886bool EvalEmitter::emitShrSint16Uint16(SourceInfo L) {
51887 if (!isActive()) return true;
51888 CurrentSource = L;
51889 return Shr<PT_Sint16, PT_Uint16>(S, CodePtr());
51890}
51891bool EvalEmitter::emitShrSint16Sint32(SourceInfo L) {
51892 if (!isActive()) return true;
51893 CurrentSource = L;
51894 return Shr<PT_Sint16, PT_Sint32>(S, CodePtr());
51895}
51896bool EvalEmitter::emitShrSint16Uint32(SourceInfo L) {
51897 if (!isActive()) return true;
51898 CurrentSource = L;
51899 return Shr<PT_Sint16, PT_Uint32>(S, CodePtr());
51900}
51901bool EvalEmitter::emitShrSint16Sint64(SourceInfo L) {
51902 if (!isActive()) return true;
51903 CurrentSource = L;
51904 return Shr<PT_Sint16, PT_Sint64>(S, CodePtr());
51905}
51906bool EvalEmitter::emitShrSint16Uint64(SourceInfo L) {
51907 if (!isActive()) return true;
51908 CurrentSource = L;
51909 return Shr<PT_Sint16, PT_Uint64>(S, CodePtr());
51910}
51911bool EvalEmitter::emitShrSint16IntAP(SourceInfo L) {
51912 if (!isActive()) return true;
51913 CurrentSource = L;
51914 return Shr<PT_Sint16, PT_IntAP>(S, CodePtr());
51915}
51916bool EvalEmitter::emitShrSint16IntAPS(SourceInfo L) {
51917 if (!isActive()) return true;
51918 CurrentSource = L;
51919 return Shr<PT_Sint16, PT_IntAPS>(S, CodePtr());
51920}
51921bool EvalEmitter::emitShrUint16Sint8(SourceInfo L) {
51922 if (!isActive()) return true;
51923 CurrentSource = L;
51924 return Shr<PT_Uint16, PT_Sint8>(S, CodePtr());
51925}
51926bool EvalEmitter::emitShrUint16Uint8(SourceInfo L) {
51927 if (!isActive()) return true;
51928 CurrentSource = L;
51929 return Shr<PT_Uint16, PT_Uint8>(S, CodePtr());
51930}
51931bool EvalEmitter::emitShrUint16Sint16(SourceInfo L) {
51932 if (!isActive()) return true;
51933 CurrentSource = L;
51934 return Shr<PT_Uint16, PT_Sint16>(S, CodePtr());
51935}
51936bool EvalEmitter::emitShrUint16Uint16(SourceInfo L) {
51937 if (!isActive()) return true;
51938 CurrentSource = L;
51939 return Shr<PT_Uint16, PT_Uint16>(S, CodePtr());
51940}
51941bool EvalEmitter::emitShrUint16Sint32(SourceInfo L) {
51942 if (!isActive()) return true;
51943 CurrentSource = L;
51944 return Shr<PT_Uint16, PT_Sint32>(S, CodePtr());
51945}
51946bool EvalEmitter::emitShrUint16Uint32(SourceInfo L) {
51947 if (!isActive()) return true;
51948 CurrentSource = L;
51949 return Shr<PT_Uint16, PT_Uint32>(S, CodePtr());
51950}
51951bool EvalEmitter::emitShrUint16Sint64(SourceInfo L) {
51952 if (!isActive()) return true;
51953 CurrentSource = L;
51954 return Shr<PT_Uint16, PT_Sint64>(S, CodePtr());
51955}
51956bool EvalEmitter::emitShrUint16Uint64(SourceInfo L) {
51957 if (!isActive()) return true;
51958 CurrentSource = L;
51959 return Shr<PT_Uint16, PT_Uint64>(S, CodePtr());
51960}
51961bool EvalEmitter::emitShrUint16IntAP(SourceInfo L) {
51962 if (!isActive()) return true;
51963 CurrentSource = L;
51964 return Shr<PT_Uint16, PT_IntAP>(S, CodePtr());
51965}
51966bool EvalEmitter::emitShrUint16IntAPS(SourceInfo L) {
51967 if (!isActive()) return true;
51968 CurrentSource = L;
51969 return Shr<PT_Uint16, PT_IntAPS>(S, CodePtr());
51970}
51971bool EvalEmitter::emitShrSint32Sint8(SourceInfo L) {
51972 if (!isActive()) return true;
51973 CurrentSource = L;
51974 return Shr<PT_Sint32, PT_Sint8>(S, CodePtr());
51975}
51976bool EvalEmitter::emitShrSint32Uint8(SourceInfo L) {
51977 if (!isActive()) return true;
51978 CurrentSource = L;
51979 return Shr<PT_Sint32, PT_Uint8>(S, CodePtr());
51980}
51981bool EvalEmitter::emitShrSint32Sint16(SourceInfo L) {
51982 if (!isActive()) return true;
51983 CurrentSource = L;
51984 return Shr<PT_Sint32, PT_Sint16>(S, CodePtr());
51985}
51986bool EvalEmitter::emitShrSint32Uint16(SourceInfo L) {
51987 if (!isActive()) return true;
51988 CurrentSource = L;
51989 return Shr<PT_Sint32, PT_Uint16>(S, CodePtr());
51990}
51991bool EvalEmitter::emitShrSint32Sint32(SourceInfo L) {
51992 if (!isActive()) return true;
51993 CurrentSource = L;
51994 return Shr<PT_Sint32, PT_Sint32>(S, CodePtr());
51995}
51996bool EvalEmitter::emitShrSint32Uint32(SourceInfo L) {
51997 if (!isActive()) return true;
51998 CurrentSource = L;
51999 return Shr<PT_Sint32, PT_Uint32>(S, CodePtr());
52000}
52001bool EvalEmitter::emitShrSint32Sint64(SourceInfo L) {
52002 if (!isActive()) return true;
52003 CurrentSource = L;
52004 return Shr<PT_Sint32, PT_Sint64>(S, CodePtr());
52005}
52006bool EvalEmitter::emitShrSint32Uint64(SourceInfo L) {
52007 if (!isActive()) return true;
52008 CurrentSource = L;
52009 return Shr<PT_Sint32, PT_Uint64>(S, CodePtr());
52010}
52011bool EvalEmitter::emitShrSint32IntAP(SourceInfo L) {
52012 if (!isActive()) return true;
52013 CurrentSource = L;
52014 return Shr<PT_Sint32, PT_IntAP>(S, CodePtr());
52015}
52016bool EvalEmitter::emitShrSint32IntAPS(SourceInfo L) {
52017 if (!isActive()) return true;
52018 CurrentSource = L;
52019 return Shr<PT_Sint32, PT_IntAPS>(S, CodePtr());
52020}
52021bool EvalEmitter::emitShrUint32Sint8(SourceInfo L) {
52022 if (!isActive()) return true;
52023 CurrentSource = L;
52024 return Shr<PT_Uint32, PT_Sint8>(S, CodePtr());
52025}
52026bool EvalEmitter::emitShrUint32Uint8(SourceInfo L) {
52027 if (!isActive()) return true;
52028 CurrentSource = L;
52029 return Shr<PT_Uint32, PT_Uint8>(S, CodePtr());
52030}
52031bool EvalEmitter::emitShrUint32Sint16(SourceInfo L) {
52032 if (!isActive()) return true;
52033 CurrentSource = L;
52034 return Shr<PT_Uint32, PT_Sint16>(S, CodePtr());
52035}
52036bool EvalEmitter::emitShrUint32Uint16(SourceInfo L) {
52037 if (!isActive()) return true;
52038 CurrentSource = L;
52039 return Shr<PT_Uint32, PT_Uint16>(S, CodePtr());
52040}
52041bool EvalEmitter::emitShrUint32Sint32(SourceInfo L) {
52042 if (!isActive()) return true;
52043 CurrentSource = L;
52044 return Shr<PT_Uint32, PT_Sint32>(S, CodePtr());
52045}
52046bool EvalEmitter::emitShrUint32Uint32(SourceInfo L) {
52047 if (!isActive()) return true;
52048 CurrentSource = L;
52049 return Shr<PT_Uint32, PT_Uint32>(S, CodePtr());
52050}
52051bool EvalEmitter::emitShrUint32Sint64(SourceInfo L) {
52052 if (!isActive()) return true;
52053 CurrentSource = L;
52054 return Shr<PT_Uint32, PT_Sint64>(S, CodePtr());
52055}
52056bool EvalEmitter::emitShrUint32Uint64(SourceInfo L) {
52057 if (!isActive()) return true;
52058 CurrentSource = L;
52059 return Shr<PT_Uint32, PT_Uint64>(S, CodePtr());
52060}
52061bool EvalEmitter::emitShrUint32IntAP(SourceInfo L) {
52062 if (!isActive()) return true;
52063 CurrentSource = L;
52064 return Shr<PT_Uint32, PT_IntAP>(S, CodePtr());
52065}
52066bool EvalEmitter::emitShrUint32IntAPS(SourceInfo L) {
52067 if (!isActive()) return true;
52068 CurrentSource = L;
52069 return Shr<PT_Uint32, PT_IntAPS>(S, CodePtr());
52070}
52071bool EvalEmitter::emitShrSint64Sint8(SourceInfo L) {
52072 if (!isActive()) return true;
52073 CurrentSource = L;
52074 return Shr<PT_Sint64, PT_Sint8>(S, CodePtr());
52075}
52076bool EvalEmitter::emitShrSint64Uint8(SourceInfo L) {
52077 if (!isActive()) return true;
52078 CurrentSource = L;
52079 return Shr<PT_Sint64, PT_Uint8>(S, CodePtr());
52080}
52081bool EvalEmitter::emitShrSint64Sint16(SourceInfo L) {
52082 if (!isActive()) return true;
52083 CurrentSource = L;
52084 return Shr<PT_Sint64, PT_Sint16>(S, CodePtr());
52085}
52086bool EvalEmitter::emitShrSint64Uint16(SourceInfo L) {
52087 if (!isActive()) return true;
52088 CurrentSource = L;
52089 return Shr<PT_Sint64, PT_Uint16>(S, CodePtr());
52090}
52091bool EvalEmitter::emitShrSint64Sint32(SourceInfo L) {
52092 if (!isActive()) return true;
52093 CurrentSource = L;
52094 return Shr<PT_Sint64, PT_Sint32>(S, CodePtr());
52095}
52096bool EvalEmitter::emitShrSint64Uint32(SourceInfo L) {
52097 if (!isActive()) return true;
52098 CurrentSource = L;
52099 return Shr<PT_Sint64, PT_Uint32>(S, CodePtr());
52100}
52101bool EvalEmitter::emitShrSint64Sint64(SourceInfo L) {
52102 if (!isActive()) return true;
52103 CurrentSource = L;
52104 return Shr<PT_Sint64, PT_Sint64>(S, CodePtr());
52105}
52106bool EvalEmitter::emitShrSint64Uint64(SourceInfo L) {
52107 if (!isActive()) return true;
52108 CurrentSource = L;
52109 return Shr<PT_Sint64, PT_Uint64>(S, CodePtr());
52110}
52111bool EvalEmitter::emitShrSint64IntAP(SourceInfo L) {
52112 if (!isActive()) return true;
52113 CurrentSource = L;
52114 return Shr<PT_Sint64, PT_IntAP>(S, CodePtr());
52115}
52116bool EvalEmitter::emitShrSint64IntAPS(SourceInfo L) {
52117 if (!isActive()) return true;
52118 CurrentSource = L;
52119 return Shr<PT_Sint64, PT_IntAPS>(S, CodePtr());
52120}
52121bool EvalEmitter::emitShrUint64Sint8(SourceInfo L) {
52122 if (!isActive()) return true;
52123 CurrentSource = L;
52124 return Shr<PT_Uint64, PT_Sint8>(S, CodePtr());
52125}
52126bool EvalEmitter::emitShrUint64Uint8(SourceInfo L) {
52127 if (!isActive()) return true;
52128 CurrentSource = L;
52129 return Shr<PT_Uint64, PT_Uint8>(S, CodePtr());
52130}
52131bool EvalEmitter::emitShrUint64Sint16(SourceInfo L) {
52132 if (!isActive()) return true;
52133 CurrentSource = L;
52134 return Shr<PT_Uint64, PT_Sint16>(S, CodePtr());
52135}
52136bool EvalEmitter::emitShrUint64Uint16(SourceInfo L) {
52137 if (!isActive()) return true;
52138 CurrentSource = L;
52139 return Shr<PT_Uint64, PT_Uint16>(S, CodePtr());
52140}
52141bool EvalEmitter::emitShrUint64Sint32(SourceInfo L) {
52142 if (!isActive()) return true;
52143 CurrentSource = L;
52144 return Shr<PT_Uint64, PT_Sint32>(S, CodePtr());
52145}
52146bool EvalEmitter::emitShrUint64Uint32(SourceInfo L) {
52147 if (!isActive()) return true;
52148 CurrentSource = L;
52149 return Shr<PT_Uint64, PT_Uint32>(S, CodePtr());
52150}
52151bool EvalEmitter::emitShrUint64Sint64(SourceInfo L) {
52152 if (!isActive()) return true;
52153 CurrentSource = L;
52154 return Shr<PT_Uint64, PT_Sint64>(S, CodePtr());
52155}
52156bool EvalEmitter::emitShrUint64Uint64(SourceInfo L) {
52157 if (!isActive()) return true;
52158 CurrentSource = L;
52159 return Shr<PT_Uint64, PT_Uint64>(S, CodePtr());
52160}
52161bool EvalEmitter::emitShrUint64IntAP(SourceInfo L) {
52162 if (!isActive()) return true;
52163 CurrentSource = L;
52164 return Shr<PT_Uint64, PT_IntAP>(S, CodePtr());
52165}
52166bool EvalEmitter::emitShrUint64IntAPS(SourceInfo L) {
52167 if (!isActive()) return true;
52168 CurrentSource = L;
52169 return Shr<PT_Uint64, PT_IntAPS>(S, CodePtr());
52170}
52171bool EvalEmitter::emitShrIntAPSint8(SourceInfo L) {
52172 if (!isActive()) return true;
52173 CurrentSource = L;
52174 return Shr<PT_IntAP, PT_Sint8>(S, CodePtr());
52175}
52176bool EvalEmitter::emitShrIntAPUint8(SourceInfo L) {
52177 if (!isActive()) return true;
52178 CurrentSource = L;
52179 return Shr<PT_IntAP, PT_Uint8>(S, CodePtr());
52180}
52181bool EvalEmitter::emitShrIntAPSint16(SourceInfo L) {
52182 if (!isActive()) return true;
52183 CurrentSource = L;
52184 return Shr<PT_IntAP, PT_Sint16>(S, CodePtr());
52185}
52186bool EvalEmitter::emitShrIntAPUint16(SourceInfo L) {
52187 if (!isActive()) return true;
52188 CurrentSource = L;
52189 return Shr<PT_IntAP, PT_Uint16>(S, CodePtr());
52190}
52191bool EvalEmitter::emitShrIntAPSint32(SourceInfo L) {
52192 if (!isActive()) return true;
52193 CurrentSource = L;
52194 return Shr<PT_IntAP, PT_Sint32>(S, CodePtr());
52195}
52196bool EvalEmitter::emitShrIntAPUint32(SourceInfo L) {
52197 if (!isActive()) return true;
52198 CurrentSource = L;
52199 return Shr<PT_IntAP, PT_Uint32>(S, CodePtr());
52200}
52201bool EvalEmitter::emitShrIntAPSint64(SourceInfo L) {
52202 if (!isActive()) return true;
52203 CurrentSource = L;
52204 return Shr<PT_IntAP, PT_Sint64>(S, CodePtr());
52205}
52206bool EvalEmitter::emitShrIntAPUint64(SourceInfo L) {
52207 if (!isActive()) return true;
52208 CurrentSource = L;
52209 return Shr<PT_IntAP, PT_Uint64>(S, CodePtr());
52210}
52211bool EvalEmitter::emitShrIntAPIntAP(SourceInfo L) {
52212 if (!isActive()) return true;
52213 CurrentSource = L;
52214 return Shr<PT_IntAP, PT_IntAP>(S, CodePtr());
52215}
52216bool EvalEmitter::emitShrIntAPIntAPS(SourceInfo L) {
52217 if (!isActive()) return true;
52218 CurrentSource = L;
52219 return Shr<PT_IntAP, PT_IntAPS>(S, CodePtr());
52220}
52221bool EvalEmitter::emitShrIntAPSSint8(SourceInfo L) {
52222 if (!isActive()) return true;
52223 CurrentSource = L;
52224 return Shr<PT_IntAPS, PT_Sint8>(S, CodePtr());
52225}
52226bool EvalEmitter::emitShrIntAPSUint8(SourceInfo L) {
52227 if (!isActive()) return true;
52228 CurrentSource = L;
52229 return Shr<PT_IntAPS, PT_Uint8>(S, CodePtr());
52230}
52231bool EvalEmitter::emitShrIntAPSSint16(SourceInfo L) {
52232 if (!isActive()) return true;
52233 CurrentSource = L;
52234 return Shr<PT_IntAPS, PT_Sint16>(S, CodePtr());
52235}
52236bool EvalEmitter::emitShrIntAPSUint16(SourceInfo L) {
52237 if (!isActive()) return true;
52238 CurrentSource = L;
52239 return Shr<PT_IntAPS, PT_Uint16>(S, CodePtr());
52240}
52241bool EvalEmitter::emitShrIntAPSSint32(SourceInfo L) {
52242 if (!isActive()) return true;
52243 CurrentSource = L;
52244 return Shr<PT_IntAPS, PT_Sint32>(S, CodePtr());
52245}
52246bool EvalEmitter::emitShrIntAPSUint32(SourceInfo L) {
52247 if (!isActive()) return true;
52248 CurrentSource = L;
52249 return Shr<PT_IntAPS, PT_Uint32>(S, CodePtr());
52250}
52251bool EvalEmitter::emitShrIntAPSSint64(SourceInfo L) {
52252 if (!isActive()) return true;
52253 CurrentSource = L;
52254 return Shr<PT_IntAPS, PT_Sint64>(S, CodePtr());
52255}
52256bool EvalEmitter::emitShrIntAPSUint64(SourceInfo L) {
52257 if (!isActive()) return true;
52258 CurrentSource = L;
52259 return Shr<PT_IntAPS, PT_Uint64>(S, CodePtr());
52260}
52261bool EvalEmitter::emitShrIntAPSIntAP(SourceInfo L) {
52262 if (!isActive()) return true;
52263 CurrentSource = L;
52264 return Shr<PT_IntAPS, PT_IntAP>(S, CodePtr());
52265}
52266bool EvalEmitter::emitShrIntAPSIntAPS(SourceInfo L) {
52267 if (!isActive()) return true;
52268 CurrentSource = L;
52269 return Shr<PT_IntAPS, PT_IntAPS>(S, CodePtr());
52270}
52271#endif
52272#ifdef GET_OPCODE_NAMES
52273OP_SideEffect,
52274#endif
52275#ifdef GET_INTERPFN_LIST
52276&Interp_SideEffect,
52277#endif
52278#ifdef GET_INTERPFN_DISPATCHERS
52279PRESERVE_NONE
52280static bool Interp_SideEffect(InterpState &S) {
52281 if (!SideEffect(S)) return false;
52282#if USE_TAILCALLS
52283 MUSTTAIL return InterpNext(S);
52284#else
52285 return true;
52286#endif
52287}
52288#endif
52289#ifdef GET_DISASM
52290case OP_SideEffect:
52291 Text.Op = PrintName("SideEffect");
52292 break;
52293#endif
52294#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52295bool emitSideEffect(SourceInfo);
52296#endif
52297#ifdef GET_LINK_IMPL
52298bool ByteCodeEmitter::emitSideEffect(SourceInfo L) {
52299 return emitOp<>(OP_SideEffect, L);
52300}
52301#endif
52302#ifdef GET_EVAL_IMPL
52303bool EvalEmitter::emitSideEffect(SourceInfo L) {
52304 if (!isActive()) return true;
52305 CurrentSource = L;
52306 return SideEffect(S);
52307}
52308#endif
52309#ifdef GET_OPCODE_NAMES
52310OP_SizelessVectorElementSize,
52311#endif
52312#ifdef GET_INTERPFN_LIST
52313&Interp_SizelessVectorElementSize,
52314#endif
52315#ifdef GET_INTERPFN_DISPATCHERS
52316PRESERVE_NONE
52317static bool Interp_SizelessVectorElementSize(InterpState &S) {
52318 if (!SizelessVectorElementSize(S, S.PC)) return false;
52319#if USE_TAILCALLS
52320 MUSTTAIL return InterpNext(S);
52321#else
52322 return true;
52323#endif
52324}
52325#endif
52326#ifdef GET_DISASM
52327case OP_SizelessVectorElementSize:
52328 Text.Op = PrintName("SizelessVectorElementSize");
52329 break;
52330#endif
52331#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52332bool emitSizelessVectorElementSize(SourceInfo);
52333#endif
52334#ifdef GET_LINK_IMPL
52335bool ByteCodeEmitter::emitSizelessVectorElementSize(SourceInfo L) {
52336 return emitOp<>(OP_SizelessVectorElementSize, L);
52337}
52338#endif
52339#ifdef GET_EVAL_IMPL
52340bool EvalEmitter::emitSizelessVectorElementSize(SourceInfo L) {
52341 if (!isActive()) return true;
52342 CurrentSource = L;
52343 return SizelessVectorElementSize(S, CodePtr());
52344}
52345#endif
52346#ifdef GET_OPCODE_NAMES
52347OP_StartFieldInit,
52348#endif
52349#ifdef GET_INTERPFN_LIST
52350&Interp_StartFieldInit,
52351#endif
52352#ifdef GET_INTERPFN_DISPATCHERS
52353PRESERVE_NONE
52354static bool Interp_StartFieldInit(InterpState &S) {
52355 {
52356 const auto V0 = ReadArg<uint32_t>(S, S.PC);
52357 StartFieldInit(S, V0);
52358 }
52359#if USE_TAILCALLS
52360 MUSTTAIL return InterpNext(S);
52361#else
52362 return true;
52363#endif
52364}
52365#endif
52366#ifdef GET_DISASM
52367case OP_StartFieldInit:
52368 Text.Op = PrintName("StartFieldInit");
52369 Text.Args.push_back(printArg<uint32_t>(PC));
52370 break;
52371#endif
52372#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52373bool emitStartFieldInit( uint32_t , SourceInfo);
52374#endif
52375#ifdef GET_LINK_IMPL
52376bool ByteCodeEmitter::emitStartFieldInit( uint32_t A0, SourceInfo L) {
52377 return emitOp<uint32_t>(OP_StartFieldInit, A0, L);
52378}
52379#endif
52380#ifdef GET_EVAL_IMPL
52381bool EvalEmitter::emitStartFieldInit( uint32_t A0, SourceInfo L) {
52382 if (!isActive()) return true;
52383 CurrentSource = L;
52384 return StartFieldInit(S, A0);
52385}
52386#endif
52387#ifdef GET_OPCODE_NAMES
52388OP_StartInit,
52389#endif
52390#ifdef GET_INTERPFN_LIST
52391&Interp_StartInit,
52392#endif
52393#ifdef GET_INTERPFN_DISPATCHERS
52394PRESERVE_NONE
52395static bool Interp_StartInit(InterpState &S) {
52396 StartInit(S);
52397#if USE_TAILCALLS
52398 MUSTTAIL return InterpNext(S);
52399#else
52400 return true;
52401#endif
52402}
52403#endif
52404#ifdef GET_DISASM
52405case OP_StartInit:
52406 Text.Op = PrintName("StartInit");
52407 break;
52408#endif
52409#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52410bool emitStartInit(SourceInfo);
52411#endif
52412#ifdef GET_LINK_IMPL
52413bool ByteCodeEmitter::emitStartInit(SourceInfo L) {
52414 return emitOp<>(OP_StartInit, L);
52415}
52416#endif
52417#ifdef GET_EVAL_IMPL
52418bool EvalEmitter::emitStartInit(SourceInfo L) {
52419 if (!isActive()) return true;
52420 CurrentSource = L;
52421 return StartInit(S);
52422}
52423#endif
52424#ifdef GET_OPCODE_NAMES
52425OP_StartSpeculation,
52426#endif
52427#ifdef GET_INTERPFN_LIST
52428&Interp_StartSpeculation,
52429#endif
52430#ifdef GET_INTERPFN_DISPATCHERS
52431PRESERVE_NONE
52432static bool Interp_StartSpeculation(InterpState &S) {
52433 StartSpeculation(S);
52434#if USE_TAILCALLS
52435 MUSTTAIL return InterpNext(S);
52436#else
52437 return true;
52438#endif
52439}
52440#endif
52441#ifdef GET_DISASM
52442case OP_StartSpeculation:
52443 Text.Op = PrintName("StartSpeculation");
52444 break;
52445#endif
52446#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52447bool emitStartSpeculation(SourceInfo);
52448#endif
52449#ifdef GET_LINK_IMPL
52450bool ByteCodeEmitter::emitStartSpeculation(SourceInfo L) {
52451 return emitOp<>(OP_StartSpeculation, L);
52452}
52453#endif
52454#ifdef GET_EVAL_IMPL
52455bool EvalEmitter::emitStartSpeculation(SourceInfo L) {
52456 if (!isActive()) return true;
52457 CurrentSource = L;
52458 return StartSpeculation(S);
52459}
52460#endif
52461#ifdef GET_OPCODE_NAMES
52462OP_StartThisLifetime,
52463#endif
52464#ifdef GET_INTERPFN_LIST
52465&Interp_StartThisLifetime,
52466#endif
52467#ifdef GET_INTERPFN_DISPATCHERS
52468PRESERVE_NONE
52469static bool Interp_StartThisLifetime(InterpState &S) {
52470 if (!StartThisLifetime(S)) return false;
52471#if USE_TAILCALLS
52472 MUSTTAIL return InterpNext(S);
52473#else
52474 return true;
52475#endif
52476}
52477#endif
52478#ifdef GET_DISASM
52479case OP_StartThisLifetime:
52480 Text.Op = PrintName("StartThisLifetime");
52481 break;
52482#endif
52483#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52484bool emitStartThisLifetime(SourceInfo);
52485#endif
52486#ifdef GET_LINK_IMPL
52487bool ByteCodeEmitter::emitStartThisLifetime(SourceInfo L) {
52488 return emitOp<>(OP_StartThisLifetime, L);
52489}
52490#endif
52491#ifdef GET_EVAL_IMPL
52492bool EvalEmitter::emitStartThisLifetime(SourceInfo L) {
52493 if (!isActive()) return true;
52494 CurrentSource = L;
52495 return StartThisLifetime(S);
52496}
52497#endif
52498#ifdef GET_OPCODE_NAMES
52499OP_StartThisLifetime1,
52500#endif
52501#ifdef GET_INTERPFN_LIST
52502&Interp_StartThisLifetime1,
52503#endif
52504#ifdef GET_INTERPFN_DISPATCHERS
52505PRESERVE_NONE
52506static bool Interp_StartThisLifetime1(InterpState &S) {
52507 if (!StartThisLifetime1(S)) return false;
52508#if USE_TAILCALLS
52509 MUSTTAIL return InterpNext(S);
52510#else
52511 return true;
52512#endif
52513}
52514#endif
52515#ifdef GET_DISASM
52516case OP_StartThisLifetime1:
52517 Text.Op = PrintName("StartThisLifetime1");
52518 break;
52519#endif
52520#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52521bool emitStartThisLifetime1(SourceInfo);
52522#endif
52523#ifdef GET_LINK_IMPL
52524bool ByteCodeEmitter::emitStartThisLifetime1(SourceInfo L) {
52525 return emitOp<>(OP_StartThisLifetime1, L);
52526}
52527#endif
52528#ifdef GET_EVAL_IMPL
52529bool EvalEmitter::emitStartThisLifetime1(SourceInfo L) {
52530 if (!isActive()) return true;
52531 CurrentSource = L;
52532 return StartThisLifetime1(S);
52533}
52534#endif
52535#ifdef GET_OPCODE_NAMES
52536OP_StoreSint8,
52537OP_StoreUint8,
52538OP_StoreSint16,
52539OP_StoreUint16,
52540OP_StoreSint32,
52541OP_StoreUint32,
52542OP_StoreSint64,
52543OP_StoreUint64,
52544OP_StoreIntAP,
52545OP_StoreIntAPS,
52546OP_StoreBool,
52547OP_StoreFixedPoint,
52548OP_StorePtr,
52549OP_StoreMemberPtr,
52550OP_StoreFloat,
52551OP_StoreReflect,
52552#endif
52553#ifdef GET_INTERPFN_LIST
52554&Interp_StoreSint8,
52555&Interp_StoreUint8,
52556&Interp_StoreSint16,
52557&Interp_StoreUint16,
52558&Interp_StoreSint32,
52559&Interp_StoreUint32,
52560&Interp_StoreSint64,
52561&Interp_StoreUint64,
52562&Interp_StoreIntAP,
52563&Interp_StoreIntAPS,
52564&Interp_StoreBool,
52565&Interp_StoreFixedPoint,
52566&Interp_StorePtr,
52567&Interp_StoreMemberPtr,
52568&Interp_StoreFloat,
52569&Interp_StoreReflect,
52570#endif
52571#ifdef GET_INTERPFN_DISPATCHERS
52572PRESERVE_NONE
52573static bool Interp_StoreSint8(InterpState &S) {
52574 if (!Store<PT_Sint8>(S, S.PC)) return false;
52575#if USE_TAILCALLS
52576 MUSTTAIL return InterpNext(S);
52577#else
52578 return true;
52579#endif
52580}
52581PRESERVE_NONE
52582static bool Interp_StoreUint8(InterpState &S) {
52583 if (!Store<PT_Uint8>(S, S.PC)) return false;
52584#if USE_TAILCALLS
52585 MUSTTAIL return InterpNext(S);
52586#else
52587 return true;
52588#endif
52589}
52590PRESERVE_NONE
52591static bool Interp_StoreSint16(InterpState &S) {
52592 if (!Store<PT_Sint16>(S, S.PC)) return false;
52593#if USE_TAILCALLS
52594 MUSTTAIL return InterpNext(S);
52595#else
52596 return true;
52597#endif
52598}
52599PRESERVE_NONE
52600static bool Interp_StoreUint16(InterpState &S) {
52601 if (!Store<PT_Uint16>(S, S.PC)) return false;
52602#if USE_TAILCALLS
52603 MUSTTAIL return InterpNext(S);
52604#else
52605 return true;
52606#endif
52607}
52608PRESERVE_NONE
52609static bool Interp_StoreSint32(InterpState &S) {
52610 if (!Store<PT_Sint32>(S, S.PC)) return false;
52611#if USE_TAILCALLS
52612 MUSTTAIL return InterpNext(S);
52613#else
52614 return true;
52615#endif
52616}
52617PRESERVE_NONE
52618static bool Interp_StoreUint32(InterpState &S) {
52619 if (!Store<PT_Uint32>(S, S.PC)) return false;
52620#if USE_TAILCALLS
52621 MUSTTAIL return InterpNext(S);
52622#else
52623 return true;
52624#endif
52625}
52626PRESERVE_NONE
52627static bool Interp_StoreSint64(InterpState &S) {
52628 if (!Store<PT_Sint64>(S, S.PC)) return false;
52629#if USE_TAILCALLS
52630 MUSTTAIL return InterpNext(S);
52631#else
52632 return true;
52633#endif
52634}
52635PRESERVE_NONE
52636static bool Interp_StoreUint64(InterpState &S) {
52637 if (!Store<PT_Uint64>(S, S.PC)) return false;
52638#if USE_TAILCALLS
52639 MUSTTAIL return InterpNext(S);
52640#else
52641 return true;
52642#endif
52643}
52644PRESERVE_NONE
52645static bool Interp_StoreIntAP(InterpState &S) {
52646 if (!Store<PT_IntAP>(S, S.PC)) return false;
52647#if USE_TAILCALLS
52648 MUSTTAIL return InterpNext(S);
52649#else
52650 return true;
52651#endif
52652}
52653PRESERVE_NONE
52654static bool Interp_StoreIntAPS(InterpState &S) {
52655 if (!Store<PT_IntAPS>(S, S.PC)) return false;
52656#if USE_TAILCALLS
52657 MUSTTAIL return InterpNext(S);
52658#else
52659 return true;
52660#endif
52661}
52662PRESERVE_NONE
52663static bool Interp_StoreBool(InterpState &S) {
52664 if (!Store<PT_Bool>(S, S.PC)) return false;
52665#if USE_TAILCALLS
52666 MUSTTAIL return InterpNext(S);
52667#else
52668 return true;
52669#endif
52670}
52671PRESERVE_NONE
52672static bool Interp_StoreFixedPoint(InterpState &S) {
52673 if (!Store<PT_FixedPoint>(S, S.PC)) return false;
52674#if USE_TAILCALLS
52675 MUSTTAIL return InterpNext(S);
52676#else
52677 return true;
52678#endif
52679}
52680PRESERVE_NONE
52681static bool Interp_StorePtr(InterpState &S) {
52682 if (!Store<PT_Ptr>(S, S.PC)) return false;
52683#if USE_TAILCALLS
52684 MUSTTAIL return InterpNext(S);
52685#else
52686 return true;
52687#endif
52688}
52689PRESERVE_NONE
52690static bool Interp_StoreMemberPtr(InterpState &S) {
52691 if (!Store<PT_MemberPtr>(S, S.PC)) return false;
52692#if USE_TAILCALLS
52693 MUSTTAIL return InterpNext(S);
52694#else
52695 return true;
52696#endif
52697}
52698PRESERVE_NONE
52699static bool Interp_StoreFloat(InterpState &S) {
52700 if (!Store<PT_Float>(S, S.PC)) return false;
52701#if USE_TAILCALLS
52702 MUSTTAIL return InterpNext(S);
52703#else
52704 return true;
52705#endif
52706}
52707PRESERVE_NONE
52708static bool Interp_StoreReflect(InterpState &S) {
52709 if (!Store<PT_Reflect>(S, S.PC)) return false;
52710#if USE_TAILCALLS
52711 MUSTTAIL return InterpNext(S);
52712#else
52713 return true;
52714#endif
52715}
52716#endif
52717#ifdef GET_DISASM
52718case OP_StoreSint8:
52719 Text.Op = PrintName("StoreSint8");
52720 break;
52721case OP_StoreUint8:
52722 Text.Op = PrintName("StoreUint8");
52723 break;
52724case OP_StoreSint16:
52725 Text.Op = PrintName("StoreSint16");
52726 break;
52727case OP_StoreUint16:
52728 Text.Op = PrintName("StoreUint16");
52729 break;
52730case OP_StoreSint32:
52731 Text.Op = PrintName("StoreSint32");
52732 break;
52733case OP_StoreUint32:
52734 Text.Op = PrintName("StoreUint32");
52735 break;
52736case OP_StoreSint64:
52737 Text.Op = PrintName("StoreSint64");
52738 break;
52739case OP_StoreUint64:
52740 Text.Op = PrintName("StoreUint64");
52741 break;
52742case OP_StoreIntAP:
52743 Text.Op = PrintName("StoreIntAP");
52744 break;
52745case OP_StoreIntAPS:
52746 Text.Op = PrintName("StoreIntAPS");
52747 break;
52748case OP_StoreBool:
52749 Text.Op = PrintName("StoreBool");
52750 break;
52751case OP_StoreFixedPoint:
52752 Text.Op = PrintName("StoreFixedPoint");
52753 break;
52754case OP_StorePtr:
52755 Text.Op = PrintName("StorePtr");
52756 break;
52757case OP_StoreMemberPtr:
52758 Text.Op = PrintName("StoreMemberPtr");
52759 break;
52760case OP_StoreFloat:
52761 Text.Op = PrintName("StoreFloat");
52762 break;
52763case OP_StoreReflect:
52764 Text.Op = PrintName("StoreReflect");
52765 break;
52766#endif
52767#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52768bool emitStoreSint8(SourceInfo);
52769bool emitStoreUint8(SourceInfo);
52770bool emitStoreSint16(SourceInfo);
52771bool emitStoreUint16(SourceInfo);
52772bool emitStoreSint32(SourceInfo);
52773bool emitStoreUint32(SourceInfo);
52774bool emitStoreSint64(SourceInfo);
52775bool emitStoreUint64(SourceInfo);
52776bool emitStoreIntAP(SourceInfo);
52777bool emitStoreIntAPS(SourceInfo);
52778bool emitStoreBool(SourceInfo);
52779bool emitStoreFixedPoint(SourceInfo);
52780bool emitStorePtr(SourceInfo);
52781bool emitStoreMemberPtr(SourceInfo);
52782bool emitStoreFloat(SourceInfo);
52783bool emitStoreReflect(SourceInfo);
52784#endif
52785#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
52786[[nodiscard]] bool emitStore(PrimType, SourceInfo I);
52787#endif
52788#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
52789bool
52790#if defined(GET_EVAL_IMPL)
52791EvalEmitter
52792#else
52793ByteCodeEmitter
52794#endif
52795::emitStore(PrimType T0, SourceInfo I) {
52796 switch (T0) {
52797 case PT_Sint8:
52798 return emitStoreSint8(I);
52799 case PT_Uint8:
52800 return emitStoreUint8(I);
52801 case PT_Sint16:
52802 return emitStoreSint16(I);
52803 case PT_Uint16:
52804 return emitStoreUint16(I);
52805 case PT_Sint32:
52806 return emitStoreSint32(I);
52807 case PT_Uint32:
52808 return emitStoreUint32(I);
52809 case PT_Sint64:
52810 return emitStoreSint64(I);
52811 case PT_Uint64:
52812 return emitStoreUint64(I);
52813 case PT_IntAP:
52814 return emitStoreIntAP(I);
52815 case PT_IntAPS:
52816 return emitStoreIntAPS(I);
52817 case PT_Bool:
52818 return emitStoreBool(I);
52819 case PT_FixedPoint:
52820 return emitStoreFixedPoint(I);
52821 case PT_Ptr:
52822 return emitStorePtr(I);
52823 case PT_MemberPtr:
52824 return emitStoreMemberPtr(I);
52825 case PT_Float:
52826 return emitStoreFloat(I);
52827 case PT_Reflect:
52828 return emitStoreReflect(I);
52829 }
52830 llvm_unreachable("invalid enum value");
52831}
52832#endif
52833#ifdef GET_LINK_IMPL
52834bool ByteCodeEmitter::emitStoreSint8(SourceInfo L) {
52835 return emitOp<>(OP_StoreSint8, L);
52836}
52837bool ByteCodeEmitter::emitStoreUint8(SourceInfo L) {
52838 return emitOp<>(OP_StoreUint8, L);
52839}
52840bool ByteCodeEmitter::emitStoreSint16(SourceInfo L) {
52841 return emitOp<>(OP_StoreSint16, L);
52842}
52843bool ByteCodeEmitter::emitStoreUint16(SourceInfo L) {
52844 return emitOp<>(OP_StoreUint16, L);
52845}
52846bool ByteCodeEmitter::emitStoreSint32(SourceInfo L) {
52847 return emitOp<>(OP_StoreSint32, L);
52848}
52849bool ByteCodeEmitter::emitStoreUint32(SourceInfo L) {
52850 return emitOp<>(OP_StoreUint32, L);
52851}
52852bool ByteCodeEmitter::emitStoreSint64(SourceInfo L) {
52853 return emitOp<>(OP_StoreSint64, L);
52854}
52855bool ByteCodeEmitter::emitStoreUint64(SourceInfo L) {
52856 return emitOp<>(OP_StoreUint64, L);
52857}
52858bool ByteCodeEmitter::emitStoreIntAP(SourceInfo L) {
52859 return emitOp<>(OP_StoreIntAP, L);
52860}
52861bool ByteCodeEmitter::emitStoreIntAPS(SourceInfo L) {
52862 return emitOp<>(OP_StoreIntAPS, L);
52863}
52864bool ByteCodeEmitter::emitStoreBool(SourceInfo L) {
52865 return emitOp<>(OP_StoreBool, L);
52866}
52867bool ByteCodeEmitter::emitStoreFixedPoint(SourceInfo L) {
52868 return emitOp<>(OP_StoreFixedPoint, L);
52869}
52870bool ByteCodeEmitter::emitStorePtr(SourceInfo L) {
52871 return emitOp<>(OP_StorePtr, L);
52872}
52873bool ByteCodeEmitter::emitStoreMemberPtr(SourceInfo L) {
52874 return emitOp<>(OP_StoreMemberPtr, L);
52875}
52876bool ByteCodeEmitter::emitStoreFloat(SourceInfo L) {
52877 return emitOp<>(OP_StoreFloat, L);
52878}
52879bool ByteCodeEmitter::emitStoreReflect(SourceInfo L) {
52880 return emitOp<>(OP_StoreReflect, L);
52881}
52882#endif
52883#ifdef GET_EVAL_IMPL
52884bool EvalEmitter::emitStoreSint8(SourceInfo L) {
52885 if (!isActive()) return true;
52886 CurrentSource = L;
52887 return Store<PT_Sint8>(S, CodePtr());
52888}
52889bool EvalEmitter::emitStoreUint8(SourceInfo L) {
52890 if (!isActive()) return true;
52891 CurrentSource = L;
52892 return Store<PT_Uint8>(S, CodePtr());
52893}
52894bool EvalEmitter::emitStoreSint16(SourceInfo L) {
52895 if (!isActive()) return true;
52896 CurrentSource = L;
52897 return Store<PT_Sint16>(S, CodePtr());
52898}
52899bool EvalEmitter::emitStoreUint16(SourceInfo L) {
52900 if (!isActive()) return true;
52901 CurrentSource = L;
52902 return Store<PT_Uint16>(S, CodePtr());
52903}
52904bool EvalEmitter::emitStoreSint32(SourceInfo L) {
52905 if (!isActive()) return true;
52906 CurrentSource = L;
52907 return Store<PT_Sint32>(S, CodePtr());
52908}
52909bool EvalEmitter::emitStoreUint32(SourceInfo L) {
52910 if (!isActive()) return true;
52911 CurrentSource = L;
52912 return Store<PT_Uint32>(S, CodePtr());
52913}
52914bool EvalEmitter::emitStoreSint64(SourceInfo L) {
52915 if (!isActive()) return true;
52916 CurrentSource = L;
52917 return Store<PT_Sint64>(S, CodePtr());
52918}
52919bool EvalEmitter::emitStoreUint64(SourceInfo L) {
52920 if (!isActive()) return true;
52921 CurrentSource = L;
52922 return Store<PT_Uint64>(S, CodePtr());
52923}
52924bool EvalEmitter::emitStoreIntAP(SourceInfo L) {
52925 if (!isActive()) return true;
52926 CurrentSource = L;
52927 return Store<PT_IntAP>(S, CodePtr());
52928}
52929bool EvalEmitter::emitStoreIntAPS(SourceInfo L) {
52930 if (!isActive()) return true;
52931 CurrentSource = L;
52932 return Store<PT_IntAPS>(S, CodePtr());
52933}
52934bool EvalEmitter::emitStoreBool(SourceInfo L) {
52935 if (!isActive()) return true;
52936 CurrentSource = L;
52937 return Store<PT_Bool>(S, CodePtr());
52938}
52939bool EvalEmitter::emitStoreFixedPoint(SourceInfo L) {
52940 if (!isActive()) return true;
52941 CurrentSource = L;
52942 return Store<PT_FixedPoint>(S, CodePtr());
52943}
52944bool EvalEmitter::emitStorePtr(SourceInfo L) {
52945 if (!isActive()) return true;
52946 CurrentSource = L;
52947 return Store<PT_Ptr>(S, CodePtr());
52948}
52949bool EvalEmitter::emitStoreMemberPtr(SourceInfo L) {
52950 if (!isActive()) return true;
52951 CurrentSource = L;
52952 return Store<PT_MemberPtr>(S, CodePtr());
52953}
52954bool EvalEmitter::emitStoreFloat(SourceInfo L) {
52955 if (!isActive()) return true;
52956 CurrentSource = L;
52957 return Store<PT_Float>(S, CodePtr());
52958}
52959bool EvalEmitter::emitStoreReflect(SourceInfo L) {
52960 if (!isActive()) return true;
52961 CurrentSource = L;
52962 return Store<PT_Reflect>(S, CodePtr());
52963}
52964#endif
52965#ifdef GET_OPCODE_NAMES
52966OP_StoreActivateSint8,
52967OP_StoreActivateUint8,
52968OP_StoreActivateSint16,
52969OP_StoreActivateUint16,
52970OP_StoreActivateSint32,
52971OP_StoreActivateUint32,
52972OP_StoreActivateSint64,
52973OP_StoreActivateUint64,
52974OP_StoreActivateIntAP,
52975OP_StoreActivateIntAPS,
52976OP_StoreActivateBool,
52977OP_StoreActivateFixedPoint,
52978OP_StoreActivatePtr,
52979OP_StoreActivateMemberPtr,
52980OP_StoreActivateFloat,
52981OP_StoreActivateReflect,
52982#endif
52983#ifdef GET_INTERPFN_LIST
52984&Interp_StoreActivateSint8,
52985&Interp_StoreActivateUint8,
52986&Interp_StoreActivateSint16,
52987&Interp_StoreActivateUint16,
52988&Interp_StoreActivateSint32,
52989&Interp_StoreActivateUint32,
52990&Interp_StoreActivateSint64,
52991&Interp_StoreActivateUint64,
52992&Interp_StoreActivateIntAP,
52993&Interp_StoreActivateIntAPS,
52994&Interp_StoreActivateBool,
52995&Interp_StoreActivateFixedPoint,
52996&Interp_StoreActivatePtr,
52997&Interp_StoreActivateMemberPtr,
52998&Interp_StoreActivateFloat,
52999&Interp_StoreActivateReflect,
53000#endif
53001#ifdef GET_INTERPFN_DISPATCHERS
53002PRESERVE_NONE
53003static bool Interp_StoreActivateSint8(InterpState &S) {
53004 if (!StoreActivate<PT_Sint8>(S, S.PC)) return false;
53005#if USE_TAILCALLS
53006 MUSTTAIL return InterpNext(S);
53007#else
53008 return true;
53009#endif
53010}
53011PRESERVE_NONE
53012static bool Interp_StoreActivateUint8(InterpState &S) {
53013 if (!StoreActivate<PT_Uint8>(S, S.PC)) return false;
53014#if USE_TAILCALLS
53015 MUSTTAIL return InterpNext(S);
53016#else
53017 return true;
53018#endif
53019}
53020PRESERVE_NONE
53021static bool Interp_StoreActivateSint16(InterpState &S) {
53022 if (!StoreActivate<PT_Sint16>(S, S.PC)) return false;
53023#if USE_TAILCALLS
53024 MUSTTAIL return InterpNext(S);
53025#else
53026 return true;
53027#endif
53028}
53029PRESERVE_NONE
53030static bool Interp_StoreActivateUint16(InterpState &S) {
53031 if (!StoreActivate<PT_Uint16>(S, S.PC)) return false;
53032#if USE_TAILCALLS
53033 MUSTTAIL return InterpNext(S);
53034#else
53035 return true;
53036#endif
53037}
53038PRESERVE_NONE
53039static bool Interp_StoreActivateSint32(InterpState &S) {
53040 if (!StoreActivate<PT_Sint32>(S, S.PC)) return false;
53041#if USE_TAILCALLS
53042 MUSTTAIL return InterpNext(S);
53043#else
53044 return true;
53045#endif
53046}
53047PRESERVE_NONE
53048static bool Interp_StoreActivateUint32(InterpState &S) {
53049 if (!StoreActivate<PT_Uint32>(S, S.PC)) return false;
53050#if USE_TAILCALLS
53051 MUSTTAIL return InterpNext(S);
53052#else
53053 return true;
53054#endif
53055}
53056PRESERVE_NONE
53057static bool Interp_StoreActivateSint64(InterpState &S) {
53058 if (!StoreActivate<PT_Sint64>(S, S.PC)) return false;
53059#if USE_TAILCALLS
53060 MUSTTAIL return InterpNext(S);
53061#else
53062 return true;
53063#endif
53064}
53065PRESERVE_NONE
53066static bool Interp_StoreActivateUint64(InterpState &S) {
53067 if (!StoreActivate<PT_Uint64>(S, S.PC)) return false;
53068#if USE_TAILCALLS
53069 MUSTTAIL return InterpNext(S);
53070#else
53071 return true;
53072#endif
53073}
53074PRESERVE_NONE
53075static bool Interp_StoreActivateIntAP(InterpState &S) {
53076 if (!StoreActivate<PT_IntAP>(S, S.PC)) return false;
53077#if USE_TAILCALLS
53078 MUSTTAIL return InterpNext(S);
53079#else
53080 return true;
53081#endif
53082}
53083PRESERVE_NONE
53084static bool Interp_StoreActivateIntAPS(InterpState &S) {
53085 if (!StoreActivate<PT_IntAPS>(S, S.PC)) return false;
53086#if USE_TAILCALLS
53087 MUSTTAIL return InterpNext(S);
53088#else
53089 return true;
53090#endif
53091}
53092PRESERVE_NONE
53093static bool Interp_StoreActivateBool(InterpState &S) {
53094 if (!StoreActivate<PT_Bool>(S, S.PC)) return false;
53095#if USE_TAILCALLS
53096 MUSTTAIL return InterpNext(S);
53097#else
53098 return true;
53099#endif
53100}
53101PRESERVE_NONE
53102static bool Interp_StoreActivateFixedPoint(InterpState &S) {
53103 if (!StoreActivate<PT_FixedPoint>(S, S.PC)) return false;
53104#if USE_TAILCALLS
53105 MUSTTAIL return InterpNext(S);
53106#else
53107 return true;
53108#endif
53109}
53110PRESERVE_NONE
53111static bool Interp_StoreActivatePtr(InterpState &S) {
53112 if (!StoreActivate<PT_Ptr>(S, S.PC)) return false;
53113#if USE_TAILCALLS
53114 MUSTTAIL return InterpNext(S);
53115#else
53116 return true;
53117#endif
53118}
53119PRESERVE_NONE
53120static bool Interp_StoreActivateMemberPtr(InterpState &S) {
53121 if (!StoreActivate<PT_MemberPtr>(S, S.PC)) return false;
53122#if USE_TAILCALLS
53123 MUSTTAIL return InterpNext(S);
53124#else
53125 return true;
53126#endif
53127}
53128PRESERVE_NONE
53129static bool Interp_StoreActivateFloat(InterpState &S) {
53130 if (!StoreActivate<PT_Float>(S, S.PC)) return false;
53131#if USE_TAILCALLS
53132 MUSTTAIL return InterpNext(S);
53133#else
53134 return true;
53135#endif
53136}
53137PRESERVE_NONE
53138static bool Interp_StoreActivateReflect(InterpState &S) {
53139 if (!StoreActivate<PT_Reflect>(S, S.PC)) return false;
53140#if USE_TAILCALLS
53141 MUSTTAIL return InterpNext(S);
53142#else
53143 return true;
53144#endif
53145}
53146#endif
53147#ifdef GET_DISASM
53148case OP_StoreActivateSint8:
53149 Text.Op = PrintName("StoreActivateSint8");
53150 break;
53151case OP_StoreActivateUint8:
53152 Text.Op = PrintName("StoreActivateUint8");
53153 break;
53154case OP_StoreActivateSint16:
53155 Text.Op = PrintName("StoreActivateSint16");
53156 break;
53157case OP_StoreActivateUint16:
53158 Text.Op = PrintName("StoreActivateUint16");
53159 break;
53160case OP_StoreActivateSint32:
53161 Text.Op = PrintName("StoreActivateSint32");
53162 break;
53163case OP_StoreActivateUint32:
53164 Text.Op = PrintName("StoreActivateUint32");
53165 break;
53166case OP_StoreActivateSint64:
53167 Text.Op = PrintName("StoreActivateSint64");
53168 break;
53169case OP_StoreActivateUint64:
53170 Text.Op = PrintName("StoreActivateUint64");
53171 break;
53172case OP_StoreActivateIntAP:
53173 Text.Op = PrintName("StoreActivateIntAP");
53174 break;
53175case OP_StoreActivateIntAPS:
53176 Text.Op = PrintName("StoreActivateIntAPS");
53177 break;
53178case OP_StoreActivateBool:
53179 Text.Op = PrintName("StoreActivateBool");
53180 break;
53181case OP_StoreActivateFixedPoint:
53182 Text.Op = PrintName("StoreActivateFixedPoint");
53183 break;
53184case OP_StoreActivatePtr:
53185 Text.Op = PrintName("StoreActivatePtr");
53186 break;
53187case OP_StoreActivateMemberPtr:
53188 Text.Op = PrintName("StoreActivateMemberPtr");
53189 break;
53190case OP_StoreActivateFloat:
53191 Text.Op = PrintName("StoreActivateFloat");
53192 break;
53193case OP_StoreActivateReflect:
53194 Text.Op = PrintName("StoreActivateReflect");
53195 break;
53196#endif
53197#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
53198bool emitStoreActivateSint8(SourceInfo);
53199bool emitStoreActivateUint8(SourceInfo);
53200bool emitStoreActivateSint16(SourceInfo);
53201bool emitStoreActivateUint16(SourceInfo);
53202bool emitStoreActivateSint32(SourceInfo);
53203bool emitStoreActivateUint32(SourceInfo);
53204bool emitStoreActivateSint64(SourceInfo);
53205bool emitStoreActivateUint64(SourceInfo);
53206bool emitStoreActivateIntAP(SourceInfo);
53207bool emitStoreActivateIntAPS(SourceInfo);
53208bool emitStoreActivateBool(SourceInfo);
53209bool emitStoreActivateFixedPoint(SourceInfo);
53210bool emitStoreActivatePtr(SourceInfo);
53211bool emitStoreActivateMemberPtr(SourceInfo);
53212bool emitStoreActivateFloat(SourceInfo);
53213bool emitStoreActivateReflect(SourceInfo);
53214#endif
53215#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
53216[[nodiscard]] bool emitStoreActivate(PrimType, SourceInfo I);
53217#endif
53218#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
53219bool
53220#if defined(GET_EVAL_IMPL)
53221EvalEmitter
53222#else
53223ByteCodeEmitter
53224#endif
53225::emitStoreActivate(PrimType T0, SourceInfo I) {
53226 switch (T0) {
53227 case PT_Sint8:
53228 return emitStoreActivateSint8(I);
53229 case PT_Uint8:
53230 return emitStoreActivateUint8(I);
53231 case PT_Sint16:
53232 return emitStoreActivateSint16(I);
53233 case PT_Uint16:
53234 return emitStoreActivateUint16(I);
53235 case PT_Sint32:
53236 return emitStoreActivateSint32(I);
53237 case PT_Uint32:
53238 return emitStoreActivateUint32(I);
53239 case PT_Sint64:
53240 return emitStoreActivateSint64(I);
53241 case PT_Uint64:
53242 return emitStoreActivateUint64(I);
53243 case PT_IntAP:
53244 return emitStoreActivateIntAP(I);
53245 case PT_IntAPS:
53246 return emitStoreActivateIntAPS(I);
53247 case PT_Bool:
53248 return emitStoreActivateBool(I);
53249 case PT_FixedPoint:
53250 return emitStoreActivateFixedPoint(I);
53251 case PT_Ptr:
53252 return emitStoreActivatePtr(I);
53253 case PT_MemberPtr:
53254 return emitStoreActivateMemberPtr(I);
53255 case PT_Float:
53256 return emitStoreActivateFloat(I);
53257 case PT_Reflect:
53258 return emitStoreActivateReflect(I);
53259 }
53260 llvm_unreachable("invalid enum value");
53261}
53262#endif
53263#ifdef GET_LINK_IMPL
53264bool ByteCodeEmitter::emitStoreActivateSint8(SourceInfo L) {
53265 return emitOp<>(OP_StoreActivateSint8, L);
53266}
53267bool ByteCodeEmitter::emitStoreActivateUint8(SourceInfo L) {
53268 return emitOp<>(OP_StoreActivateUint8, L);
53269}
53270bool ByteCodeEmitter::emitStoreActivateSint16(SourceInfo L) {
53271 return emitOp<>(OP_StoreActivateSint16, L);
53272}
53273bool ByteCodeEmitter::emitStoreActivateUint16(SourceInfo L) {
53274 return emitOp<>(OP_StoreActivateUint16, L);
53275}
53276bool ByteCodeEmitter::emitStoreActivateSint32(SourceInfo L) {
53277 return emitOp<>(OP_StoreActivateSint32, L);
53278}
53279bool ByteCodeEmitter::emitStoreActivateUint32(SourceInfo L) {
53280 return emitOp<>(OP_StoreActivateUint32, L);
53281}
53282bool ByteCodeEmitter::emitStoreActivateSint64(SourceInfo L) {
53283 return emitOp<>(OP_StoreActivateSint64, L);
53284}
53285bool ByteCodeEmitter::emitStoreActivateUint64(SourceInfo L) {
53286 return emitOp<>(OP_StoreActivateUint64, L);
53287}
53288bool ByteCodeEmitter::emitStoreActivateIntAP(SourceInfo L) {
53289 return emitOp<>(OP_StoreActivateIntAP, L);
53290}
53291bool ByteCodeEmitter::emitStoreActivateIntAPS(SourceInfo L) {
53292 return emitOp<>(OP_StoreActivateIntAPS, L);
53293}
53294bool ByteCodeEmitter::emitStoreActivateBool(SourceInfo L) {
53295 return emitOp<>(OP_StoreActivateBool, L);
53296}
53297bool ByteCodeEmitter::emitStoreActivateFixedPoint(SourceInfo L) {
53298 return emitOp<>(OP_StoreActivateFixedPoint, L);
53299}
53300bool ByteCodeEmitter::emitStoreActivatePtr(SourceInfo L) {
53301 return emitOp<>(OP_StoreActivatePtr, L);
53302}
53303bool ByteCodeEmitter::emitStoreActivateMemberPtr(SourceInfo L) {
53304 return emitOp<>(OP_StoreActivateMemberPtr, L);
53305}
53306bool ByteCodeEmitter::emitStoreActivateFloat(SourceInfo L) {
53307 return emitOp<>(OP_StoreActivateFloat, L);
53308}
53309bool ByteCodeEmitter::emitStoreActivateReflect(SourceInfo L) {
53310 return emitOp<>(OP_StoreActivateReflect, L);
53311}
53312#endif
53313#ifdef GET_EVAL_IMPL
53314bool EvalEmitter::emitStoreActivateSint8(SourceInfo L) {
53315 if (!isActive()) return true;
53316 CurrentSource = L;
53317 return StoreActivate<PT_Sint8>(S, CodePtr());
53318}
53319bool EvalEmitter::emitStoreActivateUint8(SourceInfo L) {
53320 if (!isActive()) return true;
53321 CurrentSource = L;
53322 return StoreActivate<PT_Uint8>(S, CodePtr());
53323}
53324bool EvalEmitter::emitStoreActivateSint16(SourceInfo L) {
53325 if (!isActive()) return true;
53326 CurrentSource = L;
53327 return StoreActivate<PT_Sint16>(S, CodePtr());
53328}
53329bool EvalEmitter::emitStoreActivateUint16(SourceInfo L) {
53330 if (!isActive()) return true;
53331 CurrentSource = L;
53332 return StoreActivate<PT_Uint16>(S, CodePtr());
53333}
53334bool EvalEmitter::emitStoreActivateSint32(SourceInfo L) {
53335 if (!isActive()) return true;
53336 CurrentSource = L;
53337 return StoreActivate<PT_Sint32>(S, CodePtr());
53338}
53339bool EvalEmitter::emitStoreActivateUint32(SourceInfo L) {
53340 if (!isActive()) return true;
53341 CurrentSource = L;
53342 return StoreActivate<PT_Uint32>(S, CodePtr());
53343}
53344bool EvalEmitter::emitStoreActivateSint64(SourceInfo L) {
53345 if (!isActive()) return true;
53346 CurrentSource = L;
53347 return StoreActivate<PT_Sint64>(S, CodePtr());
53348}
53349bool EvalEmitter::emitStoreActivateUint64(SourceInfo L) {
53350 if (!isActive()) return true;
53351 CurrentSource = L;
53352 return StoreActivate<PT_Uint64>(S, CodePtr());
53353}
53354bool EvalEmitter::emitStoreActivateIntAP(SourceInfo L) {
53355 if (!isActive()) return true;
53356 CurrentSource = L;
53357 return StoreActivate<PT_IntAP>(S, CodePtr());
53358}
53359bool EvalEmitter::emitStoreActivateIntAPS(SourceInfo L) {
53360 if (!isActive()) return true;
53361 CurrentSource = L;
53362 return StoreActivate<PT_IntAPS>(S, CodePtr());
53363}
53364bool EvalEmitter::emitStoreActivateBool(SourceInfo L) {
53365 if (!isActive()) return true;
53366 CurrentSource = L;
53367 return StoreActivate<PT_Bool>(S, CodePtr());
53368}
53369bool EvalEmitter::emitStoreActivateFixedPoint(SourceInfo L) {
53370 if (!isActive()) return true;
53371 CurrentSource = L;
53372 return StoreActivate<PT_FixedPoint>(S, CodePtr());
53373}
53374bool EvalEmitter::emitStoreActivatePtr(SourceInfo L) {
53375 if (!isActive()) return true;
53376 CurrentSource = L;
53377 return StoreActivate<PT_Ptr>(S, CodePtr());
53378}
53379bool EvalEmitter::emitStoreActivateMemberPtr(SourceInfo L) {
53380 if (!isActive()) return true;
53381 CurrentSource = L;
53382 return StoreActivate<PT_MemberPtr>(S, CodePtr());
53383}
53384bool EvalEmitter::emitStoreActivateFloat(SourceInfo L) {
53385 if (!isActive()) return true;
53386 CurrentSource = L;
53387 return StoreActivate<PT_Float>(S, CodePtr());
53388}
53389bool EvalEmitter::emitStoreActivateReflect(SourceInfo L) {
53390 if (!isActive()) return true;
53391 CurrentSource = L;
53392 return StoreActivate<PT_Reflect>(S, CodePtr());
53393}
53394#endif
53395#ifdef GET_OPCODE_NAMES
53396OP_StoreActivatePopSint8,
53397OP_StoreActivatePopUint8,
53398OP_StoreActivatePopSint16,
53399OP_StoreActivatePopUint16,
53400OP_StoreActivatePopSint32,
53401OP_StoreActivatePopUint32,
53402OP_StoreActivatePopSint64,
53403OP_StoreActivatePopUint64,
53404OP_StoreActivatePopIntAP,
53405OP_StoreActivatePopIntAPS,
53406OP_StoreActivatePopBool,
53407OP_StoreActivatePopFixedPoint,
53408OP_StoreActivatePopPtr,
53409OP_StoreActivatePopMemberPtr,
53410OP_StoreActivatePopFloat,
53411OP_StoreActivatePopReflect,
53412#endif
53413#ifdef GET_INTERPFN_LIST
53414&Interp_StoreActivatePopSint8,
53415&Interp_StoreActivatePopUint8,
53416&Interp_StoreActivatePopSint16,
53417&Interp_StoreActivatePopUint16,
53418&Interp_StoreActivatePopSint32,
53419&Interp_StoreActivatePopUint32,
53420&Interp_StoreActivatePopSint64,
53421&Interp_StoreActivatePopUint64,
53422&Interp_StoreActivatePopIntAP,
53423&Interp_StoreActivatePopIntAPS,
53424&Interp_StoreActivatePopBool,
53425&Interp_StoreActivatePopFixedPoint,
53426&Interp_StoreActivatePopPtr,
53427&Interp_StoreActivatePopMemberPtr,
53428&Interp_StoreActivatePopFloat,
53429&Interp_StoreActivatePopReflect,
53430#endif
53431#ifdef GET_INTERPFN_DISPATCHERS
53432PRESERVE_NONE
53433static bool Interp_StoreActivatePopSint8(InterpState &S) {
53434 if (!StoreActivatePop<PT_Sint8>(S, S.PC)) return false;
53435#if USE_TAILCALLS
53436 MUSTTAIL return InterpNext(S);
53437#else
53438 return true;
53439#endif
53440}
53441PRESERVE_NONE
53442static bool Interp_StoreActivatePopUint8(InterpState &S) {
53443 if (!StoreActivatePop<PT_Uint8>(S, S.PC)) return false;
53444#if USE_TAILCALLS
53445 MUSTTAIL return InterpNext(S);
53446#else
53447 return true;
53448#endif
53449}
53450PRESERVE_NONE
53451static bool Interp_StoreActivatePopSint16(InterpState &S) {
53452 if (!StoreActivatePop<PT_Sint16>(S, S.PC)) return false;
53453#if USE_TAILCALLS
53454 MUSTTAIL return InterpNext(S);
53455#else
53456 return true;
53457#endif
53458}
53459PRESERVE_NONE
53460static bool Interp_StoreActivatePopUint16(InterpState &S) {
53461 if (!StoreActivatePop<PT_Uint16>(S, S.PC)) return false;
53462#if USE_TAILCALLS
53463 MUSTTAIL return InterpNext(S);
53464#else
53465 return true;
53466#endif
53467}
53468PRESERVE_NONE
53469static bool Interp_StoreActivatePopSint32(InterpState &S) {
53470 if (!StoreActivatePop<PT_Sint32>(S, S.PC)) return false;
53471#if USE_TAILCALLS
53472 MUSTTAIL return InterpNext(S);
53473#else
53474 return true;
53475#endif
53476}
53477PRESERVE_NONE
53478static bool Interp_StoreActivatePopUint32(InterpState &S) {
53479 if (!StoreActivatePop<PT_Uint32>(S, S.PC)) return false;
53480#if USE_TAILCALLS
53481 MUSTTAIL return InterpNext(S);
53482#else
53483 return true;
53484#endif
53485}
53486PRESERVE_NONE
53487static bool Interp_StoreActivatePopSint64(InterpState &S) {
53488 if (!StoreActivatePop<PT_Sint64>(S, S.PC)) return false;
53489#if USE_TAILCALLS
53490 MUSTTAIL return InterpNext(S);
53491#else
53492 return true;
53493#endif
53494}
53495PRESERVE_NONE
53496static bool Interp_StoreActivatePopUint64(InterpState &S) {
53497 if (!StoreActivatePop<PT_Uint64>(S, S.PC)) return false;
53498#if USE_TAILCALLS
53499 MUSTTAIL return InterpNext(S);
53500#else
53501 return true;
53502#endif
53503}
53504PRESERVE_NONE
53505static bool Interp_StoreActivatePopIntAP(InterpState &S) {
53506 if (!StoreActivatePop<PT_IntAP>(S, S.PC)) return false;
53507#if USE_TAILCALLS
53508 MUSTTAIL return InterpNext(S);
53509#else
53510 return true;
53511#endif
53512}
53513PRESERVE_NONE
53514static bool Interp_StoreActivatePopIntAPS(InterpState &S) {
53515 if (!StoreActivatePop<PT_IntAPS>(S, S.PC)) return false;
53516#if USE_TAILCALLS
53517 MUSTTAIL return InterpNext(S);
53518#else
53519 return true;
53520#endif
53521}
53522PRESERVE_NONE
53523static bool Interp_StoreActivatePopBool(InterpState &S) {
53524 if (!StoreActivatePop<PT_Bool>(S, S.PC)) return false;
53525#if USE_TAILCALLS
53526 MUSTTAIL return InterpNext(S);
53527#else
53528 return true;
53529#endif
53530}
53531PRESERVE_NONE
53532static bool Interp_StoreActivatePopFixedPoint(InterpState &S) {
53533 if (!StoreActivatePop<PT_FixedPoint>(S, S.PC)) return false;
53534#if USE_TAILCALLS
53535 MUSTTAIL return InterpNext(S);
53536#else
53537 return true;
53538#endif
53539}
53540PRESERVE_NONE
53541static bool Interp_StoreActivatePopPtr(InterpState &S) {
53542 if (!StoreActivatePop<PT_Ptr>(S, S.PC)) return false;
53543#if USE_TAILCALLS
53544 MUSTTAIL return InterpNext(S);
53545#else
53546 return true;
53547#endif
53548}
53549PRESERVE_NONE
53550static bool Interp_StoreActivatePopMemberPtr(InterpState &S) {
53551 if (!StoreActivatePop<PT_MemberPtr>(S, S.PC)) return false;
53552#if USE_TAILCALLS
53553 MUSTTAIL return InterpNext(S);
53554#else
53555 return true;
53556#endif
53557}
53558PRESERVE_NONE
53559static bool Interp_StoreActivatePopFloat(InterpState &S) {
53560 if (!StoreActivatePop<PT_Float>(S, S.PC)) return false;
53561#if USE_TAILCALLS
53562 MUSTTAIL return InterpNext(S);
53563#else
53564 return true;
53565#endif
53566}
53567PRESERVE_NONE
53568static bool Interp_StoreActivatePopReflect(InterpState &S) {
53569 if (!StoreActivatePop<PT_Reflect>(S, S.PC)) return false;
53570#if USE_TAILCALLS
53571 MUSTTAIL return InterpNext(S);
53572#else
53573 return true;
53574#endif
53575}
53576#endif
53577#ifdef GET_DISASM
53578case OP_StoreActivatePopSint8:
53579 Text.Op = PrintName("StoreActivatePopSint8");
53580 break;
53581case OP_StoreActivatePopUint8:
53582 Text.Op = PrintName("StoreActivatePopUint8");
53583 break;
53584case OP_StoreActivatePopSint16:
53585 Text.Op = PrintName("StoreActivatePopSint16");
53586 break;
53587case OP_StoreActivatePopUint16:
53588 Text.Op = PrintName("StoreActivatePopUint16");
53589 break;
53590case OP_StoreActivatePopSint32:
53591 Text.Op = PrintName("StoreActivatePopSint32");
53592 break;
53593case OP_StoreActivatePopUint32:
53594 Text.Op = PrintName("StoreActivatePopUint32");
53595 break;
53596case OP_StoreActivatePopSint64:
53597 Text.Op = PrintName("StoreActivatePopSint64");
53598 break;
53599case OP_StoreActivatePopUint64:
53600 Text.Op = PrintName("StoreActivatePopUint64");
53601 break;
53602case OP_StoreActivatePopIntAP:
53603 Text.Op = PrintName("StoreActivatePopIntAP");
53604 break;
53605case OP_StoreActivatePopIntAPS:
53606 Text.Op = PrintName("StoreActivatePopIntAPS");
53607 break;
53608case OP_StoreActivatePopBool:
53609 Text.Op = PrintName("StoreActivatePopBool");
53610 break;
53611case OP_StoreActivatePopFixedPoint:
53612 Text.Op = PrintName("StoreActivatePopFixedPoint");
53613 break;
53614case OP_StoreActivatePopPtr:
53615 Text.Op = PrintName("StoreActivatePopPtr");
53616 break;
53617case OP_StoreActivatePopMemberPtr:
53618 Text.Op = PrintName("StoreActivatePopMemberPtr");
53619 break;
53620case OP_StoreActivatePopFloat:
53621 Text.Op = PrintName("StoreActivatePopFloat");
53622 break;
53623case OP_StoreActivatePopReflect:
53624 Text.Op = PrintName("StoreActivatePopReflect");
53625 break;
53626#endif
53627#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
53628bool emitStoreActivatePopSint8(SourceInfo);
53629bool emitStoreActivatePopUint8(SourceInfo);
53630bool emitStoreActivatePopSint16(SourceInfo);
53631bool emitStoreActivatePopUint16(SourceInfo);
53632bool emitStoreActivatePopSint32(SourceInfo);
53633bool emitStoreActivatePopUint32(SourceInfo);
53634bool emitStoreActivatePopSint64(SourceInfo);
53635bool emitStoreActivatePopUint64(SourceInfo);
53636bool emitStoreActivatePopIntAP(SourceInfo);
53637bool emitStoreActivatePopIntAPS(SourceInfo);
53638bool emitStoreActivatePopBool(SourceInfo);
53639bool emitStoreActivatePopFixedPoint(SourceInfo);
53640bool emitStoreActivatePopPtr(SourceInfo);
53641bool emitStoreActivatePopMemberPtr(SourceInfo);
53642bool emitStoreActivatePopFloat(SourceInfo);
53643bool emitStoreActivatePopReflect(SourceInfo);
53644#endif
53645#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
53646[[nodiscard]] bool emitStoreActivatePop(PrimType, SourceInfo I);
53647#endif
53648#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
53649bool
53650#if defined(GET_EVAL_IMPL)
53651EvalEmitter
53652#else
53653ByteCodeEmitter
53654#endif
53655::emitStoreActivatePop(PrimType T0, SourceInfo I) {
53656 switch (T0) {
53657 case PT_Sint8:
53658 return emitStoreActivatePopSint8(I);
53659 case PT_Uint8:
53660 return emitStoreActivatePopUint8(I);
53661 case PT_Sint16:
53662 return emitStoreActivatePopSint16(I);
53663 case PT_Uint16:
53664 return emitStoreActivatePopUint16(I);
53665 case PT_Sint32:
53666 return emitStoreActivatePopSint32(I);
53667 case PT_Uint32:
53668 return emitStoreActivatePopUint32(I);
53669 case PT_Sint64:
53670 return emitStoreActivatePopSint64(I);
53671 case PT_Uint64:
53672 return emitStoreActivatePopUint64(I);
53673 case PT_IntAP:
53674 return emitStoreActivatePopIntAP(I);
53675 case PT_IntAPS:
53676 return emitStoreActivatePopIntAPS(I);
53677 case PT_Bool:
53678 return emitStoreActivatePopBool(I);
53679 case PT_FixedPoint:
53680 return emitStoreActivatePopFixedPoint(I);
53681 case PT_Ptr:
53682 return emitStoreActivatePopPtr(I);
53683 case PT_MemberPtr:
53684 return emitStoreActivatePopMemberPtr(I);
53685 case PT_Float:
53686 return emitStoreActivatePopFloat(I);
53687 case PT_Reflect:
53688 return emitStoreActivatePopReflect(I);
53689 }
53690 llvm_unreachable("invalid enum value");
53691}
53692#endif
53693#ifdef GET_LINK_IMPL
53694bool ByteCodeEmitter::emitStoreActivatePopSint8(SourceInfo L) {
53695 return emitOp<>(OP_StoreActivatePopSint8, L);
53696}
53697bool ByteCodeEmitter::emitStoreActivatePopUint8(SourceInfo L) {
53698 return emitOp<>(OP_StoreActivatePopUint8, L);
53699}
53700bool ByteCodeEmitter::emitStoreActivatePopSint16(SourceInfo L) {
53701 return emitOp<>(OP_StoreActivatePopSint16, L);
53702}
53703bool ByteCodeEmitter::emitStoreActivatePopUint16(SourceInfo L) {
53704 return emitOp<>(OP_StoreActivatePopUint16, L);
53705}
53706bool ByteCodeEmitter::emitStoreActivatePopSint32(SourceInfo L) {
53707 return emitOp<>(OP_StoreActivatePopSint32, L);
53708}
53709bool ByteCodeEmitter::emitStoreActivatePopUint32(SourceInfo L) {
53710 return emitOp<>(OP_StoreActivatePopUint32, L);
53711}
53712bool ByteCodeEmitter::emitStoreActivatePopSint64(SourceInfo L) {
53713 return emitOp<>(OP_StoreActivatePopSint64, L);
53714}
53715bool ByteCodeEmitter::emitStoreActivatePopUint64(SourceInfo L) {
53716 return emitOp<>(OP_StoreActivatePopUint64, L);
53717}
53718bool ByteCodeEmitter::emitStoreActivatePopIntAP(SourceInfo L) {
53719 return emitOp<>(OP_StoreActivatePopIntAP, L);
53720}
53721bool ByteCodeEmitter::emitStoreActivatePopIntAPS(SourceInfo L) {
53722 return emitOp<>(OP_StoreActivatePopIntAPS, L);
53723}
53724bool ByteCodeEmitter::emitStoreActivatePopBool(SourceInfo L) {
53725 return emitOp<>(OP_StoreActivatePopBool, L);
53726}
53727bool ByteCodeEmitter::emitStoreActivatePopFixedPoint(SourceInfo L) {
53728 return emitOp<>(OP_StoreActivatePopFixedPoint, L);
53729}
53730bool ByteCodeEmitter::emitStoreActivatePopPtr(SourceInfo L) {
53731 return emitOp<>(OP_StoreActivatePopPtr, L);
53732}
53733bool ByteCodeEmitter::emitStoreActivatePopMemberPtr(SourceInfo L) {
53734 return emitOp<>(OP_StoreActivatePopMemberPtr, L);
53735}
53736bool ByteCodeEmitter::emitStoreActivatePopFloat(SourceInfo L) {
53737 return emitOp<>(OP_StoreActivatePopFloat, L);
53738}
53739bool ByteCodeEmitter::emitStoreActivatePopReflect(SourceInfo L) {
53740 return emitOp<>(OP_StoreActivatePopReflect, L);
53741}
53742#endif
53743#ifdef GET_EVAL_IMPL
53744bool EvalEmitter::emitStoreActivatePopSint8(SourceInfo L) {
53745 if (!isActive()) return true;
53746 CurrentSource = L;
53747 return StoreActivatePop<PT_Sint8>(S, CodePtr());
53748}
53749bool EvalEmitter::emitStoreActivatePopUint8(SourceInfo L) {
53750 if (!isActive()) return true;
53751 CurrentSource = L;
53752 return StoreActivatePop<PT_Uint8>(S, CodePtr());
53753}
53754bool EvalEmitter::emitStoreActivatePopSint16(SourceInfo L) {
53755 if (!isActive()) return true;
53756 CurrentSource = L;
53757 return StoreActivatePop<PT_Sint16>(S, CodePtr());
53758}
53759bool EvalEmitter::emitStoreActivatePopUint16(SourceInfo L) {
53760 if (!isActive()) return true;
53761 CurrentSource = L;
53762 return StoreActivatePop<PT_Uint16>(S, CodePtr());
53763}
53764bool EvalEmitter::emitStoreActivatePopSint32(SourceInfo L) {
53765 if (!isActive()) return true;
53766 CurrentSource = L;
53767 return StoreActivatePop<PT_Sint32>(S, CodePtr());
53768}
53769bool EvalEmitter::emitStoreActivatePopUint32(SourceInfo L) {
53770 if (!isActive()) return true;
53771 CurrentSource = L;
53772 return StoreActivatePop<PT_Uint32>(S, CodePtr());
53773}
53774bool EvalEmitter::emitStoreActivatePopSint64(SourceInfo L) {
53775 if (!isActive()) return true;
53776 CurrentSource = L;
53777 return StoreActivatePop<PT_Sint64>(S, CodePtr());
53778}
53779bool EvalEmitter::emitStoreActivatePopUint64(SourceInfo L) {
53780 if (!isActive()) return true;
53781 CurrentSource = L;
53782 return StoreActivatePop<PT_Uint64>(S, CodePtr());
53783}
53784bool EvalEmitter::emitStoreActivatePopIntAP(SourceInfo L) {
53785 if (!isActive()) return true;
53786 CurrentSource = L;
53787 return StoreActivatePop<PT_IntAP>(S, CodePtr());
53788}
53789bool EvalEmitter::emitStoreActivatePopIntAPS(SourceInfo L) {
53790 if (!isActive()) return true;
53791 CurrentSource = L;
53792 return StoreActivatePop<PT_IntAPS>(S, CodePtr());
53793}
53794bool EvalEmitter::emitStoreActivatePopBool(SourceInfo L) {
53795 if (!isActive()) return true;
53796 CurrentSource = L;
53797 return StoreActivatePop<PT_Bool>(S, CodePtr());
53798}
53799bool EvalEmitter::emitStoreActivatePopFixedPoint(SourceInfo L) {
53800 if (!isActive()) return true;
53801 CurrentSource = L;
53802 return StoreActivatePop<PT_FixedPoint>(S, CodePtr());
53803}
53804bool EvalEmitter::emitStoreActivatePopPtr(SourceInfo L) {
53805 if (!isActive()) return true;
53806 CurrentSource = L;
53807 return StoreActivatePop<PT_Ptr>(S, CodePtr());
53808}
53809bool EvalEmitter::emitStoreActivatePopMemberPtr(SourceInfo L) {
53810 if (!isActive()) return true;
53811 CurrentSource = L;
53812 return StoreActivatePop<PT_MemberPtr>(S, CodePtr());
53813}
53814bool EvalEmitter::emitStoreActivatePopFloat(SourceInfo L) {
53815 if (!isActive()) return true;
53816 CurrentSource = L;
53817 return StoreActivatePop<PT_Float>(S, CodePtr());
53818}
53819bool EvalEmitter::emitStoreActivatePopReflect(SourceInfo L) {
53820 if (!isActive()) return true;
53821 CurrentSource = L;
53822 return StoreActivatePop<PT_Reflect>(S, CodePtr());
53823}
53824#endif
53825#ifdef GET_OPCODE_NAMES
53826OP_StoreBitFieldSint8,
53827OP_StoreBitFieldUint8,
53828OP_StoreBitFieldSint16,
53829OP_StoreBitFieldUint16,
53830OP_StoreBitFieldSint32,
53831OP_StoreBitFieldUint32,
53832OP_StoreBitFieldSint64,
53833OP_StoreBitFieldUint64,
53834OP_StoreBitFieldIntAP,
53835OP_StoreBitFieldIntAPS,
53836OP_StoreBitFieldBool,
53837OP_StoreBitFieldFixedPoint,
53838#endif
53839#ifdef GET_INTERPFN_LIST
53840&Interp_StoreBitFieldSint8,
53841&Interp_StoreBitFieldUint8,
53842&Interp_StoreBitFieldSint16,
53843&Interp_StoreBitFieldUint16,
53844&Interp_StoreBitFieldSint32,
53845&Interp_StoreBitFieldUint32,
53846&Interp_StoreBitFieldSint64,
53847&Interp_StoreBitFieldUint64,
53848&Interp_StoreBitFieldIntAP,
53849&Interp_StoreBitFieldIntAPS,
53850&Interp_StoreBitFieldBool,
53851&Interp_StoreBitFieldFixedPoint,
53852#endif
53853#ifdef GET_INTERPFN_DISPATCHERS
53854PRESERVE_NONE
53855static bool Interp_StoreBitFieldSint8(InterpState &S) {
53856 if (!StoreBitField<PT_Sint8>(S, S.PC)) return false;
53857#if USE_TAILCALLS
53858 MUSTTAIL return InterpNext(S);
53859#else
53860 return true;
53861#endif
53862}
53863PRESERVE_NONE
53864static bool Interp_StoreBitFieldUint8(InterpState &S) {
53865 if (!StoreBitField<PT_Uint8>(S, S.PC)) return false;
53866#if USE_TAILCALLS
53867 MUSTTAIL return InterpNext(S);
53868#else
53869 return true;
53870#endif
53871}
53872PRESERVE_NONE
53873static bool Interp_StoreBitFieldSint16(InterpState &S) {
53874 if (!StoreBitField<PT_Sint16>(S, S.PC)) return false;
53875#if USE_TAILCALLS
53876 MUSTTAIL return InterpNext(S);
53877#else
53878 return true;
53879#endif
53880}
53881PRESERVE_NONE
53882static bool Interp_StoreBitFieldUint16(InterpState &S) {
53883 if (!StoreBitField<PT_Uint16>(S, S.PC)) return false;
53884#if USE_TAILCALLS
53885 MUSTTAIL return InterpNext(S);
53886#else
53887 return true;
53888#endif
53889}
53890PRESERVE_NONE
53891static bool Interp_StoreBitFieldSint32(InterpState &S) {
53892 if (!StoreBitField<PT_Sint32>(S, S.PC)) return false;
53893#if USE_TAILCALLS
53894 MUSTTAIL return InterpNext(S);
53895#else
53896 return true;
53897#endif
53898}
53899PRESERVE_NONE
53900static bool Interp_StoreBitFieldUint32(InterpState &S) {
53901 if (!StoreBitField<PT_Uint32>(S, S.PC)) return false;
53902#if USE_TAILCALLS
53903 MUSTTAIL return InterpNext(S);
53904#else
53905 return true;
53906#endif
53907}
53908PRESERVE_NONE
53909static bool Interp_StoreBitFieldSint64(InterpState &S) {
53910 if (!StoreBitField<PT_Sint64>(S, S.PC)) return false;
53911#if USE_TAILCALLS
53912 MUSTTAIL return InterpNext(S);
53913#else
53914 return true;
53915#endif
53916}
53917PRESERVE_NONE
53918static bool Interp_StoreBitFieldUint64(InterpState &S) {
53919 if (!StoreBitField<PT_Uint64>(S, S.PC)) return false;
53920#if USE_TAILCALLS
53921 MUSTTAIL return InterpNext(S);
53922#else
53923 return true;
53924#endif
53925}
53926PRESERVE_NONE
53927static bool Interp_StoreBitFieldIntAP(InterpState &S) {
53928 if (!StoreBitField<PT_IntAP>(S, S.PC)) return false;
53929#if USE_TAILCALLS
53930 MUSTTAIL return InterpNext(S);
53931#else
53932 return true;
53933#endif
53934}
53935PRESERVE_NONE
53936static bool Interp_StoreBitFieldIntAPS(InterpState &S) {
53937 if (!StoreBitField<PT_IntAPS>(S, S.PC)) return false;
53938#if USE_TAILCALLS
53939 MUSTTAIL return InterpNext(S);
53940#else
53941 return true;
53942#endif
53943}
53944PRESERVE_NONE
53945static bool Interp_StoreBitFieldBool(InterpState &S) {
53946 if (!StoreBitField<PT_Bool>(S, S.PC)) return false;
53947#if USE_TAILCALLS
53948 MUSTTAIL return InterpNext(S);
53949#else
53950 return true;
53951#endif
53952}
53953PRESERVE_NONE
53954static bool Interp_StoreBitFieldFixedPoint(InterpState &S) {
53955 if (!StoreBitField<PT_FixedPoint>(S, S.PC)) return false;
53956#if USE_TAILCALLS
53957 MUSTTAIL return InterpNext(S);
53958#else
53959 return true;
53960#endif
53961}
53962#endif
53963#ifdef GET_DISASM
53964case OP_StoreBitFieldSint8:
53965 Text.Op = PrintName("StoreBitFieldSint8");
53966 break;
53967case OP_StoreBitFieldUint8:
53968 Text.Op = PrintName("StoreBitFieldUint8");
53969 break;
53970case OP_StoreBitFieldSint16:
53971 Text.Op = PrintName("StoreBitFieldSint16");
53972 break;
53973case OP_StoreBitFieldUint16:
53974 Text.Op = PrintName("StoreBitFieldUint16");
53975 break;
53976case OP_StoreBitFieldSint32:
53977 Text.Op = PrintName("StoreBitFieldSint32");
53978 break;
53979case OP_StoreBitFieldUint32:
53980 Text.Op = PrintName("StoreBitFieldUint32");
53981 break;
53982case OP_StoreBitFieldSint64:
53983 Text.Op = PrintName("StoreBitFieldSint64");
53984 break;
53985case OP_StoreBitFieldUint64:
53986 Text.Op = PrintName("StoreBitFieldUint64");
53987 break;
53988case OP_StoreBitFieldIntAP:
53989 Text.Op = PrintName("StoreBitFieldIntAP");
53990 break;
53991case OP_StoreBitFieldIntAPS:
53992 Text.Op = PrintName("StoreBitFieldIntAPS");
53993 break;
53994case OP_StoreBitFieldBool:
53995 Text.Op = PrintName("StoreBitFieldBool");
53996 break;
53997case OP_StoreBitFieldFixedPoint:
53998 Text.Op = PrintName("StoreBitFieldFixedPoint");
53999 break;
54000#endif
54001#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
54002bool emitStoreBitFieldSint8(SourceInfo);
54003bool emitStoreBitFieldUint8(SourceInfo);
54004bool emitStoreBitFieldSint16(SourceInfo);
54005bool emitStoreBitFieldUint16(SourceInfo);
54006bool emitStoreBitFieldSint32(SourceInfo);
54007bool emitStoreBitFieldUint32(SourceInfo);
54008bool emitStoreBitFieldSint64(SourceInfo);
54009bool emitStoreBitFieldUint64(SourceInfo);
54010bool emitStoreBitFieldIntAP(SourceInfo);
54011bool emitStoreBitFieldIntAPS(SourceInfo);
54012bool emitStoreBitFieldBool(SourceInfo);
54013bool emitStoreBitFieldFixedPoint(SourceInfo);
54014#endif
54015#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
54016[[nodiscard]] bool emitStoreBitField(PrimType, SourceInfo I);
54017#endif
54018#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
54019bool
54020#if defined(GET_EVAL_IMPL)
54021EvalEmitter
54022#else
54023ByteCodeEmitter
54024#endif
54025::emitStoreBitField(PrimType T0, SourceInfo I) {
54026 switch (T0) {
54027 case PT_Sint8:
54028 return emitStoreBitFieldSint8(I);
54029 case PT_Uint8:
54030 return emitStoreBitFieldUint8(I);
54031 case PT_Sint16:
54032 return emitStoreBitFieldSint16(I);
54033 case PT_Uint16:
54034 return emitStoreBitFieldUint16(I);
54035 case PT_Sint32:
54036 return emitStoreBitFieldSint32(I);
54037 case PT_Uint32:
54038 return emitStoreBitFieldUint32(I);
54039 case PT_Sint64:
54040 return emitStoreBitFieldSint64(I);
54041 case PT_Uint64:
54042 return emitStoreBitFieldUint64(I);
54043 case PT_IntAP:
54044 return emitStoreBitFieldIntAP(I);
54045 case PT_IntAPS:
54046 return emitStoreBitFieldIntAPS(I);
54047 case PT_Bool:
54048 return emitStoreBitFieldBool(I);
54049 case PT_FixedPoint:
54050 return emitStoreBitFieldFixedPoint(I);
54051 default: llvm_unreachable("invalid type: emitStoreBitField");
54052 }
54053 llvm_unreachable("invalid enum value");
54054}
54055#endif
54056#ifdef GET_LINK_IMPL
54057bool ByteCodeEmitter::emitStoreBitFieldSint8(SourceInfo L) {
54058 return emitOp<>(OP_StoreBitFieldSint8, L);
54059}
54060bool ByteCodeEmitter::emitStoreBitFieldUint8(SourceInfo L) {
54061 return emitOp<>(OP_StoreBitFieldUint8, L);
54062}
54063bool ByteCodeEmitter::emitStoreBitFieldSint16(SourceInfo L) {
54064 return emitOp<>(OP_StoreBitFieldSint16, L);
54065}
54066bool ByteCodeEmitter::emitStoreBitFieldUint16(SourceInfo L) {
54067 return emitOp<>(OP_StoreBitFieldUint16, L);
54068}
54069bool ByteCodeEmitter::emitStoreBitFieldSint32(SourceInfo L) {
54070 return emitOp<>(OP_StoreBitFieldSint32, L);
54071}
54072bool ByteCodeEmitter::emitStoreBitFieldUint32(SourceInfo L) {
54073 return emitOp<>(OP_StoreBitFieldUint32, L);
54074}
54075bool ByteCodeEmitter::emitStoreBitFieldSint64(SourceInfo L) {
54076 return emitOp<>(OP_StoreBitFieldSint64, L);
54077}
54078bool ByteCodeEmitter::emitStoreBitFieldUint64(SourceInfo L) {
54079 return emitOp<>(OP_StoreBitFieldUint64, L);
54080}
54081bool ByteCodeEmitter::emitStoreBitFieldIntAP(SourceInfo L) {
54082 return emitOp<>(OP_StoreBitFieldIntAP, L);
54083}
54084bool ByteCodeEmitter::emitStoreBitFieldIntAPS(SourceInfo L) {
54085 return emitOp<>(OP_StoreBitFieldIntAPS, L);
54086}
54087bool ByteCodeEmitter::emitStoreBitFieldBool(SourceInfo L) {
54088 return emitOp<>(OP_StoreBitFieldBool, L);
54089}
54090bool ByteCodeEmitter::emitStoreBitFieldFixedPoint(SourceInfo L) {
54091 return emitOp<>(OP_StoreBitFieldFixedPoint, L);
54092}
54093#endif
54094#ifdef GET_EVAL_IMPL
54095bool EvalEmitter::emitStoreBitFieldSint8(SourceInfo L) {
54096 if (!isActive()) return true;
54097 CurrentSource = L;
54098 return StoreBitField<PT_Sint8>(S, CodePtr());
54099}
54100bool EvalEmitter::emitStoreBitFieldUint8(SourceInfo L) {
54101 if (!isActive()) return true;
54102 CurrentSource = L;
54103 return StoreBitField<PT_Uint8>(S, CodePtr());
54104}
54105bool EvalEmitter::emitStoreBitFieldSint16(SourceInfo L) {
54106 if (!isActive()) return true;
54107 CurrentSource = L;
54108 return StoreBitField<PT_Sint16>(S, CodePtr());
54109}
54110bool EvalEmitter::emitStoreBitFieldUint16(SourceInfo L) {
54111 if (!isActive()) return true;
54112 CurrentSource = L;
54113 return StoreBitField<PT_Uint16>(S, CodePtr());
54114}
54115bool EvalEmitter::emitStoreBitFieldSint32(SourceInfo L) {
54116 if (!isActive()) return true;
54117 CurrentSource = L;
54118 return StoreBitField<PT_Sint32>(S, CodePtr());
54119}
54120bool EvalEmitter::emitStoreBitFieldUint32(SourceInfo L) {
54121 if (!isActive()) return true;
54122 CurrentSource = L;
54123 return StoreBitField<PT_Uint32>(S, CodePtr());
54124}
54125bool EvalEmitter::emitStoreBitFieldSint64(SourceInfo L) {
54126 if (!isActive()) return true;
54127 CurrentSource = L;
54128 return StoreBitField<PT_Sint64>(S, CodePtr());
54129}
54130bool EvalEmitter::emitStoreBitFieldUint64(SourceInfo L) {
54131 if (!isActive()) return true;
54132 CurrentSource = L;
54133 return StoreBitField<PT_Uint64>(S, CodePtr());
54134}
54135bool EvalEmitter::emitStoreBitFieldIntAP(SourceInfo L) {
54136 if (!isActive()) return true;
54137 CurrentSource = L;
54138 return StoreBitField<PT_IntAP>(S, CodePtr());
54139}
54140bool EvalEmitter::emitStoreBitFieldIntAPS(SourceInfo L) {
54141 if (!isActive()) return true;
54142 CurrentSource = L;
54143 return StoreBitField<PT_IntAPS>(S, CodePtr());
54144}
54145bool EvalEmitter::emitStoreBitFieldBool(SourceInfo L) {
54146 if (!isActive()) return true;
54147 CurrentSource = L;
54148 return StoreBitField<PT_Bool>(S, CodePtr());
54149}
54150bool EvalEmitter::emitStoreBitFieldFixedPoint(SourceInfo L) {
54151 if (!isActive()) return true;
54152 CurrentSource = L;
54153 return StoreBitField<PT_FixedPoint>(S, CodePtr());
54154}
54155#endif
54156#ifdef GET_OPCODE_NAMES
54157OP_StoreBitFieldActivateSint8,
54158OP_StoreBitFieldActivateUint8,
54159OP_StoreBitFieldActivateSint16,
54160OP_StoreBitFieldActivateUint16,
54161OP_StoreBitFieldActivateSint32,
54162OP_StoreBitFieldActivateUint32,
54163OP_StoreBitFieldActivateSint64,
54164OP_StoreBitFieldActivateUint64,
54165OP_StoreBitFieldActivateIntAP,
54166OP_StoreBitFieldActivateIntAPS,
54167OP_StoreBitFieldActivateBool,
54168OP_StoreBitFieldActivateFixedPoint,
54169#endif
54170#ifdef GET_INTERPFN_LIST
54171&Interp_StoreBitFieldActivateSint8,
54172&Interp_StoreBitFieldActivateUint8,
54173&Interp_StoreBitFieldActivateSint16,
54174&Interp_StoreBitFieldActivateUint16,
54175&Interp_StoreBitFieldActivateSint32,
54176&Interp_StoreBitFieldActivateUint32,
54177&Interp_StoreBitFieldActivateSint64,
54178&Interp_StoreBitFieldActivateUint64,
54179&Interp_StoreBitFieldActivateIntAP,
54180&Interp_StoreBitFieldActivateIntAPS,
54181&Interp_StoreBitFieldActivateBool,
54182&Interp_StoreBitFieldActivateFixedPoint,
54183#endif
54184#ifdef GET_INTERPFN_DISPATCHERS
54185PRESERVE_NONE
54186static bool Interp_StoreBitFieldActivateSint8(InterpState &S) {
54187 if (!StoreBitFieldActivate<PT_Sint8>(S, S.PC)) return false;
54188#if USE_TAILCALLS
54189 MUSTTAIL return InterpNext(S);
54190#else
54191 return true;
54192#endif
54193}
54194PRESERVE_NONE
54195static bool Interp_StoreBitFieldActivateUint8(InterpState &S) {
54196 if (!StoreBitFieldActivate<PT_Uint8>(S, S.PC)) return false;
54197#if USE_TAILCALLS
54198 MUSTTAIL return InterpNext(S);
54199#else
54200 return true;
54201#endif
54202}
54203PRESERVE_NONE
54204static bool Interp_StoreBitFieldActivateSint16(InterpState &S) {
54205 if (!StoreBitFieldActivate<PT_Sint16>(S, S.PC)) return false;
54206#if USE_TAILCALLS
54207 MUSTTAIL return InterpNext(S);
54208#else
54209 return true;
54210#endif
54211}
54212PRESERVE_NONE
54213static bool Interp_StoreBitFieldActivateUint16(InterpState &S) {
54214 if (!StoreBitFieldActivate<PT_Uint16>(S, S.PC)) return false;
54215#if USE_TAILCALLS
54216 MUSTTAIL return InterpNext(S);
54217#else
54218 return true;
54219#endif
54220}
54221PRESERVE_NONE
54222static bool Interp_StoreBitFieldActivateSint32(InterpState &S) {
54223 if (!StoreBitFieldActivate<PT_Sint32>(S, S.PC)) return false;
54224#if USE_TAILCALLS
54225 MUSTTAIL return InterpNext(S);
54226#else
54227 return true;
54228#endif
54229}
54230PRESERVE_NONE
54231static bool Interp_StoreBitFieldActivateUint32(InterpState &S) {
54232 if (!StoreBitFieldActivate<PT_Uint32>(S, S.PC)) return false;
54233#if USE_TAILCALLS
54234 MUSTTAIL return InterpNext(S);
54235#else
54236 return true;
54237#endif
54238}
54239PRESERVE_NONE
54240static bool Interp_StoreBitFieldActivateSint64(InterpState &S) {
54241 if (!StoreBitFieldActivate<PT_Sint64>(S, S.PC)) return false;
54242#if USE_TAILCALLS
54243 MUSTTAIL return InterpNext(S);
54244#else
54245 return true;
54246#endif
54247}
54248PRESERVE_NONE
54249static bool Interp_StoreBitFieldActivateUint64(InterpState &S) {
54250 if (!StoreBitFieldActivate<PT_Uint64>(S, S.PC)) return false;
54251#if USE_TAILCALLS
54252 MUSTTAIL return InterpNext(S);
54253#else
54254 return true;
54255#endif
54256}
54257PRESERVE_NONE
54258static bool Interp_StoreBitFieldActivateIntAP(InterpState &S) {
54259 if (!StoreBitFieldActivate<PT_IntAP>(S, S.PC)) return false;
54260#if USE_TAILCALLS
54261 MUSTTAIL return InterpNext(S);
54262#else
54263 return true;
54264#endif
54265}
54266PRESERVE_NONE
54267static bool Interp_StoreBitFieldActivateIntAPS(InterpState &S) {
54268 if (!StoreBitFieldActivate<PT_IntAPS>(S, S.PC)) return false;
54269#if USE_TAILCALLS
54270 MUSTTAIL return InterpNext(S);
54271#else
54272 return true;
54273#endif
54274}
54275PRESERVE_NONE
54276static bool Interp_StoreBitFieldActivateBool(InterpState &S) {
54277 if (!StoreBitFieldActivate<PT_Bool>(S, S.PC)) return false;
54278#if USE_TAILCALLS
54279 MUSTTAIL return InterpNext(S);
54280#else
54281 return true;
54282#endif
54283}
54284PRESERVE_NONE
54285static bool Interp_StoreBitFieldActivateFixedPoint(InterpState &S) {
54286 if (!StoreBitFieldActivate<PT_FixedPoint>(S, S.PC)) return false;
54287#if USE_TAILCALLS
54288 MUSTTAIL return InterpNext(S);
54289#else
54290 return true;
54291#endif
54292}
54293#endif
54294#ifdef GET_DISASM
54295case OP_StoreBitFieldActivateSint8:
54296 Text.Op = PrintName("StoreBitFieldActivateSint8");
54297 break;
54298case OP_StoreBitFieldActivateUint8:
54299 Text.Op = PrintName("StoreBitFieldActivateUint8");
54300 break;
54301case OP_StoreBitFieldActivateSint16:
54302 Text.Op = PrintName("StoreBitFieldActivateSint16");
54303 break;
54304case OP_StoreBitFieldActivateUint16:
54305 Text.Op = PrintName("StoreBitFieldActivateUint16");
54306 break;
54307case OP_StoreBitFieldActivateSint32:
54308 Text.Op = PrintName("StoreBitFieldActivateSint32");
54309 break;
54310case OP_StoreBitFieldActivateUint32:
54311 Text.Op = PrintName("StoreBitFieldActivateUint32");
54312 break;
54313case OP_StoreBitFieldActivateSint64:
54314 Text.Op = PrintName("StoreBitFieldActivateSint64");
54315 break;
54316case OP_StoreBitFieldActivateUint64:
54317 Text.Op = PrintName("StoreBitFieldActivateUint64");
54318 break;
54319case OP_StoreBitFieldActivateIntAP:
54320 Text.Op = PrintName("StoreBitFieldActivateIntAP");
54321 break;
54322case OP_StoreBitFieldActivateIntAPS:
54323 Text.Op = PrintName("StoreBitFieldActivateIntAPS");
54324 break;
54325case OP_StoreBitFieldActivateBool:
54326 Text.Op = PrintName("StoreBitFieldActivateBool");
54327 break;
54328case OP_StoreBitFieldActivateFixedPoint:
54329 Text.Op = PrintName("StoreBitFieldActivateFixedPoint");
54330 break;
54331#endif
54332#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
54333bool emitStoreBitFieldActivateSint8(SourceInfo);
54334bool emitStoreBitFieldActivateUint8(SourceInfo);
54335bool emitStoreBitFieldActivateSint16(SourceInfo);
54336bool emitStoreBitFieldActivateUint16(SourceInfo);
54337bool emitStoreBitFieldActivateSint32(SourceInfo);
54338bool emitStoreBitFieldActivateUint32(SourceInfo);
54339bool emitStoreBitFieldActivateSint64(SourceInfo);
54340bool emitStoreBitFieldActivateUint64(SourceInfo);
54341bool emitStoreBitFieldActivateIntAP(SourceInfo);
54342bool emitStoreBitFieldActivateIntAPS(SourceInfo);
54343bool emitStoreBitFieldActivateBool(SourceInfo);
54344bool emitStoreBitFieldActivateFixedPoint(SourceInfo);
54345#endif
54346#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
54347[[nodiscard]] bool emitStoreBitFieldActivate(PrimType, SourceInfo I);
54348#endif
54349#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
54350bool
54351#if defined(GET_EVAL_IMPL)
54352EvalEmitter
54353#else
54354ByteCodeEmitter
54355#endif
54356::emitStoreBitFieldActivate(PrimType T0, SourceInfo I) {
54357 switch (T0) {
54358 case PT_Sint8:
54359 return emitStoreBitFieldActivateSint8(I);
54360 case PT_Uint8:
54361 return emitStoreBitFieldActivateUint8(I);
54362 case PT_Sint16:
54363 return emitStoreBitFieldActivateSint16(I);
54364 case PT_Uint16:
54365 return emitStoreBitFieldActivateUint16(I);
54366 case PT_Sint32:
54367 return emitStoreBitFieldActivateSint32(I);
54368 case PT_Uint32:
54369 return emitStoreBitFieldActivateUint32(I);
54370 case PT_Sint64:
54371 return emitStoreBitFieldActivateSint64(I);
54372 case PT_Uint64:
54373 return emitStoreBitFieldActivateUint64(I);
54374 case PT_IntAP:
54375 return emitStoreBitFieldActivateIntAP(I);
54376 case PT_IntAPS:
54377 return emitStoreBitFieldActivateIntAPS(I);
54378 case PT_Bool:
54379 return emitStoreBitFieldActivateBool(I);
54380 case PT_FixedPoint:
54381 return emitStoreBitFieldActivateFixedPoint(I);
54382 default: llvm_unreachable("invalid type: emitStoreBitFieldActivate");
54383 }
54384 llvm_unreachable("invalid enum value");
54385}
54386#endif
54387#ifdef GET_LINK_IMPL
54388bool ByteCodeEmitter::emitStoreBitFieldActivateSint8(SourceInfo L) {
54389 return emitOp<>(OP_StoreBitFieldActivateSint8, L);
54390}
54391bool ByteCodeEmitter::emitStoreBitFieldActivateUint8(SourceInfo L) {
54392 return emitOp<>(OP_StoreBitFieldActivateUint8, L);
54393}
54394bool ByteCodeEmitter::emitStoreBitFieldActivateSint16(SourceInfo L) {
54395 return emitOp<>(OP_StoreBitFieldActivateSint16, L);
54396}
54397bool ByteCodeEmitter::emitStoreBitFieldActivateUint16(SourceInfo L) {
54398 return emitOp<>(OP_StoreBitFieldActivateUint16, L);
54399}
54400bool ByteCodeEmitter::emitStoreBitFieldActivateSint32(SourceInfo L) {
54401 return emitOp<>(OP_StoreBitFieldActivateSint32, L);
54402}
54403bool ByteCodeEmitter::emitStoreBitFieldActivateUint32(SourceInfo L) {
54404 return emitOp<>(OP_StoreBitFieldActivateUint32, L);
54405}
54406bool ByteCodeEmitter::emitStoreBitFieldActivateSint64(SourceInfo L) {
54407 return emitOp<>(OP_StoreBitFieldActivateSint64, L);
54408}
54409bool ByteCodeEmitter::emitStoreBitFieldActivateUint64(SourceInfo L) {
54410 return emitOp<>(OP_StoreBitFieldActivateUint64, L);
54411}
54412bool ByteCodeEmitter::emitStoreBitFieldActivateIntAP(SourceInfo L) {
54413 return emitOp<>(OP_StoreBitFieldActivateIntAP, L);
54414}
54415bool ByteCodeEmitter::emitStoreBitFieldActivateIntAPS(SourceInfo L) {
54416 return emitOp<>(OP_StoreBitFieldActivateIntAPS, L);
54417}
54418bool ByteCodeEmitter::emitStoreBitFieldActivateBool(SourceInfo L) {
54419 return emitOp<>(OP_StoreBitFieldActivateBool, L);
54420}
54421bool ByteCodeEmitter::emitStoreBitFieldActivateFixedPoint(SourceInfo L) {
54422 return emitOp<>(OP_StoreBitFieldActivateFixedPoint, L);
54423}
54424#endif
54425#ifdef GET_EVAL_IMPL
54426bool EvalEmitter::emitStoreBitFieldActivateSint8(SourceInfo L) {
54427 if (!isActive()) return true;
54428 CurrentSource = L;
54429 return StoreBitFieldActivate<PT_Sint8>(S, CodePtr());
54430}
54431bool EvalEmitter::emitStoreBitFieldActivateUint8(SourceInfo L) {
54432 if (!isActive()) return true;
54433 CurrentSource = L;
54434 return StoreBitFieldActivate<PT_Uint8>(S, CodePtr());
54435}
54436bool EvalEmitter::emitStoreBitFieldActivateSint16(SourceInfo L) {
54437 if (!isActive()) return true;
54438 CurrentSource = L;
54439 return StoreBitFieldActivate<PT_Sint16>(S, CodePtr());
54440}
54441bool EvalEmitter::emitStoreBitFieldActivateUint16(SourceInfo L) {
54442 if (!isActive()) return true;
54443 CurrentSource = L;
54444 return StoreBitFieldActivate<PT_Uint16>(S, CodePtr());
54445}
54446bool EvalEmitter::emitStoreBitFieldActivateSint32(SourceInfo L) {
54447 if (!isActive()) return true;
54448 CurrentSource = L;
54449 return StoreBitFieldActivate<PT_Sint32>(S, CodePtr());
54450}
54451bool EvalEmitter::emitStoreBitFieldActivateUint32(SourceInfo L) {
54452 if (!isActive()) return true;
54453 CurrentSource = L;
54454 return StoreBitFieldActivate<PT_Uint32>(S, CodePtr());
54455}
54456bool EvalEmitter::emitStoreBitFieldActivateSint64(SourceInfo L) {
54457 if (!isActive()) return true;
54458 CurrentSource = L;
54459 return StoreBitFieldActivate<PT_Sint64>(S, CodePtr());
54460}
54461bool EvalEmitter::emitStoreBitFieldActivateUint64(SourceInfo L) {
54462 if (!isActive()) return true;
54463 CurrentSource = L;
54464 return StoreBitFieldActivate<PT_Uint64>(S, CodePtr());
54465}
54466bool EvalEmitter::emitStoreBitFieldActivateIntAP(SourceInfo L) {
54467 if (!isActive()) return true;
54468 CurrentSource = L;
54469 return StoreBitFieldActivate<PT_IntAP>(S, CodePtr());
54470}
54471bool EvalEmitter::emitStoreBitFieldActivateIntAPS(SourceInfo L) {
54472 if (!isActive()) return true;
54473 CurrentSource = L;
54474 return StoreBitFieldActivate<PT_IntAPS>(S, CodePtr());
54475}
54476bool EvalEmitter::emitStoreBitFieldActivateBool(SourceInfo L) {
54477 if (!isActive()) return true;
54478 CurrentSource = L;
54479 return StoreBitFieldActivate<PT_Bool>(S, CodePtr());
54480}
54481bool EvalEmitter::emitStoreBitFieldActivateFixedPoint(SourceInfo L) {
54482 if (!isActive()) return true;
54483 CurrentSource = L;
54484 return StoreBitFieldActivate<PT_FixedPoint>(S, CodePtr());
54485}
54486#endif
54487#ifdef GET_OPCODE_NAMES
54488OP_StoreBitFieldActivatePopSint8,
54489OP_StoreBitFieldActivatePopUint8,
54490OP_StoreBitFieldActivatePopSint16,
54491OP_StoreBitFieldActivatePopUint16,
54492OP_StoreBitFieldActivatePopSint32,
54493OP_StoreBitFieldActivatePopUint32,
54494OP_StoreBitFieldActivatePopSint64,
54495OP_StoreBitFieldActivatePopUint64,
54496OP_StoreBitFieldActivatePopIntAP,
54497OP_StoreBitFieldActivatePopIntAPS,
54498OP_StoreBitFieldActivatePopBool,
54499OP_StoreBitFieldActivatePopFixedPoint,
54500#endif
54501#ifdef GET_INTERPFN_LIST
54502&Interp_StoreBitFieldActivatePopSint8,
54503&Interp_StoreBitFieldActivatePopUint8,
54504&Interp_StoreBitFieldActivatePopSint16,
54505&Interp_StoreBitFieldActivatePopUint16,
54506&Interp_StoreBitFieldActivatePopSint32,
54507&Interp_StoreBitFieldActivatePopUint32,
54508&Interp_StoreBitFieldActivatePopSint64,
54509&Interp_StoreBitFieldActivatePopUint64,
54510&Interp_StoreBitFieldActivatePopIntAP,
54511&Interp_StoreBitFieldActivatePopIntAPS,
54512&Interp_StoreBitFieldActivatePopBool,
54513&Interp_StoreBitFieldActivatePopFixedPoint,
54514#endif
54515#ifdef GET_INTERPFN_DISPATCHERS
54516PRESERVE_NONE
54517static bool Interp_StoreBitFieldActivatePopSint8(InterpState &S) {
54518 if (!StoreBitFieldActivatePop<PT_Sint8>(S, S.PC)) return false;
54519#if USE_TAILCALLS
54520 MUSTTAIL return InterpNext(S);
54521#else
54522 return true;
54523#endif
54524}
54525PRESERVE_NONE
54526static bool Interp_StoreBitFieldActivatePopUint8(InterpState &S) {
54527 if (!StoreBitFieldActivatePop<PT_Uint8>(S, S.PC)) return false;
54528#if USE_TAILCALLS
54529 MUSTTAIL return InterpNext(S);
54530#else
54531 return true;
54532#endif
54533}
54534PRESERVE_NONE
54535static bool Interp_StoreBitFieldActivatePopSint16(InterpState &S) {
54536 if (!StoreBitFieldActivatePop<PT_Sint16>(S, S.PC)) return false;
54537#if USE_TAILCALLS
54538 MUSTTAIL return InterpNext(S);
54539#else
54540 return true;
54541#endif
54542}
54543PRESERVE_NONE
54544static bool Interp_StoreBitFieldActivatePopUint16(InterpState &S) {
54545 if (!StoreBitFieldActivatePop<PT_Uint16>(S, S.PC)) return false;
54546#if USE_TAILCALLS
54547 MUSTTAIL return InterpNext(S);
54548#else
54549 return true;
54550#endif
54551}
54552PRESERVE_NONE
54553static bool Interp_StoreBitFieldActivatePopSint32(InterpState &S) {
54554 if (!StoreBitFieldActivatePop<PT_Sint32>(S, S.PC)) return false;
54555#if USE_TAILCALLS
54556 MUSTTAIL return InterpNext(S);
54557#else
54558 return true;
54559#endif
54560}
54561PRESERVE_NONE
54562static bool Interp_StoreBitFieldActivatePopUint32(InterpState &S) {
54563 if (!StoreBitFieldActivatePop<PT_Uint32>(S, S.PC)) return false;
54564#if USE_TAILCALLS
54565 MUSTTAIL return InterpNext(S);
54566#else
54567 return true;
54568#endif
54569}
54570PRESERVE_NONE
54571static bool Interp_StoreBitFieldActivatePopSint64(InterpState &S) {
54572 if (!StoreBitFieldActivatePop<PT_Sint64>(S, S.PC)) return false;
54573#if USE_TAILCALLS
54574 MUSTTAIL return InterpNext(S);
54575#else
54576 return true;
54577#endif
54578}
54579PRESERVE_NONE
54580static bool Interp_StoreBitFieldActivatePopUint64(InterpState &S) {
54581 if (!StoreBitFieldActivatePop<PT_Uint64>(S, S.PC)) return false;
54582#if USE_TAILCALLS
54583 MUSTTAIL return InterpNext(S);
54584#else
54585 return true;
54586#endif
54587}
54588PRESERVE_NONE
54589static bool Interp_StoreBitFieldActivatePopIntAP(InterpState &S) {
54590 if (!StoreBitFieldActivatePop<PT_IntAP>(S, S.PC)) return false;
54591#if USE_TAILCALLS
54592 MUSTTAIL return InterpNext(S);
54593#else
54594 return true;
54595#endif
54596}
54597PRESERVE_NONE
54598static bool Interp_StoreBitFieldActivatePopIntAPS(InterpState &S) {
54599 if (!StoreBitFieldActivatePop<PT_IntAPS>(S, S.PC)) return false;
54600#if USE_TAILCALLS
54601 MUSTTAIL return InterpNext(S);
54602#else
54603 return true;
54604#endif
54605}
54606PRESERVE_NONE
54607static bool Interp_StoreBitFieldActivatePopBool(InterpState &S) {
54608 if (!StoreBitFieldActivatePop<PT_Bool>(S, S.PC)) return false;
54609#if USE_TAILCALLS
54610 MUSTTAIL return InterpNext(S);
54611#else
54612 return true;
54613#endif
54614}
54615PRESERVE_NONE
54616static bool Interp_StoreBitFieldActivatePopFixedPoint(InterpState &S) {
54617 if (!StoreBitFieldActivatePop<PT_FixedPoint>(S, S.PC)) return false;
54618#if USE_TAILCALLS
54619 MUSTTAIL return InterpNext(S);
54620#else
54621 return true;
54622#endif
54623}
54624#endif
54625#ifdef GET_DISASM
54626case OP_StoreBitFieldActivatePopSint8:
54627 Text.Op = PrintName("StoreBitFieldActivatePopSint8");
54628 break;
54629case OP_StoreBitFieldActivatePopUint8:
54630 Text.Op = PrintName("StoreBitFieldActivatePopUint8");
54631 break;
54632case OP_StoreBitFieldActivatePopSint16:
54633 Text.Op = PrintName("StoreBitFieldActivatePopSint16");
54634 break;
54635case OP_StoreBitFieldActivatePopUint16:
54636 Text.Op = PrintName("StoreBitFieldActivatePopUint16");
54637 break;
54638case OP_StoreBitFieldActivatePopSint32:
54639 Text.Op = PrintName("StoreBitFieldActivatePopSint32");
54640 break;
54641case OP_StoreBitFieldActivatePopUint32:
54642 Text.Op = PrintName("StoreBitFieldActivatePopUint32");
54643 break;
54644case OP_StoreBitFieldActivatePopSint64:
54645 Text.Op = PrintName("StoreBitFieldActivatePopSint64");
54646 break;
54647case OP_StoreBitFieldActivatePopUint64:
54648 Text.Op = PrintName("StoreBitFieldActivatePopUint64");
54649 break;
54650case OP_StoreBitFieldActivatePopIntAP:
54651 Text.Op = PrintName("StoreBitFieldActivatePopIntAP");
54652 break;
54653case OP_StoreBitFieldActivatePopIntAPS:
54654 Text.Op = PrintName("StoreBitFieldActivatePopIntAPS");
54655 break;
54656case OP_StoreBitFieldActivatePopBool:
54657 Text.Op = PrintName("StoreBitFieldActivatePopBool");
54658 break;
54659case OP_StoreBitFieldActivatePopFixedPoint:
54660 Text.Op = PrintName("StoreBitFieldActivatePopFixedPoint");
54661 break;
54662#endif
54663#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
54664bool emitStoreBitFieldActivatePopSint8(SourceInfo);
54665bool emitStoreBitFieldActivatePopUint8(SourceInfo);
54666bool emitStoreBitFieldActivatePopSint16(SourceInfo);
54667bool emitStoreBitFieldActivatePopUint16(SourceInfo);
54668bool emitStoreBitFieldActivatePopSint32(SourceInfo);
54669bool emitStoreBitFieldActivatePopUint32(SourceInfo);
54670bool emitStoreBitFieldActivatePopSint64(SourceInfo);
54671bool emitStoreBitFieldActivatePopUint64(SourceInfo);
54672bool emitStoreBitFieldActivatePopIntAP(SourceInfo);
54673bool emitStoreBitFieldActivatePopIntAPS(SourceInfo);
54674bool emitStoreBitFieldActivatePopBool(SourceInfo);
54675bool emitStoreBitFieldActivatePopFixedPoint(SourceInfo);
54676#endif
54677#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
54678[[nodiscard]] bool emitStoreBitFieldActivatePop(PrimType, SourceInfo I);
54679#endif
54680#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
54681bool
54682#if defined(GET_EVAL_IMPL)
54683EvalEmitter
54684#else
54685ByteCodeEmitter
54686#endif
54687::emitStoreBitFieldActivatePop(PrimType T0, SourceInfo I) {
54688 switch (T0) {
54689 case PT_Sint8:
54690 return emitStoreBitFieldActivatePopSint8(I);
54691 case PT_Uint8:
54692 return emitStoreBitFieldActivatePopUint8(I);
54693 case PT_Sint16:
54694 return emitStoreBitFieldActivatePopSint16(I);
54695 case PT_Uint16:
54696 return emitStoreBitFieldActivatePopUint16(I);
54697 case PT_Sint32:
54698 return emitStoreBitFieldActivatePopSint32(I);
54699 case PT_Uint32:
54700 return emitStoreBitFieldActivatePopUint32(I);
54701 case PT_Sint64:
54702 return emitStoreBitFieldActivatePopSint64(I);
54703 case PT_Uint64:
54704 return emitStoreBitFieldActivatePopUint64(I);
54705 case PT_IntAP:
54706 return emitStoreBitFieldActivatePopIntAP(I);
54707 case PT_IntAPS:
54708 return emitStoreBitFieldActivatePopIntAPS(I);
54709 case PT_Bool:
54710 return emitStoreBitFieldActivatePopBool(I);
54711 case PT_FixedPoint:
54712 return emitStoreBitFieldActivatePopFixedPoint(I);
54713 default: llvm_unreachable("invalid type: emitStoreBitFieldActivatePop");
54714 }
54715 llvm_unreachable("invalid enum value");
54716}
54717#endif
54718#ifdef GET_LINK_IMPL
54719bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint8(SourceInfo L) {
54720 return emitOp<>(OP_StoreBitFieldActivatePopSint8, L);
54721}
54722bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint8(SourceInfo L) {
54723 return emitOp<>(OP_StoreBitFieldActivatePopUint8, L);
54724}
54725bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint16(SourceInfo L) {
54726 return emitOp<>(OP_StoreBitFieldActivatePopSint16, L);
54727}
54728bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint16(SourceInfo L) {
54729 return emitOp<>(OP_StoreBitFieldActivatePopUint16, L);
54730}
54731bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint32(SourceInfo L) {
54732 return emitOp<>(OP_StoreBitFieldActivatePopSint32, L);
54733}
54734bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint32(SourceInfo L) {
54735 return emitOp<>(OP_StoreBitFieldActivatePopUint32, L);
54736}
54737bool ByteCodeEmitter::emitStoreBitFieldActivatePopSint64(SourceInfo L) {
54738 return emitOp<>(OP_StoreBitFieldActivatePopSint64, L);
54739}
54740bool ByteCodeEmitter::emitStoreBitFieldActivatePopUint64(SourceInfo L) {
54741 return emitOp<>(OP_StoreBitFieldActivatePopUint64, L);
54742}
54743bool ByteCodeEmitter::emitStoreBitFieldActivatePopIntAP(SourceInfo L) {
54744 return emitOp<>(OP_StoreBitFieldActivatePopIntAP, L);
54745}
54746bool ByteCodeEmitter::emitStoreBitFieldActivatePopIntAPS(SourceInfo L) {
54747 return emitOp<>(OP_StoreBitFieldActivatePopIntAPS, L);
54748}
54749bool ByteCodeEmitter::emitStoreBitFieldActivatePopBool(SourceInfo L) {
54750 return emitOp<>(OP_StoreBitFieldActivatePopBool, L);
54751}
54752bool ByteCodeEmitter::emitStoreBitFieldActivatePopFixedPoint(SourceInfo L) {
54753 return emitOp<>(OP_StoreBitFieldActivatePopFixedPoint, L);
54754}
54755#endif
54756#ifdef GET_EVAL_IMPL
54757bool EvalEmitter::emitStoreBitFieldActivatePopSint8(SourceInfo L) {
54758 if (!isActive()) return true;
54759 CurrentSource = L;
54760 return StoreBitFieldActivatePop<PT_Sint8>(S, CodePtr());
54761}
54762bool EvalEmitter::emitStoreBitFieldActivatePopUint8(SourceInfo L) {
54763 if (!isActive()) return true;
54764 CurrentSource = L;
54765 return StoreBitFieldActivatePop<PT_Uint8>(S, CodePtr());
54766}
54767bool EvalEmitter::emitStoreBitFieldActivatePopSint16(SourceInfo L) {
54768 if (!isActive()) return true;
54769 CurrentSource = L;
54770 return StoreBitFieldActivatePop<PT_Sint16>(S, CodePtr());
54771}
54772bool EvalEmitter::emitStoreBitFieldActivatePopUint16(SourceInfo L) {
54773 if (!isActive()) return true;
54774 CurrentSource = L;
54775 return StoreBitFieldActivatePop<PT_Uint16>(S, CodePtr());
54776}
54777bool EvalEmitter::emitStoreBitFieldActivatePopSint32(SourceInfo L) {
54778 if (!isActive()) return true;
54779 CurrentSource = L;
54780 return StoreBitFieldActivatePop<PT_Sint32>(S, CodePtr());
54781}
54782bool EvalEmitter::emitStoreBitFieldActivatePopUint32(SourceInfo L) {
54783 if (!isActive()) return true;
54784 CurrentSource = L;
54785 return StoreBitFieldActivatePop<PT_Uint32>(S, CodePtr());
54786}
54787bool EvalEmitter::emitStoreBitFieldActivatePopSint64(SourceInfo L) {
54788 if (!isActive()) return true;
54789 CurrentSource = L;
54790 return StoreBitFieldActivatePop<PT_Sint64>(S, CodePtr());
54791}
54792bool EvalEmitter::emitStoreBitFieldActivatePopUint64(SourceInfo L) {
54793 if (!isActive()) return true;
54794 CurrentSource = L;
54795 return StoreBitFieldActivatePop<PT_Uint64>(S, CodePtr());
54796}
54797bool EvalEmitter::emitStoreBitFieldActivatePopIntAP(SourceInfo L) {
54798 if (!isActive()) return true;
54799 CurrentSource = L;
54800 return StoreBitFieldActivatePop<PT_IntAP>(S, CodePtr());
54801}
54802bool EvalEmitter::emitStoreBitFieldActivatePopIntAPS(SourceInfo L) {
54803 if (!isActive()) return true;
54804 CurrentSource = L;
54805 return StoreBitFieldActivatePop<PT_IntAPS>(S, CodePtr());
54806}
54807bool EvalEmitter::emitStoreBitFieldActivatePopBool(SourceInfo L) {
54808 if (!isActive()) return true;
54809 CurrentSource = L;
54810 return StoreBitFieldActivatePop<PT_Bool>(S, CodePtr());
54811}
54812bool EvalEmitter::emitStoreBitFieldActivatePopFixedPoint(SourceInfo L) {
54813 if (!isActive()) return true;
54814 CurrentSource = L;
54815 return StoreBitFieldActivatePop<PT_FixedPoint>(S, CodePtr());
54816}
54817#endif
54818#ifdef GET_OPCODE_NAMES
54819OP_StoreBitFieldPopSint8,
54820OP_StoreBitFieldPopUint8,
54821OP_StoreBitFieldPopSint16,
54822OP_StoreBitFieldPopUint16,
54823OP_StoreBitFieldPopSint32,
54824OP_StoreBitFieldPopUint32,
54825OP_StoreBitFieldPopSint64,
54826OP_StoreBitFieldPopUint64,
54827OP_StoreBitFieldPopIntAP,
54828OP_StoreBitFieldPopIntAPS,
54829OP_StoreBitFieldPopBool,
54830OP_StoreBitFieldPopFixedPoint,
54831#endif
54832#ifdef GET_INTERPFN_LIST
54833&Interp_StoreBitFieldPopSint8,
54834&Interp_StoreBitFieldPopUint8,
54835&Interp_StoreBitFieldPopSint16,
54836&Interp_StoreBitFieldPopUint16,
54837&Interp_StoreBitFieldPopSint32,
54838&Interp_StoreBitFieldPopUint32,
54839&Interp_StoreBitFieldPopSint64,
54840&Interp_StoreBitFieldPopUint64,
54841&Interp_StoreBitFieldPopIntAP,
54842&Interp_StoreBitFieldPopIntAPS,
54843&Interp_StoreBitFieldPopBool,
54844&Interp_StoreBitFieldPopFixedPoint,
54845#endif
54846#ifdef GET_INTERPFN_DISPATCHERS
54847PRESERVE_NONE
54848static bool Interp_StoreBitFieldPopSint8(InterpState &S) {
54849 if (!StoreBitFieldPop<PT_Sint8>(S, S.PC)) return false;
54850#if USE_TAILCALLS
54851 MUSTTAIL return InterpNext(S);
54852#else
54853 return true;
54854#endif
54855}
54856PRESERVE_NONE
54857static bool Interp_StoreBitFieldPopUint8(InterpState &S) {
54858 if (!StoreBitFieldPop<PT_Uint8>(S, S.PC)) return false;
54859#if USE_TAILCALLS
54860 MUSTTAIL return InterpNext(S);
54861#else
54862 return true;
54863#endif
54864}
54865PRESERVE_NONE
54866static bool Interp_StoreBitFieldPopSint16(InterpState &S) {
54867 if (!StoreBitFieldPop<PT_Sint16>(S, S.PC)) return false;
54868#if USE_TAILCALLS
54869 MUSTTAIL return InterpNext(S);
54870#else
54871 return true;
54872#endif
54873}
54874PRESERVE_NONE
54875static bool Interp_StoreBitFieldPopUint16(InterpState &S) {
54876 if (!StoreBitFieldPop<PT_Uint16>(S, S.PC)) return false;
54877#if USE_TAILCALLS
54878 MUSTTAIL return InterpNext(S);
54879#else
54880 return true;
54881#endif
54882}
54883PRESERVE_NONE
54884static bool Interp_StoreBitFieldPopSint32(InterpState &S) {
54885 if (!StoreBitFieldPop<PT_Sint32>(S, S.PC)) return false;
54886#if USE_TAILCALLS
54887 MUSTTAIL return InterpNext(S);
54888#else
54889 return true;
54890#endif
54891}
54892PRESERVE_NONE
54893static bool Interp_StoreBitFieldPopUint32(InterpState &S) {
54894 if (!StoreBitFieldPop<PT_Uint32>(S, S.PC)) return false;
54895#if USE_TAILCALLS
54896 MUSTTAIL return InterpNext(S);
54897#else
54898 return true;
54899#endif
54900}
54901PRESERVE_NONE
54902static bool Interp_StoreBitFieldPopSint64(InterpState &S) {
54903 if (!StoreBitFieldPop<PT_Sint64>(S, S.PC)) return false;
54904#if USE_TAILCALLS
54905 MUSTTAIL return InterpNext(S);
54906#else
54907 return true;
54908#endif
54909}
54910PRESERVE_NONE
54911static bool Interp_StoreBitFieldPopUint64(InterpState &S) {
54912 if (!StoreBitFieldPop<PT_Uint64>(S, S.PC)) return false;
54913#if USE_TAILCALLS
54914 MUSTTAIL return InterpNext(S);
54915#else
54916 return true;
54917#endif
54918}
54919PRESERVE_NONE
54920static bool Interp_StoreBitFieldPopIntAP(InterpState &S) {
54921 if (!StoreBitFieldPop<PT_IntAP>(S, S.PC)) return false;
54922#if USE_TAILCALLS
54923 MUSTTAIL return InterpNext(S);
54924#else
54925 return true;
54926#endif
54927}
54928PRESERVE_NONE
54929static bool Interp_StoreBitFieldPopIntAPS(InterpState &S) {
54930 if (!StoreBitFieldPop<PT_IntAPS>(S, S.PC)) return false;
54931#if USE_TAILCALLS
54932 MUSTTAIL return InterpNext(S);
54933#else
54934 return true;
54935#endif
54936}
54937PRESERVE_NONE
54938static bool Interp_StoreBitFieldPopBool(InterpState &S) {
54939 if (!StoreBitFieldPop<PT_Bool>(S, S.PC)) return false;
54940#if USE_TAILCALLS
54941 MUSTTAIL return InterpNext(S);
54942#else
54943 return true;
54944#endif
54945}
54946PRESERVE_NONE
54947static bool Interp_StoreBitFieldPopFixedPoint(InterpState &S) {
54948 if (!StoreBitFieldPop<PT_FixedPoint>(S, S.PC)) return false;
54949#if USE_TAILCALLS
54950 MUSTTAIL return InterpNext(S);
54951#else
54952 return true;
54953#endif
54954}
54955#endif
54956#ifdef GET_DISASM
54957case OP_StoreBitFieldPopSint8:
54958 Text.Op = PrintName("StoreBitFieldPopSint8");
54959 break;
54960case OP_StoreBitFieldPopUint8:
54961 Text.Op = PrintName("StoreBitFieldPopUint8");
54962 break;
54963case OP_StoreBitFieldPopSint16:
54964 Text.Op = PrintName("StoreBitFieldPopSint16");
54965 break;
54966case OP_StoreBitFieldPopUint16:
54967 Text.Op = PrintName("StoreBitFieldPopUint16");
54968 break;
54969case OP_StoreBitFieldPopSint32:
54970 Text.Op = PrintName("StoreBitFieldPopSint32");
54971 break;
54972case OP_StoreBitFieldPopUint32:
54973 Text.Op = PrintName("StoreBitFieldPopUint32");
54974 break;
54975case OP_StoreBitFieldPopSint64:
54976 Text.Op = PrintName("StoreBitFieldPopSint64");
54977 break;
54978case OP_StoreBitFieldPopUint64:
54979 Text.Op = PrintName("StoreBitFieldPopUint64");
54980 break;
54981case OP_StoreBitFieldPopIntAP:
54982 Text.Op = PrintName("StoreBitFieldPopIntAP");
54983 break;
54984case OP_StoreBitFieldPopIntAPS:
54985 Text.Op = PrintName("StoreBitFieldPopIntAPS");
54986 break;
54987case OP_StoreBitFieldPopBool:
54988 Text.Op = PrintName("StoreBitFieldPopBool");
54989 break;
54990case OP_StoreBitFieldPopFixedPoint:
54991 Text.Op = PrintName("StoreBitFieldPopFixedPoint");
54992 break;
54993#endif
54994#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
54995bool emitStoreBitFieldPopSint8(SourceInfo);
54996bool emitStoreBitFieldPopUint8(SourceInfo);
54997bool emitStoreBitFieldPopSint16(SourceInfo);
54998bool emitStoreBitFieldPopUint16(SourceInfo);
54999bool emitStoreBitFieldPopSint32(SourceInfo);
55000bool emitStoreBitFieldPopUint32(SourceInfo);
55001bool emitStoreBitFieldPopSint64(SourceInfo);
55002bool emitStoreBitFieldPopUint64(SourceInfo);
55003bool emitStoreBitFieldPopIntAP(SourceInfo);
55004bool emitStoreBitFieldPopIntAPS(SourceInfo);
55005bool emitStoreBitFieldPopBool(SourceInfo);
55006bool emitStoreBitFieldPopFixedPoint(SourceInfo);
55007#endif
55008#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
55009[[nodiscard]] bool emitStoreBitFieldPop(PrimType, SourceInfo I);
55010#endif
55011#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
55012bool
55013#if defined(GET_EVAL_IMPL)
55014EvalEmitter
55015#else
55016ByteCodeEmitter
55017#endif
55018::emitStoreBitFieldPop(PrimType T0, SourceInfo I) {
55019 switch (T0) {
55020 case PT_Sint8:
55021 return emitStoreBitFieldPopSint8(I);
55022 case PT_Uint8:
55023 return emitStoreBitFieldPopUint8(I);
55024 case PT_Sint16:
55025 return emitStoreBitFieldPopSint16(I);
55026 case PT_Uint16:
55027 return emitStoreBitFieldPopUint16(I);
55028 case PT_Sint32:
55029 return emitStoreBitFieldPopSint32(I);
55030 case PT_Uint32:
55031 return emitStoreBitFieldPopUint32(I);
55032 case PT_Sint64:
55033 return emitStoreBitFieldPopSint64(I);
55034 case PT_Uint64:
55035 return emitStoreBitFieldPopUint64(I);
55036 case PT_IntAP:
55037 return emitStoreBitFieldPopIntAP(I);
55038 case PT_IntAPS:
55039 return emitStoreBitFieldPopIntAPS(I);
55040 case PT_Bool:
55041 return emitStoreBitFieldPopBool(I);
55042 case PT_FixedPoint:
55043 return emitStoreBitFieldPopFixedPoint(I);
55044 default: llvm_unreachable("invalid type: emitStoreBitFieldPop");
55045 }
55046 llvm_unreachable("invalid enum value");
55047}
55048#endif
55049#ifdef GET_LINK_IMPL
55050bool ByteCodeEmitter::emitStoreBitFieldPopSint8(SourceInfo L) {
55051 return emitOp<>(OP_StoreBitFieldPopSint8, L);
55052}
55053bool ByteCodeEmitter::emitStoreBitFieldPopUint8(SourceInfo L) {
55054 return emitOp<>(OP_StoreBitFieldPopUint8, L);
55055}
55056bool ByteCodeEmitter::emitStoreBitFieldPopSint16(SourceInfo L) {
55057 return emitOp<>(OP_StoreBitFieldPopSint16, L);
55058}
55059bool ByteCodeEmitter::emitStoreBitFieldPopUint16(SourceInfo L) {
55060 return emitOp<>(OP_StoreBitFieldPopUint16, L);
55061}
55062bool ByteCodeEmitter::emitStoreBitFieldPopSint32(SourceInfo L) {
55063 return emitOp<>(OP_StoreBitFieldPopSint32, L);
55064}
55065bool ByteCodeEmitter::emitStoreBitFieldPopUint32(SourceInfo L) {
55066 return emitOp<>(OP_StoreBitFieldPopUint32, L);
55067}
55068bool ByteCodeEmitter::emitStoreBitFieldPopSint64(SourceInfo L) {
55069 return emitOp<>(OP_StoreBitFieldPopSint64, L);
55070}
55071bool ByteCodeEmitter::emitStoreBitFieldPopUint64(SourceInfo L) {
55072 return emitOp<>(OP_StoreBitFieldPopUint64, L);
55073}
55074bool ByteCodeEmitter::emitStoreBitFieldPopIntAP(SourceInfo L) {
55075 return emitOp<>(OP_StoreBitFieldPopIntAP, L);
55076}
55077bool ByteCodeEmitter::emitStoreBitFieldPopIntAPS(SourceInfo L) {
55078 return emitOp<>(OP_StoreBitFieldPopIntAPS, L);
55079}
55080bool ByteCodeEmitter::emitStoreBitFieldPopBool(SourceInfo L) {
55081 return emitOp<>(OP_StoreBitFieldPopBool, L);
55082}
55083bool ByteCodeEmitter::emitStoreBitFieldPopFixedPoint(SourceInfo L) {
55084 return emitOp<>(OP_StoreBitFieldPopFixedPoint, L);
55085}
55086#endif
55087#ifdef GET_EVAL_IMPL
55088bool EvalEmitter::emitStoreBitFieldPopSint8(SourceInfo L) {
55089 if (!isActive()) return true;
55090 CurrentSource = L;
55091 return StoreBitFieldPop<PT_Sint8>(S, CodePtr());
55092}
55093bool EvalEmitter::emitStoreBitFieldPopUint8(SourceInfo L) {
55094 if (!isActive()) return true;
55095 CurrentSource = L;
55096 return StoreBitFieldPop<PT_Uint8>(S, CodePtr());
55097}
55098bool EvalEmitter::emitStoreBitFieldPopSint16(SourceInfo L) {
55099 if (!isActive()) return true;
55100 CurrentSource = L;
55101 return StoreBitFieldPop<PT_Sint16>(S, CodePtr());
55102}
55103bool EvalEmitter::emitStoreBitFieldPopUint16(SourceInfo L) {
55104 if (!isActive()) return true;
55105 CurrentSource = L;
55106 return StoreBitFieldPop<PT_Uint16>(S, CodePtr());
55107}
55108bool EvalEmitter::emitStoreBitFieldPopSint32(SourceInfo L) {
55109 if (!isActive()) return true;
55110 CurrentSource = L;
55111 return StoreBitFieldPop<PT_Sint32>(S, CodePtr());
55112}
55113bool EvalEmitter::emitStoreBitFieldPopUint32(SourceInfo L) {
55114 if (!isActive()) return true;
55115 CurrentSource = L;
55116 return StoreBitFieldPop<PT_Uint32>(S, CodePtr());
55117}
55118bool EvalEmitter::emitStoreBitFieldPopSint64(SourceInfo L) {
55119 if (!isActive()) return true;
55120 CurrentSource = L;
55121 return StoreBitFieldPop<PT_Sint64>(S, CodePtr());
55122}
55123bool EvalEmitter::emitStoreBitFieldPopUint64(SourceInfo L) {
55124 if (!isActive()) return true;
55125 CurrentSource = L;
55126 return StoreBitFieldPop<PT_Uint64>(S, CodePtr());
55127}
55128bool EvalEmitter::emitStoreBitFieldPopIntAP(SourceInfo L) {
55129 if (!isActive()) return true;
55130 CurrentSource = L;
55131 return StoreBitFieldPop<PT_IntAP>(S, CodePtr());
55132}
55133bool EvalEmitter::emitStoreBitFieldPopIntAPS(SourceInfo L) {
55134 if (!isActive()) return true;
55135 CurrentSource = L;
55136 return StoreBitFieldPop<PT_IntAPS>(S, CodePtr());
55137}
55138bool EvalEmitter::emitStoreBitFieldPopBool(SourceInfo L) {
55139 if (!isActive()) return true;
55140 CurrentSource = L;
55141 return StoreBitFieldPop<PT_Bool>(S, CodePtr());
55142}
55143bool EvalEmitter::emitStoreBitFieldPopFixedPoint(SourceInfo L) {
55144 if (!isActive()) return true;
55145 CurrentSource = L;
55146 return StoreBitFieldPop<PT_FixedPoint>(S, CodePtr());
55147}
55148#endif
55149#ifdef GET_OPCODE_NAMES
55150OP_StorePopSint8,
55151OP_StorePopUint8,
55152OP_StorePopSint16,
55153OP_StorePopUint16,
55154OP_StorePopSint32,
55155OP_StorePopUint32,
55156OP_StorePopSint64,
55157OP_StorePopUint64,
55158OP_StorePopIntAP,
55159OP_StorePopIntAPS,
55160OP_StorePopBool,
55161OP_StorePopFixedPoint,
55162OP_StorePopPtr,
55163OP_StorePopMemberPtr,
55164OP_StorePopFloat,
55165OP_StorePopReflect,
55166#endif
55167#ifdef GET_INTERPFN_LIST
55168&Interp_StorePopSint8,
55169&Interp_StorePopUint8,
55170&Interp_StorePopSint16,
55171&Interp_StorePopUint16,
55172&Interp_StorePopSint32,
55173&Interp_StorePopUint32,
55174&Interp_StorePopSint64,
55175&Interp_StorePopUint64,
55176&Interp_StorePopIntAP,
55177&Interp_StorePopIntAPS,
55178&Interp_StorePopBool,
55179&Interp_StorePopFixedPoint,
55180&Interp_StorePopPtr,
55181&Interp_StorePopMemberPtr,
55182&Interp_StorePopFloat,
55183&Interp_StorePopReflect,
55184#endif
55185#ifdef GET_INTERPFN_DISPATCHERS
55186PRESERVE_NONE
55187static bool Interp_StorePopSint8(InterpState &S) {
55188 if (!StorePop<PT_Sint8>(S, S.PC)) return false;
55189#if USE_TAILCALLS
55190 MUSTTAIL return InterpNext(S);
55191#else
55192 return true;
55193#endif
55194}
55195PRESERVE_NONE
55196static bool Interp_StorePopUint8(InterpState &S) {
55197 if (!StorePop<PT_Uint8>(S, S.PC)) return false;
55198#if USE_TAILCALLS
55199 MUSTTAIL return InterpNext(S);
55200#else
55201 return true;
55202#endif
55203}
55204PRESERVE_NONE
55205static bool Interp_StorePopSint16(InterpState &S) {
55206 if (!StorePop<PT_Sint16>(S, S.PC)) return false;
55207#if USE_TAILCALLS
55208 MUSTTAIL return InterpNext(S);
55209#else
55210 return true;
55211#endif
55212}
55213PRESERVE_NONE
55214static bool Interp_StorePopUint16(InterpState &S) {
55215 if (!StorePop<PT_Uint16>(S, S.PC)) return false;
55216#if USE_TAILCALLS
55217 MUSTTAIL return InterpNext(S);
55218#else
55219 return true;
55220#endif
55221}
55222PRESERVE_NONE
55223static bool Interp_StorePopSint32(InterpState &S) {
55224 if (!StorePop<PT_Sint32>(S, S.PC)) return false;
55225#if USE_TAILCALLS
55226 MUSTTAIL return InterpNext(S);
55227#else
55228 return true;
55229#endif
55230}
55231PRESERVE_NONE
55232static bool Interp_StorePopUint32(InterpState &S) {
55233 if (!StorePop<PT_Uint32>(S, S.PC)) return false;
55234#if USE_TAILCALLS
55235 MUSTTAIL return InterpNext(S);
55236#else
55237 return true;
55238#endif
55239}
55240PRESERVE_NONE
55241static bool Interp_StorePopSint64(InterpState &S) {
55242 if (!StorePop<PT_Sint64>(S, S.PC)) return false;
55243#if USE_TAILCALLS
55244 MUSTTAIL return InterpNext(S);
55245#else
55246 return true;
55247#endif
55248}
55249PRESERVE_NONE
55250static bool Interp_StorePopUint64(InterpState &S) {
55251 if (!StorePop<PT_Uint64>(S, S.PC)) return false;
55252#if USE_TAILCALLS
55253 MUSTTAIL return InterpNext(S);
55254#else
55255 return true;
55256#endif
55257}
55258PRESERVE_NONE
55259static bool Interp_StorePopIntAP(InterpState &S) {
55260 if (!StorePop<PT_IntAP>(S, S.PC)) return false;
55261#if USE_TAILCALLS
55262 MUSTTAIL return InterpNext(S);
55263#else
55264 return true;
55265#endif
55266}
55267PRESERVE_NONE
55268static bool Interp_StorePopIntAPS(InterpState &S) {
55269 if (!StorePop<PT_IntAPS>(S, S.PC)) return false;
55270#if USE_TAILCALLS
55271 MUSTTAIL return InterpNext(S);
55272#else
55273 return true;
55274#endif
55275}
55276PRESERVE_NONE
55277static bool Interp_StorePopBool(InterpState &S) {
55278 if (!StorePop<PT_Bool>(S, S.PC)) return false;
55279#if USE_TAILCALLS
55280 MUSTTAIL return InterpNext(S);
55281#else
55282 return true;
55283#endif
55284}
55285PRESERVE_NONE
55286static bool Interp_StorePopFixedPoint(InterpState &S) {
55287 if (!StorePop<PT_FixedPoint>(S, S.PC)) return false;
55288#if USE_TAILCALLS
55289 MUSTTAIL return InterpNext(S);
55290#else
55291 return true;
55292#endif
55293}
55294PRESERVE_NONE
55295static bool Interp_StorePopPtr(InterpState &S) {
55296 if (!StorePop<PT_Ptr>(S, S.PC)) return false;
55297#if USE_TAILCALLS
55298 MUSTTAIL return InterpNext(S);
55299#else
55300 return true;
55301#endif
55302}
55303PRESERVE_NONE
55304static bool Interp_StorePopMemberPtr(InterpState &S) {
55305 if (!StorePop<PT_MemberPtr>(S, S.PC)) return false;
55306#if USE_TAILCALLS
55307 MUSTTAIL return InterpNext(S);
55308#else
55309 return true;
55310#endif
55311}
55312PRESERVE_NONE
55313static bool Interp_StorePopFloat(InterpState &S) {
55314 if (!StorePop<PT_Float>(S, S.PC)) return false;
55315#if USE_TAILCALLS
55316 MUSTTAIL return InterpNext(S);
55317#else
55318 return true;
55319#endif
55320}
55321PRESERVE_NONE
55322static bool Interp_StorePopReflect(InterpState &S) {
55323 if (!StorePop<PT_Reflect>(S, S.PC)) return false;
55324#if USE_TAILCALLS
55325 MUSTTAIL return InterpNext(S);
55326#else
55327 return true;
55328#endif
55329}
55330#endif
55331#ifdef GET_DISASM
55332case OP_StorePopSint8:
55333 Text.Op = PrintName("StorePopSint8");
55334 break;
55335case OP_StorePopUint8:
55336 Text.Op = PrintName("StorePopUint8");
55337 break;
55338case OP_StorePopSint16:
55339 Text.Op = PrintName("StorePopSint16");
55340 break;
55341case OP_StorePopUint16:
55342 Text.Op = PrintName("StorePopUint16");
55343 break;
55344case OP_StorePopSint32:
55345 Text.Op = PrintName("StorePopSint32");
55346 break;
55347case OP_StorePopUint32:
55348 Text.Op = PrintName("StorePopUint32");
55349 break;
55350case OP_StorePopSint64:
55351 Text.Op = PrintName("StorePopSint64");
55352 break;
55353case OP_StorePopUint64:
55354 Text.Op = PrintName("StorePopUint64");
55355 break;
55356case OP_StorePopIntAP:
55357 Text.Op = PrintName("StorePopIntAP");
55358 break;
55359case OP_StorePopIntAPS:
55360 Text.Op = PrintName("StorePopIntAPS");
55361 break;
55362case OP_StorePopBool:
55363 Text.Op = PrintName("StorePopBool");
55364 break;
55365case OP_StorePopFixedPoint:
55366 Text.Op = PrintName("StorePopFixedPoint");
55367 break;
55368case OP_StorePopPtr:
55369 Text.Op = PrintName("StorePopPtr");
55370 break;
55371case OP_StorePopMemberPtr:
55372 Text.Op = PrintName("StorePopMemberPtr");
55373 break;
55374case OP_StorePopFloat:
55375 Text.Op = PrintName("StorePopFloat");
55376 break;
55377case OP_StorePopReflect:
55378 Text.Op = PrintName("StorePopReflect");
55379 break;
55380#endif
55381#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
55382bool emitStorePopSint8(SourceInfo);
55383bool emitStorePopUint8(SourceInfo);
55384bool emitStorePopSint16(SourceInfo);
55385bool emitStorePopUint16(SourceInfo);
55386bool emitStorePopSint32(SourceInfo);
55387bool emitStorePopUint32(SourceInfo);
55388bool emitStorePopSint64(SourceInfo);
55389bool emitStorePopUint64(SourceInfo);
55390bool emitStorePopIntAP(SourceInfo);
55391bool emitStorePopIntAPS(SourceInfo);
55392bool emitStorePopBool(SourceInfo);
55393bool emitStorePopFixedPoint(SourceInfo);
55394bool emitStorePopPtr(SourceInfo);
55395bool emitStorePopMemberPtr(SourceInfo);
55396bool emitStorePopFloat(SourceInfo);
55397bool emitStorePopReflect(SourceInfo);
55398#endif
55399#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
55400[[nodiscard]] bool emitStorePop(PrimType, SourceInfo I);
55401#endif
55402#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
55403bool
55404#if defined(GET_EVAL_IMPL)
55405EvalEmitter
55406#else
55407ByteCodeEmitter
55408#endif
55409::emitStorePop(PrimType T0, SourceInfo I) {
55410 switch (T0) {
55411 case PT_Sint8:
55412 return emitStorePopSint8(I);
55413 case PT_Uint8:
55414 return emitStorePopUint8(I);
55415 case PT_Sint16:
55416 return emitStorePopSint16(I);
55417 case PT_Uint16:
55418 return emitStorePopUint16(I);
55419 case PT_Sint32:
55420 return emitStorePopSint32(I);
55421 case PT_Uint32:
55422 return emitStorePopUint32(I);
55423 case PT_Sint64:
55424 return emitStorePopSint64(I);
55425 case PT_Uint64:
55426 return emitStorePopUint64(I);
55427 case PT_IntAP:
55428 return emitStorePopIntAP(I);
55429 case PT_IntAPS:
55430 return emitStorePopIntAPS(I);
55431 case PT_Bool:
55432 return emitStorePopBool(I);
55433 case PT_FixedPoint:
55434 return emitStorePopFixedPoint(I);
55435 case PT_Ptr:
55436 return emitStorePopPtr(I);
55437 case PT_MemberPtr:
55438 return emitStorePopMemberPtr(I);
55439 case PT_Float:
55440 return emitStorePopFloat(I);
55441 case PT_Reflect:
55442 return emitStorePopReflect(I);
55443 }
55444 llvm_unreachable("invalid enum value");
55445}
55446#endif
55447#ifdef GET_LINK_IMPL
55448bool ByteCodeEmitter::emitStorePopSint8(SourceInfo L) {
55449 return emitOp<>(OP_StorePopSint8, L);
55450}
55451bool ByteCodeEmitter::emitStorePopUint8(SourceInfo L) {
55452 return emitOp<>(OP_StorePopUint8, L);
55453}
55454bool ByteCodeEmitter::emitStorePopSint16(SourceInfo L) {
55455 return emitOp<>(OP_StorePopSint16, L);
55456}
55457bool ByteCodeEmitter::emitStorePopUint16(SourceInfo L) {
55458 return emitOp<>(OP_StorePopUint16, L);
55459}
55460bool ByteCodeEmitter::emitStorePopSint32(SourceInfo L) {
55461 return emitOp<>(OP_StorePopSint32, L);
55462}
55463bool ByteCodeEmitter::emitStorePopUint32(SourceInfo L) {
55464 return emitOp<>(OP_StorePopUint32, L);
55465}
55466bool ByteCodeEmitter::emitStorePopSint64(SourceInfo L) {
55467 return emitOp<>(OP_StorePopSint64, L);
55468}
55469bool ByteCodeEmitter::emitStorePopUint64(SourceInfo L) {
55470 return emitOp<>(OP_StorePopUint64, L);
55471}
55472bool ByteCodeEmitter::emitStorePopIntAP(SourceInfo L) {
55473 return emitOp<>(OP_StorePopIntAP, L);
55474}
55475bool ByteCodeEmitter::emitStorePopIntAPS(SourceInfo L) {
55476 return emitOp<>(OP_StorePopIntAPS, L);
55477}
55478bool ByteCodeEmitter::emitStorePopBool(SourceInfo L) {
55479 return emitOp<>(OP_StorePopBool, L);
55480}
55481bool ByteCodeEmitter::emitStorePopFixedPoint(SourceInfo L) {
55482 return emitOp<>(OP_StorePopFixedPoint, L);
55483}
55484bool ByteCodeEmitter::emitStorePopPtr(SourceInfo L) {
55485 return emitOp<>(OP_StorePopPtr, L);
55486}
55487bool ByteCodeEmitter::emitStorePopMemberPtr(SourceInfo L) {
55488 return emitOp<>(OP_StorePopMemberPtr, L);
55489}
55490bool ByteCodeEmitter::emitStorePopFloat(SourceInfo L) {
55491 return emitOp<>(OP_StorePopFloat, L);
55492}
55493bool ByteCodeEmitter::emitStorePopReflect(SourceInfo L) {
55494 return emitOp<>(OP_StorePopReflect, L);
55495}
55496#endif
55497#ifdef GET_EVAL_IMPL
55498bool EvalEmitter::emitStorePopSint8(SourceInfo L) {
55499 if (!isActive()) return true;
55500 CurrentSource = L;
55501 return StorePop<PT_Sint8>(S, CodePtr());
55502}
55503bool EvalEmitter::emitStorePopUint8(SourceInfo L) {
55504 if (!isActive()) return true;
55505 CurrentSource = L;
55506 return StorePop<PT_Uint8>(S, CodePtr());
55507}
55508bool EvalEmitter::emitStorePopSint16(SourceInfo L) {
55509 if (!isActive()) return true;
55510 CurrentSource = L;
55511 return StorePop<PT_Sint16>(S, CodePtr());
55512}
55513bool EvalEmitter::emitStorePopUint16(SourceInfo L) {
55514 if (!isActive()) return true;
55515 CurrentSource = L;
55516 return StorePop<PT_Uint16>(S, CodePtr());
55517}
55518bool EvalEmitter::emitStorePopSint32(SourceInfo L) {
55519 if (!isActive()) return true;
55520 CurrentSource = L;
55521 return StorePop<PT_Sint32>(S, CodePtr());
55522}
55523bool EvalEmitter::emitStorePopUint32(SourceInfo L) {
55524 if (!isActive()) return true;
55525 CurrentSource = L;
55526 return StorePop<PT_Uint32>(S, CodePtr());
55527}
55528bool EvalEmitter::emitStorePopSint64(SourceInfo L) {
55529 if (!isActive()) return true;
55530 CurrentSource = L;
55531 return StorePop<PT_Sint64>(S, CodePtr());
55532}
55533bool EvalEmitter::emitStorePopUint64(SourceInfo L) {
55534 if (!isActive()) return true;
55535 CurrentSource = L;
55536 return StorePop<PT_Uint64>(S, CodePtr());
55537}
55538bool EvalEmitter::emitStorePopIntAP(SourceInfo L) {
55539 if (!isActive()) return true;
55540 CurrentSource = L;
55541 return StorePop<PT_IntAP>(S, CodePtr());
55542}
55543bool EvalEmitter::emitStorePopIntAPS(SourceInfo L) {
55544 if (!isActive()) return true;
55545 CurrentSource = L;
55546 return StorePop<PT_IntAPS>(S, CodePtr());
55547}
55548bool EvalEmitter::emitStorePopBool(SourceInfo L) {
55549 if (!isActive()) return true;
55550 CurrentSource = L;
55551 return StorePop<PT_Bool>(S, CodePtr());
55552}
55553bool EvalEmitter::emitStorePopFixedPoint(SourceInfo L) {
55554 if (!isActive()) return true;
55555 CurrentSource = L;
55556 return StorePop<PT_FixedPoint>(S, CodePtr());
55557}
55558bool EvalEmitter::emitStorePopPtr(SourceInfo L) {
55559 if (!isActive()) return true;
55560 CurrentSource = L;
55561 return StorePop<PT_Ptr>(S, CodePtr());
55562}
55563bool EvalEmitter::emitStorePopMemberPtr(SourceInfo L) {
55564 if (!isActive()) return true;
55565 CurrentSource = L;
55566 return StorePop<PT_MemberPtr>(S, CodePtr());
55567}
55568bool EvalEmitter::emitStorePopFloat(SourceInfo L) {
55569 if (!isActive()) return true;
55570 CurrentSource = L;
55571 return StorePop<PT_Float>(S, CodePtr());
55572}
55573bool EvalEmitter::emitStorePopReflect(SourceInfo L) {
55574 if (!isActive()) return true;
55575 CurrentSource = L;
55576 return StorePop<PT_Reflect>(S, CodePtr());
55577}
55578#endif
55579#ifdef GET_OPCODE_NAMES
55580OP_SubSint8,
55581OP_SubUint8,
55582OP_SubSint16,
55583OP_SubUint16,
55584OP_SubSint32,
55585OP_SubUint32,
55586OP_SubSint64,
55587OP_SubUint64,
55588OP_SubIntAP,
55589OP_SubIntAPS,
55590OP_SubBool,
55591OP_SubFixedPoint,
55592#endif
55593#ifdef GET_INTERPFN_LIST
55594&Interp_SubSint8,
55595&Interp_SubUint8,
55596&Interp_SubSint16,
55597&Interp_SubUint16,
55598&Interp_SubSint32,
55599&Interp_SubUint32,
55600&Interp_SubSint64,
55601&Interp_SubUint64,
55602&Interp_SubIntAP,
55603&Interp_SubIntAPS,
55604&Interp_SubBool,
55605&Interp_SubFixedPoint,
55606#endif
55607#ifdef GET_INTERPFN_DISPATCHERS
55608PRESERVE_NONE
55609static bool Interp_SubSint8(InterpState &S) {
55610 if (!Sub<PT_Sint8>(S, S.PC)) return false;
55611#if USE_TAILCALLS
55612 MUSTTAIL return InterpNext(S);
55613#else
55614 return true;
55615#endif
55616}
55617PRESERVE_NONE
55618static bool Interp_SubUint8(InterpState &S) {
55619 if (!Sub<PT_Uint8>(S, S.PC)) return false;
55620#if USE_TAILCALLS
55621 MUSTTAIL return InterpNext(S);
55622#else
55623 return true;
55624#endif
55625}
55626PRESERVE_NONE
55627static bool Interp_SubSint16(InterpState &S) {
55628 if (!Sub<PT_Sint16>(S, S.PC)) return false;
55629#if USE_TAILCALLS
55630 MUSTTAIL return InterpNext(S);
55631#else
55632 return true;
55633#endif
55634}
55635PRESERVE_NONE
55636static bool Interp_SubUint16(InterpState &S) {
55637 if (!Sub<PT_Uint16>(S, S.PC)) return false;
55638#if USE_TAILCALLS
55639 MUSTTAIL return InterpNext(S);
55640#else
55641 return true;
55642#endif
55643}
55644PRESERVE_NONE
55645static bool Interp_SubSint32(InterpState &S) {
55646 if (!Sub<PT_Sint32>(S, S.PC)) return false;
55647#if USE_TAILCALLS
55648 MUSTTAIL return InterpNext(S);
55649#else
55650 return true;
55651#endif
55652}
55653PRESERVE_NONE
55654static bool Interp_SubUint32(InterpState &S) {
55655 if (!Sub<PT_Uint32>(S, S.PC)) return false;
55656#if USE_TAILCALLS
55657 MUSTTAIL return InterpNext(S);
55658#else
55659 return true;
55660#endif
55661}
55662PRESERVE_NONE
55663static bool Interp_SubSint64(InterpState &S) {
55664 if (!Sub<PT_Sint64>(S, S.PC)) return false;
55665#if USE_TAILCALLS
55666 MUSTTAIL return InterpNext(S);
55667#else
55668 return true;
55669#endif
55670}
55671PRESERVE_NONE
55672static bool Interp_SubUint64(InterpState &S) {
55673 if (!Sub<PT_Uint64>(S, S.PC)) return false;
55674#if USE_TAILCALLS
55675 MUSTTAIL return InterpNext(S);
55676#else
55677 return true;
55678#endif
55679}
55680PRESERVE_NONE
55681static bool Interp_SubIntAP(InterpState &S) {
55682 if (!Sub<PT_IntAP>(S, S.PC)) return false;
55683#if USE_TAILCALLS
55684 MUSTTAIL return InterpNext(S);
55685#else
55686 return true;
55687#endif
55688}
55689PRESERVE_NONE
55690static bool Interp_SubIntAPS(InterpState &S) {
55691 if (!Sub<PT_IntAPS>(S, S.PC)) return false;
55692#if USE_TAILCALLS
55693 MUSTTAIL return InterpNext(S);
55694#else
55695 return true;
55696#endif
55697}
55698PRESERVE_NONE
55699static bool Interp_SubBool(InterpState &S) {
55700 if (!Sub<PT_Bool>(S, S.PC)) return false;
55701#if USE_TAILCALLS
55702 MUSTTAIL return InterpNext(S);
55703#else
55704 return true;
55705#endif
55706}
55707PRESERVE_NONE
55708static bool Interp_SubFixedPoint(InterpState &S) {
55709 if (!Sub<PT_FixedPoint>(S, S.PC)) return false;
55710#if USE_TAILCALLS
55711 MUSTTAIL return InterpNext(S);
55712#else
55713 return true;
55714#endif
55715}
55716#endif
55717#ifdef GET_DISASM
55718case OP_SubSint8:
55719 Text.Op = PrintName("SubSint8");
55720 break;
55721case OP_SubUint8:
55722 Text.Op = PrintName("SubUint8");
55723 break;
55724case OP_SubSint16:
55725 Text.Op = PrintName("SubSint16");
55726 break;
55727case OP_SubUint16:
55728 Text.Op = PrintName("SubUint16");
55729 break;
55730case OP_SubSint32:
55731 Text.Op = PrintName("SubSint32");
55732 break;
55733case OP_SubUint32:
55734 Text.Op = PrintName("SubUint32");
55735 break;
55736case OP_SubSint64:
55737 Text.Op = PrintName("SubSint64");
55738 break;
55739case OP_SubUint64:
55740 Text.Op = PrintName("SubUint64");
55741 break;
55742case OP_SubIntAP:
55743 Text.Op = PrintName("SubIntAP");
55744 break;
55745case OP_SubIntAPS:
55746 Text.Op = PrintName("SubIntAPS");
55747 break;
55748case OP_SubBool:
55749 Text.Op = PrintName("SubBool");
55750 break;
55751case OP_SubFixedPoint:
55752 Text.Op = PrintName("SubFixedPoint");
55753 break;
55754#endif
55755#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
55756bool emitSubSint8(SourceInfo);
55757bool emitSubUint8(SourceInfo);
55758bool emitSubSint16(SourceInfo);
55759bool emitSubUint16(SourceInfo);
55760bool emitSubSint32(SourceInfo);
55761bool emitSubUint32(SourceInfo);
55762bool emitSubSint64(SourceInfo);
55763bool emitSubUint64(SourceInfo);
55764bool emitSubIntAP(SourceInfo);
55765bool emitSubIntAPS(SourceInfo);
55766bool emitSubBool(SourceInfo);
55767bool emitSubFixedPoint(SourceInfo);
55768#endif
55769#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
55770[[nodiscard]] bool emitSub(PrimType, SourceInfo I);
55771#endif
55772#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
55773bool
55774#if defined(GET_EVAL_IMPL)
55775EvalEmitter
55776#else
55777ByteCodeEmitter
55778#endif
55779::emitSub(PrimType T0, SourceInfo I) {
55780 switch (T0) {
55781 case PT_Sint8:
55782 return emitSubSint8(I);
55783 case PT_Uint8:
55784 return emitSubUint8(I);
55785 case PT_Sint16:
55786 return emitSubSint16(I);
55787 case PT_Uint16:
55788 return emitSubUint16(I);
55789 case PT_Sint32:
55790 return emitSubSint32(I);
55791 case PT_Uint32:
55792 return emitSubUint32(I);
55793 case PT_Sint64:
55794 return emitSubSint64(I);
55795 case PT_Uint64:
55796 return emitSubUint64(I);
55797 case PT_IntAP:
55798 return emitSubIntAP(I);
55799 case PT_IntAPS:
55800 return emitSubIntAPS(I);
55801 case PT_Bool:
55802 return emitSubBool(I);
55803 case PT_FixedPoint:
55804 return emitSubFixedPoint(I);
55805 default: llvm_unreachable("invalid type: emitSub");
55806 }
55807 llvm_unreachable("invalid enum value");
55808}
55809#endif
55810#ifdef GET_LINK_IMPL
55811bool ByteCodeEmitter::emitSubSint8(SourceInfo L) {
55812 return emitOp<>(OP_SubSint8, L);
55813}
55814bool ByteCodeEmitter::emitSubUint8(SourceInfo L) {
55815 return emitOp<>(OP_SubUint8, L);
55816}
55817bool ByteCodeEmitter::emitSubSint16(SourceInfo L) {
55818 return emitOp<>(OP_SubSint16, L);
55819}
55820bool ByteCodeEmitter::emitSubUint16(SourceInfo L) {
55821 return emitOp<>(OP_SubUint16, L);
55822}
55823bool ByteCodeEmitter::emitSubSint32(SourceInfo L) {
55824 return emitOp<>(OP_SubSint32, L);
55825}
55826bool ByteCodeEmitter::emitSubUint32(SourceInfo L) {
55827 return emitOp<>(OP_SubUint32, L);
55828}
55829bool ByteCodeEmitter::emitSubSint64(SourceInfo L) {
55830 return emitOp<>(OP_SubSint64, L);
55831}
55832bool ByteCodeEmitter::emitSubUint64(SourceInfo L) {
55833 return emitOp<>(OP_SubUint64, L);
55834}
55835bool ByteCodeEmitter::emitSubIntAP(SourceInfo L) {
55836 return emitOp<>(OP_SubIntAP, L);
55837}
55838bool ByteCodeEmitter::emitSubIntAPS(SourceInfo L) {
55839 return emitOp<>(OP_SubIntAPS, L);
55840}
55841bool ByteCodeEmitter::emitSubBool(SourceInfo L) {
55842 return emitOp<>(OP_SubBool, L);
55843}
55844bool ByteCodeEmitter::emitSubFixedPoint(SourceInfo L) {
55845 return emitOp<>(OP_SubFixedPoint, L);
55846}
55847#endif
55848#ifdef GET_EVAL_IMPL
55849bool EvalEmitter::emitSubSint8(SourceInfo L) {
55850 if (!isActive()) return true;
55851 CurrentSource = L;
55852 return Sub<PT_Sint8>(S, CodePtr());
55853}
55854bool EvalEmitter::emitSubUint8(SourceInfo L) {
55855 if (!isActive()) return true;
55856 CurrentSource = L;
55857 return Sub<PT_Uint8>(S, CodePtr());
55858}
55859bool EvalEmitter::emitSubSint16(SourceInfo L) {
55860 if (!isActive()) return true;
55861 CurrentSource = L;
55862 return Sub<PT_Sint16>(S, CodePtr());
55863}
55864bool EvalEmitter::emitSubUint16(SourceInfo L) {
55865 if (!isActive()) return true;
55866 CurrentSource = L;
55867 return Sub<PT_Uint16>(S, CodePtr());
55868}
55869bool EvalEmitter::emitSubSint32(SourceInfo L) {
55870 if (!isActive()) return true;
55871 CurrentSource = L;
55872 return Sub<PT_Sint32>(S, CodePtr());
55873}
55874bool EvalEmitter::emitSubUint32(SourceInfo L) {
55875 if (!isActive()) return true;
55876 CurrentSource = L;
55877 return Sub<PT_Uint32>(S, CodePtr());
55878}
55879bool EvalEmitter::emitSubSint64(SourceInfo L) {
55880 if (!isActive()) return true;
55881 CurrentSource = L;
55882 return Sub<PT_Sint64>(S, CodePtr());
55883}
55884bool EvalEmitter::emitSubUint64(SourceInfo L) {
55885 if (!isActive()) return true;
55886 CurrentSource = L;
55887 return Sub<PT_Uint64>(S, CodePtr());
55888}
55889bool EvalEmitter::emitSubIntAP(SourceInfo L) {
55890 if (!isActive()) return true;
55891 CurrentSource = L;
55892 return Sub<PT_IntAP>(S, CodePtr());
55893}
55894bool EvalEmitter::emitSubIntAPS(SourceInfo L) {
55895 if (!isActive()) return true;
55896 CurrentSource = L;
55897 return Sub<PT_IntAPS>(S, CodePtr());
55898}
55899bool EvalEmitter::emitSubBool(SourceInfo L) {
55900 if (!isActive()) return true;
55901 CurrentSource = L;
55902 return Sub<PT_Bool>(S, CodePtr());
55903}
55904bool EvalEmitter::emitSubFixedPoint(SourceInfo L) {
55905 if (!isActive()) return true;
55906 CurrentSource = L;
55907 return Sub<PT_FixedPoint>(S, CodePtr());
55908}
55909#endif
55910#ifdef GET_OPCODE_NAMES
55911OP_SubOffsetSint8,
55912OP_SubOffsetUint8,
55913OP_SubOffsetSint16,
55914OP_SubOffsetUint16,
55915OP_SubOffsetSint32,
55916OP_SubOffsetUint32,
55917OP_SubOffsetSint64,
55918OP_SubOffsetUint64,
55919OP_SubOffsetIntAP,
55920OP_SubOffsetIntAPS,
55921OP_SubOffsetBool,
55922#endif
55923#ifdef GET_INTERPFN_LIST
55924&Interp_SubOffsetSint8,
55925&Interp_SubOffsetUint8,
55926&Interp_SubOffsetSint16,
55927&Interp_SubOffsetUint16,
55928&Interp_SubOffsetSint32,
55929&Interp_SubOffsetUint32,
55930&Interp_SubOffsetSint64,
55931&Interp_SubOffsetUint64,
55932&Interp_SubOffsetIntAP,
55933&Interp_SubOffsetIntAPS,
55934&Interp_SubOffsetBool,
55935#endif
55936#ifdef GET_INTERPFN_DISPATCHERS
55937PRESERVE_NONE
55938static bool Interp_SubOffsetSint8(InterpState &S) {
55939 if (!SubOffset<PT_Sint8>(S, S.PC)) return false;
55940#if USE_TAILCALLS
55941 MUSTTAIL return InterpNext(S);
55942#else
55943 return true;
55944#endif
55945}
55946PRESERVE_NONE
55947static bool Interp_SubOffsetUint8(InterpState &S) {
55948 if (!SubOffset<PT_Uint8>(S, S.PC)) return false;
55949#if USE_TAILCALLS
55950 MUSTTAIL return InterpNext(S);
55951#else
55952 return true;
55953#endif
55954}
55955PRESERVE_NONE
55956static bool Interp_SubOffsetSint16(InterpState &S) {
55957 if (!SubOffset<PT_Sint16>(S, S.PC)) return false;
55958#if USE_TAILCALLS
55959 MUSTTAIL return InterpNext(S);
55960#else
55961 return true;
55962#endif
55963}
55964PRESERVE_NONE
55965static bool Interp_SubOffsetUint16(InterpState &S) {
55966 if (!SubOffset<PT_Uint16>(S, S.PC)) return false;
55967#if USE_TAILCALLS
55968 MUSTTAIL return InterpNext(S);
55969#else
55970 return true;
55971#endif
55972}
55973PRESERVE_NONE
55974static bool Interp_SubOffsetSint32(InterpState &S) {
55975 if (!SubOffset<PT_Sint32>(S, S.PC)) return false;
55976#if USE_TAILCALLS
55977 MUSTTAIL return InterpNext(S);
55978#else
55979 return true;
55980#endif
55981}
55982PRESERVE_NONE
55983static bool Interp_SubOffsetUint32(InterpState &S) {
55984 if (!SubOffset<PT_Uint32>(S, S.PC)) return false;
55985#if USE_TAILCALLS
55986 MUSTTAIL return InterpNext(S);
55987#else
55988 return true;
55989#endif
55990}
55991PRESERVE_NONE
55992static bool Interp_SubOffsetSint64(InterpState &S) {
55993 if (!SubOffset<PT_Sint64>(S, S.PC)) return false;
55994#if USE_TAILCALLS
55995 MUSTTAIL return InterpNext(S);
55996#else
55997 return true;
55998#endif
55999}
56000PRESERVE_NONE
56001static bool Interp_SubOffsetUint64(InterpState &S) {
56002 if (!SubOffset<PT_Uint64>(S, S.PC)) return false;
56003#if USE_TAILCALLS
56004 MUSTTAIL return InterpNext(S);
56005#else
56006 return true;
56007#endif
56008}
56009PRESERVE_NONE
56010static bool Interp_SubOffsetIntAP(InterpState &S) {
56011 if (!SubOffset<PT_IntAP>(S, S.PC)) return false;
56012#if USE_TAILCALLS
56013 MUSTTAIL return InterpNext(S);
56014#else
56015 return true;
56016#endif
56017}
56018PRESERVE_NONE
56019static bool Interp_SubOffsetIntAPS(InterpState &S) {
56020 if (!SubOffset<PT_IntAPS>(S, S.PC)) return false;
56021#if USE_TAILCALLS
56022 MUSTTAIL return InterpNext(S);
56023#else
56024 return true;
56025#endif
56026}
56027PRESERVE_NONE
56028static bool Interp_SubOffsetBool(InterpState &S) {
56029 if (!SubOffset<PT_Bool>(S, S.PC)) return false;
56030#if USE_TAILCALLS
56031 MUSTTAIL return InterpNext(S);
56032#else
56033 return true;
56034#endif
56035}
56036#endif
56037#ifdef GET_DISASM
56038case OP_SubOffsetSint8:
56039 Text.Op = PrintName("SubOffsetSint8");
56040 break;
56041case OP_SubOffsetUint8:
56042 Text.Op = PrintName("SubOffsetUint8");
56043 break;
56044case OP_SubOffsetSint16:
56045 Text.Op = PrintName("SubOffsetSint16");
56046 break;
56047case OP_SubOffsetUint16:
56048 Text.Op = PrintName("SubOffsetUint16");
56049 break;
56050case OP_SubOffsetSint32:
56051 Text.Op = PrintName("SubOffsetSint32");
56052 break;
56053case OP_SubOffsetUint32:
56054 Text.Op = PrintName("SubOffsetUint32");
56055 break;
56056case OP_SubOffsetSint64:
56057 Text.Op = PrintName("SubOffsetSint64");
56058 break;
56059case OP_SubOffsetUint64:
56060 Text.Op = PrintName("SubOffsetUint64");
56061 break;
56062case OP_SubOffsetIntAP:
56063 Text.Op = PrintName("SubOffsetIntAP");
56064 break;
56065case OP_SubOffsetIntAPS:
56066 Text.Op = PrintName("SubOffsetIntAPS");
56067 break;
56068case OP_SubOffsetBool:
56069 Text.Op = PrintName("SubOffsetBool");
56070 break;
56071#endif
56072#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56073bool emitSubOffsetSint8(SourceInfo);
56074bool emitSubOffsetUint8(SourceInfo);
56075bool emitSubOffsetSint16(SourceInfo);
56076bool emitSubOffsetUint16(SourceInfo);
56077bool emitSubOffsetSint32(SourceInfo);
56078bool emitSubOffsetUint32(SourceInfo);
56079bool emitSubOffsetSint64(SourceInfo);
56080bool emitSubOffsetUint64(SourceInfo);
56081bool emitSubOffsetIntAP(SourceInfo);
56082bool emitSubOffsetIntAPS(SourceInfo);
56083bool emitSubOffsetBool(SourceInfo);
56084#endif
56085#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56086[[nodiscard]] bool emitSubOffset(PrimType, SourceInfo I);
56087#endif
56088#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
56089bool
56090#if defined(GET_EVAL_IMPL)
56091EvalEmitter
56092#else
56093ByteCodeEmitter
56094#endif
56095::emitSubOffset(PrimType T0, SourceInfo I) {
56096 switch (T0) {
56097 case PT_Sint8:
56098 return emitSubOffsetSint8(I);
56099 case PT_Uint8:
56100 return emitSubOffsetUint8(I);
56101 case PT_Sint16:
56102 return emitSubOffsetSint16(I);
56103 case PT_Uint16:
56104 return emitSubOffsetUint16(I);
56105 case PT_Sint32:
56106 return emitSubOffsetSint32(I);
56107 case PT_Uint32:
56108 return emitSubOffsetUint32(I);
56109 case PT_Sint64:
56110 return emitSubOffsetSint64(I);
56111 case PT_Uint64:
56112 return emitSubOffsetUint64(I);
56113 case PT_IntAP:
56114 return emitSubOffsetIntAP(I);
56115 case PT_IntAPS:
56116 return emitSubOffsetIntAPS(I);
56117 case PT_Bool:
56118 return emitSubOffsetBool(I);
56119 default: llvm_unreachable("invalid type: emitSubOffset");
56120 }
56121 llvm_unreachable("invalid enum value");
56122}
56123#endif
56124#ifdef GET_LINK_IMPL
56125bool ByteCodeEmitter::emitSubOffsetSint8(SourceInfo L) {
56126 return emitOp<>(OP_SubOffsetSint8, L);
56127}
56128bool ByteCodeEmitter::emitSubOffsetUint8(SourceInfo L) {
56129 return emitOp<>(OP_SubOffsetUint8, L);
56130}
56131bool ByteCodeEmitter::emitSubOffsetSint16(SourceInfo L) {
56132 return emitOp<>(OP_SubOffsetSint16, L);
56133}
56134bool ByteCodeEmitter::emitSubOffsetUint16(SourceInfo L) {
56135 return emitOp<>(OP_SubOffsetUint16, L);
56136}
56137bool ByteCodeEmitter::emitSubOffsetSint32(SourceInfo L) {
56138 return emitOp<>(OP_SubOffsetSint32, L);
56139}
56140bool ByteCodeEmitter::emitSubOffsetUint32(SourceInfo L) {
56141 return emitOp<>(OP_SubOffsetUint32, L);
56142}
56143bool ByteCodeEmitter::emitSubOffsetSint64(SourceInfo L) {
56144 return emitOp<>(OP_SubOffsetSint64, L);
56145}
56146bool ByteCodeEmitter::emitSubOffsetUint64(SourceInfo L) {
56147 return emitOp<>(OP_SubOffsetUint64, L);
56148}
56149bool ByteCodeEmitter::emitSubOffsetIntAP(SourceInfo L) {
56150 return emitOp<>(OP_SubOffsetIntAP, L);
56151}
56152bool ByteCodeEmitter::emitSubOffsetIntAPS(SourceInfo L) {
56153 return emitOp<>(OP_SubOffsetIntAPS, L);
56154}
56155bool ByteCodeEmitter::emitSubOffsetBool(SourceInfo L) {
56156 return emitOp<>(OP_SubOffsetBool, L);
56157}
56158#endif
56159#ifdef GET_EVAL_IMPL
56160bool EvalEmitter::emitSubOffsetSint8(SourceInfo L) {
56161 if (!isActive()) return true;
56162 CurrentSource = L;
56163 return SubOffset<PT_Sint8>(S, CodePtr());
56164}
56165bool EvalEmitter::emitSubOffsetUint8(SourceInfo L) {
56166 if (!isActive()) return true;
56167 CurrentSource = L;
56168 return SubOffset<PT_Uint8>(S, CodePtr());
56169}
56170bool EvalEmitter::emitSubOffsetSint16(SourceInfo L) {
56171 if (!isActive()) return true;
56172 CurrentSource = L;
56173 return SubOffset<PT_Sint16>(S, CodePtr());
56174}
56175bool EvalEmitter::emitSubOffsetUint16(SourceInfo L) {
56176 if (!isActive()) return true;
56177 CurrentSource = L;
56178 return SubOffset<PT_Uint16>(S, CodePtr());
56179}
56180bool EvalEmitter::emitSubOffsetSint32(SourceInfo L) {
56181 if (!isActive()) return true;
56182 CurrentSource = L;
56183 return SubOffset<PT_Sint32>(S, CodePtr());
56184}
56185bool EvalEmitter::emitSubOffsetUint32(SourceInfo L) {
56186 if (!isActive()) return true;
56187 CurrentSource = L;
56188 return SubOffset<PT_Uint32>(S, CodePtr());
56189}
56190bool EvalEmitter::emitSubOffsetSint64(SourceInfo L) {
56191 if (!isActive()) return true;
56192 CurrentSource = L;
56193 return SubOffset<PT_Sint64>(S, CodePtr());
56194}
56195bool EvalEmitter::emitSubOffsetUint64(SourceInfo L) {
56196 if (!isActive()) return true;
56197 CurrentSource = L;
56198 return SubOffset<PT_Uint64>(S, CodePtr());
56199}
56200bool EvalEmitter::emitSubOffsetIntAP(SourceInfo L) {
56201 if (!isActive()) return true;
56202 CurrentSource = L;
56203 return SubOffset<PT_IntAP>(S, CodePtr());
56204}
56205bool EvalEmitter::emitSubOffsetIntAPS(SourceInfo L) {
56206 if (!isActive()) return true;
56207 CurrentSource = L;
56208 return SubOffset<PT_IntAPS>(S, CodePtr());
56209}
56210bool EvalEmitter::emitSubOffsetBool(SourceInfo L) {
56211 if (!isActive()) return true;
56212 CurrentSource = L;
56213 return SubOffset<PT_Bool>(S, CodePtr());
56214}
56215#endif
56216#ifdef GET_OPCODE_NAMES
56217OP_SubPtrSint8,
56218OP_SubPtrUint8,
56219OP_SubPtrSint16,
56220OP_SubPtrUint16,
56221OP_SubPtrSint32,
56222OP_SubPtrUint32,
56223OP_SubPtrSint64,
56224OP_SubPtrUint64,
56225OP_SubPtrIntAP,
56226OP_SubPtrIntAPS,
56227#endif
56228#ifdef GET_INTERPFN_LIST
56229&Interp_SubPtrSint8,
56230&Interp_SubPtrUint8,
56231&Interp_SubPtrSint16,
56232&Interp_SubPtrUint16,
56233&Interp_SubPtrSint32,
56234&Interp_SubPtrUint32,
56235&Interp_SubPtrSint64,
56236&Interp_SubPtrUint64,
56237&Interp_SubPtrIntAP,
56238&Interp_SubPtrIntAPS,
56239#endif
56240#ifdef GET_INTERPFN_DISPATCHERS
56241PRESERVE_NONE
56242static bool Interp_SubPtrSint8(InterpState &S) {
56243 {
56244 CodePtr OpPC = S.PC;
56245 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56246 if (!SubPtr<PT_Sint8>(S, OpPC, V0)) return false;
56247 }
56248#if USE_TAILCALLS
56249 MUSTTAIL return InterpNext(S);
56250#else
56251 return true;
56252#endif
56253}
56254PRESERVE_NONE
56255static bool Interp_SubPtrUint8(InterpState &S) {
56256 {
56257 CodePtr OpPC = S.PC;
56258 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56259 if (!SubPtr<PT_Uint8>(S, OpPC, V0)) return false;
56260 }
56261#if USE_TAILCALLS
56262 MUSTTAIL return InterpNext(S);
56263#else
56264 return true;
56265#endif
56266}
56267PRESERVE_NONE
56268static bool Interp_SubPtrSint16(InterpState &S) {
56269 {
56270 CodePtr OpPC = S.PC;
56271 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56272 if (!SubPtr<PT_Sint16>(S, OpPC, V0)) return false;
56273 }
56274#if USE_TAILCALLS
56275 MUSTTAIL return InterpNext(S);
56276#else
56277 return true;
56278#endif
56279}
56280PRESERVE_NONE
56281static bool Interp_SubPtrUint16(InterpState &S) {
56282 {
56283 CodePtr OpPC = S.PC;
56284 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56285 if (!SubPtr<PT_Uint16>(S, OpPC, V0)) return false;
56286 }
56287#if USE_TAILCALLS
56288 MUSTTAIL return InterpNext(S);
56289#else
56290 return true;
56291#endif
56292}
56293PRESERVE_NONE
56294static bool Interp_SubPtrSint32(InterpState &S) {
56295 {
56296 CodePtr OpPC = S.PC;
56297 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56298 if (!SubPtr<PT_Sint32>(S, OpPC, V0)) return false;
56299 }
56300#if USE_TAILCALLS
56301 MUSTTAIL return InterpNext(S);
56302#else
56303 return true;
56304#endif
56305}
56306PRESERVE_NONE
56307static bool Interp_SubPtrUint32(InterpState &S) {
56308 {
56309 CodePtr OpPC = S.PC;
56310 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56311 if (!SubPtr<PT_Uint32>(S, OpPC, V0)) return false;
56312 }
56313#if USE_TAILCALLS
56314 MUSTTAIL return InterpNext(S);
56315#else
56316 return true;
56317#endif
56318}
56319PRESERVE_NONE
56320static bool Interp_SubPtrSint64(InterpState &S) {
56321 {
56322 CodePtr OpPC = S.PC;
56323 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56324 if (!SubPtr<PT_Sint64>(S, OpPC, V0)) return false;
56325 }
56326#if USE_TAILCALLS
56327 MUSTTAIL return InterpNext(S);
56328#else
56329 return true;
56330#endif
56331}
56332PRESERVE_NONE
56333static bool Interp_SubPtrUint64(InterpState &S) {
56334 {
56335 CodePtr OpPC = S.PC;
56336 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56337 if (!SubPtr<PT_Uint64>(S, OpPC, V0)) return false;
56338 }
56339#if USE_TAILCALLS
56340 MUSTTAIL return InterpNext(S);
56341#else
56342 return true;
56343#endif
56344}
56345PRESERVE_NONE
56346static bool Interp_SubPtrIntAP(InterpState &S) {
56347 {
56348 CodePtr OpPC = S.PC;
56349 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56350 if (!SubPtr<PT_IntAP>(S, OpPC, V0)) return false;
56351 }
56352#if USE_TAILCALLS
56353 MUSTTAIL return InterpNext(S);
56354#else
56355 return true;
56356#endif
56357}
56358PRESERVE_NONE
56359static bool Interp_SubPtrIntAPS(InterpState &S) {
56360 {
56361 CodePtr OpPC = S.PC;
56362 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56363 if (!SubPtr<PT_IntAPS>(S, OpPC, V0)) return false;
56364 }
56365#if USE_TAILCALLS
56366 MUSTTAIL return InterpNext(S);
56367#else
56368 return true;
56369#endif
56370}
56371#endif
56372#ifdef GET_DISASM
56373case OP_SubPtrSint8:
56374 Text.Op = PrintName("SubPtrSint8");
56375 Text.Args.push_back(printArg<uint32_t>(PC));
56376 break;
56377case OP_SubPtrUint8:
56378 Text.Op = PrintName("SubPtrUint8");
56379 Text.Args.push_back(printArg<uint32_t>(PC));
56380 break;
56381case OP_SubPtrSint16:
56382 Text.Op = PrintName("SubPtrSint16");
56383 Text.Args.push_back(printArg<uint32_t>(PC));
56384 break;
56385case OP_SubPtrUint16:
56386 Text.Op = PrintName("SubPtrUint16");
56387 Text.Args.push_back(printArg<uint32_t>(PC));
56388 break;
56389case OP_SubPtrSint32:
56390 Text.Op = PrintName("SubPtrSint32");
56391 Text.Args.push_back(printArg<uint32_t>(PC));
56392 break;
56393case OP_SubPtrUint32:
56394 Text.Op = PrintName("SubPtrUint32");
56395 Text.Args.push_back(printArg<uint32_t>(PC));
56396 break;
56397case OP_SubPtrSint64:
56398 Text.Op = PrintName("SubPtrSint64");
56399 Text.Args.push_back(printArg<uint32_t>(PC));
56400 break;
56401case OP_SubPtrUint64:
56402 Text.Op = PrintName("SubPtrUint64");
56403 Text.Args.push_back(printArg<uint32_t>(PC));
56404 break;
56405case OP_SubPtrIntAP:
56406 Text.Op = PrintName("SubPtrIntAP");
56407 Text.Args.push_back(printArg<uint32_t>(PC));
56408 break;
56409case OP_SubPtrIntAPS:
56410 Text.Op = PrintName("SubPtrIntAPS");
56411 Text.Args.push_back(printArg<uint32_t>(PC));
56412 break;
56413#endif
56414#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56415bool emitSubPtrSint8( uint32_t , SourceInfo);
56416bool emitSubPtrUint8( uint32_t , SourceInfo);
56417bool emitSubPtrSint16( uint32_t , SourceInfo);
56418bool emitSubPtrUint16( uint32_t , SourceInfo);
56419bool emitSubPtrSint32( uint32_t , SourceInfo);
56420bool emitSubPtrUint32( uint32_t , SourceInfo);
56421bool emitSubPtrSint64( uint32_t , SourceInfo);
56422bool emitSubPtrUint64( uint32_t , SourceInfo);
56423bool emitSubPtrIntAP( uint32_t , SourceInfo);
56424bool emitSubPtrIntAPS( uint32_t , SourceInfo);
56425#endif
56426#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56427[[nodiscard]] bool emitSubPtr(PrimType, uint32_t, SourceInfo I);
56428#endif
56429#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
56430bool
56431#if defined(GET_EVAL_IMPL)
56432EvalEmitter
56433#else
56434ByteCodeEmitter
56435#endif
56436::emitSubPtr(PrimType T0, uint32_t A0, SourceInfo I) {
56437 switch (T0) {
56438 case PT_Sint8:
56439 return emitSubPtrSint8(A0, I);
56440 case PT_Uint8:
56441 return emitSubPtrUint8(A0, I);
56442 case PT_Sint16:
56443 return emitSubPtrSint16(A0, I);
56444 case PT_Uint16:
56445 return emitSubPtrUint16(A0, I);
56446 case PT_Sint32:
56447 return emitSubPtrSint32(A0, I);
56448 case PT_Uint32:
56449 return emitSubPtrUint32(A0, I);
56450 case PT_Sint64:
56451 return emitSubPtrSint64(A0, I);
56452 case PT_Uint64:
56453 return emitSubPtrUint64(A0, I);
56454 case PT_IntAP:
56455 return emitSubPtrIntAP(A0, I);
56456 case PT_IntAPS:
56457 return emitSubPtrIntAPS(A0, I);
56458 default: llvm_unreachable("invalid type: emitSubPtr");
56459 }
56460 llvm_unreachable("invalid enum value");
56461}
56462#endif
56463#ifdef GET_LINK_IMPL
56464bool ByteCodeEmitter::emitSubPtrSint8( uint32_t A0, SourceInfo L) {
56465 return emitOp<uint32_t>(OP_SubPtrSint8, A0, L);
56466}
56467bool ByteCodeEmitter::emitSubPtrUint8( uint32_t A0, SourceInfo L) {
56468 return emitOp<uint32_t>(OP_SubPtrUint8, A0, L);
56469}
56470bool ByteCodeEmitter::emitSubPtrSint16( uint32_t A0, SourceInfo L) {
56471 return emitOp<uint32_t>(OP_SubPtrSint16, A0, L);
56472}
56473bool ByteCodeEmitter::emitSubPtrUint16( uint32_t A0, SourceInfo L) {
56474 return emitOp<uint32_t>(OP_SubPtrUint16, A0, L);
56475}
56476bool ByteCodeEmitter::emitSubPtrSint32( uint32_t A0, SourceInfo L) {
56477 return emitOp<uint32_t>(OP_SubPtrSint32, A0, L);
56478}
56479bool ByteCodeEmitter::emitSubPtrUint32( uint32_t A0, SourceInfo L) {
56480 return emitOp<uint32_t>(OP_SubPtrUint32, A0, L);
56481}
56482bool ByteCodeEmitter::emitSubPtrSint64( uint32_t A0, SourceInfo L) {
56483 return emitOp<uint32_t>(OP_SubPtrSint64, A0, L);
56484}
56485bool ByteCodeEmitter::emitSubPtrUint64( uint32_t A0, SourceInfo L) {
56486 return emitOp<uint32_t>(OP_SubPtrUint64, A0, L);
56487}
56488bool ByteCodeEmitter::emitSubPtrIntAP( uint32_t A0, SourceInfo L) {
56489 return emitOp<uint32_t>(OP_SubPtrIntAP, A0, L);
56490}
56491bool ByteCodeEmitter::emitSubPtrIntAPS( uint32_t A0, SourceInfo L) {
56492 return emitOp<uint32_t>(OP_SubPtrIntAPS, A0, L);
56493}
56494#endif
56495#ifdef GET_EVAL_IMPL
56496bool EvalEmitter::emitSubPtrSint8( uint32_t A0, SourceInfo L) {
56497 if (!isActive()) return true;
56498 CurrentSource = L;
56499 return SubPtr<PT_Sint8>(S, CodePtr(), A0);
56500}
56501bool EvalEmitter::emitSubPtrUint8( uint32_t A0, SourceInfo L) {
56502 if (!isActive()) return true;
56503 CurrentSource = L;
56504 return SubPtr<PT_Uint8>(S, CodePtr(), A0);
56505}
56506bool EvalEmitter::emitSubPtrSint16( uint32_t A0, SourceInfo L) {
56507 if (!isActive()) return true;
56508 CurrentSource = L;
56509 return SubPtr<PT_Sint16>(S, CodePtr(), A0);
56510}
56511bool EvalEmitter::emitSubPtrUint16( uint32_t A0, SourceInfo L) {
56512 if (!isActive()) return true;
56513 CurrentSource = L;
56514 return SubPtr<PT_Uint16>(S, CodePtr(), A0);
56515}
56516bool EvalEmitter::emitSubPtrSint32( uint32_t A0, SourceInfo L) {
56517 if (!isActive()) return true;
56518 CurrentSource = L;
56519 return SubPtr<PT_Sint32>(S, CodePtr(), A0);
56520}
56521bool EvalEmitter::emitSubPtrUint32( uint32_t A0, SourceInfo L) {
56522 if (!isActive()) return true;
56523 CurrentSource = L;
56524 return SubPtr<PT_Uint32>(S, CodePtr(), A0);
56525}
56526bool EvalEmitter::emitSubPtrSint64( uint32_t A0, SourceInfo L) {
56527 if (!isActive()) return true;
56528 CurrentSource = L;
56529 return SubPtr<PT_Sint64>(S, CodePtr(), A0);
56530}
56531bool EvalEmitter::emitSubPtrUint64( uint32_t A0, SourceInfo L) {
56532 if (!isActive()) return true;
56533 CurrentSource = L;
56534 return SubPtr<PT_Uint64>(S, CodePtr(), A0);
56535}
56536bool EvalEmitter::emitSubPtrIntAP( uint32_t A0, SourceInfo L) {
56537 if (!isActive()) return true;
56538 CurrentSource = L;
56539 return SubPtr<PT_IntAP>(S, CodePtr(), A0);
56540}
56541bool EvalEmitter::emitSubPtrIntAPS( uint32_t A0, SourceInfo L) {
56542 if (!isActive()) return true;
56543 CurrentSource = L;
56544 return SubPtr<PT_IntAPS>(S, CodePtr(), A0);
56545}
56546#endif
56547#ifdef GET_OPCODE_NAMES
56548OP_Subf,
56549#endif
56550#ifdef GET_INTERPFN_LIST
56551&Interp_Subf,
56552#endif
56553#ifdef GET_INTERPFN_DISPATCHERS
56554PRESERVE_NONE
56555static bool Interp_Subf(InterpState &S) {
56556 {
56557 CodePtr OpPC = S.PC;
56558 const auto V0 = ReadArg<uint32_t>(S, S.PC);
56559 if (!Subf(S, OpPC, V0)) return false;
56560 }
56561#if USE_TAILCALLS
56562 MUSTTAIL return InterpNext(S);
56563#else
56564 return true;
56565#endif
56566}
56567#endif
56568#ifdef GET_DISASM
56569case OP_Subf:
56570 Text.Op = PrintName("Subf");
56571 Text.Args.push_back(printArg<uint32_t>(PC));
56572 break;
56573#endif
56574#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56575bool emitSubf( uint32_t , SourceInfo);
56576#endif
56577#ifdef GET_LINK_IMPL
56578bool ByteCodeEmitter::emitSubf( uint32_t A0, SourceInfo L) {
56579 return emitOp<uint32_t>(OP_Subf, A0, L);
56580}
56581#endif
56582#ifdef GET_EVAL_IMPL
56583bool EvalEmitter::emitSubf( uint32_t A0, SourceInfo L) {
56584 if (!isActive()) return true;
56585 CurrentSource = L;
56586 return Subf(S, CodePtr(), A0);
56587}
56588#endif
56589#ifdef GET_OPCODE_NAMES
56590OP_This,
56591#endif
56592#ifdef GET_INTERPFN_LIST
56593&Interp_This,
56594#endif
56595#ifdef GET_INTERPFN_DISPATCHERS
56596PRESERVE_NONE
56597static bool Interp_This(InterpState &S) {
56598 if (!This(S, S.PC)) return false;
56599#if USE_TAILCALLS
56600 MUSTTAIL return InterpNext(S);
56601#else
56602 return true;
56603#endif
56604}
56605#endif
56606#ifdef GET_DISASM
56607case OP_This:
56608 Text.Op = PrintName("This");
56609 break;
56610#endif
56611#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56612bool emitThis(SourceInfo);
56613#endif
56614#ifdef GET_LINK_IMPL
56615bool ByteCodeEmitter::emitThis(SourceInfo L) {
56616 return emitOp<>(OP_This, L);
56617}
56618#endif
56619#ifdef GET_EVAL_IMPL
56620bool EvalEmitter::emitThis(SourceInfo L) {
56621 if (!isActive()) return true;
56622 CurrentSource = L;
56623 return This(S, CodePtr());
56624}
56625#endif
56626#ifdef GET_OPCODE_NAMES
56627OP_ToMemberPtr,
56628#endif
56629#ifdef GET_INTERPFN_LIST
56630&Interp_ToMemberPtr,
56631#endif
56632#ifdef GET_INTERPFN_DISPATCHERS
56633PRESERVE_NONE
56634static bool Interp_ToMemberPtr(InterpState &S) {
56635 ToMemberPtr(S);
56636#if USE_TAILCALLS
56637 MUSTTAIL return InterpNext(S);
56638#else
56639 return true;
56640#endif
56641}
56642#endif
56643#ifdef GET_DISASM
56644case OP_ToMemberPtr:
56645 Text.Op = PrintName("ToMemberPtr");
56646 break;
56647#endif
56648#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56649bool emitToMemberPtr(SourceInfo);
56650#endif
56651#ifdef GET_LINK_IMPL
56652bool ByteCodeEmitter::emitToMemberPtr(SourceInfo L) {
56653 return emitOp<>(OP_ToMemberPtr, L);
56654}
56655#endif
56656#ifdef GET_EVAL_IMPL
56657bool EvalEmitter::emitToMemberPtr(SourceInfo L) {
56658 if (!isActive()) return true;
56659 CurrentSource = L;
56660 return ToMemberPtr(S);
56661}
56662#endif
56663#ifdef GET_OPCODE_NAMES
56664OP_TrivialCopy,
56665#endif
56666#ifdef GET_INTERPFN_LIST
56667&Interp_TrivialCopy,
56668#endif
56669#ifdef GET_INTERPFN_DISPATCHERS
56670PRESERVE_NONE
56671static bool Interp_TrivialCopy(InterpState &S) {
56672 {
56673 CodePtr OpPC = S.PC;
56674 const auto V0 = ReadArg<bool>(S, S.PC);
56675 const auto V1 = ReadArg<const Function *>(S, S.PC);
56676 if (!TrivialCopy(S, OpPC, V0, V1)) return false;
56677 }
56678#if USE_TAILCALLS
56679 MUSTTAIL return InterpNext(S);
56680#else
56681 return true;
56682#endif
56683}
56684#endif
56685#ifdef GET_DISASM
56686case OP_TrivialCopy:
56687 Text.Op = PrintName("TrivialCopy");
56688 Text.Args.push_back(printArg<bool>(PC));
56689 Text.Args.push_back(printArg<const Function *>(PC));
56690 break;
56691#endif
56692#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56693bool emitTrivialCopy( bool , const Function * , SourceInfo);
56694#endif
56695#ifdef GET_LINK_IMPL
56696bool ByteCodeEmitter::emitTrivialCopy( bool A0, const Function * A1, SourceInfo L) {
56697 return emitOp<bool, const Function *>(OP_TrivialCopy, A0, A1, L);
56698}
56699#endif
56700#ifdef GET_EVAL_IMPL
56701bool EvalEmitter::emitTrivialCopy( bool A0, const Function * A1, SourceInfo L) {
56702 if (!isActive()) return true;
56703 CurrentSource = L;
56704 return TrivialCopy(S, CodePtr(), A0, A1);
56705}
56706#endif
56707#ifdef GET_OPCODE_NAMES
56708OP_Unsupported,
56709#endif
56710#ifdef GET_INTERPFN_LIST
56711&Interp_Unsupported,
56712#endif
56713#ifdef GET_INTERPFN_DISPATCHERS
56714PRESERVE_NONE
56715static bool Interp_Unsupported(InterpState &S) {
56716 if (!Unsupported(S, S.PC)) return false;
56717#if USE_TAILCALLS
56718 MUSTTAIL return InterpNext(S);
56719#else
56720 return true;
56721#endif
56722}
56723#endif
56724#ifdef GET_DISASM
56725case OP_Unsupported:
56726 Text.Op = PrintName("Unsupported");
56727 break;
56728#endif
56729#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56730bool emitUnsupported(SourceInfo);
56731#endif
56732#ifdef GET_LINK_IMPL
56733bool ByteCodeEmitter::emitUnsupported(SourceInfo L) {
56734 return emitOp<>(OP_Unsupported, L);
56735}
56736#endif
56737#ifdef GET_EVAL_IMPL
56738bool EvalEmitter::emitUnsupported(SourceInfo L) {
56739 if (!isActive()) return true;
56740 CurrentSource = L;
56741 return Unsupported(S, CodePtr());
56742}
56743#endif
56744#ifdef GET_OPCODE_NAMES
56745OP_ZeroSint8,
56746OP_ZeroUint8,
56747OP_ZeroSint16,
56748OP_ZeroUint16,
56749OP_ZeroSint32,
56750OP_ZeroUint32,
56751OP_ZeroSint64,
56752OP_ZeroUint64,
56753OP_ZeroBool,
56754#endif
56755#ifdef GET_INTERPFN_LIST
56756&Interp_ZeroSint8,
56757&Interp_ZeroUint8,
56758&Interp_ZeroSint16,
56759&Interp_ZeroUint16,
56760&Interp_ZeroSint32,
56761&Interp_ZeroUint32,
56762&Interp_ZeroSint64,
56763&Interp_ZeroUint64,
56764&Interp_ZeroBool,
56765#endif
56766#ifdef GET_INTERPFN_DISPATCHERS
56767PRESERVE_NONE
56768static bool Interp_ZeroSint8(InterpState &S) {
56769 Zero<PT_Sint8>(S);
56770#if USE_TAILCALLS
56771 MUSTTAIL return InterpNext(S);
56772#else
56773 return true;
56774#endif
56775}
56776PRESERVE_NONE
56777static bool Interp_ZeroUint8(InterpState &S) {
56778 Zero<PT_Uint8>(S);
56779#if USE_TAILCALLS
56780 MUSTTAIL return InterpNext(S);
56781#else
56782 return true;
56783#endif
56784}
56785PRESERVE_NONE
56786static bool Interp_ZeroSint16(InterpState &S) {
56787 Zero<PT_Sint16>(S);
56788#if USE_TAILCALLS
56789 MUSTTAIL return InterpNext(S);
56790#else
56791 return true;
56792#endif
56793}
56794PRESERVE_NONE
56795static bool Interp_ZeroUint16(InterpState &S) {
56796 Zero<PT_Uint16>(S);
56797#if USE_TAILCALLS
56798 MUSTTAIL return InterpNext(S);
56799#else
56800 return true;
56801#endif
56802}
56803PRESERVE_NONE
56804static bool Interp_ZeroSint32(InterpState &S) {
56805 Zero<PT_Sint32>(S);
56806#if USE_TAILCALLS
56807 MUSTTAIL return InterpNext(S);
56808#else
56809 return true;
56810#endif
56811}
56812PRESERVE_NONE
56813static bool Interp_ZeroUint32(InterpState &S) {
56814 Zero<PT_Uint32>(S);
56815#if USE_TAILCALLS
56816 MUSTTAIL return InterpNext(S);
56817#else
56818 return true;
56819#endif
56820}
56821PRESERVE_NONE
56822static bool Interp_ZeroSint64(InterpState &S) {
56823 Zero<PT_Sint64>(S);
56824#if USE_TAILCALLS
56825 MUSTTAIL return InterpNext(S);
56826#else
56827 return true;
56828#endif
56829}
56830PRESERVE_NONE
56831static bool Interp_ZeroUint64(InterpState &S) {
56832 Zero<PT_Uint64>(S);
56833#if USE_TAILCALLS
56834 MUSTTAIL return InterpNext(S);
56835#else
56836 return true;
56837#endif
56838}
56839PRESERVE_NONE
56840static bool Interp_ZeroBool(InterpState &S) {
56841 Zero<PT_Bool>(S);
56842#if USE_TAILCALLS
56843 MUSTTAIL return InterpNext(S);
56844#else
56845 return true;
56846#endif
56847}
56848#endif
56849#ifdef GET_DISASM
56850case OP_ZeroSint8:
56851 Text.Op = PrintName("ZeroSint8");
56852 break;
56853case OP_ZeroUint8:
56854 Text.Op = PrintName("ZeroUint8");
56855 break;
56856case OP_ZeroSint16:
56857 Text.Op = PrintName("ZeroSint16");
56858 break;
56859case OP_ZeroUint16:
56860 Text.Op = PrintName("ZeroUint16");
56861 break;
56862case OP_ZeroSint32:
56863 Text.Op = PrintName("ZeroSint32");
56864 break;
56865case OP_ZeroUint32:
56866 Text.Op = PrintName("ZeroUint32");
56867 break;
56868case OP_ZeroSint64:
56869 Text.Op = PrintName("ZeroSint64");
56870 break;
56871case OP_ZeroUint64:
56872 Text.Op = PrintName("ZeroUint64");
56873 break;
56874case OP_ZeroBool:
56875 Text.Op = PrintName("ZeroBool");
56876 break;
56877#endif
56878#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56879bool emitZeroSint8(SourceInfo);
56880bool emitZeroUint8(SourceInfo);
56881bool emitZeroSint16(SourceInfo);
56882bool emitZeroUint16(SourceInfo);
56883bool emitZeroSint32(SourceInfo);
56884bool emitZeroUint32(SourceInfo);
56885bool emitZeroSint64(SourceInfo);
56886bool emitZeroUint64(SourceInfo);
56887bool emitZeroBool(SourceInfo);
56888#endif
56889#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
56890[[nodiscard]] bool emitZero(PrimType, SourceInfo I);
56891#endif
56892#if defined(GET_EVAL_IMPL) || defined(GET_LINK_IMPL)
56893bool
56894#if defined(GET_EVAL_IMPL)
56895EvalEmitter
56896#else
56897ByteCodeEmitter
56898#endif
56899::emitZero(PrimType T0, SourceInfo I) {
56900 switch (T0) {
56901 case PT_Sint8:
56902 return emitZeroSint8(I);
56903 case PT_Uint8:
56904 return emitZeroUint8(I);
56905 case PT_Sint16:
56906 return emitZeroSint16(I);
56907 case PT_Uint16:
56908 return emitZeroUint16(I);
56909 case PT_Sint32:
56910 return emitZeroSint32(I);
56911 case PT_Uint32:
56912 return emitZeroUint32(I);
56913 case PT_Sint64:
56914 return emitZeroSint64(I);
56915 case PT_Uint64:
56916 return emitZeroUint64(I);
56917 case PT_Bool:
56918 return emitZeroBool(I);
56919 default: llvm_unreachable("invalid type: emitZero");
56920 }
56921 llvm_unreachable("invalid enum value");
56922}
56923#endif
56924#ifdef GET_LINK_IMPL
56925bool ByteCodeEmitter::emitZeroSint8(SourceInfo L) {
56926 return emitOp<>(OP_ZeroSint8, L);
56927}
56928bool ByteCodeEmitter::emitZeroUint8(SourceInfo L) {
56929 return emitOp<>(OP_ZeroUint8, L);
56930}
56931bool ByteCodeEmitter::emitZeroSint16(SourceInfo L) {
56932 return emitOp<>(OP_ZeroSint16, L);
56933}
56934bool ByteCodeEmitter::emitZeroUint16(SourceInfo L) {
56935 return emitOp<>(OP_ZeroUint16, L);
56936}
56937bool ByteCodeEmitter::emitZeroSint32(SourceInfo L) {
56938 return emitOp<>(OP_ZeroSint32, L);
56939}
56940bool ByteCodeEmitter::emitZeroUint32(SourceInfo L) {
56941 return emitOp<>(OP_ZeroUint32, L);
56942}
56943bool ByteCodeEmitter::emitZeroSint64(SourceInfo L) {
56944 return emitOp<>(OP_ZeroSint64, L);
56945}
56946bool ByteCodeEmitter::emitZeroUint64(SourceInfo L) {
56947 return emitOp<>(OP_ZeroUint64, L);
56948}
56949bool ByteCodeEmitter::emitZeroBool(SourceInfo L) {
56950 return emitOp<>(OP_ZeroBool, L);
56951}
56952#endif
56953#ifdef GET_EVAL_IMPL
56954bool EvalEmitter::emitZeroSint8(SourceInfo L) {
56955 if (!isActive()) return true;
56956 CurrentSource = L;
56957 return Zero<PT_Sint8>(S);
56958}
56959bool EvalEmitter::emitZeroUint8(SourceInfo L) {
56960 if (!isActive()) return true;
56961 CurrentSource = L;
56962 return Zero<PT_Uint8>(S);
56963}
56964bool EvalEmitter::emitZeroSint16(SourceInfo L) {
56965 if (!isActive()) return true;
56966 CurrentSource = L;
56967 return Zero<PT_Sint16>(S);
56968}
56969bool EvalEmitter::emitZeroUint16(SourceInfo L) {
56970 if (!isActive()) return true;
56971 CurrentSource = L;
56972 return Zero<PT_Uint16>(S);
56973}
56974bool EvalEmitter::emitZeroSint32(SourceInfo L) {
56975 if (!isActive()) return true;
56976 CurrentSource = L;
56977 return Zero<PT_Sint32>(S);
56978}
56979bool EvalEmitter::emitZeroUint32(SourceInfo L) {
56980 if (!isActive()) return true;
56981 CurrentSource = L;
56982 return Zero<PT_Uint32>(S);
56983}
56984bool EvalEmitter::emitZeroSint64(SourceInfo L) {
56985 if (!isActive()) return true;
56986 CurrentSource = L;
56987 return Zero<PT_Sint64>(S);
56988}
56989bool EvalEmitter::emitZeroUint64(SourceInfo L) {
56990 if (!isActive()) return true;
56991 CurrentSource = L;
56992 return Zero<PT_Uint64>(S);
56993}
56994bool EvalEmitter::emitZeroBool(SourceInfo L) {
56995 if (!isActive()) return true;
56996 CurrentSource = L;
56997 return Zero<PT_Bool>(S);
56998}
56999#endif
57000#ifdef GET_OPCODE_NAMES
57001OP_ZeroIntAP,
57002#endif
57003#ifdef GET_INTERPFN_LIST
57004&Interp_ZeroIntAP,
57005#endif
57006#ifdef GET_INTERPFN_DISPATCHERS
57007PRESERVE_NONE
57008static bool Interp_ZeroIntAP(InterpState &S) {
57009 {
57010 const auto V0 = ReadArg<uint32_t>(S, S.PC);
57011 ZeroIntAP(S, V0);
57012 }
57013#if USE_TAILCALLS
57014 MUSTTAIL return InterpNext(S);
57015#else
57016 return true;
57017#endif
57018}
57019#endif
57020#ifdef GET_DISASM
57021case OP_ZeroIntAP:
57022 Text.Op = PrintName("ZeroIntAP");
57023 Text.Args.push_back(printArg<uint32_t>(PC));
57024 break;
57025#endif
57026#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
57027bool emitZeroIntAP( uint32_t , SourceInfo);
57028#endif
57029#ifdef GET_LINK_IMPL
57030bool ByteCodeEmitter::emitZeroIntAP( uint32_t A0, SourceInfo L) {
57031 return emitOp<uint32_t>(OP_ZeroIntAP, A0, L);
57032}
57033#endif
57034#ifdef GET_EVAL_IMPL
57035bool EvalEmitter::emitZeroIntAP( uint32_t A0, SourceInfo L) {
57036 if (!isActive()) return true;
57037 CurrentSource = L;
57038 return ZeroIntAP(S, A0);
57039}
57040#endif
57041#ifdef GET_OPCODE_NAMES
57042OP_ZeroIntAPS,
57043#endif
57044#ifdef GET_INTERPFN_LIST
57045&Interp_ZeroIntAPS,
57046#endif
57047#ifdef GET_INTERPFN_DISPATCHERS
57048PRESERVE_NONE
57049static bool Interp_ZeroIntAPS(InterpState &S) {
57050 {
57051 const auto V0 = ReadArg<uint32_t>(S, S.PC);
57052 ZeroIntAPS(S, V0);
57053 }
57054#if USE_TAILCALLS
57055 MUSTTAIL return InterpNext(S);
57056#else
57057 return true;
57058#endif
57059}
57060#endif
57061#ifdef GET_DISASM
57062case OP_ZeroIntAPS:
57063 Text.Op = PrintName("ZeroIntAPS");
57064 Text.Args.push_back(printArg<uint32_t>(PC));
57065 break;
57066#endif
57067#if defined(GET_EVAL_PROTO) || defined(GET_LINK_PROTO)
57068bool emitZeroIntAPS( uint32_t , SourceInfo);
57069#endif
57070#ifdef GET_LINK_IMPL
57071bool ByteCodeEmitter::emitZeroIntAPS( uint32_t A0, SourceInfo L) {
57072 return emitOp<uint32_t>(OP_ZeroIntAPS, A0, L);
57073}
57074#endif
57075#ifdef GET_EVAL_IMPL
57076bool EvalEmitter::emitZeroIntAPS( uint32_t A0, SourceInfo L) {
57077 if (!isActive()) return true;
57078 CurrentSource = L;
57079 return ZeroIntAPS(S, A0);
57080}
57081#endif
57082