Debian Codegraph @

SheepShaver/src/Windows/cygwin_precompiled_dyngen/basic-dyngen-ops.hpp

raw
1 #ifndef DEFINE_CST
2 #define DEFINE_CST(NAME, VALUE)
3 #endif
4 DEFINE_GEN(gen_op_mov_ad_A0_im,void,(long param1))
5 #ifdef DYNGEN_IMPL
6 #define HAVE_gen_op_mov_ad_A0_im
7 {
8 static const uint8 op_mov_ad_A0_im_code[] = {
9 0xbb, 0x00, 0x00, 0x00, 0x00
10 };
11 copy_block(op_mov_ad_A0_im_code, 5);
12 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
13 inc_code_ptr(5);
14 }
15 #endif
16
17 DEFINE_GEN(gen_op_mov_ad_A1_im,void,(long param1))
18 #ifdef DYNGEN_IMPL
19 #define HAVE_gen_op_mov_ad_A1_im
20 {
21 static const uint8 op_mov_ad_A1_im_code[] = {
22 0xbe, 0x00, 0x00, 0x00, 0x00
23 };
24 copy_block(op_mov_ad_A1_im_code, 5);
25 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
26 inc_code_ptr(5);
27 }
28 #endif
29
30 DEFINE_GEN(gen_op_mov_ad_A2_im,void,(long param1))
31 #ifdef DYNGEN_IMPL
32 #define HAVE_gen_op_mov_ad_A2_im
33 {
34 static const uint8 op_mov_ad_A2_im_code[] = {
35 0xbf, 0x00, 0x00, 0x00, 0x00
36 };
37 copy_block(op_mov_ad_A2_im_code, 5);
38 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
39 inc_code_ptr(5);
40 }
41 #endif
42
43 DEFINE_GEN(gen_op_mov_32_T0_im,void,(long param1))
44 #ifdef DYNGEN_IMPL
45 #define HAVE_gen_op_mov_32_T0_im
46 {
47 static const uint8 op_mov_32_T0_im_code[] = {
48 0xbb, 0x00, 0x00, 0x00, 0x00
49 };
50 copy_block(op_mov_32_T0_im_code, 5);
51 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
52 inc_code_ptr(5);
53 }
54 #endif
55
56 DEFINE_GEN(gen_op_mov_32_T0_T1,void,(void))
57 #ifdef DYNGEN_IMPL
58 #define HAVE_gen_op_mov_32_T0_T1
59 {
60 static const uint8 op_mov_32_T0_T1_code[] = {
61 0x89, 0xf3
62 };
63 copy_block(op_mov_32_T0_T1_code, 2);
64 inc_code_ptr(2);
65 }
66 #endif
67
68 DEFINE_GEN(gen_op_mov_32_T0_T2,void,(void))
69 #ifdef DYNGEN_IMPL
70 #define HAVE_gen_op_mov_32_T0_T2
71 {
72 static const uint8 op_mov_32_T0_T2_code[] = {
73 0x89, 0xfb
74 };
75 copy_block(op_mov_32_T0_T2_code, 2);
76 inc_code_ptr(2);
77 }
78 #endif
79
80 DEFINE_GEN(gen_op_mov_32_T1_im,void,(long param1))
81 #ifdef DYNGEN_IMPL
82 #define HAVE_gen_op_mov_32_T1_im
83 {
84 static const uint8 op_mov_32_T1_im_code[] = {
85 0xbe, 0x00, 0x00, 0x00, 0x00
86 };
87 copy_block(op_mov_32_T1_im_code, 5);
88 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
89 inc_code_ptr(5);
90 }
91 #endif
92
93 DEFINE_GEN(gen_op_mov_32_T1_T0,void,(void))
94 #ifdef DYNGEN_IMPL
95 #define HAVE_gen_op_mov_32_T1_T0
96 {
97 static const uint8 op_mov_32_T1_T0_code[] = {
98 0x89, 0xde
99 };
100 copy_block(op_mov_32_T1_T0_code, 2);
101 inc_code_ptr(2);
102 }
103 #endif
104
105 DEFINE_GEN(gen_op_mov_32_T1_T2,void,(void))
106 #ifdef DYNGEN_IMPL
107 #define HAVE_gen_op_mov_32_T1_T2
108 {
109 static const uint8 op_mov_32_T1_T2_code[] = {
110 0x89, 0xfe
111 };
112 copy_block(op_mov_32_T1_T2_code, 2);
113 inc_code_ptr(2);
114 }
115 #endif
116
117 DEFINE_GEN(gen_op_mov_32_T2_im,void,(long param1))
118 #ifdef DYNGEN_IMPL
119 #define HAVE_gen_op_mov_32_T2_im
120 {
121 static const uint8 op_mov_32_T2_im_code[] = {
122 0xbf, 0x00, 0x00, 0x00, 0x00
123 };
124 copy_block(op_mov_32_T2_im_code, 5);
125 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
126 inc_code_ptr(5);
127 }
128 #endif
129
130 DEFINE_GEN(gen_op_mov_32_T2_T1,void,(void))
131 #ifdef DYNGEN_IMPL
132 #define HAVE_gen_op_mov_32_T2_T1
133 {
134 static const uint8 op_mov_32_T2_T1_code[] = {
135 0x89, 0xf7
136 };
137 copy_block(op_mov_32_T2_T1_code, 2);
138 inc_code_ptr(2);
139 }
140 #endif
141
142 DEFINE_GEN(gen_op_mov_32_T2_T0,void,(void))
143 #ifdef DYNGEN_IMPL
144 #define HAVE_gen_op_mov_32_T2_T0
145 {
146 static const uint8 op_mov_32_T2_T0_code[] = {
147 0x89, 0xdf
148 };
149 copy_block(op_mov_32_T2_T0_code, 2);
150 inc_code_ptr(2);
151 }
152 #endif
153
154 DEFINE_GEN(gen_op_mov_32_T0_0,void,(void))
155 #ifdef DYNGEN_IMPL
156 #define HAVE_gen_op_mov_32_T0_0
157 {
158 static const uint8 op_mov_32_T0_0_code[] = {
159 0x31, 0xdb
160 };
161 copy_block(op_mov_32_T0_0_code, 2);
162 inc_code_ptr(2);
163 }
164 #endif
165
166 DEFINE_GEN(gen_op_mov_32_T1_0,void,(void))
167 #ifdef DYNGEN_IMPL
168 #define HAVE_gen_op_mov_32_T1_0
169 {
170 static const uint8 op_mov_32_T1_0_code[] = {
171 0x31, 0xf6
172 };
173 copy_block(op_mov_32_T1_0_code, 2);
174 inc_code_ptr(2);
175 }
176 #endif
177
178 DEFINE_GEN(gen_op_mov_32_T2_0,void,(void))
179 #ifdef DYNGEN_IMPL
180 #define HAVE_gen_op_mov_32_T2_0
181 {
182 static const uint8 op_mov_32_T2_0_code[] = {
183 0x31, 0xff
184 };
185 copy_block(op_mov_32_T2_0_code, 2);
186 inc_code_ptr(2);
187 }
188 #endif
189
190 DEFINE_GEN(gen_op_add_32_T0_T2,void,(void))
191 #ifdef DYNGEN_IMPL
192 #define HAVE_gen_op_add_32_T0_T2
193 {
194 static const uint8 op_add_32_T0_T2_code[] = {
195 0x01, 0xfb
196 };
197 copy_block(op_add_32_T0_T2_code, 2);
198 inc_code_ptr(2);
199 }
200 #endif
201
202 DEFINE_GEN(gen_op_add_32_T0_T1,void,(void))
203 #ifdef DYNGEN_IMPL
204 #define HAVE_gen_op_add_32_T0_T1
205 {
206 static const uint8 op_add_32_T0_T1_code[] = {
207 0x01, 0xf3
208 };
209 copy_block(op_add_32_T0_T1_code, 2);
210 inc_code_ptr(2);
211 }
212 #endif
213
214 DEFINE_GEN(gen_op_add_32_T0_im,void,(long param1))
215 #ifdef DYNGEN_IMPL
216 #define HAVE_gen_op_add_32_T0_im
217 {
218 static const uint8 op_add_32_T0_im_code[] = {
219 0x81, 0xc3, 0x00, 0x00, 0x00, 0x00
220 };
221 copy_block(op_add_32_T0_im_code, 6);
222 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
223 inc_code_ptr(6);
224 }
225 #endif
226
227 DEFINE_GEN(gen_op_add_32_T0_1,void,(void))
228 #ifdef DYNGEN_IMPL
229 #define HAVE_gen_op_add_32_T0_1
230 {
231 static const uint8 op_add_32_T0_1_code[] = {
232 0x43
233 };
234 copy_block(op_add_32_T0_1_code, 1);
235 inc_code_ptr(1);
236 }
237 #endif
238
239 DEFINE_GEN(gen_op_add_32_T0_2,void,(void))
240 #ifdef DYNGEN_IMPL
241 #define HAVE_gen_op_add_32_T0_2
242 {
243 static const uint8 op_add_32_T0_2_code[] = {
244 0x83, 0xc3, 0x02
245 };
246 copy_block(op_add_32_T0_2_code, 3);
247 inc_code_ptr(3);
248 }
249 #endif
250
251 DEFINE_GEN(gen_op_add_32_T0_4,void,(void))
252 #ifdef DYNGEN_IMPL
253 #define HAVE_gen_op_add_32_T0_4
254 {
255 static const uint8 op_add_32_T0_4_code[] = {
256 0x83, 0xc3, 0x04
257 };
258 copy_block(op_add_32_T0_4_code, 3);
259 inc_code_ptr(3);
260 }
261 #endif
262
263 DEFINE_GEN(gen_op_add_32_T0_8,void,(void))
264 #ifdef DYNGEN_IMPL
265 #define HAVE_gen_op_add_32_T0_8
266 {
267 static const uint8 op_add_32_T0_8_code[] = {
268 0x83, 0xc3, 0x08
269 };
270 copy_block(op_add_32_T0_8_code, 3);
271 inc_code_ptr(3);
272 }
273 #endif
274
275 DEFINE_GEN(gen_op_sub_32_T0_T2,void,(void))
276 #ifdef DYNGEN_IMPL
277 #define HAVE_gen_op_sub_32_T0_T2
278 {
279 static const uint8 op_sub_32_T0_T2_code[] = {
280 0x29, 0xfb
281 };
282 copy_block(op_sub_32_T0_T2_code, 2);
283 inc_code_ptr(2);
284 }
285 #endif
286
287 DEFINE_GEN(gen_op_sub_32_T0_T1,void,(void))
288 #ifdef DYNGEN_IMPL
289 #define HAVE_gen_op_sub_32_T0_T1
290 {
291 static const uint8 op_sub_32_T0_T1_code[] = {
292 0x29, 0xf3
293 };
294 copy_block(op_sub_32_T0_T1_code, 2);
295 inc_code_ptr(2);
296 }
297 #endif
298
299 DEFINE_GEN(gen_op_sub_32_T0_im,void,(long param1))
300 #ifdef DYNGEN_IMPL
301 #define HAVE_gen_op_sub_32_T0_im
302 {
303 static const uint8 op_sub_32_T0_im_code[] = {
304 0x81, 0xeb, 0x00, 0x00, 0x00, 0x00
305 };
306 copy_block(op_sub_32_T0_im_code, 6);
307 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
308 inc_code_ptr(6);
309 }
310 #endif
311
312 DEFINE_GEN(gen_op_sub_32_T0_1,void,(void))
313 #ifdef DYNGEN_IMPL
314 #define HAVE_gen_op_sub_32_T0_1
315 {
316 static const uint8 op_sub_32_T0_1_code[] = {
317 0x4b
318 };
319 copy_block(op_sub_32_T0_1_code, 1);
320 inc_code_ptr(1);
321 }
322 #endif
323
324 DEFINE_GEN(gen_op_sub_32_T0_2,void,(void))
325 #ifdef DYNGEN_IMPL
326 #define HAVE_gen_op_sub_32_T0_2
327 {
328 static const uint8 op_sub_32_T0_2_code[] = {
329 0x83, 0xeb, 0x02
330 };
331 copy_block(op_sub_32_T0_2_code, 3);
332 inc_code_ptr(3);
333 }
334 #endif
335
336 DEFINE_GEN(gen_op_sub_32_T0_4,void,(void))
337 #ifdef DYNGEN_IMPL
338 #define HAVE_gen_op_sub_32_T0_4
339 {
340 static const uint8 op_sub_32_T0_4_code[] = {
341 0x83, 0xeb, 0x04
342 };
343 copy_block(op_sub_32_T0_4_code, 3);
344 inc_code_ptr(3);
345 }
346 #endif
347
348 DEFINE_GEN(gen_op_sub_32_T0_8,void,(void))
349 #ifdef DYNGEN_IMPL
350 #define HAVE_gen_op_sub_32_T0_8
351 {
352 static const uint8 op_sub_32_T0_8_code[] = {
353 0x83, 0xeb, 0x08
354 };
355 copy_block(op_sub_32_T0_8_code, 3);
356 inc_code_ptr(3);
357 }
358 #endif
359
360 DEFINE_GEN(gen_op_add_32_T1_T2,void,(void))
361 #ifdef DYNGEN_IMPL
362 #define HAVE_gen_op_add_32_T1_T2
363 {
364 static const uint8 op_add_32_T1_T2_code[] = {
365 0x01, 0xfe
366 };
367 copy_block(op_add_32_T1_T2_code, 2);
368 inc_code_ptr(2);
369 }
370 #endif
371
372 DEFINE_GEN(gen_op_add_32_T1_T0,void,(void))
373 #ifdef DYNGEN_IMPL
374 #define HAVE_gen_op_add_32_T1_T0
375 {
376 static const uint8 op_add_32_T1_T0_code[] = {
377 0x01, 0xde
378 };
379 copy_block(op_add_32_T1_T0_code, 2);
380 inc_code_ptr(2);
381 }
382 #endif
383
384 DEFINE_GEN(gen_op_add_32_T1_im,void,(long param1))
385 #ifdef DYNGEN_IMPL
386 #define HAVE_gen_op_add_32_T1_im
387 {
388 static const uint8 op_add_32_T1_im_code[] = {
389 0x81, 0xc6, 0x00, 0x00, 0x00, 0x00
390 };
391 copy_block(op_add_32_T1_im_code, 6);
392 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
393 inc_code_ptr(6);
394 }
395 #endif
396
397 DEFINE_GEN(gen_op_add_32_T1_1,void,(void))
398 #ifdef DYNGEN_IMPL
399 #define HAVE_gen_op_add_32_T1_1
400 {
401 static const uint8 op_add_32_T1_1_code[] = {
402 0x46
403 };
404 copy_block(op_add_32_T1_1_code, 1);
405 inc_code_ptr(1);
406 }
407 #endif
408
409 DEFINE_GEN(gen_op_add_32_T1_2,void,(void))
410 #ifdef DYNGEN_IMPL
411 #define HAVE_gen_op_add_32_T1_2
412 {
413 static const uint8 op_add_32_T1_2_code[] = {
414 0x83, 0xc6, 0x02
415 };
416 copy_block(op_add_32_T1_2_code, 3);
417 inc_code_ptr(3);
418 }
419 #endif
420
421 DEFINE_GEN(gen_op_add_32_T1_4,void,(void))
422 #ifdef DYNGEN_IMPL
423 #define HAVE_gen_op_add_32_T1_4
424 {
425 static const uint8 op_add_32_T1_4_code[] = {
426 0x83, 0xc6, 0x04
427 };
428 copy_block(op_add_32_T1_4_code, 3);
429 inc_code_ptr(3);
430 }
431 #endif
432
433 DEFINE_GEN(gen_op_add_32_T1_8,void,(void))
434 #ifdef DYNGEN_IMPL
435 #define HAVE_gen_op_add_32_T1_8
436 {
437 static const uint8 op_add_32_T1_8_code[] = {
438 0x83, 0xc6, 0x08
439 };
440 copy_block(op_add_32_T1_8_code, 3);
441 inc_code_ptr(3);
442 }
443 #endif
444
445 DEFINE_GEN(gen_op_sub_32_T1_T2,void,(void))
446 #ifdef DYNGEN_IMPL
447 #define HAVE_gen_op_sub_32_T1_T2
448 {
449 static const uint8 op_sub_32_T1_T2_code[] = {
450 0x29, 0xfe
451 };
452 copy_block(op_sub_32_T1_T2_code, 2);
453 inc_code_ptr(2);
454 }
455 #endif
456
457 DEFINE_GEN(gen_op_sub_32_T1_T0,void,(void))
458 #ifdef DYNGEN_IMPL
459 #define HAVE_gen_op_sub_32_T1_T0
460 {
461 static const uint8 op_sub_32_T1_T0_code[] = {
462 0x29, 0xde
463 };
464 copy_block(op_sub_32_T1_T0_code, 2);
465 inc_code_ptr(2);
466 }
467 #endif
468
469 DEFINE_GEN(gen_op_sub_32_T1_im,void,(long param1))
470 #ifdef DYNGEN_IMPL
471 #define HAVE_gen_op_sub_32_T1_im
472 {
473 static const uint8 op_sub_32_T1_im_code[] = {
474 0x81, 0xee, 0x00, 0x00, 0x00, 0x00
475 };
476 copy_block(op_sub_32_T1_im_code, 6);
477 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
478 inc_code_ptr(6);
479 }
480 #endif
481
482 DEFINE_GEN(gen_op_sub_32_T1_1,void,(void))
483 #ifdef DYNGEN_IMPL
484 #define HAVE_gen_op_sub_32_T1_1
485 {
486 static const uint8 op_sub_32_T1_1_code[] = {
487 0x4e
488 };
489 copy_block(op_sub_32_T1_1_code, 1);
490 inc_code_ptr(1);
491 }
492 #endif
493
494 DEFINE_GEN(gen_op_sub_32_T1_2,void,(void))
495 #ifdef DYNGEN_IMPL
496 #define HAVE_gen_op_sub_32_T1_2
497 {
498 static const uint8 op_sub_32_T1_2_code[] = {
499 0x83, 0xee, 0x02
500 };
501 copy_block(op_sub_32_T1_2_code, 3);
502 inc_code_ptr(3);
503 }
504 #endif
505
506 DEFINE_GEN(gen_op_sub_32_T1_4,void,(void))
507 #ifdef DYNGEN_IMPL
508 #define HAVE_gen_op_sub_32_T1_4
509 {
510 static const uint8 op_sub_32_T1_4_code[] = {
511 0x83, 0xee, 0x04
512 };
513 copy_block(op_sub_32_T1_4_code, 3);
514 inc_code_ptr(3);
515 }
516 #endif
517
518 DEFINE_GEN(gen_op_sub_32_T1_8,void,(void))
519 #ifdef DYNGEN_IMPL
520 #define HAVE_gen_op_sub_32_T1_8
521 {
522 static const uint8 op_sub_32_T1_8_code[] = {
523 0x83, 0xee, 0x08
524 };
525 copy_block(op_sub_32_T1_8_code, 3);
526 inc_code_ptr(3);
527 }
528 #endif
529
530 DEFINE_GEN(gen_op_umul_32_T0_T1,void,(void))
531 #ifdef DYNGEN_IMPL
532 #define HAVE_gen_op_umul_32_T0_T1
533 {
534 static const uint8 op_umul_32_T0_T1_code[] = {
535 0x0f, 0xaf, 0xde
536 };
537 copy_block(op_umul_32_T0_T1_code, 3);
538 inc_code_ptr(3);
539 }
540 #endif
541
542 DEFINE_GEN(gen_op_smul_32_T0_T1,void,(void))
543 #ifdef DYNGEN_IMPL
544 #define HAVE_gen_op_smul_32_T0_T1
545 {
546 static const uint8 op_smul_32_T0_T1_code[] = {
547 0x0f, 0xaf, 0xde
548 };
549 copy_block(op_smul_32_T0_T1_code, 3);
550 inc_code_ptr(3);
551 }
552 #endif
553
554 DEFINE_GEN(gen_op_udiv_32_T0_T1,void,(void))
555 #ifdef DYNGEN_IMPL
556 #define HAVE_gen_op_udiv_32_T0_T1
557 {
558 static const uint8 op_udiv_32_T0_T1_code[] = {
559 0x89, 0xd8, 0x31, 0xd2, 0xf7, 0xf6, 0x89, 0xc3
560 };
561 copy_block(op_udiv_32_T0_T1_code, 8);
562 inc_code_ptr(8);
563 }
564 #endif
565
566 DEFINE_GEN(gen_op_sdiv_32_T0_T1,void,(void))
567 #ifdef DYNGEN_IMPL
568 #define HAVE_gen_op_sdiv_32_T0_T1
569 {
570 static const uint8 op_sdiv_32_T0_T1_code[] = {
571 0x89, 0xd8, 0x99, 0xf7, 0xfe, 0x89, 0xc3
572 };
573 copy_block(op_sdiv_32_T0_T1_code, 7);
574 inc_code_ptr(7);
575 }
576 #endif
577
578 DEFINE_GEN(gen_op_xchg_32_T0_T1,void,(void))
579 #ifdef DYNGEN_IMPL
580 #define HAVE_gen_op_xchg_32_T0_T1
581 {
582 static const uint8 op_xchg_32_T0_T1_code[] = {
583 0x87, 0xde
584 };
585 copy_block(op_xchg_32_T0_T1_code, 2);
586 inc_code_ptr(2);
587 }
588 #endif
589
590 DEFINE_GEN(gen_op_bswap_16_T0,void,(void))
591 #ifdef DYNGEN_IMPL
592 #define HAVE_gen_op_bswap_16_T0
593 {
594 static const uint8 op_bswap_16_T0_code[] = {
595 0x0f, 0xb7, 0xc3, 0x66, 0xc1, 0xc0, 0x08, 0x0f, 0xb7, 0xd8
596 };
597 copy_block(op_bswap_16_T0_code, 10);
598 inc_code_ptr(10);
599 }
600 #endif
601
602 DEFINE_GEN(gen_op_bswap_32_T0,void,(void))
603 #ifdef DYNGEN_IMPL
604 #define HAVE_gen_op_bswap_32_T0
605 {
606 static const uint8 op_bswap_32_T0_code[] = {
607 0x0f, 0xcb
608 };
609 copy_block(op_bswap_32_T0_code, 2);
610 inc_code_ptr(2);
611 }
612 #endif
613
614 DEFINE_GEN(gen_op_neg_32_T0,void,(void))
615 #ifdef DYNGEN_IMPL
616 #define HAVE_gen_op_neg_32_T0
617 {
618 static const uint8 op_neg_32_T0_code[] = {
619 0xf7, 0xdb
620 };
621 copy_block(op_neg_32_T0_code, 2);
622 inc_code_ptr(2);
623 }
624 #endif
625
626 DEFINE_GEN(gen_op_not_32_T0,void,(void))
627 #ifdef DYNGEN_IMPL
628 #define HAVE_gen_op_not_32_T0
629 {
630 static const uint8 op_not_32_T0_code[] = {
631 0x85, 0xdb, 0x0f, 0x94, 0xc0, 0x0f, 0xb6, 0xd8
632 };
633 copy_block(op_not_32_T0_code, 8);
634 inc_code_ptr(8);
635 }
636 #endif
637
638 DEFINE_GEN(gen_op_not_32_T1,void,(void))
639 #ifdef DYNGEN_IMPL
640 #define HAVE_gen_op_not_32_T1
641 {
642 static const uint8 op_not_32_T1_code[] = {
643 0x85, 0xf6, 0x0f, 0x94, 0xc0, 0x0f, 0xb6, 0xf0
644 };
645 copy_block(op_not_32_T1_code, 8);
646 inc_code_ptr(8);
647 }
648 #endif
649
650 DEFINE_GEN(gen_op_and_32_T0_T1,void,(void))
651 #ifdef DYNGEN_IMPL
652 #define HAVE_gen_op_and_32_T0_T1
653 {
654 static const uint8 op_and_32_T0_T1_code[] = {
655 0x21, 0xf3
656 };
657 copy_block(op_and_32_T0_T1_code, 2);
658 inc_code_ptr(2);
659 }
660 #endif
661
662 DEFINE_GEN(gen_op_and_32_T0_im,void,(long param1))
663 #ifdef DYNGEN_IMPL
664 #define HAVE_gen_op_and_32_T0_im
665 {
666 static const uint8 op_and_32_T0_im_code[] = {
667 0x81, 0xe3, 0x00, 0x00, 0x00, 0x00
668 };
669 copy_block(op_and_32_T0_im_code, 6);
670 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
671 inc_code_ptr(6);
672 }
673 #endif
674
675 DEFINE_GEN(gen_op_or_32_T0_T1,void,(void))
676 #ifdef DYNGEN_IMPL
677 #define HAVE_gen_op_or_32_T0_T1
678 {
679 static const uint8 op_or_32_T0_T1_code[] = {
680 0x09, 0xf3
681 };
682 copy_block(op_or_32_T0_T1_code, 2);
683 inc_code_ptr(2);
684 }
685 #endif
686
687 DEFINE_GEN(gen_op_or_32_T0_im,void,(long param1))
688 #ifdef DYNGEN_IMPL
689 #define HAVE_gen_op_or_32_T0_im
690 {
691 static const uint8 op_or_32_T0_im_code[] = {
692 0x81, 0xcb, 0x00, 0x00, 0x00, 0x00
693 };
694 copy_block(op_or_32_T0_im_code, 6);
695 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
696 inc_code_ptr(6);
697 }
698 #endif
699
700 DEFINE_GEN(gen_op_xor_32_T0_T1,void,(void))
701 #ifdef DYNGEN_IMPL
702 #define HAVE_gen_op_xor_32_T0_T1
703 {
704 static const uint8 op_xor_32_T0_T1_code[] = {
705 0x31, 0xf3
706 };
707 copy_block(op_xor_32_T0_T1_code, 2);
708 inc_code_ptr(2);
709 }
710 #endif
711
712 DEFINE_GEN(gen_op_xor_32_T0_im,void,(long param1))
713 #ifdef DYNGEN_IMPL
714 #define HAVE_gen_op_xor_32_T0_im
715 {
716 static const uint8 op_xor_32_T0_im_code[] = {
717 0x81, 0xf3, 0x00, 0x00, 0x00, 0x00
718 };
719 copy_block(op_xor_32_T0_im_code, 6);
720 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
721 inc_code_ptr(6);
722 }
723 #endif
724
725 DEFINE_GEN(gen_op_orc_32_T0_T1,void,(void))
726 #ifdef DYNGEN_IMPL
727 #define HAVE_gen_op_orc_32_T0_T1
728 {
729 static const uint8 op_orc_32_T0_T1_code[] = {
730 0x89, 0xf0, 0xf7, 0xd0, 0x09, 0xc3
731 };
732 copy_block(op_orc_32_T0_T1_code, 6);
733 inc_code_ptr(6);
734 }
735 #endif
736
737 DEFINE_GEN(gen_op_andc_32_T0_T1,void,(void))
738 #ifdef DYNGEN_IMPL
739 #define HAVE_gen_op_andc_32_T0_T1
740 {
741 static const uint8 op_andc_32_T0_T1_code[] = {
742 0x89, 0xf0, 0xf7, 0xd0, 0x21, 0xc3
743 };
744 copy_block(op_andc_32_T0_T1_code, 6);
745 inc_code_ptr(6);
746 }
747 #endif
748
749 DEFINE_GEN(gen_op_nand_32_T0_T1,void,(void))
750 #ifdef DYNGEN_IMPL
751 #define HAVE_gen_op_nand_32_T0_T1
752 {
753 static const uint8 op_nand_32_T0_T1_code[] = {
754 0x89, 0xd8, 0x21, 0xf0, 0x89, 0xc3, 0xf7, 0xd3
755 };
756 copy_block(op_nand_32_T0_T1_code, 8);
757 inc_code_ptr(8);
758 }
759 #endif
760
761 DEFINE_GEN(gen_op_nor_32_T0_T1,void,(void))
762 #ifdef DYNGEN_IMPL
763 #define HAVE_gen_op_nor_32_T0_T1
764 {
765 static const uint8 op_nor_32_T0_T1_code[] = {
766 0x89, 0xd8, 0x09, 0xf0, 0x89, 0xc3, 0xf7, 0xd3
767 };
768 copy_block(op_nor_32_T0_T1_code, 8);
769 inc_code_ptr(8);
770 }
771 #endif
772
773 DEFINE_GEN(gen_op_eqv_32_T0_T1,void,(void))
774 #ifdef DYNGEN_IMPL
775 #define HAVE_gen_op_eqv_32_T0_T1
776 {
777 static const uint8 op_eqv_32_T0_T1_code[] = {
778 0x89, 0xd8, 0x31, 0xf0, 0x89, 0xc3, 0xf7, 0xd3
779 };
780 copy_block(op_eqv_32_T0_T1_code, 8);
781 inc_code_ptr(8);
782 }
783 #endif
784
785 DEFINE_GEN(gen_op_lsl_32_T0_T1,void,(void))
786 #ifdef DYNGEN_IMPL
787 #define HAVE_gen_op_lsl_32_T0_T1
788 {
789 static const uint8 op_lsl_32_T0_T1_code[] = {
790 0x89, 0xf1, 0xd3, 0xe3
791 };
792 copy_block(op_lsl_32_T0_T1_code, 4);
793 inc_code_ptr(4);
794 }
795 #endif
796
797 DEFINE_GEN(gen_op_lsl_32_T0_im,void,(long param1))
798 #ifdef DYNGEN_IMPL
799 #define HAVE_gen_op_lsl_32_T0_im
800 {
801 static const uint8 op_lsl_32_T0_im_code[] = {
802 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xe3
803 };
804 copy_block(op_lsl_32_T0_im_code, 9);
805 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
806 inc_code_ptr(9);
807 }
808 #endif
809
810 DEFINE_GEN(gen_op_lsr_32_T0_T1,void,(void))
811 #ifdef DYNGEN_IMPL
812 #define HAVE_gen_op_lsr_32_T0_T1
813 {
814 static const uint8 op_lsr_32_T0_T1_code[] = {
815 0x89, 0xf1, 0xd3, 0xeb
816 };
817 copy_block(op_lsr_32_T0_T1_code, 4);
818 inc_code_ptr(4);
819 }
820 #endif
821
822 DEFINE_GEN(gen_op_lsr_32_T0_im,void,(long param1))
823 #ifdef DYNGEN_IMPL
824 #define HAVE_gen_op_lsr_32_T0_im
825 {
826 static const uint8 op_lsr_32_T0_im_code[] = {
827 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xeb
828 };
829 copy_block(op_lsr_32_T0_im_code, 9);
830 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
831 inc_code_ptr(9);
832 }
833 #endif
834
835 DEFINE_GEN(gen_op_asr_32_T0_T1,void,(void))
836 #ifdef DYNGEN_IMPL
837 #define HAVE_gen_op_asr_32_T0_T1
838 {
839 static const uint8 op_asr_32_T0_T1_code[] = {
840 0x89, 0xf1, 0xd3, 0xfb
841 };
842 copy_block(op_asr_32_T0_T1_code, 4);
843 inc_code_ptr(4);
844 }
845 #endif
846
847 DEFINE_GEN(gen_op_asr_32_T0_im,void,(long param1))
848 #ifdef DYNGEN_IMPL
849 #define HAVE_gen_op_asr_32_T0_im
850 {
851 static const uint8 op_asr_32_T0_im_code[] = {
852 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xfb
853 };
854 copy_block(op_asr_32_T0_im_code, 9);
855 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
856 inc_code_ptr(9);
857 }
858 #endif
859
860 DEFINE_GEN(gen_op_rol_32_T0_T1,void,(void))
861 #ifdef DYNGEN_IMPL
862 #define HAVE_gen_op_rol_32_T0_T1
863 {
864 static const uint8 op_rol_32_T0_T1_code[] = {
865 0x89, 0xf1, 0xd3, 0xc3
866 };
867 copy_block(op_rol_32_T0_T1_code, 4);
868 inc_code_ptr(4);
869 }
870 #endif
871
872 DEFINE_GEN(gen_op_rol_32_T0_im,void,(long param1))
873 #ifdef DYNGEN_IMPL
874 #define HAVE_gen_op_rol_32_T0_im
875 {
876 static const uint8 op_rol_32_T0_im_code[] = {
877 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xc3
878 };
879 copy_block(op_rol_32_T0_im_code, 9);
880 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
881 inc_code_ptr(9);
882 }
883 #endif
884
885 DEFINE_GEN(gen_op_ror_32_T0_T1,void,(void))
886 #ifdef DYNGEN_IMPL
887 #define HAVE_gen_op_ror_32_T0_T1
888 {
889 static const uint8 op_ror_32_T0_T1_code[] = {
890 0x89, 0xf1, 0xd3, 0xcb
891 };
892 copy_block(op_ror_32_T0_T1_code, 4);
893 inc_code_ptr(4);
894 }
895 #endif
896
897 DEFINE_GEN(gen_op_ror_32_T0_im,void,(long param1))
898 #ifdef DYNGEN_IMPL
899 #define HAVE_gen_op_ror_32_T0_im
900 {
901 static const uint8 op_ror_32_T0_im_code[] = {
902 0xb8, 0x00, 0x00, 0x00, 0x00, 0x88, 0xc1, 0xd3, 0xcb
903 };
904 copy_block(op_ror_32_T0_im_code, 9);
905 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
906 inc_code_ptr(9);
907 }
908 #endif
909
910 DEFINE_GEN(gen_op_se_16_32_T0,void,(void))
911 #ifdef DYNGEN_IMPL
912 #define HAVE_gen_op_se_16_32_T0
913 {
914 static const uint8 op_se_16_32_T0_code[] = {
915 0x0f, 0xbf, 0xdb
916 };
917 copy_block(op_se_16_32_T0_code, 3);
918 inc_code_ptr(3);
919 }
920 #endif
921
922 DEFINE_GEN(gen_op_se_16_32_T1,void,(void))
923 #ifdef DYNGEN_IMPL
924 #define HAVE_gen_op_se_16_32_T1
925 {
926 static const uint8 op_se_16_32_T1_code[] = {
927 0x0f, 0xbf, 0xf6
928 };
929 copy_block(op_se_16_32_T1_code, 3);
930 inc_code_ptr(3);
931 }
932 #endif
933
934 DEFINE_GEN(gen_op_ze_16_32_T0,void,(void))
935 #ifdef DYNGEN_IMPL
936 #define HAVE_gen_op_ze_16_32_T0
937 {
938 static const uint8 op_ze_16_32_T0_code[] = {
939 0x0f, 0xb7, 0xdb
940 };
941 copy_block(op_ze_16_32_T0_code, 3);
942 inc_code_ptr(3);
943 }
944 #endif
945
946 DEFINE_GEN(gen_op_se_8_32_T0,void,(void))
947 #ifdef DYNGEN_IMPL
948 #define HAVE_gen_op_se_8_32_T0
949 {
950 static const uint8 op_se_8_32_T0_code[] = {
951 0x0f, 0xbe, 0xdb
952 };
953 copy_block(op_se_8_32_T0_code, 3);
954 inc_code_ptr(3);
955 }
956 #endif
957
958 DEFINE_GEN(gen_op_ze_8_32_T0,void,(void))
959 #ifdef DYNGEN_IMPL
960 #define HAVE_gen_op_ze_8_32_T0
961 {
962 static const uint8 op_ze_8_32_T0_code[] = {
963 0x0f, 0xb6, 0xdb
964 };
965 copy_block(op_ze_8_32_T0_code, 3);
966 inc_code_ptr(3);
967 }
968 #endif
969
970 DEFINE_GEN(gen_op_load_u32_T0_T1_0,void,(void))
971 #ifdef DYNGEN_IMPL
972 #define HAVE_gen_op_load_u32_T0_T1_0
973 {
974 static const uint8 op_load_u32_T0_T1_0_code[] = {
975 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb
976 };
977 copy_block(op_load_u32_T0_T1_0_code, 10);
978 inc_code_ptr(10);
979 }
980 #endif
981
982 DEFINE_GEN(gen_op_load_s32_T0_T1_0,void,(void))
983 #ifdef DYNGEN_IMPL
984 #define HAVE_gen_op_load_s32_T0_T1_0
985 {
986 static const uint8 op_load_s32_T0_T1_0_code[] = {
987 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb
988 };
989 copy_block(op_load_s32_T0_T1_0_code, 10);
990 inc_code_ptr(10);
991 }
992 #endif
993
994 DEFINE_GEN(gen_op_store_32_T0_T1_0,void,(void))
995 #ifdef DYNGEN_IMPL
996 #define HAVE_gen_op_store_32_T0_T1_0
997 {
998 static const uint8 op_store_32_T0_T1_0_code[] = {
999 0x89, 0xd8, 0x0f, 0xc8, 0x89, 0x86, 0x00, 0x00, 0x00, 0x11
1000 };
1001 copy_block(op_store_32_T0_T1_0_code, 10);
1002 inc_code_ptr(10);
1003 }
1004 #endif
1005
1006 DEFINE_GEN(gen_op_load_u32_T0_T1_im,void,(long param1))
1007 #ifdef DYNGEN_IMPL
1008 #define HAVE_gen_op_load_u32_T0_T1_im
1009 {
1010 static const uint8 op_load_u32_T0_T1_im_code[] = {
1011 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb
1012 };
1013 copy_block(op_load_u32_T0_T1_im_code, 10);
1014 *(uint32_t *)(code_ptr() + 2) = param1 + 285212672;
1015 inc_code_ptr(10);
1016 }
1017 #endif
1018
1019 DEFINE_GEN(gen_op_load_s32_T0_T1_im,void,(long param1))
1020 #ifdef DYNGEN_IMPL
1021 #define HAVE_gen_op_load_s32_T0_T1_im
1022 {
1023 static const uint8 op_load_s32_T0_T1_im_code[] = {
1024 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb
1025 };
1026 copy_block(op_load_s32_T0_T1_im_code, 10);
1027 *(uint32_t *)(code_ptr() + 2) = param1 + 285212672;
1028 inc_code_ptr(10);
1029 }
1030 #endif
1031
1032 DEFINE_GEN(gen_op_store_32_T0_T1_im,void,(long param1))
1033 #ifdef DYNGEN_IMPL
1034 #define HAVE_gen_op_store_32_T0_T1_im
1035 {
1036 static const uint8 op_store_32_T0_T1_im_code[] = {
1037 0x8d, 0x96, 0x00, 0x00, 0x00, 0x00, 0x89, 0xd8, 0x0f, 0xc8, 0x89, 0x82,
1038 0x00, 0x00, 0x00, 0x11
1039 };
1040 copy_block(op_store_32_T0_T1_im_code, 16);
1041 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
1042 inc_code_ptr(16);
1043 }
1044 #endif
1045
1046 DEFINE_GEN(gen_op_load_u32_T0_T1_T2,void,(void))
1047 #ifdef DYNGEN_IMPL
1048 #define HAVE_gen_op_load_u32_T0_T1_T2
1049 {
1050 static const uint8 op_load_u32_T0_T1_T2_code[] = {
1051 0x8b, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb
1052 };
1053 copy_block(op_load_u32_T0_T1_T2_code, 11);
1054 inc_code_ptr(11);
1055 }
1056 #endif
1057
1058 DEFINE_GEN(gen_op_load_s32_T0_T1_T2,void,(void))
1059 #ifdef DYNGEN_IMPL
1060 #define HAVE_gen_op_load_s32_T0_T1_T2
1061 {
1062 static const uint8 op_load_s32_T0_T1_T2_code[] = {
1063 0x8b, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb
1064 };
1065 copy_block(op_load_s32_T0_T1_T2_code, 11);
1066 inc_code_ptr(11);
1067 }
1068 #endif
1069
1070 DEFINE_GEN(gen_op_store_32_T0_T1_T2,void,(void))
1071 #ifdef DYNGEN_IMPL
1072 #define HAVE_gen_op_store_32_T0_T1_T2
1073 {
1074 static const uint8 op_store_32_T0_T1_T2_code[] = {
1075 0x8d, 0x14, 0x3e, 0x89, 0xd8, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, 0x00,
1076 0x11
1077 };
1078 copy_block(op_store_32_T0_T1_T2_code, 13);
1079 inc_code_ptr(13);
1080 }
1081 #endif
1082
1083 DEFINE_GEN(gen_op_load_u16_T0_T1_0,void,(void))
1084 #ifdef DYNGEN_IMPL
1085 #define HAVE_gen_op_load_u16_T0_T1_0
1086 {
1087 static const uint8 op_load_u16_T0_T1_0_code[] = {
1088 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, 0x0f,
1089 0xb7, 0xd8
1090 };
1091 copy_block(op_load_u16_T0_T1_0_code, 14);
1092 inc_code_ptr(14);
1093 }
1094 #endif
1095
1096 DEFINE_GEN(gen_op_load_s16_T0_T1_0,void,(void))
1097 #ifdef DYNGEN_IMPL
1098 #define HAVE_gen_op_load_s16_T0_T1_0
1099 {
1100 static const uint8 op_load_s16_T0_T1_0_code[] = {
1101 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, 0x0f,
1102 0xbf, 0xd8
1103 };
1104 copy_block(op_load_s16_T0_T1_0_code, 14);
1105 inc_code_ptr(14);
1106 }
1107 #endif
1108
1109 DEFINE_GEN(gen_op_store_16_T0_T1_0,void,(void))
1110 #ifdef DYNGEN_IMPL
1111 #define HAVE_gen_op_store_16_T0_T1_0
1112 {
1113 static const uint8 op_store_16_T0_T1_0_code[] = {
1114 0x0f, 0xb7, 0xc3, 0x66, 0xc1, 0xc0, 0x08, 0x66, 0x89, 0x86, 0x00, 0x00,
1115 0x00, 0x11
1116 };
1117 copy_block(op_store_16_T0_T1_0_code, 14);
1118 inc_code_ptr(14);
1119 }
1120 #endif
1121
1122 DEFINE_GEN(gen_op_load_u16_T0_T1_im,void,(long param1))
1123 #ifdef DYNGEN_IMPL
1124 #define HAVE_gen_op_load_u16_T0_T1_im
1125 {
1126 static const uint8 op_load_u16_T0_T1_im_code[] = {
1127 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, 0x0f,
1128 0xb7, 0xd8
1129 };
1130 copy_block(op_load_u16_T0_T1_im_code, 14);
1131 *(uint32_t *)(code_ptr() + 3) = param1 + 285212672;
1132 inc_code_ptr(14);
1133 }
1134 #endif
1135
1136 DEFINE_GEN(gen_op_load_s16_T0_T1_im,void,(long param1))
1137 #ifdef DYNGEN_IMPL
1138 #define HAVE_gen_op_load_s16_T0_T1_im
1139 {
1140 static const uint8 op_load_s16_T0_T1_im_code[] = {
1141 0x0f, 0xb7, 0x86, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08, 0x0f,
1142 0xbf, 0xd8
1143 };
1144 copy_block(op_load_s16_T0_T1_im_code, 14);
1145 *(uint32_t *)(code_ptr() + 3) = param1 + 285212672;
1146 inc_code_ptr(14);
1147 }
1148 #endif
1149
1150 DEFINE_GEN(gen_op_store_16_T0_T1_im,void,(long param1))
1151 #ifdef DYNGEN_IMPL
1152 #define HAVE_gen_op_store_16_T0_T1_im
1153 {
1154 static const uint8 op_store_16_T0_T1_im_code[] = {
1155 0x8d, 0x96, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xb7, 0xc3, 0x66, 0xc1, 0xc0,
1156 0x08, 0x66, 0x89, 0x82, 0x00, 0x00, 0x00, 0x11
1157 };
1158 copy_block(op_store_16_T0_T1_im_code, 20);
1159 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
1160 inc_code_ptr(20);
1161 }
1162 #endif
1163
1164 DEFINE_GEN(gen_op_load_u16_T0_T1_T2,void,(void))
1165 #ifdef DYNGEN_IMPL
1166 #define HAVE_gen_op_load_u16_T0_T1_T2
1167 {
1168 static const uint8 op_load_u16_T0_T1_T2_code[] = {
1169 0x0f, 0xb7, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08,
1170 0x0f, 0xb7, 0xd8
1171 };
1172 copy_block(op_load_u16_T0_T1_T2_code, 15);
1173 inc_code_ptr(15);
1174 }
1175 #endif
1176
1177 DEFINE_GEN(gen_op_load_s16_T0_T1_T2,void,(void))
1178 #ifdef DYNGEN_IMPL
1179 #define HAVE_gen_op_load_s16_T0_T1_T2
1180 {
1181 static const uint8 op_load_s16_T0_T1_T2_code[] = {
1182 0x0f, 0xb7, 0x84, 0x3e, 0x00, 0x00, 0x00, 0x11, 0x66, 0xc1, 0xc0, 0x08,
1183 0x0f, 0xbf, 0xd8
1184 };
1185 copy_block(op_load_s16_T0_T1_T2_code, 15);
1186 inc_code_ptr(15);
1187 }
1188 #endif
1189
1190 DEFINE_GEN(gen_op_store_16_T0_T1_T2,void,(void))
1191 #ifdef DYNGEN_IMPL
1192 #define HAVE_gen_op_store_16_T0_T1_T2
1193 {
1194 static const uint8 op_store_16_T0_T1_T2_code[] = {
1195 0x8d, 0x14, 0x3e, 0x0f, 0xb7, 0xc3, 0x66, 0xc1, 0xc0, 0x08, 0x66, 0x89,
1196 0x82, 0x00, 0x00, 0x00, 0x11
1197 };
1198 copy_block(op_store_16_T0_T1_T2_code, 17);
1199 inc_code_ptr(17);
1200 }
1201 #endif
1202
1203 DEFINE_GEN(gen_op_load_u8_T0_T1_0,void,(void))
1204 #ifdef DYNGEN_IMPL
1205 #define HAVE_gen_op_load_u8_T0_T1_0
1206 {
1207 static const uint8 op_load_u8_T0_T1_0_code[] = {
1208 0x0f, 0xb6, 0x9e, 0x00, 0x00, 0x00, 0x11
1209 };
1210 copy_block(op_load_u8_T0_T1_0_code, 7);
1211 inc_code_ptr(7);
1212 }
1213 #endif
1214
1215 DEFINE_GEN(gen_op_load_s8_T0_T1_0,void,(void))
1216 #ifdef DYNGEN_IMPL
1217 #define HAVE_gen_op_load_s8_T0_T1_0
1218 {
1219 static const uint8 op_load_s8_T0_T1_0_code[] = {
1220 0x0f, 0xbe, 0x9e, 0x00, 0x00, 0x00, 0x11
1221 };
1222 copy_block(op_load_s8_T0_T1_0_code, 7);
1223 inc_code_ptr(7);
1224 }
1225 #endif
1226
1227 DEFINE_GEN(gen_op_store_8_T0_T1_0,void,(void))
1228 #ifdef DYNGEN_IMPL
1229 #define HAVE_gen_op_store_8_T0_T1_0
1230 {
1231 static const uint8 op_store_8_T0_T1_0_code[] = {
1232 0x88, 0x9e, 0x00, 0x00, 0x00, 0x11
1233 };
1234 copy_block(op_store_8_T0_T1_0_code, 6);
1235 inc_code_ptr(6);
1236 }
1237 #endif
1238
1239 DEFINE_GEN(gen_op_load_u8_T0_T1_im,void,(long param1))
1240 #ifdef DYNGEN_IMPL
1241 #define HAVE_gen_op_load_u8_T0_T1_im
1242 {
1243 static const uint8 op_load_u8_T0_T1_im_code[] = {
1244 0x0f, 0xb6, 0x9e, 0x00, 0x00, 0x00, 0x11
1245 };
1246 copy_block(op_load_u8_T0_T1_im_code, 7);
1247 *(uint32_t *)(code_ptr() + 3) = param1 + 285212672;
1248 inc_code_ptr(7);
1249 }
1250 #endif
1251
1252 DEFINE_GEN(gen_op_load_s8_T0_T1_im,void,(long param1))
1253 #ifdef DYNGEN_IMPL
1254 #define HAVE_gen_op_load_s8_T0_T1_im
1255 {
1256 static const uint8 op_load_s8_T0_T1_im_code[] = {
1257 0x0f, 0xbe, 0x9e, 0x00, 0x00, 0x00, 0x11
1258 };
1259 copy_block(op_load_s8_T0_T1_im_code, 7);
1260 *(uint32_t *)(code_ptr() + 3) = param1 + 285212672;
1261 inc_code_ptr(7);
1262 }
1263 #endif
1264
1265 DEFINE_GEN(gen_op_store_8_T0_T1_im,void,(long param1))
1266 #ifdef DYNGEN_IMPL
1267 #define HAVE_gen_op_store_8_T0_T1_im
1268 {
1269 static const uint8 op_store_8_T0_T1_im_code[] = {
1270 0x88, 0x9e, 0x00, 0x00, 0x00, 0x11
1271 };
1272 copy_block(op_store_8_T0_T1_im_code, 6);
1273 *(uint32_t *)(code_ptr() + 2) = param1 + 285212672;
1274 inc_code_ptr(6);
1275 }
1276 #endif
1277
1278 DEFINE_GEN(gen_op_load_u8_T0_T1_T2,void,(void))
1279 #ifdef DYNGEN_IMPL
1280 #define HAVE_gen_op_load_u8_T0_T1_T2
1281 {
1282 static const uint8 op_load_u8_T0_T1_T2_code[] = {
1283 0x0f, 0xb6, 0x9c, 0x3e, 0x00, 0x00, 0x00, 0x11
1284 };
1285 copy_block(op_load_u8_T0_T1_T2_code, 8);
1286 inc_code_ptr(8);
1287 }
1288 #endif
1289
1290 DEFINE_GEN(gen_op_load_s8_T0_T1_T2,void,(void))
1291 #ifdef DYNGEN_IMPL
1292 #define HAVE_gen_op_load_s8_T0_T1_T2
1293 {
1294 static const uint8 op_load_s8_T0_T1_T2_code[] = {
1295 0x0f, 0xbe, 0x9c, 0x3e, 0x00, 0x00, 0x00, 0x11
1296 };
1297 copy_block(op_load_s8_T0_T1_T2_code, 8);
1298 inc_code_ptr(8);
1299 }
1300 #endif
1301
1302 DEFINE_GEN(gen_op_store_8_T0_T1_T2,void,(void))
1303 #ifdef DYNGEN_IMPL
1304 #define HAVE_gen_op_store_8_T0_T1_T2
1305 {
1306 static const uint8 op_store_8_T0_T1_T2_code[] = {
1307 0x88, 0x9c, 0x3e, 0x00, 0x00, 0x00, 0x11
1308 };
1309 copy_block(op_store_8_T0_T1_T2_code, 7);
1310 inc_code_ptr(7);
1311 }
1312 #endif
1313
1314 DEFINE_GEN(gen_op_execute,void,(void))
1315 #ifdef DYNGEN_IMPL
1316 #define HAVE_gen_op_execute
1317 {
1318 static const uint8 op_execute_code[] = {
1319 0x83, 0xec, 0x50, 0x89, 0x6c, 0x24, 0x4c, 0x8b, 0x6c, 0x24, 0x58, 0x89,
1320 0x5c, 0x24, 0x48, 0x89, 0x74, 0x24, 0x44, 0x89, 0x7c, 0x24, 0x40, 0xff,
1321 0x64, 0x24, 0x54, 0x90, 0x8d, 0x74, 0x26, 0x00, 0xff, 0x54, 0x24, 0x54,
1322 0x8b, 0x7c, 0x24, 0x40, 0x8b, 0x74, 0x24, 0x44, 0x8b, 0x5c, 0x24, 0x48,
1323 0x8b, 0x6c, 0x24, 0x4c, 0x83, 0xc4, 0x50, 0xc3, 0x90, 0x8d, 0xb4, 0x26,
1324 0x00, 0x00, 0x00, 0x00
1325 };
1326 copy_block(op_execute_code, 64);
1327 inc_code_ptr(64);
1328 }
1329 #endif
1330
1331 DEFINE_GEN(gen_op_jmp_slow,void,(long param1))
1332 #ifdef DYNGEN_IMPL
1333 #define HAVE_gen_op_jmp_slow
1334 {
1335 static const uint8 op_jmp_slow_code[] = {
1336 0xb8, 0x00, 0x00, 0x00, 0x00, 0xff, 0xe0
1337 };
1338 copy_block(op_jmp_slow_code, 7);
1339 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
1340 inc_code_ptr(7);
1341 }
1342 #endif
1343
1344 DEFINE_GEN(gen_op_jmp_fast,void,(long param1))
1345 #ifdef DYNGEN_IMPL
1346 #define HAVE_gen_op_jmp_fast
1347 {
1348 static const uint8 op_jmp_fast_code[] = {
1349 0xe9, 0x00, 0x00, 0x00, 0x00
1350 };
1351 copy_block(op_jmp_fast_code, 5);
1352 *(uint32_t *)(code_ptr() + 1) = param1 - (long)(code_ptr() + 1) + 0 -4;
1353 inc_code_ptr(5);
1354 }
1355 #endif
1356
1357 DEFINE_GEN(gen_op_jmp_A0,void,(void))
1358 #ifdef DYNGEN_IMPL
1359 #define HAVE_gen_op_jmp_A0
1360 {
1361 static const uint8 op_jmp_A0_code[] = {
1362 0xff, 0xe3
1363 };
1364 copy_block(op_jmp_A0_code, 2);
1365 inc_code_ptr(2);
1366 }
1367 #endif
1368
1369 DEFINE_GEN(gen_op_invoke,void,(long param1))
1370 #ifdef DYNGEN_IMPL
1371 #define HAVE_gen_op_invoke
1372 {
1373 static const uint8 helper_op_invoke_code[] = {
1374 0xe8, 0x00, 0x00, 0x00, 0x00
1375 };
1376 copy_block(helper_op_invoke_code, 5);
1377 *(uint32_t *)(code_ptr() + 1) = param1 - (long)(code_ptr() + 1) + 0 -4;
1378 inc_code_ptr(5);
1379 }
1380 #endif
1381
1382 DEFINE_GEN(gen_op_invoke_T0,void,(long param1))
1383 #ifdef DYNGEN_IMPL
1384 #define HAVE_gen_op_invoke_T0
1385 {
1386 static const uint8 helper_op_invoke_T0_code[] = {
1387 0x83, 0xec, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x58
1388 };
1389 copy_block(helper_op_invoke_T0_code, 12);
1390 *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4;
1391 inc_code_ptr(12);
1392 }
1393 #endif
1394
1395 DEFINE_GEN(gen_op_invoke_T0_T1,void,(long param1))
1396 #ifdef DYNGEN_IMPL
1397 #define HAVE_gen_op_invoke_T0_T1
1398 {
1399 static const uint8 helper_op_invoke_T0_T1_code[] = {
1400 0x83, 0xec, 0x08, 0x89, 0x74, 0x24, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00,
1401 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08
1402 };
1403 copy_block(helper_op_invoke_T0_T1_code, 18);
1404 *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4;
1405 inc_code_ptr(18);
1406 }
1407 #endif
1408
1409 DEFINE_GEN(gen_op_invoke_T0_T1_T2,void,(long param1))
1410 #ifdef DYNGEN_IMPL
1411 #define HAVE_gen_op_invoke_T0_T1_T2
1412 {
1413 static const uint8 helper_op_invoke_T0_T1_T2_code[] = {
1414 0x83, 0xec, 0x0c, 0x89, 0x7c, 0x24, 0x08, 0x89, 0x74, 0x24, 0x04, 0x89,
1415 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x0c
1416 };
1417 copy_block(helper_op_invoke_T0_T1_T2_code, 22);
1418 *(uint32_t *)(code_ptr() + 15) = param1 - (long)(code_ptr() + 15) + 0 -4;
1419 inc_code_ptr(22);
1420 }
1421 #endif
1422
1423 DEFINE_GEN(gen_op_invoke_T0_ret_T0,void,(long param1))
1424 #ifdef DYNGEN_IMPL
1425 #define HAVE_gen_op_invoke_T0_ret_T0
1426 {
1427 static const uint8 helper_op_invoke_T0_ret_T0_code[] = {
1428 0x83, 0xec, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x5a,
1429 0x89, 0xc3
1430 };
1431 copy_block(helper_op_invoke_T0_ret_T0_code, 14);
1432 *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4;
1433 inc_code_ptr(14);
1434 }
1435 #endif
1436
1437 DEFINE_GEN(gen_op_invoke_im,void,(long param1, long param2))
1438 #ifdef DYNGEN_IMPL
1439 #define HAVE_gen_op_invoke_im
1440 {
1441 static const uint8 helper_op_invoke_im_code[] = {
1442 0x83, 0xec, 0x04, 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x00,
1443 0x00, 0x00, 0x00, 0x59
1444 };
1445 copy_block(helper_op_invoke_im_code, 16);
1446 *(uint32_t *)(code_ptr() + 6) = param2 + 0;
1447 *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4;
1448 inc_code_ptr(16);
1449 }
1450 #endif
1451
1452 DEFINE_GEN(gen_op_invoke_CPU,void,(long param1))
1453 #ifdef DYNGEN_IMPL
1454 #define HAVE_gen_op_invoke_CPU
1455 {
1456 static const uint8 helper_op_invoke_CPU_code[] = {
1457 0x83, 0xec, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x58
1458 };
1459 copy_block(helper_op_invoke_CPU_code, 12);
1460 *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4;
1461 inc_code_ptr(12);
1462 }
1463 #endif
1464
1465 DEFINE_GEN(gen_op_invoke_CPU_T0,void,(long param1))
1466 #ifdef DYNGEN_IMPL
1467 #define HAVE_gen_op_invoke_CPU_T0
1468 {
1469 static const uint8 helper_op_invoke_CPU_T0_code[] = {
1470 0x83, 0xec, 0x08, 0x89, 0x5c, 0x24, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00,
1471 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08
1472 };
1473 copy_block(helper_op_invoke_CPU_T0_code, 18);
1474 *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4;
1475 inc_code_ptr(18);
1476 }
1477 #endif
1478
1479 DEFINE_GEN(gen_op_invoke_CPU_im,void,(long param1, long param2))
1480 #ifdef DYNGEN_IMPL
1481 #define HAVE_gen_op_invoke_CPU_im
1482 {
1483 static const uint8 helper_op_invoke_CPU_im_code[] = {
1484 0x83, 0xec, 0x08, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x04,
1485 0x89, 0x2c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08
1486 };
1487 copy_block(helper_op_invoke_CPU_im_code, 23);
1488 *(uint32_t *)(code_ptr() + 4) = param2 + 0;
1489 *(uint32_t *)(code_ptr() + 16) = param1 - (long)(code_ptr() + 16) + 0 -4;
1490 inc_code_ptr(23);
1491 }
1492 #endif
1493
1494 DEFINE_GEN(gen_op_invoke_CPU_im_im,void,(long param1, long param2, long param3))
1495 #ifdef DYNGEN_IMPL
1496 #define HAVE_gen_op_invoke_CPU_im_im
1497 {
1498 static const uint8 helper_op_invoke_CPU_im_im_code[] = {
1499 0x83, 0xec, 0x0c, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x08,
1500 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x04, 0x89, 0x2c, 0x24,
1501 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x0c
1502 };
1503 copy_block(helper_op_invoke_CPU_im_im_code, 32);
1504 *(uint32_t *)(code_ptr() + 4) = param3 + 0;
1505 *(uint32_t *)(code_ptr() + 13) = param2 + 0;
1506 *(uint32_t *)(code_ptr() + 25) = param1 - (long)(code_ptr() + 25) + 0 -4;
1507 inc_code_ptr(32);
1508 }
1509 #endif
1510
1511 DEFINE_GEN(gen_op_invoke_CPU_A0_ret_A0,void,(long param1))
1512 #ifdef DYNGEN_IMPL
1513 #define HAVE_gen_op_invoke_CPU_A0_ret_A0
1514 {
1515 static const uint8 helper_op_invoke_CPU_A0_ret_A0_code[] = {
1516 0x83, 0xec, 0x08, 0x89, 0x5c, 0x24, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00,
1517 0x00, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xc4, 0x08
1518 };
1519 copy_block(helper_op_invoke_CPU_A0_ret_A0_code, 20);
1520 *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4;
1521 inc_code_ptr(20);
1522 }
1523 #endif
1524
1525 DEFINE_GEN(gen_op_invoke_direct,void,(long param1))
1526 #ifdef DYNGEN_IMPL
1527 #define HAVE_gen_op_invoke_direct
1528 {
1529 static const uint8 helper_op_invoke_direct_code[] = {
1530 0xe8, 0x00, 0x00, 0x00, 0x00
1531 };
1532 copy_block(helper_op_invoke_direct_code, 5);
1533 *(uint32_t *)(code_ptr() + 1) = param1 - (long)(code_ptr() + 1) + 0 -4;
1534 inc_code_ptr(5);
1535 }
1536 #endif
1537
1538 DEFINE_GEN(gen_op_invoke_direct_T0,void,(long param1))
1539 #ifdef DYNGEN_IMPL
1540 #define HAVE_gen_op_invoke_direct_T0
1541 {
1542 static const uint8 helper_op_invoke_direct_T0_code[] = {
1543 0x83, 0xec, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x58
1544 };
1545 copy_block(helper_op_invoke_direct_T0_code, 12);
1546 *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4;
1547 inc_code_ptr(12);
1548 }
1549 #endif
1550
1551 DEFINE_GEN(gen_op_invoke_direct_T0_T1,void,(long param1))
1552 #ifdef DYNGEN_IMPL
1553 #define HAVE_gen_op_invoke_direct_T0_T1
1554 {
1555 static const uint8 helper_op_invoke_direct_T0_T1_code[] = {
1556 0x83, 0xec, 0x08, 0x89, 0x74, 0x24, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00,
1557 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08
1558 };
1559 copy_block(helper_op_invoke_direct_T0_T1_code, 18);
1560 *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4;
1561 inc_code_ptr(18);
1562 }
1563 #endif
1564
1565 DEFINE_GEN(gen_op_invoke_direct_T0_T1_T2,void,(long param1))
1566 #ifdef DYNGEN_IMPL
1567 #define HAVE_gen_op_invoke_direct_T0_T1_T2
1568 {
1569 static const uint8 helper_op_invoke_direct_T0_T1_T2_code[] = {
1570 0x83, 0xec, 0x0c, 0x89, 0x7c, 0x24, 0x08, 0x89, 0x74, 0x24, 0x04, 0x89,
1571 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x0c
1572 };
1573 copy_block(helper_op_invoke_direct_T0_T1_T2_code, 22);
1574 *(uint32_t *)(code_ptr() + 15) = param1 - (long)(code_ptr() + 15) + 0 -4;
1575 inc_code_ptr(22);
1576 }
1577 #endif
1578
1579 DEFINE_GEN(gen_op_invoke_direct_T0_ret_T0,void,(long param1))
1580 #ifdef DYNGEN_IMPL
1581 #define HAVE_gen_op_invoke_direct_T0_ret_T0
1582 {
1583 static const uint8 helper_op_invoke_direct_T0_ret_T0_code[] = {
1584 0x83, 0xec, 0x04, 0x89, 0x1c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x89,
1585 0xc3, 0x58
1586 };
1587 copy_block(helper_op_invoke_direct_T0_ret_T0_code, 14);
1588 *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4;
1589 inc_code_ptr(14);
1590 }
1591 #endif
1592
1593 DEFINE_GEN(gen_op_invoke_direct_im,void,(long param1, long param2))
1594 #ifdef DYNGEN_IMPL
1595 #define HAVE_gen_op_invoke_direct_im
1596 {
1597 static const uint8 helper_op_invoke_direct_im_code[] = {
1598 0x83, 0xec, 0x04, 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x00,
1599 0x00, 0x00, 0x00, 0x5a
1600 };
1601 copy_block(helper_op_invoke_direct_im_code, 16);
1602 *(uint32_t *)(code_ptr() + 6) = param2 + 0;
1603 *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4;
1604 inc_code_ptr(16);
1605 }
1606 #endif
1607
1608 DEFINE_GEN(gen_op_invoke_direct_CPU,void,(long param1))
1609 #ifdef DYNGEN_IMPL
1610 #define HAVE_gen_op_invoke_direct_CPU
1611 {
1612 static const uint8 helper_op_invoke_direct_CPU_code[] = {
1613 0x83, 0xec, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x59
1614 };
1615 copy_block(helper_op_invoke_direct_CPU_code, 12);
1616 *(uint32_t *)(code_ptr() + 7) = param1 - (long)(code_ptr() + 7) + 0 -4;
1617 inc_code_ptr(12);
1618 }
1619 #endif
1620
1621 DEFINE_GEN(gen_op_invoke_direct_CPU_T0,void,(long param1))
1622 #ifdef DYNGEN_IMPL
1623 #define HAVE_gen_op_invoke_direct_CPU_T0
1624 {
1625 static const uint8 helper_op_invoke_direct_CPU_T0_code[] = {
1626 0x83, 0xec, 0x08, 0x89, 0x5c, 0x24, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00,
1627 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08
1628 };
1629 copy_block(helper_op_invoke_direct_CPU_T0_code, 18);
1630 *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4;
1631 inc_code_ptr(18);
1632 }
1633 #endif
1634
1635 DEFINE_GEN(gen_op_invoke_direct_CPU_im,void,(long param1, long param2))
1636 #ifdef DYNGEN_IMPL
1637 #define HAVE_gen_op_invoke_direct_CPU_im
1638 {
1639 static const uint8 helper_op_invoke_direct_CPU_im_code[] = {
1640 0x83, 0xec, 0x08, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x04,
1641 0x89, 0x2c, 0x24, 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x08
1642 };
1643 copy_block(helper_op_invoke_direct_CPU_im_code, 23);
1644 *(uint32_t *)(code_ptr() + 4) = param2 + 0;
1645 *(uint32_t *)(code_ptr() + 16) = param1 - (long)(code_ptr() + 16) + 0 -4;
1646 inc_code_ptr(23);
1647 }
1648 #endif
1649
1650 DEFINE_GEN(gen_op_invoke_direct_CPU_im_im,void,(long param1, long param2, long param3))
1651 #ifdef DYNGEN_IMPL
1652 #define HAVE_gen_op_invoke_direct_CPU_im_im
1653 {
1654 static const uint8 helper_op_invoke_direct_CPU_im_im_code[] = {
1655 0x83, 0xec, 0x0c, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x08,
1656 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x44, 0x24, 0x04, 0x89, 0x2c, 0x24,
1657 0xe8, 0x00, 0x00, 0x00, 0x00, 0x83, 0xc4, 0x0c
1658 };
1659 copy_block(helper_op_invoke_direct_CPU_im_im_code, 32);
1660 *(uint32_t *)(code_ptr() + 4) = param3 + 0;
1661 *(uint32_t *)(code_ptr() + 13) = param2 + 0;
1662 *(uint32_t *)(code_ptr() + 25) = param1 - (long)(code_ptr() + 25) + 0 -4;
1663 inc_code_ptr(32);
1664 }
1665 #endif
1666
1667 DEFINE_GEN(gen_op_invoke_direct_CPU_A0_ret_A0,void,(long param1))
1668 #ifdef DYNGEN_IMPL
1669 #define HAVE_gen_op_invoke_direct_CPU_A0_ret_A0
1670 {
1671 static const uint8 helper_op_invoke_direct_CPU_A0_ret_A0_code[] = {
1672 0x83, 0xec, 0x08, 0x89, 0x5c, 0x24, 0x04, 0x89, 0x2c, 0x24, 0xe8, 0x00,
1673 0x00, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xc4, 0x08
1674 };
1675 copy_block(helper_op_invoke_direct_CPU_A0_ret_A0_code, 20);
1676 *(uint32_t *)(code_ptr() + 11) = param1 - (long)(code_ptr() + 11) + 0 -4;
1677 inc_code_ptr(20);
1678 }
1679 #endif
1680
1681 DEFINE_CST(op_exec_return_offset,0x24L)
1682
1683 #undef DEFINE_CST
1684 #undef DEFINE_GEN