| author | Scott Ehlert <ds@alliedmods.net> |
| Wed Aug 15 06:19:30 2007 +0000 (2007-08-15) | |
| changeset 1330 | ab94316bb52b |
| parent 831 | 1995c0dd5c04 |
| child 1931 | e0187c4811c5 |
| permissions | -rw-r--r-- |
1 /**
2 * vim: set ts=4 :
3 * =============================================================================
4 * SourcePawn JIT
5 * Copyright (C)2004-2007 AlliedModders LLC. All rights reserved.
6 * =============================================================================
7 *
8 * This file is not open source and may not be copied without explicit wriiten
9 * permission of AlliedModders LLC. This file may not be redistributed in whole
10 * or significant part.
11 * For information, see LICENSE.txt or http://www.sourcemod.net/license.php
12 *
13 * Version: $Id$
14 */
16 case OP_MOVE_PRI:
17 {
18 WriteOp_Move_Pri(jit);
19 break;
20 }
21 case OP_MOVE_ALT:
22 {
23 WriteOp_Move_Alt(jit);
24 break;
25 }
26 case OP_XCHG:
27 {
28 WriteOp_Xchg(jit);
29 break;
30 }
31 case OP_PUSH:
32 {
33 WriteOp_Push(jit);
34 break;
35 }
36 case OP_PUSH_S:
37 {
38 WriteOp_Push_S(jit);
39 break;
40 }
41 case OP_PUSH2_C:
42 {
43 WriteOp_Push2_C(jit);
44 break;
45 }
46 case OP_PUSH3_C:
47 {
48 WriteOp_Push3_C(jit);
49 break;
50 }
51 case OP_PUSH4_C:
52 {
53 WriteOp_Push4_C(jit);
54 break;
55 }
56 case OP_PUSH5_C:
57 {
58 WriteOp_Push5_C(jit);
59 break;
60 }
61 case OP_PUSH2_ADR:
62 {
63 WriteOp_Push2_Adr(jit);
64 break;
65 }
66 case OP_PUSH3_ADR:
67 {
68 WriteOp_Push3_Adr(jit);
69 break;
70 }
71 case OP_PUSH4_ADR:
72 {
73 WriteOp_Push4_Adr(jit);
74 break;
75 }
76 case OP_PUSH5_ADR:
77 {
78 WriteOp_Push5_Adr(jit);
79 break;
80 }
81 case OP_PUSH2_S:
82 {
83 WriteOp_Push2_S(jit);
84 break;
85 }
86 case OP_PUSH3_S:
87 {
88 WriteOp_Push3_S(jit);
89 break;
90 }
91 case OP_PUSH4_S:
92 {
93 WriteOp_Push4_S(jit);
94 break;
95 }
96 case OP_PUSH5_S:
97 {
98 WriteOp_Push5_S(jit);
99 break;
100 }
101 case OP_PUSH5:
102 {
103 WriteOp_Push5(jit);
104 break;
105 }
106 case OP_PUSH4:
107 {
108 WriteOp_Push4(jit);
109 break;
110 }
111 case OP_PUSH3:
112 {
113 WriteOp_Push3(jit);
114 break;
115 }
116 case OP_PUSH2:
117 {
118 WriteOp_Push2(jit);
119 break;
120 }
121 case OP_ZERO_PRI:
122 {
123 WriteOp_Zero_Pri(jit);
124 break;
125 }
126 case OP_ZERO_ALT:
127 {
128 WriteOp_Zero_Alt(jit);
129 break;
130 }
131 case OP_PROC:
132 {
133 WriteOp_Proc(jit);
134 break;
135 }
136 case OP_SHL:
137 {
138 WriteOp_Shl(jit);
139 break;
140 }
141 case OP_SHR:
142 {
143 WriteOp_Shr(jit);
144 break;
145 }
146 case OP_SSHR:
147 {
148 WriteOp_Sshr(jit);
149 break;
150 }
151 case OP_SHL_C_PRI:
152 {
153 WriteOp_Shl_C_Pri(jit);
154 break;
155 }
156 case OP_SHL_C_ALT:
157 {
158 WriteOp_Shl_C_Alt(jit);
159 break;
160 }
161 case OP_SHR_C_PRI:
162 {
163 WriteOp_Shr_C_Pri(jit);
164 break;
165 }
166 case OP_SHR_C_ALT:
167 {
168 WriteOp_Shr_C_Alt(jit);
169 break;
170 }
171 case OP_SMUL:
172 {
173 WriteOp_SMul(jit);
174 break;
175 }
176 case OP_ADD:
177 {
178 WriteOp_Add(jit);
179 break;
180 }
181 case OP_SUB:
182 {
183 WriteOp_Sub(jit);
184 break;
185 }
186 case OP_SUB_ALT:
187 {
188 WriteOp_Sub_Alt(jit);
189 break;
190 }
191 case OP_NOP:
192 {
193 /* do nothing */
194 break;
195 }
196 case OP_NOT:
197 {
198 WriteOp_Not(jit);
199 break;
200 }
201 case OP_NEG:
202 {
203 WriteOp_Neg(jit);
204 break;
205 }
206 case OP_XOR:
207 {
208 WriteOp_Xor(jit);
209 break;
210 }
211 case OP_OR:
212 {
213 WriteOp_Or(jit);
214 break;
215 }
216 case OP_AND:
217 {
218 WriteOp_And(jit);
219 break;
220 }
221 case OP_INVERT:
222 {
223 WriteOp_Invert(jit);
224 break;
225 }
226 case OP_ADD_C:
227 {
228 WriteOp_Add_C(jit);
229 break;
230 }
231 case OP_SMUL_C:
232 {
233 WriteOp_SMul_C(jit);
234 break;
235 }
236 case OP_SIGN_PRI:
237 {
238 WriteOp_Sign_Pri(jit);
239 break;
240 }
241 case OP_SIGN_ALT:
242 {
243 WriteOp_Sign_Alt(jit);
244 break;
245 }
246 case OP_EQ:
247 {
248 WriteOp_Eq(jit);
249 break;
250 }
251 case OP_NEQ:
252 {
253 WriteOp_Neq(jit);
254 break;
255 }
256 case OP_SLESS:
257 {
258 WriteOp_Sless(jit);
259 break;
260 }
261 case OP_SLEQ:
262 {
263 WriteOp_Sleq(jit);
264 break;
265 }
266 case OP_SGRTR:
267 {
268 WriteOp_Sgrtr(jit);
269 break;
270 }
271 case OP_SGEQ:
272 {
273 WriteOp_Sgeq(jit);
274 break;
275 }
276 case OP_EQ_C_PRI:
277 {
278 WriteOp_Eq_C_Pri(jit);
279 break;
280 }
281 case OP_EQ_C_ALT:
282 {
283 WriteOp_Eq_C_Alt(jit);
284 break;
285 }
286 case OP_INC_PRI:
287 {
288 WriteOp_Inc_Pri(jit);
289 break;
290 }
291 case OP_INC_ALT:
292 {
293 WriteOp_Inc_Alt(jit);
294 break;
295 }
296 case OP_INC:
297 {
298 WriteOp_Inc(jit);
299 break;
300 }
301 case OP_INC_S:
302 {
303 WriteOp_Inc_S(jit);
304 break;
305 }
306 case OP_INC_I:
307 {
308 WriteOp_Inc_I(jit);
309 break;
310 }
311 case OP_DEC_PRI:
312 {
313 WriteOp_Dec_Pri(jit);
314 break;
315 }
316 case OP_DEC_ALT:
317 {
318 WriteOp_Dec_Alt(jit);
319 break;
320 }
321 case OP_DEC:
322 {
323 WriteOp_Dec(jit);
324 break;
325 }
326 case OP_DEC_S:
327 {
328 WriteOp_Dec_S(jit);
329 break;
330 }
331 case OP_DEC_I:
332 {
333 WriteOp_Dec_I(jit);
334 break;
335 }
336 case OP_LOAD_PRI:
337 {
338 WriteOp_Load_Pri(jit);
339 break;
340 }
341 case OP_LOAD_ALT:
342 {
343 WriteOp_Load_Alt(jit);
344 break;
345 }
346 case OP_LOAD_S_PRI:
347 {
348 WriteOp_Load_S_Pri(jit);
349 break;
350 }
351 case OP_LOAD_S_ALT:
352 {
353 WriteOp_Load_S_Alt(jit);
354 break;
355 }
356 case OP_LREF_PRI:
357 {
358 WriteOp_Lref_Pri(jit);
359 break;
360 }
361 case OP_LREF_ALT:
362 {
363 WriteOp_Lref_Alt(jit);
364 break;
365 }
366 case OP_LREF_S_PRI:
367 {
368 WriteOp_Lref_S_Pri(jit);
369 break;
370 }
371 case OP_LREF_S_ALT:
372 {
373 WriteOp_Lref_S_Alt(jit);
374 break;
375 }
376 case OP_CONST_PRI:
377 {
378 WriteOp_Const_Pri(jit);
379 break;
380 }
381 case OP_CONST_ALT:
382 {
383 WriteOp_Const_Alt(jit);
384 break;
385 }
386 case OP_ADDR_PRI:
387 {
388 WriteOp_Addr_Pri(jit);
389 break;
390 }
391 case OP_ADDR_ALT:
392 {
393 WriteOp_Addr_Alt(jit);
394 break;
395 }
396 case OP_STOR_PRI:
397 {
398 WriteOp_Stor_Pri(jit);
399 break;
400 }
401 case OP_STOR_ALT:
402 {
403 WriteOp_Stor_Alt(jit);
404 break;
405 }
406 case OP_STOR_S_PRI:
407 {
408 WriteOp_Stor_S_Pri(jit);
409 break;
410 }
411 case OP_STOR_S_ALT:
412 {
413 WriteOp_Stor_S_Alt(jit);
414 break;
415 }
416 case OP_IDXADDR:
417 {
418 WriteOp_Idxaddr(jit);
419 break;
420 }
421 case OP_SREF_PRI:
422 {
423 WriteOp_Sref_Pri(jit);
424 break;
425 }
426 case OP_SREF_ALT:
427 {
428 WriteOp_Sref_Alt(jit);
429 break;
430 }
431 case OP_SREF_S_PRI:
432 {
433 WriteOp_Sref_S_Pri(jit);
434 break;
435 }
436 case OP_SREF_S_ALT:
437 {
438 WriteOp_Sref_S_Alt(jit);
439 break;
440 }
441 case OP_POP_PRI:
442 {
443 WriteOp_Pop_Pri(jit);
444 break;
445 }
446 case OP_POP_ALT:
447 {
448 WriteOp_Pop_Alt(jit);
449 break;
450 }
451 case OP_SWAP_PRI:
452 {
453 WriteOp_Swap_Pri(jit);
454 break;
455 }
456 case OP_SWAP_ALT:
457 {
458 WriteOp_Swap_Alt(jit);
459 break;
460 }
461 case OP_PUSH_ADR:
462 {
463 WriteOp_PushAddr(jit);
464 break;
465 }
466 case OP_MOVS:
467 {
468 WriteOp_Movs(jit);
469 break;
470 }
471 case OP_FILL:
472 {
473 WriteOp_Fill(jit);
474 break;
475 }
476 case OP_PUSH_C:
477 {
478 WriteOp_Push_C(jit);
479 break;
480 }
481 case OP_ZERO:
482 {
483 WriteOp_Zero(jit);
484 break;
485 }
486 case OP_ZERO_S:
487 {
488 WriteOp_Zero_S(jit);
489 break;
490 }
491 case OP_PUSH_PRI:
492 {
493 WriteOp_Push_Pri(jit);
494 break;
495 }
496 case OP_PUSH_ALT:
497 {
498 WriteOp_Push_Alt(jit);
499 break;
500 }
501 case OP_LOAD_BOTH:
502 {
503 WriteOp_Load_Both(jit);
504 break;
505 }
506 case OP_LOAD_S_BOTH:
507 {
508 WriteOp_Load_S_Both(jit);
509 break;
510 }
511 case OP_CONST:
512 {
513 WriteOp_Const(jit);
514 break;
515 }
516 case OP_CONST_S:
517 {
518 WriteOp_Const_S(jit);
519 break;
520 }
521 case OP_LOAD_I:
522 {
523 WriteOp_Load_I(jit);
524 break;
525 }
526 case OP_LODB_I:
527 {
528 WriteOp_Lodb_I(jit);
529 break;
530 }
531 case OP_STOR_I:
532 {
533 WriteOp_Stor_I(jit);
534 break;
535 }
536 case OP_STRB_I:
537 {
538 WriteOp_Strb_I(jit);
539 break;
540 }
541 case OP_LIDX:
542 {
543 WriteOp_Lidx(jit);
544 break;
545 }
546 case OP_LIDX_B:
547 {
548 WriteOp_Lidx_B(jit);
549 break;
550 }
551 case OP_IDXADDR_B:
552 {
553 WriteOp_Idxaddr_B(jit);
554 break;
555 }
556 case OP_STACK:
557 {
558 WriteOp_Stack(jit);
559 break;
560 }
561 case OP_HEAP:
562 {
563 WriteOp_Heap(jit);
564 break;
565 }
566 case OP_SDIV:
567 {
568 WriteOp_SDiv(jit);
569 break;
570 }
571 case OP_SDIV_ALT:
572 {
573 WriteOp_SDiv_Alt(jit);
574 break;
575 }
576 case OP_RETN:
577 {
578 WriteOp_Retn(jit);
579 break;
580 }
581 case OP_BOUNDS:
582 {
583 WriteOp_Bounds(jit);
584 break;
585 }
586 case OP_HALT:
587 {
588 WriteOp_Halt(jit);
589 break;
590 }
591 case OP_BREAK:
592 {
593 WriteOp_Break(jit);
594 break;
595 }
596 case OP_JUMP:
597 {
598 WriteOp_Jump(jit);
599 break;
600 }
601 case OP_JZER:
602 {
603 WriteOp_Jzer(jit);
604 break;
605 }
606 case OP_JNZ:
607 {
608 WriteOp_Jnz(jit);
609 break;
610 }
611 case OP_JEQ:
612 {
613 WriteOp_Jeq(jit);
614 break;
615 }
616 case OP_JNEQ:
617 {
618 WriteOp_Jneq(jit);
619 break;
620 }
621 case OP_JSLESS:
622 {
623 WriteOp_Jsless(jit);
624 break;
625 }
626 case OP_JSGRTR:
627 {
628 WriteOp_JsGrtr(jit);
629 break;
630 }
631 case OP_JSGEQ:
632 {
633 WriteOp_JsGeq(jit);
634 break;
635 }
636 case OP_JSLEQ:
637 {
638 WriteOp_Jsleq(jit);
639 break;
640 }
641 case OP_SWITCH:
642 {
643 WriteOp_Switch(jit);
644 break;
645 }
646 case OP_CASETBL:
647 {
648 WriteOp_Casetbl(jit);
649 break;
650 }
651 case OP_CALL:
652 {
653 WriteOp_Call(jit);
654 break;
655 }
656 case OP_SYSREQ_C:
657 {
658 WriteOp_Sysreq_C(jit);
659 break;
660 }
661 case OP_SYSREQ_N:
662 {
663 if (data->inline_level & JIT_INLINE_NATIVES)
664 {
665 WriteOp_Sysreq_N(jit);
666 } else {
667 WriteOp_Sysreq_N_NoInline(jit);
668 }
669 break;
670 }
671 case OP_TRACKER_PUSH_C:
672 {
673 WriteOp_Tracker_Push_C(jit);
674 break;
675 }
676 case OP_TRACKER_POP_SETHEAP:
677 {
678 WriteOp_Tracker_Pop_SetHeap(jit);
679 break;
680 }
681 case OP_GENARRAY:
682 {
683 WriteOp_GenArray(jit, false);
684 break;
685 }
686 case OP_GENARRAY_Z:
687 {
688 WriteOp_GenArray(jit, true);
689 break;
690 }
691 case OP_STRADJUST_PRI:
692 {
693 WriteOp_Stradjust_Pri(jit);
694 break;
695 }
696 case OP_FABS:
697 {
698 WriteOp_FloatAbs(jit);
699 break;
700 }
701 case OP_FLOAT:
702 {
703 WriteOp_Float(jit);
704 break;
705 }
706 case OP_FLOATADD:
707 {
708 WriteOp_FloatAdd(jit);
709 break;
710 }
711 case OP_FLOATSUB:
712 {
713 WriteOp_FloatSub(jit);
714 break;
715 }
716 case OP_FLOATMUL:
717 {
718 WriteOp_FloatMul(jit);
719 break;
720 }
721 case OP_FLOATDIV:
722 {
723 WriteOp_FloatDiv(jit);
724 break;
725 }
726 case OP_RND_TO_NEAREST:
727 {
728 WriteOp_RountToNearest(jit);
729 break;
730 }
731 case OP_RND_TO_FLOOR:
732 {
733 WriteOp_RoundToFloor(jit);
734 break;
735 }
736 case OP_RND_TO_ZERO:
737 {
738 WriteOp_RoundToZero(jit);
739 break;
740 }
741 case OP_RND_TO_CEIL:
742 {
743 WriteOp_RoundToCeil(jit);
744 break;
745 }
746 case OP_FLOATCMP:
747 {
748 WriteOp_FloatCompare(jit);
749 break;
750 }
751 #if defined USE_UNGEN_OPCODES
752 #include "ungen_opcode_switch.inc"
753 #endif
754 default:
755 {
756 data->error_set = SP_ERROR_INVALID_INSTRUCTION;
757 break;
758 }