Debian Codegraph @

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

raw
1 #ifndef DEFINE_CST
2 #define DEFINE_CST(NAME, VALUE)
3 #endif
4 DEFINE_GEN(gen_op_load_T0_GPR0,void,(void))
5 #ifdef DYNGEN_IMPL
6 #define HAVE_gen_op_load_T0_GPR0
7 {
8 static const uint8 op_load_T0_GPR0_code[] = {
9 0x8b, 0x5d, 0x10
10 };
11 copy_block(op_load_T0_GPR0_code, 3);
12 inc_code_ptr(3);
13 }
14 #endif
15
16 DEFINE_GEN(gen_op_store_T0_GPR0,void,(void))
17 #ifdef DYNGEN_IMPL
18 #define HAVE_gen_op_store_T0_GPR0
19 {
20 static const uint8 op_store_T0_GPR0_code[] = {
21 0x89, 0x5d, 0x10
22 };
23 copy_block(op_store_T0_GPR0_code, 3);
24 inc_code_ptr(3);
25 }
26 #endif
27
28 DEFINE_GEN(gen_op_load_T1_GPR0,void,(void))
29 #ifdef DYNGEN_IMPL
30 #define HAVE_gen_op_load_T1_GPR0
31 {
32 static const uint8 op_load_T1_GPR0_code[] = {
33 0x8b, 0x75, 0x10
34 };
35 copy_block(op_load_T1_GPR0_code, 3);
36 inc_code_ptr(3);
37 }
38 #endif
39
40 DEFINE_GEN(gen_op_store_T1_GPR0,void,(void))
41 #ifdef DYNGEN_IMPL
42 #define HAVE_gen_op_store_T1_GPR0
43 {
44 static const uint8 op_store_T1_GPR0_code[] = {
45 0x89, 0x75, 0x10
46 };
47 copy_block(op_store_T1_GPR0_code, 3);
48 inc_code_ptr(3);
49 }
50 #endif
51
52 DEFINE_GEN(gen_op_load_T2_GPR0,void,(void))
53 #ifdef DYNGEN_IMPL
54 #define HAVE_gen_op_load_T2_GPR0
55 {
56 static const uint8 op_load_T2_GPR0_code[] = {
57 0x8b, 0x7d, 0x10
58 };
59 copy_block(op_load_T2_GPR0_code, 3);
60 inc_code_ptr(3);
61 }
62 #endif
63
64 DEFINE_GEN(gen_op_store_T2_GPR0,void,(void))
65 #ifdef DYNGEN_IMPL
66 #define HAVE_gen_op_store_T2_GPR0
67 {
68 static const uint8 op_store_T2_GPR0_code[] = {
69 0x89, 0x7d, 0x10
70 };
71 copy_block(op_store_T2_GPR0_code, 3);
72 inc_code_ptr(3);
73 }
74 #endif
75
76 DEFINE_GEN(gen_op_load_T0_GPR1,void,(void))
77 #ifdef DYNGEN_IMPL
78 #define HAVE_gen_op_load_T0_GPR1
79 {
80 static const uint8 op_load_T0_GPR1_code[] = {
81 0x8b, 0x5d, 0x14
82 };
83 copy_block(op_load_T0_GPR1_code, 3);
84 inc_code_ptr(3);
85 }
86 #endif
87
88 DEFINE_GEN(gen_op_store_T0_GPR1,void,(void))
89 #ifdef DYNGEN_IMPL
90 #define HAVE_gen_op_store_T0_GPR1
91 {
92 static const uint8 op_store_T0_GPR1_code[] = {
93 0x89, 0x5d, 0x14
94 };
95 copy_block(op_store_T0_GPR1_code, 3);
96 inc_code_ptr(3);
97 }
98 #endif
99
100 DEFINE_GEN(gen_op_load_T1_GPR1,void,(void))
101 #ifdef DYNGEN_IMPL
102 #define HAVE_gen_op_load_T1_GPR1
103 {
104 static const uint8 op_load_T1_GPR1_code[] = {
105 0x8b, 0x75, 0x14
106 };
107 copy_block(op_load_T1_GPR1_code, 3);
108 inc_code_ptr(3);
109 }
110 #endif
111
112 DEFINE_GEN(gen_op_store_T1_GPR1,void,(void))
113 #ifdef DYNGEN_IMPL
114 #define HAVE_gen_op_store_T1_GPR1
115 {
116 static const uint8 op_store_T1_GPR1_code[] = {
117 0x89, 0x75, 0x14
118 };
119 copy_block(op_store_T1_GPR1_code, 3);
120 inc_code_ptr(3);
121 }
122 #endif
123
124 DEFINE_GEN(gen_op_load_T2_GPR1,void,(void))
125 #ifdef DYNGEN_IMPL
126 #define HAVE_gen_op_load_T2_GPR1
127 {
128 static const uint8 op_load_T2_GPR1_code[] = {
129 0x8b, 0x7d, 0x14
130 };
131 copy_block(op_load_T2_GPR1_code, 3);
132 inc_code_ptr(3);
133 }
134 #endif
135
136 DEFINE_GEN(gen_op_store_T2_GPR1,void,(void))
137 #ifdef DYNGEN_IMPL
138 #define HAVE_gen_op_store_T2_GPR1
139 {
140 static const uint8 op_store_T2_GPR1_code[] = {
141 0x89, 0x7d, 0x14
142 };
143 copy_block(op_store_T2_GPR1_code, 3);
144 inc_code_ptr(3);
145 }
146 #endif
147
148 DEFINE_GEN(gen_op_load_T0_GPR2,void,(void))
149 #ifdef DYNGEN_IMPL
150 #define HAVE_gen_op_load_T0_GPR2
151 {
152 static const uint8 op_load_T0_GPR2_code[] = {
153 0x8b, 0x5d, 0x18
154 };
155 copy_block(op_load_T0_GPR2_code, 3);
156 inc_code_ptr(3);
157 }
158 #endif
159
160 DEFINE_GEN(gen_op_store_T0_GPR2,void,(void))
161 #ifdef DYNGEN_IMPL
162 #define HAVE_gen_op_store_T0_GPR2
163 {
164 static const uint8 op_store_T0_GPR2_code[] = {
165 0x89, 0x5d, 0x18
166 };
167 copy_block(op_store_T0_GPR2_code, 3);
168 inc_code_ptr(3);
169 }
170 #endif
171
172 DEFINE_GEN(gen_op_load_T1_GPR2,void,(void))
173 #ifdef DYNGEN_IMPL
174 #define HAVE_gen_op_load_T1_GPR2
175 {
176 static const uint8 op_load_T1_GPR2_code[] = {
177 0x8b, 0x75, 0x18
178 };
179 copy_block(op_load_T1_GPR2_code, 3);
180 inc_code_ptr(3);
181 }
182 #endif
183
184 DEFINE_GEN(gen_op_store_T1_GPR2,void,(void))
185 #ifdef DYNGEN_IMPL
186 #define HAVE_gen_op_store_T1_GPR2
187 {
188 static const uint8 op_store_T1_GPR2_code[] = {
189 0x89, 0x75, 0x18
190 };
191 copy_block(op_store_T1_GPR2_code, 3);
192 inc_code_ptr(3);
193 }
194 #endif
195
196 DEFINE_GEN(gen_op_load_T2_GPR2,void,(void))
197 #ifdef DYNGEN_IMPL
198 #define HAVE_gen_op_load_T2_GPR2
199 {
200 static const uint8 op_load_T2_GPR2_code[] = {
201 0x8b, 0x7d, 0x18
202 };
203 copy_block(op_load_T2_GPR2_code, 3);
204 inc_code_ptr(3);
205 }
206 #endif
207
208 DEFINE_GEN(gen_op_store_T2_GPR2,void,(void))
209 #ifdef DYNGEN_IMPL
210 #define HAVE_gen_op_store_T2_GPR2
211 {
212 static const uint8 op_store_T2_GPR2_code[] = {
213 0x89, 0x7d, 0x18
214 };
215 copy_block(op_store_T2_GPR2_code, 3);
216 inc_code_ptr(3);
217 }
218 #endif
219
220 DEFINE_GEN(gen_op_load_T0_GPR3,void,(void))
221 #ifdef DYNGEN_IMPL
222 #define HAVE_gen_op_load_T0_GPR3
223 {
224 static const uint8 op_load_T0_GPR3_code[] = {
225 0x8b, 0x5d, 0x1c
226 };
227 copy_block(op_load_T0_GPR3_code, 3);
228 inc_code_ptr(3);
229 }
230 #endif
231
232 DEFINE_GEN(gen_op_store_T0_GPR3,void,(void))
233 #ifdef DYNGEN_IMPL
234 #define HAVE_gen_op_store_T0_GPR3
235 {
236 static const uint8 op_store_T0_GPR3_code[] = {
237 0x89, 0x5d, 0x1c
238 };
239 copy_block(op_store_T0_GPR3_code, 3);
240 inc_code_ptr(3);
241 }
242 #endif
243
244 DEFINE_GEN(gen_op_load_T1_GPR3,void,(void))
245 #ifdef DYNGEN_IMPL
246 #define HAVE_gen_op_load_T1_GPR3
247 {
248 static const uint8 op_load_T1_GPR3_code[] = {
249 0x8b, 0x75, 0x1c
250 };
251 copy_block(op_load_T1_GPR3_code, 3);
252 inc_code_ptr(3);
253 }
254 #endif
255
256 DEFINE_GEN(gen_op_store_T1_GPR3,void,(void))
257 #ifdef DYNGEN_IMPL
258 #define HAVE_gen_op_store_T1_GPR3
259 {
260 static const uint8 op_store_T1_GPR3_code[] = {
261 0x89, 0x75, 0x1c
262 };
263 copy_block(op_store_T1_GPR3_code, 3);
264 inc_code_ptr(3);
265 }
266 #endif
267
268 DEFINE_GEN(gen_op_load_T2_GPR3,void,(void))
269 #ifdef DYNGEN_IMPL
270 #define HAVE_gen_op_load_T2_GPR3
271 {
272 static const uint8 op_load_T2_GPR3_code[] = {
273 0x8b, 0x7d, 0x1c
274 };
275 copy_block(op_load_T2_GPR3_code, 3);
276 inc_code_ptr(3);
277 }
278 #endif
279
280 DEFINE_GEN(gen_op_store_T2_GPR3,void,(void))
281 #ifdef DYNGEN_IMPL
282 #define HAVE_gen_op_store_T2_GPR3
283 {
284 static const uint8 op_store_T2_GPR3_code[] = {
285 0x89, 0x7d, 0x1c
286 };
287 copy_block(op_store_T2_GPR3_code, 3);
288 inc_code_ptr(3);
289 }
290 #endif
291
292 DEFINE_GEN(gen_op_load_T0_GPR4,void,(void))
293 #ifdef DYNGEN_IMPL
294 #define HAVE_gen_op_load_T0_GPR4
295 {
296 static const uint8 op_load_T0_GPR4_code[] = {
297 0x8b, 0x5d, 0x20
298 };
299 copy_block(op_load_T0_GPR4_code, 3);
300 inc_code_ptr(3);
301 }
302 #endif
303
304 DEFINE_GEN(gen_op_store_T0_GPR4,void,(void))
305 #ifdef DYNGEN_IMPL
306 #define HAVE_gen_op_store_T0_GPR4
307 {
308 static const uint8 op_store_T0_GPR4_code[] = {
309 0x89, 0x5d, 0x20
310 };
311 copy_block(op_store_T0_GPR4_code, 3);
312 inc_code_ptr(3);
313 }
314 #endif
315
316 DEFINE_GEN(gen_op_load_T1_GPR4,void,(void))
317 #ifdef DYNGEN_IMPL
318 #define HAVE_gen_op_load_T1_GPR4
319 {
320 static const uint8 op_load_T1_GPR4_code[] = {
321 0x8b, 0x75, 0x20
322 };
323 copy_block(op_load_T1_GPR4_code, 3);
324 inc_code_ptr(3);
325 }
326 #endif
327
328 DEFINE_GEN(gen_op_store_T1_GPR4,void,(void))
329 #ifdef DYNGEN_IMPL
330 #define HAVE_gen_op_store_T1_GPR4
331 {
332 static const uint8 op_store_T1_GPR4_code[] = {
333 0x89, 0x75, 0x20
334 };
335 copy_block(op_store_T1_GPR4_code, 3);
336 inc_code_ptr(3);
337 }
338 #endif
339
340 DEFINE_GEN(gen_op_load_T2_GPR4,void,(void))
341 #ifdef DYNGEN_IMPL
342 #define HAVE_gen_op_load_T2_GPR4
343 {
344 static const uint8 op_load_T2_GPR4_code[] = {
345 0x8b, 0x7d, 0x20
346 };
347 copy_block(op_load_T2_GPR4_code, 3);
348 inc_code_ptr(3);
349 }
350 #endif
351
352 DEFINE_GEN(gen_op_store_T2_GPR4,void,(void))
353 #ifdef DYNGEN_IMPL
354 #define HAVE_gen_op_store_T2_GPR4
355 {
356 static const uint8 op_store_T2_GPR4_code[] = {
357 0x89, 0x7d, 0x20
358 };
359 copy_block(op_store_T2_GPR4_code, 3);
360 inc_code_ptr(3);
361 }
362 #endif
363
364 DEFINE_GEN(gen_op_load_T0_GPR5,void,(void))
365 #ifdef DYNGEN_IMPL
366 #define HAVE_gen_op_load_T0_GPR5
367 {
368 static const uint8 op_load_T0_GPR5_code[] = {
369 0x8b, 0x5d, 0x24
370 };
371 copy_block(op_load_T0_GPR5_code, 3);
372 inc_code_ptr(3);
373 }
374 #endif
375
376 DEFINE_GEN(gen_op_store_T0_GPR5,void,(void))
377 #ifdef DYNGEN_IMPL
378 #define HAVE_gen_op_store_T0_GPR5
379 {
380 static const uint8 op_store_T0_GPR5_code[] = {
381 0x89, 0x5d, 0x24
382 };
383 copy_block(op_store_T0_GPR5_code, 3);
384 inc_code_ptr(3);
385 }
386 #endif
387
388 DEFINE_GEN(gen_op_load_T1_GPR5,void,(void))
389 #ifdef DYNGEN_IMPL
390 #define HAVE_gen_op_load_T1_GPR5
391 {
392 static const uint8 op_load_T1_GPR5_code[] = {
393 0x8b, 0x75, 0x24
394 };
395 copy_block(op_load_T1_GPR5_code, 3);
396 inc_code_ptr(3);
397 }
398 #endif
399
400 DEFINE_GEN(gen_op_store_T1_GPR5,void,(void))
401 #ifdef DYNGEN_IMPL
402 #define HAVE_gen_op_store_T1_GPR5
403 {
404 static const uint8 op_store_T1_GPR5_code[] = {
405 0x89, 0x75, 0x24
406 };
407 copy_block(op_store_T1_GPR5_code, 3);
408 inc_code_ptr(3);
409 }
410 #endif
411
412 DEFINE_GEN(gen_op_load_T2_GPR5,void,(void))
413 #ifdef DYNGEN_IMPL
414 #define HAVE_gen_op_load_T2_GPR5
415 {
416 static const uint8 op_load_T2_GPR5_code[] = {
417 0x8b, 0x7d, 0x24
418 };
419 copy_block(op_load_T2_GPR5_code, 3);
420 inc_code_ptr(3);
421 }
422 #endif
423
424 DEFINE_GEN(gen_op_store_T2_GPR5,void,(void))
425 #ifdef DYNGEN_IMPL
426 #define HAVE_gen_op_store_T2_GPR5
427 {
428 static const uint8 op_store_T2_GPR5_code[] = {
429 0x89, 0x7d, 0x24
430 };
431 copy_block(op_store_T2_GPR5_code, 3);
432 inc_code_ptr(3);
433 }
434 #endif
435
436 DEFINE_GEN(gen_op_load_T0_GPR6,void,(void))
437 #ifdef DYNGEN_IMPL
438 #define HAVE_gen_op_load_T0_GPR6
439 {
440 static const uint8 op_load_T0_GPR6_code[] = {
441 0x8b, 0x5d, 0x28
442 };
443 copy_block(op_load_T0_GPR6_code, 3);
444 inc_code_ptr(3);
445 }
446 #endif
447
448 DEFINE_GEN(gen_op_store_T0_GPR6,void,(void))
449 #ifdef DYNGEN_IMPL
450 #define HAVE_gen_op_store_T0_GPR6
451 {
452 static const uint8 op_store_T0_GPR6_code[] = {
453 0x89, 0x5d, 0x28
454 };
455 copy_block(op_store_T0_GPR6_code, 3);
456 inc_code_ptr(3);
457 }
458 #endif
459
460 DEFINE_GEN(gen_op_load_T1_GPR6,void,(void))
461 #ifdef DYNGEN_IMPL
462 #define HAVE_gen_op_load_T1_GPR6
463 {
464 static const uint8 op_load_T1_GPR6_code[] = {
465 0x8b, 0x75, 0x28
466 };
467 copy_block(op_load_T1_GPR6_code, 3);
468 inc_code_ptr(3);
469 }
470 #endif
471
472 DEFINE_GEN(gen_op_store_T1_GPR6,void,(void))
473 #ifdef DYNGEN_IMPL
474 #define HAVE_gen_op_store_T1_GPR6
475 {
476 static const uint8 op_store_T1_GPR6_code[] = {
477 0x89, 0x75, 0x28
478 };
479 copy_block(op_store_T1_GPR6_code, 3);
480 inc_code_ptr(3);
481 }
482 #endif
483
484 DEFINE_GEN(gen_op_load_T2_GPR6,void,(void))
485 #ifdef DYNGEN_IMPL
486 #define HAVE_gen_op_load_T2_GPR6
487 {
488 static const uint8 op_load_T2_GPR6_code[] = {
489 0x8b, 0x7d, 0x28
490 };
491 copy_block(op_load_T2_GPR6_code, 3);
492 inc_code_ptr(3);
493 }
494 #endif
495
496 DEFINE_GEN(gen_op_store_T2_GPR6,void,(void))
497 #ifdef DYNGEN_IMPL
498 #define HAVE_gen_op_store_T2_GPR6
499 {
500 static const uint8 op_store_T2_GPR6_code[] = {
501 0x89, 0x7d, 0x28
502 };
503 copy_block(op_store_T2_GPR6_code, 3);
504 inc_code_ptr(3);
505 }
506 #endif
507
508 DEFINE_GEN(gen_op_load_T0_GPR7,void,(void))
509 #ifdef DYNGEN_IMPL
510 #define HAVE_gen_op_load_T0_GPR7
511 {
512 static const uint8 op_load_T0_GPR7_code[] = {
513 0x8b, 0x5d, 0x2c
514 };
515 copy_block(op_load_T0_GPR7_code, 3);
516 inc_code_ptr(3);
517 }
518 #endif
519
520 DEFINE_GEN(gen_op_store_T0_GPR7,void,(void))
521 #ifdef DYNGEN_IMPL
522 #define HAVE_gen_op_store_T0_GPR7
523 {
524 static const uint8 op_store_T0_GPR7_code[] = {
525 0x89, 0x5d, 0x2c
526 };
527 copy_block(op_store_T0_GPR7_code, 3);
528 inc_code_ptr(3);
529 }
530 #endif
531
532 DEFINE_GEN(gen_op_load_T1_GPR7,void,(void))
533 #ifdef DYNGEN_IMPL
534 #define HAVE_gen_op_load_T1_GPR7
535 {
536 static const uint8 op_load_T1_GPR7_code[] = {
537 0x8b, 0x75, 0x2c
538 };
539 copy_block(op_load_T1_GPR7_code, 3);
540 inc_code_ptr(3);
541 }
542 #endif
543
544 DEFINE_GEN(gen_op_store_T1_GPR7,void,(void))
545 #ifdef DYNGEN_IMPL
546 #define HAVE_gen_op_store_T1_GPR7
547 {
548 static const uint8 op_store_T1_GPR7_code[] = {
549 0x89, 0x75, 0x2c
550 };
551 copy_block(op_store_T1_GPR7_code, 3);
552 inc_code_ptr(3);
553 }
554 #endif
555
556 DEFINE_GEN(gen_op_load_T2_GPR7,void,(void))
557 #ifdef DYNGEN_IMPL
558 #define HAVE_gen_op_load_T2_GPR7
559 {
560 static const uint8 op_load_T2_GPR7_code[] = {
561 0x8b, 0x7d, 0x2c
562 };
563 copy_block(op_load_T2_GPR7_code, 3);
564 inc_code_ptr(3);
565 }
566 #endif
567
568 DEFINE_GEN(gen_op_store_T2_GPR7,void,(void))
569 #ifdef DYNGEN_IMPL
570 #define HAVE_gen_op_store_T2_GPR7
571 {
572 static const uint8 op_store_T2_GPR7_code[] = {
573 0x89, 0x7d, 0x2c
574 };
575 copy_block(op_store_T2_GPR7_code, 3);
576 inc_code_ptr(3);
577 }
578 #endif
579
580 DEFINE_GEN(gen_op_load_T0_GPR8,void,(void))
581 #ifdef DYNGEN_IMPL
582 #define HAVE_gen_op_load_T0_GPR8
583 {
584 static const uint8 op_load_T0_GPR8_code[] = {
585 0x8b, 0x5d, 0x30
586 };
587 copy_block(op_load_T0_GPR8_code, 3);
588 inc_code_ptr(3);
589 }
590 #endif
591
592 DEFINE_GEN(gen_op_store_T0_GPR8,void,(void))
593 #ifdef DYNGEN_IMPL
594 #define HAVE_gen_op_store_T0_GPR8
595 {
596 static const uint8 op_store_T0_GPR8_code[] = {
597 0x89, 0x5d, 0x30
598 };
599 copy_block(op_store_T0_GPR8_code, 3);
600 inc_code_ptr(3);
601 }
602 #endif
603
604 DEFINE_GEN(gen_op_load_T1_GPR8,void,(void))
605 #ifdef DYNGEN_IMPL
606 #define HAVE_gen_op_load_T1_GPR8
607 {
608 static const uint8 op_load_T1_GPR8_code[] = {
609 0x8b, 0x75, 0x30
610 };
611 copy_block(op_load_T1_GPR8_code, 3);
612 inc_code_ptr(3);
613 }
614 #endif
615
616 DEFINE_GEN(gen_op_store_T1_GPR8,void,(void))
617 #ifdef DYNGEN_IMPL
618 #define HAVE_gen_op_store_T1_GPR8
619 {
620 static const uint8 op_store_T1_GPR8_code[] = {
621 0x89, 0x75, 0x30
622 };
623 copy_block(op_store_T1_GPR8_code, 3);
624 inc_code_ptr(3);
625 }
626 #endif
627
628 DEFINE_GEN(gen_op_load_T2_GPR8,void,(void))
629 #ifdef DYNGEN_IMPL
630 #define HAVE_gen_op_load_T2_GPR8
631 {
632 static const uint8 op_load_T2_GPR8_code[] = {
633 0x8b, 0x7d, 0x30
634 };
635 copy_block(op_load_T2_GPR8_code, 3);
636 inc_code_ptr(3);
637 }
638 #endif
639
640 DEFINE_GEN(gen_op_store_T2_GPR8,void,(void))
641 #ifdef DYNGEN_IMPL
642 #define HAVE_gen_op_store_T2_GPR8
643 {
644 static const uint8 op_store_T2_GPR8_code[] = {
645 0x89, 0x7d, 0x30
646 };
647 copy_block(op_store_T2_GPR8_code, 3);
648 inc_code_ptr(3);
649 }
650 #endif
651
652 DEFINE_GEN(gen_op_load_T0_GPR9,void,(void))
653 #ifdef DYNGEN_IMPL
654 #define HAVE_gen_op_load_T0_GPR9
655 {
656 static const uint8 op_load_T0_GPR9_code[] = {
657 0x8b, 0x5d, 0x34
658 };
659 copy_block(op_load_T0_GPR9_code, 3);
660 inc_code_ptr(3);
661 }
662 #endif
663
664 DEFINE_GEN(gen_op_store_T0_GPR9,void,(void))
665 #ifdef DYNGEN_IMPL
666 #define HAVE_gen_op_store_T0_GPR9
667 {
668 static const uint8 op_store_T0_GPR9_code[] = {
669 0x89, 0x5d, 0x34
670 };
671 copy_block(op_store_T0_GPR9_code, 3);
672 inc_code_ptr(3);
673 }
674 #endif
675
676 DEFINE_GEN(gen_op_load_T1_GPR9,void,(void))
677 #ifdef DYNGEN_IMPL
678 #define HAVE_gen_op_load_T1_GPR9
679 {
680 static const uint8 op_load_T1_GPR9_code[] = {
681 0x8b, 0x75, 0x34
682 };
683 copy_block(op_load_T1_GPR9_code, 3);
684 inc_code_ptr(3);
685 }
686 #endif
687
688 DEFINE_GEN(gen_op_store_T1_GPR9,void,(void))
689 #ifdef DYNGEN_IMPL
690 #define HAVE_gen_op_store_T1_GPR9
691 {
692 static const uint8 op_store_T1_GPR9_code[] = {
693 0x89, 0x75, 0x34
694 };
695 copy_block(op_store_T1_GPR9_code, 3);
696 inc_code_ptr(3);
697 }
698 #endif
699
700 DEFINE_GEN(gen_op_load_T2_GPR9,void,(void))
701 #ifdef DYNGEN_IMPL
702 #define HAVE_gen_op_load_T2_GPR9
703 {
704 static const uint8 op_load_T2_GPR9_code[] = {
705 0x8b, 0x7d, 0x34
706 };
707 copy_block(op_load_T2_GPR9_code, 3);
708 inc_code_ptr(3);
709 }
710 #endif
711
712 DEFINE_GEN(gen_op_store_T2_GPR9,void,(void))
713 #ifdef DYNGEN_IMPL
714 #define HAVE_gen_op_store_T2_GPR9
715 {
716 static const uint8 op_store_T2_GPR9_code[] = {
717 0x89, 0x7d, 0x34
718 };
719 copy_block(op_store_T2_GPR9_code, 3);
720 inc_code_ptr(3);
721 }
722 #endif
723
724 DEFINE_GEN(gen_op_load_T0_GPR10,void,(void))
725 #ifdef DYNGEN_IMPL
726 #define HAVE_gen_op_load_T0_GPR10
727 {
728 static const uint8 op_load_T0_GPR10_code[] = {
729 0x8b, 0x5d, 0x38
730 };
731 copy_block(op_load_T0_GPR10_code, 3);
732 inc_code_ptr(3);
733 }
734 #endif
735
736 DEFINE_GEN(gen_op_store_T0_GPR10,void,(void))
737 #ifdef DYNGEN_IMPL
738 #define HAVE_gen_op_store_T0_GPR10
739 {
740 static const uint8 op_store_T0_GPR10_code[] = {
741 0x89, 0x5d, 0x38
742 };
743 copy_block(op_store_T0_GPR10_code, 3);
744 inc_code_ptr(3);
745 }
746 #endif
747
748 DEFINE_GEN(gen_op_load_T1_GPR10,void,(void))
749 #ifdef DYNGEN_IMPL
750 #define HAVE_gen_op_load_T1_GPR10
751 {
752 static const uint8 op_load_T1_GPR10_code[] = {
753 0x8b, 0x75, 0x38
754 };
755 copy_block(op_load_T1_GPR10_code, 3);
756 inc_code_ptr(3);
757 }
758 #endif
759
760 DEFINE_GEN(gen_op_store_T1_GPR10,void,(void))
761 #ifdef DYNGEN_IMPL
762 #define HAVE_gen_op_store_T1_GPR10
763 {
764 static const uint8 op_store_T1_GPR10_code[] = {
765 0x89, 0x75, 0x38
766 };
767 copy_block(op_store_T1_GPR10_code, 3);
768 inc_code_ptr(3);
769 }
770 #endif
771
772 DEFINE_GEN(gen_op_load_T2_GPR10,void,(void))
773 #ifdef DYNGEN_IMPL
774 #define HAVE_gen_op_load_T2_GPR10
775 {
776 static const uint8 op_load_T2_GPR10_code[] = {
777 0x8b, 0x7d, 0x38
778 };
779 copy_block(op_load_T2_GPR10_code, 3);
780 inc_code_ptr(3);
781 }
782 #endif
783
784 DEFINE_GEN(gen_op_store_T2_GPR10,void,(void))
785 #ifdef DYNGEN_IMPL
786 #define HAVE_gen_op_store_T2_GPR10
787 {
788 static const uint8 op_store_T2_GPR10_code[] = {
789 0x89, 0x7d, 0x38
790 };
791 copy_block(op_store_T2_GPR10_code, 3);
792 inc_code_ptr(3);
793 }
794 #endif
795
796 DEFINE_GEN(gen_op_load_T0_GPR11,void,(void))
797 #ifdef DYNGEN_IMPL
798 #define HAVE_gen_op_load_T0_GPR11
799 {
800 static const uint8 op_load_T0_GPR11_code[] = {
801 0x8b, 0x5d, 0x3c
802 };
803 copy_block(op_load_T0_GPR11_code, 3);
804 inc_code_ptr(3);
805 }
806 #endif
807
808 DEFINE_GEN(gen_op_store_T0_GPR11,void,(void))
809 #ifdef DYNGEN_IMPL
810 #define HAVE_gen_op_store_T0_GPR11
811 {
812 static const uint8 op_store_T0_GPR11_code[] = {
813 0x89, 0x5d, 0x3c
814 };
815 copy_block(op_store_T0_GPR11_code, 3);
816 inc_code_ptr(3);
817 }
818 #endif
819
820 DEFINE_GEN(gen_op_load_T1_GPR11,void,(void))
821 #ifdef DYNGEN_IMPL
822 #define HAVE_gen_op_load_T1_GPR11
823 {
824 static const uint8 op_load_T1_GPR11_code[] = {
825 0x8b, 0x75, 0x3c
826 };
827 copy_block(op_load_T1_GPR11_code, 3);
828 inc_code_ptr(3);
829 }
830 #endif
831
832 DEFINE_GEN(gen_op_store_T1_GPR11,void,(void))
833 #ifdef DYNGEN_IMPL
834 #define HAVE_gen_op_store_T1_GPR11
835 {
836 static const uint8 op_store_T1_GPR11_code[] = {
837 0x89, 0x75, 0x3c
838 };
839 copy_block(op_store_T1_GPR11_code, 3);
840 inc_code_ptr(3);
841 }
842 #endif
843
844 DEFINE_GEN(gen_op_load_T2_GPR11,void,(void))
845 #ifdef DYNGEN_IMPL
846 #define HAVE_gen_op_load_T2_GPR11
847 {
848 static const uint8 op_load_T2_GPR11_code[] = {
849 0x8b, 0x7d, 0x3c
850 };
851 copy_block(op_load_T2_GPR11_code, 3);
852 inc_code_ptr(3);
853 }
854 #endif
855
856 DEFINE_GEN(gen_op_store_T2_GPR11,void,(void))
857 #ifdef DYNGEN_IMPL
858 #define HAVE_gen_op_store_T2_GPR11
859 {
860 static const uint8 op_store_T2_GPR11_code[] = {
861 0x89, 0x7d, 0x3c
862 };
863 copy_block(op_store_T2_GPR11_code, 3);
864 inc_code_ptr(3);
865 }
866 #endif
867
868 DEFINE_GEN(gen_op_load_T0_GPR12,void,(void))
869 #ifdef DYNGEN_IMPL
870 #define HAVE_gen_op_load_T0_GPR12
871 {
872 static const uint8 op_load_T0_GPR12_code[] = {
873 0x8b, 0x5d, 0x40
874 };
875 copy_block(op_load_T0_GPR12_code, 3);
876 inc_code_ptr(3);
877 }
878 #endif
879
880 DEFINE_GEN(gen_op_store_T0_GPR12,void,(void))
881 #ifdef DYNGEN_IMPL
882 #define HAVE_gen_op_store_T0_GPR12
883 {
884 static const uint8 op_store_T0_GPR12_code[] = {
885 0x89, 0x5d, 0x40
886 };
887 copy_block(op_store_T0_GPR12_code, 3);
888 inc_code_ptr(3);
889 }
890 #endif
891
892 DEFINE_GEN(gen_op_load_T1_GPR12,void,(void))
893 #ifdef DYNGEN_IMPL
894 #define HAVE_gen_op_load_T1_GPR12
895 {
896 static const uint8 op_load_T1_GPR12_code[] = {
897 0x8b, 0x75, 0x40
898 };
899 copy_block(op_load_T1_GPR12_code, 3);
900 inc_code_ptr(3);
901 }
902 #endif
903
904 DEFINE_GEN(gen_op_store_T1_GPR12,void,(void))
905 #ifdef DYNGEN_IMPL
906 #define HAVE_gen_op_store_T1_GPR12
907 {
908 static const uint8 op_store_T1_GPR12_code[] = {
909 0x89, 0x75, 0x40
910 };
911 copy_block(op_store_T1_GPR12_code, 3);
912 inc_code_ptr(3);
913 }
914 #endif
915
916 DEFINE_GEN(gen_op_load_T2_GPR12,void,(void))
917 #ifdef DYNGEN_IMPL
918 #define HAVE_gen_op_load_T2_GPR12
919 {
920 static const uint8 op_load_T2_GPR12_code[] = {
921 0x8b, 0x7d, 0x40
922 };
923 copy_block(op_load_T2_GPR12_code, 3);
924 inc_code_ptr(3);
925 }
926 #endif
927
928 DEFINE_GEN(gen_op_store_T2_GPR12,void,(void))
929 #ifdef DYNGEN_IMPL
930 #define HAVE_gen_op_store_T2_GPR12
931 {
932 static const uint8 op_store_T2_GPR12_code[] = {
933 0x89, 0x7d, 0x40
934 };
935 copy_block(op_store_T2_GPR12_code, 3);
936 inc_code_ptr(3);
937 }
938 #endif
939
940 DEFINE_GEN(gen_op_load_T0_GPR13,void,(void))
941 #ifdef DYNGEN_IMPL
942 #define HAVE_gen_op_load_T0_GPR13
943 {
944 static const uint8 op_load_T0_GPR13_code[] = {
945 0x8b, 0x5d, 0x44
946 };
947 copy_block(op_load_T0_GPR13_code, 3);
948 inc_code_ptr(3);
949 }
950 #endif
951
952 DEFINE_GEN(gen_op_store_T0_GPR13,void,(void))
953 #ifdef DYNGEN_IMPL
954 #define HAVE_gen_op_store_T0_GPR13
955 {
956 static const uint8 op_store_T0_GPR13_code[] = {
957 0x89, 0x5d, 0x44
958 };
959 copy_block(op_store_T0_GPR13_code, 3);
960 inc_code_ptr(3);
961 }
962 #endif
963
964 DEFINE_GEN(gen_op_load_T1_GPR13,void,(void))
965 #ifdef DYNGEN_IMPL
966 #define HAVE_gen_op_load_T1_GPR13
967 {
968 static const uint8 op_load_T1_GPR13_code[] = {
969 0x8b, 0x75, 0x44
970 };
971 copy_block(op_load_T1_GPR13_code, 3);
972 inc_code_ptr(3);
973 }
974 #endif
975
976 DEFINE_GEN(gen_op_store_T1_GPR13,void,(void))
977 #ifdef DYNGEN_IMPL
978 #define HAVE_gen_op_store_T1_GPR13
979 {
980 static const uint8 op_store_T1_GPR13_code[] = {
981 0x89, 0x75, 0x44
982 };
983 copy_block(op_store_T1_GPR13_code, 3);
984 inc_code_ptr(3);
985 }
986 #endif
987
988 DEFINE_GEN(gen_op_load_T2_GPR13,void,(void))
989 #ifdef DYNGEN_IMPL
990 #define HAVE_gen_op_load_T2_GPR13
991 {
992 static const uint8 op_load_T2_GPR13_code[] = {
993 0x8b, 0x7d, 0x44
994 };
995 copy_block(op_load_T2_GPR13_code, 3);
996 inc_code_ptr(3);
997 }
998 #endif
999
1000 DEFINE_GEN(gen_op_store_T2_GPR13,void,(void))
1001 #ifdef DYNGEN_IMPL
1002 #define HAVE_gen_op_store_T2_GPR13
1003 {
1004 static const uint8 op_store_T2_GPR13_code[] = {
1005 0x89, 0x7d, 0x44
1006 };
1007 copy_block(op_store_T2_GPR13_code, 3);
1008 inc_code_ptr(3);
1009 }
1010 #endif
1011
1012 DEFINE_GEN(gen_op_load_T0_GPR14,void,(void))
1013 #ifdef DYNGEN_IMPL
1014 #define HAVE_gen_op_load_T0_GPR14
1015 {
1016 static const uint8 op_load_T0_GPR14_code[] = {
1017 0x8b, 0x5d, 0x48
1018 };
1019 copy_block(op_load_T0_GPR14_code, 3);
1020 inc_code_ptr(3);
1021 }
1022 #endif
1023
1024 DEFINE_GEN(gen_op_store_T0_GPR14,void,(void))
1025 #ifdef DYNGEN_IMPL
1026 #define HAVE_gen_op_store_T0_GPR14
1027 {
1028 static const uint8 op_store_T0_GPR14_code[] = {
1029 0x89, 0x5d, 0x48
1030 };
1031 copy_block(op_store_T0_GPR14_code, 3);
1032 inc_code_ptr(3);
1033 }
1034 #endif
1035
1036 DEFINE_GEN(gen_op_load_T1_GPR14,void,(void))
1037 #ifdef DYNGEN_IMPL
1038 #define HAVE_gen_op_load_T1_GPR14
1039 {
1040 static const uint8 op_load_T1_GPR14_code[] = {
1041 0x8b, 0x75, 0x48
1042 };
1043 copy_block(op_load_T1_GPR14_code, 3);
1044 inc_code_ptr(3);
1045 }
1046 #endif
1047
1048 DEFINE_GEN(gen_op_store_T1_GPR14,void,(void))
1049 #ifdef DYNGEN_IMPL
1050 #define HAVE_gen_op_store_T1_GPR14
1051 {
1052 static const uint8 op_store_T1_GPR14_code[] = {
1053 0x89, 0x75, 0x48
1054 };
1055 copy_block(op_store_T1_GPR14_code, 3);
1056 inc_code_ptr(3);
1057 }
1058 #endif
1059
1060 DEFINE_GEN(gen_op_load_T2_GPR14,void,(void))
1061 #ifdef DYNGEN_IMPL
1062 #define HAVE_gen_op_load_T2_GPR14
1063 {
1064 static const uint8 op_load_T2_GPR14_code[] = {
1065 0x8b, 0x7d, 0x48
1066 };
1067 copy_block(op_load_T2_GPR14_code, 3);
1068 inc_code_ptr(3);
1069 }
1070 #endif
1071
1072 DEFINE_GEN(gen_op_store_T2_GPR14,void,(void))
1073 #ifdef DYNGEN_IMPL
1074 #define HAVE_gen_op_store_T2_GPR14
1075 {
1076 static const uint8 op_store_T2_GPR14_code[] = {
1077 0x89, 0x7d, 0x48
1078 };
1079 copy_block(op_store_T2_GPR14_code, 3);
1080 inc_code_ptr(3);
1081 }
1082 #endif
1083
1084 DEFINE_GEN(gen_op_load_T0_GPR15,void,(void))
1085 #ifdef DYNGEN_IMPL
1086 #define HAVE_gen_op_load_T0_GPR15
1087 {
1088 static const uint8 op_load_T0_GPR15_code[] = {
1089 0x8b, 0x5d, 0x4c
1090 };
1091 copy_block(op_load_T0_GPR15_code, 3);
1092 inc_code_ptr(3);
1093 }
1094 #endif
1095
1096 DEFINE_GEN(gen_op_store_T0_GPR15,void,(void))
1097 #ifdef DYNGEN_IMPL
1098 #define HAVE_gen_op_store_T0_GPR15
1099 {
1100 static const uint8 op_store_T0_GPR15_code[] = {
1101 0x89, 0x5d, 0x4c
1102 };
1103 copy_block(op_store_T0_GPR15_code, 3);
1104 inc_code_ptr(3);
1105 }
1106 #endif
1107
1108 DEFINE_GEN(gen_op_load_T1_GPR15,void,(void))
1109 #ifdef DYNGEN_IMPL
1110 #define HAVE_gen_op_load_T1_GPR15
1111 {
1112 static const uint8 op_load_T1_GPR15_code[] = {
1113 0x8b, 0x75, 0x4c
1114 };
1115 copy_block(op_load_T1_GPR15_code, 3);
1116 inc_code_ptr(3);
1117 }
1118 #endif
1119
1120 DEFINE_GEN(gen_op_store_T1_GPR15,void,(void))
1121 #ifdef DYNGEN_IMPL
1122 #define HAVE_gen_op_store_T1_GPR15
1123 {
1124 static const uint8 op_store_T1_GPR15_code[] = {
1125 0x89, 0x75, 0x4c
1126 };
1127 copy_block(op_store_T1_GPR15_code, 3);
1128 inc_code_ptr(3);
1129 }
1130 #endif
1131
1132 DEFINE_GEN(gen_op_load_T2_GPR15,void,(void))
1133 #ifdef DYNGEN_IMPL
1134 #define HAVE_gen_op_load_T2_GPR15
1135 {
1136 static const uint8 op_load_T2_GPR15_code[] = {
1137 0x8b, 0x7d, 0x4c
1138 };
1139 copy_block(op_load_T2_GPR15_code, 3);
1140 inc_code_ptr(3);
1141 }
1142 #endif
1143
1144 DEFINE_GEN(gen_op_store_T2_GPR15,void,(void))
1145 #ifdef DYNGEN_IMPL
1146 #define HAVE_gen_op_store_T2_GPR15
1147 {
1148 static const uint8 op_store_T2_GPR15_code[] = {
1149 0x89, 0x7d, 0x4c
1150 };
1151 copy_block(op_store_T2_GPR15_code, 3);
1152 inc_code_ptr(3);
1153 }
1154 #endif
1155
1156 DEFINE_GEN(gen_op_load_T0_GPR16,void,(void))
1157 #ifdef DYNGEN_IMPL
1158 #define HAVE_gen_op_load_T0_GPR16
1159 {
1160 static const uint8 op_load_T0_GPR16_code[] = {
1161 0x8b, 0x5d, 0x50
1162 };
1163 copy_block(op_load_T0_GPR16_code, 3);
1164 inc_code_ptr(3);
1165 }
1166 #endif
1167
1168 DEFINE_GEN(gen_op_store_T0_GPR16,void,(void))
1169 #ifdef DYNGEN_IMPL
1170 #define HAVE_gen_op_store_T0_GPR16
1171 {
1172 static const uint8 op_store_T0_GPR16_code[] = {
1173 0x89, 0x5d, 0x50
1174 };
1175 copy_block(op_store_T0_GPR16_code, 3);
1176 inc_code_ptr(3);
1177 }
1178 #endif
1179
1180 DEFINE_GEN(gen_op_load_T1_GPR16,void,(void))
1181 #ifdef DYNGEN_IMPL
1182 #define HAVE_gen_op_load_T1_GPR16
1183 {
1184 static const uint8 op_load_T1_GPR16_code[] = {
1185 0x8b, 0x75, 0x50
1186 };
1187 copy_block(op_load_T1_GPR16_code, 3);
1188 inc_code_ptr(3);
1189 }
1190 #endif
1191
1192 DEFINE_GEN(gen_op_store_T1_GPR16,void,(void))
1193 #ifdef DYNGEN_IMPL
1194 #define HAVE_gen_op_store_T1_GPR16
1195 {
1196 static const uint8 op_store_T1_GPR16_code[] = {
1197 0x89, 0x75, 0x50
1198 };
1199 copy_block(op_store_T1_GPR16_code, 3);
1200 inc_code_ptr(3);
1201 }
1202 #endif
1203
1204 DEFINE_GEN(gen_op_load_T2_GPR16,void,(void))
1205 #ifdef DYNGEN_IMPL
1206 #define HAVE_gen_op_load_T2_GPR16
1207 {
1208 static const uint8 op_load_T2_GPR16_code[] = {
1209 0x8b, 0x7d, 0x50
1210 };
1211 copy_block(op_load_T2_GPR16_code, 3);
1212 inc_code_ptr(3);
1213 }
1214 #endif
1215
1216 DEFINE_GEN(gen_op_store_T2_GPR16,void,(void))
1217 #ifdef DYNGEN_IMPL
1218 #define HAVE_gen_op_store_T2_GPR16
1219 {
1220 static const uint8 op_store_T2_GPR16_code[] = {
1221 0x89, 0x7d, 0x50
1222 };
1223 copy_block(op_store_T2_GPR16_code, 3);
1224 inc_code_ptr(3);
1225 }
1226 #endif
1227
1228 DEFINE_GEN(gen_op_load_T0_GPR17,void,(void))
1229 #ifdef DYNGEN_IMPL
1230 #define HAVE_gen_op_load_T0_GPR17
1231 {
1232 static const uint8 op_load_T0_GPR17_code[] = {
1233 0x8b, 0x5d, 0x54
1234 };
1235 copy_block(op_load_T0_GPR17_code, 3);
1236 inc_code_ptr(3);
1237 }
1238 #endif
1239
1240 DEFINE_GEN(gen_op_store_T0_GPR17,void,(void))
1241 #ifdef DYNGEN_IMPL
1242 #define HAVE_gen_op_store_T0_GPR17
1243 {
1244 static const uint8 op_store_T0_GPR17_code[] = {
1245 0x89, 0x5d, 0x54
1246 };
1247 copy_block(op_store_T0_GPR17_code, 3);
1248 inc_code_ptr(3);
1249 }
1250 #endif
1251
1252 DEFINE_GEN(gen_op_load_T1_GPR17,void,(void))
1253 #ifdef DYNGEN_IMPL
1254 #define HAVE_gen_op_load_T1_GPR17
1255 {
1256 static const uint8 op_load_T1_GPR17_code[] = {
1257 0x8b, 0x75, 0x54
1258 };
1259 copy_block(op_load_T1_GPR17_code, 3);
1260 inc_code_ptr(3);
1261 }
1262 #endif
1263
1264 DEFINE_GEN(gen_op_store_T1_GPR17,void,(void))
1265 #ifdef DYNGEN_IMPL
1266 #define HAVE_gen_op_store_T1_GPR17
1267 {
1268 static const uint8 op_store_T1_GPR17_code[] = {
1269 0x89, 0x75, 0x54
1270 };
1271 copy_block(op_store_T1_GPR17_code, 3);
1272 inc_code_ptr(3);
1273 }
1274 #endif
1275
1276 DEFINE_GEN(gen_op_load_T2_GPR17,void,(void))
1277 #ifdef DYNGEN_IMPL
1278 #define HAVE_gen_op_load_T2_GPR17
1279 {
1280 static const uint8 op_load_T2_GPR17_code[] = {
1281 0x8b, 0x7d, 0x54
1282 };
1283 copy_block(op_load_T2_GPR17_code, 3);
1284 inc_code_ptr(3);
1285 }
1286 #endif
1287
1288 DEFINE_GEN(gen_op_store_T2_GPR17,void,(void))
1289 #ifdef DYNGEN_IMPL
1290 #define HAVE_gen_op_store_T2_GPR17
1291 {
1292 static const uint8 op_store_T2_GPR17_code[] = {
1293 0x89, 0x7d, 0x54
1294 };
1295 copy_block(op_store_T2_GPR17_code, 3);
1296 inc_code_ptr(3);
1297 }
1298 #endif
1299
1300 DEFINE_GEN(gen_op_load_T0_GPR18,void,(void))
1301 #ifdef DYNGEN_IMPL
1302 #define HAVE_gen_op_load_T0_GPR18
1303 {
1304 static const uint8 op_load_T0_GPR18_code[] = {
1305 0x8b, 0x5d, 0x58
1306 };
1307 copy_block(op_load_T0_GPR18_code, 3);
1308 inc_code_ptr(3);
1309 }
1310 #endif
1311
1312 DEFINE_GEN(gen_op_store_T0_GPR18,void,(void))
1313 #ifdef DYNGEN_IMPL
1314 #define HAVE_gen_op_store_T0_GPR18
1315 {
1316 static const uint8 op_store_T0_GPR18_code[] = {
1317 0x89, 0x5d, 0x58
1318 };
1319 copy_block(op_store_T0_GPR18_code, 3);
1320 inc_code_ptr(3);
1321 }
1322 #endif
1323
1324 DEFINE_GEN(gen_op_load_T1_GPR18,void,(void))
1325 #ifdef DYNGEN_IMPL
1326 #define HAVE_gen_op_load_T1_GPR18
1327 {
1328 static const uint8 op_load_T1_GPR18_code[] = {
1329 0x8b, 0x75, 0x58
1330 };
1331 copy_block(op_load_T1_GPR18_code, 3);
1332 inc_code_ptr(3);
1333 }
1334 #endif
1335
1336 DEFINE_GEN(gen_op_store_T1_GPR18,void,(void))
1337 #ifdef DYNGEN_IMPL
1338 #define HAVE_gen_op_store_T1_GPR18
1339 {
1340 static const uint8 op_store_T1_GPR18_code[] = {
1341 0x89, 0x75, 0x58
1342 };
1343 copy_block(op_store_T1_GPR18_code, 3);
1344 inc_code_ptr(3);
1345 }
1346 #endif
1347
1348 DEFINE_GEN(gen_op_load_T2_GPR18,void,(void))
1349 #ifdef DYNGEN_IMPL
1350 #define HAVE_gen_op_load_T2_GPR18
1351 {
1352 static const uint8 op_load_T2_GPR18_code[] = {
1353 0x8b, 0x7d, 0x58
1354 };
1355 copy_block(op_load_T2_GPR18_code, 3);
1356 inc_code_ptr(3);
1357 }
1358 #endif
1359
1360 DEFINE_GEN(gen_op_store_T2_GPR18,void,(void))
1361 #ifdef DYNGEN_IMPL
1362 #define HAVE_gen_op_store_T2_GPR18
1363 {
1364 static const uint8 op_store_T2_GPR18_code[] = {
1365 0x89, 0x7d, 0x58
1366 };
1367 copy_block(op_store_T2_GPR18_code, 3);
1368 inc_code_ptr(3);
1369 }
1370 #endif
1371
1372 DEFINE_GEN(gen_op_load_T0_GPR19,void,(void))
1373 #ifdef DYNGEN_IMPL
1374 #define HAVE_gen_op_load_T0_GPR19
1375 {
1376 static const uint8 op_load_T0_GPR19_code[] = {
1377 0x8b, 0x5d, 0x5c
1378 };
1379 copy_block(op_load_T0_GPR19_code, 3);
1380 inc_code_ptr(3);
1381 }
1382 #endif
1383
1384 DEFINE_GEN(gen_op_store_T0_GPR19,void,(void))
1385 #ifdef DYNGEN_IMPL
1386 #define HAVE_gen_op_store_T0_GPR19
1387 {
1388 static const uint8 op_store_T0_GPR19_code[] = {
1389 0x89, 0x5d, 0x5c
1390 };
1391 copy_block(op_store_T0_GPR19_code, 3);
1392 inc_code_ptr(3);
1393 }
1394 #endif
1395
1396 DEFINE_GEN(gen_op_load_T1_GPR19,void,(void))
1397 #ifdef DYNGEN_IMPL
1398 #define HAVE_gen_op_load_T1_GPR19
1399 {
1400 static const uint8 op_load_T1_GPR19_code[] = {
1401 0x8b, 0x75, 0x5c
1402 };
1403 copy_block(op_load_T1_GPR19_code, 3);
1404 inc_code_ptr(3);
1405 }
1406 #endif
1407
1408 DEFINE_GEN(gen_op_store_T1_GPR19,void,(void))
1409 #ifdef DYNGEN_IMPL
1410 #define HAVE_gen_op_store_T1_GPR19
1411 {
1412 static const uint8 op_store_T1_GPR19_code[] = {
1413 0x89, 0x75, 0x5c
1414 };
1415 copy_block(op_store_T1_GPR19_code, 3);
1416 inc_code_ptr(3);
1417 }
1418 #endif
1419
1420 DEFINE_GEN(gen_op_load_T2_GPR19,void,(void))
1421 #ifdef DYNGEN_IMPL
1422 #define HAVE_gen_op_load_T2_GPR19
1423 {
1424 static const uint8 op_load_T2_GPR19_code[] = {
1425 0x8b, 0x7d, 0x5c
1426 };
1427 copy_block(op_load_T2_GPR19_code, 3);
1428 inc_code_ptr(3);
1429 }
1430 #endif
1431
1432 DEFINE_GEN(gen_op_store_T2_GPR19,void,(void))
1433 #ifdef DYNGEN_IMPL
1434 #define HAVE_gen_op_store_T2_GPR19
1435 {
1436 static const uint8 op_store_T2_GPR19_code[] = {
1437 0x89, 0x7d, 0x5c
1438 };
1439 copy_block(op_store_T2_GPR19_code, 3);
1440 inc_code_ptr(3);
1441 }
1442 #endif
1443
1444 DEFINE_GEN(gen_op_load_T0_GPR20,void,(void))
1445 #ifdef DYNGEN_IMPL
1446 #define HAVE_gen_op_load_T0_GPR20
1447 {
1448 static const uint8 op_load_T0_GPR20_code[] = {
1449 0x8b, 0x5d, 0x60
1450 };
1451 copy_block(op_load_T0_GPR20_code, 3);
1452 inc_code_ptr(3);
1453 }
1454 #endif
1455
1456 DEFINE_GEN(gen_op_store_T0_GPR20,void,(void))
1457 #ifdef DYNGEN_IMPL
1458 #define HAVE_gen_op_store_T0_GPR20
1459 {
1460 static const uint8 op_store_T0_GPR20_code[] = {
1461 0x89, 0x5d, 0x60
1462 };
1463 copy_block(op_store_T0_GPR20_code, 3);
1464 inc_code_ptr(3);
1465 }
1466 #endif
1467
1468 DEFINE_GEN(gen_op_load_T1_GPR20,void,(void))
1469 #ifdef DYNGEN_IMPL
1470 #define HAVE_gen_op_load_T1_GPR20
1471 {
1472 static const uint8 op_load_T1_GPR20_code[] = {
1473 0x8b, 0x75, 0x60
1474 };
1475 copy_block(op_load_T1_GPR20_code, 3);
1476 inc_code_ptr(3);
1477 }
1478 #endif
1479
1480 DEFINE_GEN(gen_op_store_T1_GPR20,void,(void))
1481 #ifdef DYNGEN_IMPL
1482 #define HAVE_gen_op_store_T1_GPR20
1483 {
1484 static const uint8 op_store_T1_GPR20_code[] = {
1485 0x89, 0x75, 0x60
1486 };
1487 copy_block(op_store_T1_GPR20_code, 3);
1488 inc_code_ptr(3);
1489 }
1490 #endif
1491
1492 DEFINE_GEN(gen_op_load_T2_GPR20,void,(void))
1493 #ifdef DYNGEN_IMPL
1494 #define HAVE_gen_op_load_T2_GPR20
1495 {
1496 static const uint8 op_load_T2_GPR20_code[] = {
1497 0x8b, 0x7d, 0x60
1498 };
1499 copy_block(op_load_T2_GPR20_code, 3);
1500 inc_code_ptr(3);
1501 }
1502 #endif
1503
1504 DEFINE_GEN(gen_op_store_T2_GPR20,void,(void))
1505 #ifdef DYNGEN_IMPL
1506 #define HAVE_gen_op_store_T2_GPR20
1507 {
1508 static const uint8 op_store_T2_GPR20_code[] = {
1509 0x89, 0x7d, 0x60
1510 };
1511 copy_block(op_store_T2_GPR20_code, 3);
1512 inc_code_ptr(3);
1513 }
1514 #endif
1515
1516 DEFINE_GEN(gen_op_load_T0_GPR21,void,(void))
1517 #ifdef DYNGEN_IMPL
1518 #define HAVE_gen_op_load_T0_GPR21
1519 {
1520 static const uint8 op_load_T0_GPR21_code[] = {
1521 0x8b, 0x5d, 0x64
1522 };
1523 copy_block(op_load_T0_GPR21_code, 3);
1524 inc_code_ptr(3);
1525 }
1526 #endif
1527
1528 DEFINE_GEN(gen_op_store_T0_GPR21,void,(void))
1529 #ifdef DYNGEN_IMPL
1530 #define HAVE_gen_op_store_T0_GPR21
1531 {
1532 static const uint8 op_store_T0_GPR21_code[] = {
1533 0x89, 0x5d, 0x64
1534 };
1535 copy_block(op_store_T0_GPR21_code, 3);
1536 inc_code_ptr(3);
1537 }
1538 #endif
1539
1540 DEFINE_GEN(gen_op_load_T1_GPR21,void,(void))
1541 #ifdef DYNGEN_IMPL
1542 #define HAVE_gen_op_load_T1_GPR21
1543 {
1544 static const uint8 op_load_T1_GPR21_code[] = {
1545 0x8b, 0x75, 0x64
1546 };
1547 copy_block(op_load_T1_GPR21_code, 3);
1548 inc_code_ptr(3);
1549 }
1550 #endif
1551
1552 DEFINE_GEN(gen_op_store_T1_GPR21,void,(void))
1553 #ifdef DYNGEN_IMPL
1554 #define HAVE_gen_op_store_T1_GPR21
1555 {
1556 static const uint8 op_store_T1_GPR21_code[] = {
1557 0x89, 0x75, 0x64
1558 };
1559 copy_block(op_store_T1_GPR21_code, 3);
1560 inc_code_ptr(3);
1561 }
1562 #endif
1563
1564 DEFINE_GEN(gen_op_load_T2_GPR21,void,(void))
1565 #ifdef DYNGEN_IMPL
1566 #define HAVE_gen_op_load_T2_GPR21
1567 {
1568 static const uint8 op_load_T2_GPR21_code[] = {
1569 0x8b, 0x7d, 0x64
1570 };
1571 copy_block(op_load_T2_GPR21_code, 3);
1572 inc_code_ptr(3);
1573 }
1574 #endif
1575
1576 DEFINE_GEN(gen_op_store_T2_GPR21,void,(void))
1577 #ifdef DYNGEN_IMPL
1578 #define HAVE_gen_op_store_T2_GPR21
1579 {
1580 static const uint8 op_store_T2_GPR21_code[] = {
1581 0x89, 0x7d, 0x64
1582 };
1583 copy_block(op_store_T2_GPR21_code, 3);
1584 inc_code_ptr(3);
1585 }
1586 #endif
1587
1588 DEFINE_GEN(gen_op_load_T0_GPR22,void,(void))
1589 #ifdef DYNGEN_IMPL
1590 #define HAVE_gen_op_load_T0_GPR22
1591 {
1592 static const uint8 op_load_T0_GPR22_code[] = {
1593 0x8b, 0x5d, 0x68
1594 };
1595 copy_block(op_load_T0_GPR22_code, 3);
1596 inc_code_ptr(3);
1597 }
1598 #endif
1599
1600 DEFINE_GEN(gen_op_store_T0_GPR22,void,(void))
1601 #ifdef DYNGEN_IMPL
1602 #define HAVE_gen_op_store_T0_GPR22
1603 {
1604 static const uint8 op_store_T0_GPR22_code[] = {
1605 0x89, 0x5d, 0x68
1606 };
1607 copy_block(op_store_T0_GPR22_code, 3);
1608 inc_code_ptr(3);
1609 }
1610 #endif
1611
1612 DEFINE_GEN(gen_op_load_T1_GPR22,void,(void))
1613 #ifdef DYNGEN_IMPL
1614 #define HAVE_gen_op_load_T1_GPR22
1615 {
1616 static const uint8 op_load_T1_GPR22_code[] = {
1617 0x8b, 0x75, 0x68
1618 };
1619 copy_block(op_load_T1_GPR22_code, 3);
1620 inc_code_ptr(3);
1621 }
1622 #endif
1623
1624 DEFINE_GEN(gen_op_store_T1_GPR22,void,(void))
1625 #ifdef DYNGEN_IMPL
1626 #define HAVE_gen_op_store_T1_GPR22
1627 {
1628 static const uint8 op_store_T1_GPR22_code[] = {
1629 0x89, 0x75, 0x68
1630 };
1631 copy_block(op_store_T1_GPR22_code, 3);
1632 inc_code_ptr(3);
1633 }
1634 #endif
1635
1636 DEFINE_GEN(gen_op_load_T2_GPR22,void,(void))
1637 #ifdef DYNGEN_IMPL
1638 #define HAVE_gen_op_load_T2_GPR22
1639 {
1640 static const uint8 op_load_T2_GPR22_code[] = {
1641 0x8b, 0x7d, 0x68
1642 };
1643 copy_block(op_load_T2_GPR22_code, 3);
1644 inc_code_ptr(3);
1645 }
1646 #endif
1647
1648 DEFINE_GEN(gen_op_store_T2_GPR22,void,(void))
1649 #ifdef DYNGEN_IMPL
1650 #define HAVE_gen_op_store_T2_GPR22
1651 {
1652 static const uint8 op_store_T2_GPR22_code[] = {
1653 0x89, 0x7d, 0x68
1654 };
1655 copy_block(op_store_T2_GPR22_code, 3);
1656 inc_code_ptr(3);
1657 }
1658 #endif
1659
1660 DEFINE_GEN(gen_op_load_T0_GPR23,void,(void))
1661 #ifdef DYNGEN_IMPL
1662 #define HAVE_gen_op_load_T0_GPR23
1663 {
1664 static const uint8 op_load_T0_GPR23_code[] = {
1665 0x8b, 0x5d, 0x6c
1666 };
1667 copy_block(op_load_T0_GPR23_code, 3);
1668 inc_code_ptr(3);
1669 }
1670 #endif
1671
1672 DEFINE_GEN(gen_op_store_T0_GPR23,void,(void))
1673 #ifdef DYNGEN_IMPL
1674 #define HAVE_gen_op_store_T0_GPR23
1675 {
1676 static const uint8 op_store_T0_GPR23_code[] = {
1677 0x89, 0x5d, 0x6c
1678 };
1679 copy_block(op_store_T0_GPR23_code, 3);
1680 inc_code_ptr(3);
1681 }
1682 #endif
1683
1684 DEFINE_GEN(gen_op_load_T1_GPR23,void,(void))
1685 #ifdef DYNGEN_IMPL
1686 #define HAVE_gen_op_load_T1_GPR23
1687 {
1688 static const uint8 op_load_T1_GPR23_code[] = {
1689 0x8b, 0x75, 0x6c
1690 };
1691 copy_block(op_load_T1_GPR23_code, 3);
1692 inc_code_ptr(3);
1693 }
1694 #endif
1695
1696 DEFINE_GEN(gen_op_store_T1_GPR23,void,(void))
1697 #ifdef DYNGEN_IMPL
1698 #define HAVE_gen_op_store_T1_GPR23
1699 {
1700 static const uint8 op_store_T1_GPR23_code[] = {
1701 0x89, 0x75, 0x6c
1702 };
1703 copy_block(op_store_T1_GPR23_code, 3);
1704 inc_code_ptr(3);
1705 }
1706 #endif
1707
1708 DEFINE_GEN(gen_op_load_T2_GPR23,void,(void))
1709 #ifdef DYNGEN_IMPL
1710 #define HAVE_gen_op_load_T2_GPR23
1711 {
1712 static const uint8 op_load_T2_GPR23_code[] = {
1713 0x8b, 0x7d, 0x6c
1714 };
1715 copy_block(op_load_T2_GPR23_code, 3);
1716 inc_code_ptr(3);
1717 }
1718 #endif
1719
1720 DEFINE_GEN(gen_op_store_T2_GPR23,void,(void))
1721 #ifdef DYNGEN_IMPL
1722 #define HAVE_gen_op_store_T2_GPR23
1723 {
1724 static const uint8 op_store_T2_GPR23_code[] = {
1725 0x89, 0x7d, 0x6c
1726 };
1727 copy_block(op_store_T2_GPR23_code, 3);
1728 inc_code_ptr(3);
1729 }
1730 #endif
1731
1732 DEFINE_GEN(gen_op_load_T0_GPR24,void,(void))
1733 #ifdef DYNGEN_IMPL
1734 #define HAVE_gen_op_load_T0_GPR24
1735 {
1736 static const uint8 op_load_T0_GPR24_code[] = {
1737 0x8b, 0x5d, 0x70
1738 };
1739 copy_block(op_load_T0_GPR24_code, 3);
1740 inc_code_ptr(3);
1741 }
1742 #endif
1743
1744 DEFINE_GEN(gen_op_store_T0_GPR24,void,(void))
1745 #ifdef DYNGEN_IMPL
1746 #define HAVE_gen_op_store_T0_GPR24
1747 {
1748 static const uint8 op_store_T0_GPR24_code[] = {
1749 0x89, 0x5d, 0x70
1750 };
1751 copy_block(op_store_T0_GPR24_code, 3);
1752 inc_code_ptr(3);
1753 }
1754 #endif
1755
1756 DEFINE_GEN(gen_op_load_T1_GPR24,void,(void))
1757 #ifdef DYNGEN_IMPL
1758 #define HAVE_gen_op_load_T1_GPR24
1759 {
1760 static const uint8 op_load_T1_GPR24_code[] = {
1761 0x8b, 0x75, 0x70
1762 };
1763 copy_block(op_load_T1_GPR24_code, 3);
1764 inc_code_ptr(3);
1765 }
1766 #endif
1767
1768 DEFINE_GEN(gen_op_store_T1_GPR24,void,(void))
1769 #ifdef DYNGEN_IMPL
1770 #define HAVE_gen_op_store_T1_GPR24
1771 {
1772 static const uint8 op_store_T1_GPR24_code[] = {
1773 0x89, 0x75, 0x70
1774 };
1775 copy_block(op_store_T1_GPR24_code, 3);
1776 inc_code_ptr(3);
1777 }
1778 #endif
1779
1780 DEFINE_GEN(gen_op_load_T2_GPR24,void,(void))
1781 #ifdef DYNGEN_IMPL
1782 #define HAVE_gen_op_load_T2_GPR24
1783 {
1784 static const uint8 op_load_T2_GPR24_code[] = {
1785 0x8b, 0x7d, 0x70
1786 };
1787 copy_block(op_load_T2_GPR24_code, 3);
1788 inc_code_ptr(3);
1789 }
1790 #endif
1791
1792 DEFINE_GEN(gen_op_store_T2_GPR24,void,(void))
1793 #ifdef DYNGEN_IMPL
1794 #define HAVE_gen_op_store_T2_GPR24
1795 {
1796 static const uint8 op_store_T2_GPR24_code[] = {
1797 0x89, 0x7d, 0x70
1798 };
1799 copy_block(op_store_T2_GPR24_code, 3);
1800 inc_code_ptr(3);
1801 }
1802 #endif
1803
1804 DEFINE_GEN(gen_op_load_T0_GPR25,void,(void))
1805 #ifdef DYNGEN_IMPL
1806 #define HAVE_gen_op_load_T0_GPR25
1807 {
1808 static const uint8 op_load_T0_GPR25_code[] = {
1809 0x8b, 0x5d, 0x74
1810 };
1811 copy_block(op_load_T0_GPR25_code, 3);
1812 inc_code_ptr(3);
1813 }
1814 #endif
1815
1816 DEFINE_GEN(gen_op_store_T0_GPR25,void,(void))
1817 #ifdef DYNGEN_IMPL
1818 #define HAVE_gen_op_store_T0_GPR25
1819 {
1820 static const uint8 op_store_T0_GPR25_code[] = {
1821 0x89, 0x5d, 0x74
1822 };
1823 copy_block(op_store_T0_GPR25_code, 3);
1824 inc_code_ptr(3);
1825 }
1826 #endif
1827
1828 DEFINE_GEN(gen_op_load_T1_GPR25,void,(void))
1829 #ifdef DYNGEN_IMPL
1830 #define HAVE_gen_op_load_T1_GPR25
1831 {
1832 static const uint8 op_load_T1_GPR25_code[] = {
1833 0x8b, 0x75, 0x74
1834 };
1835 copy_block(op_load_T1_GPR25_code, 3);
1836 inc_code_ptr(3);
1837 }
1838 #endif
1839
1840 DEFINE_GEN(gen_op_store_T1_GPR25,void,(void))
1841 #ifdef DYNGEN_IMPL
1842 #define HAVE_gen_op_store_T1_GPR25
1843 {
1844 static const uint8 op_store_T1_GPR25_code[] = {
1845 0x89, 0x75, 0x74
1846 };
1847 copy_block(op_store_T1_GPR25_code, 3);
1848 inc_code_ptr(3);
1849 }
1850 #endif
1851
1852 DEFINE_GEN(gen_op_load_T2_GPR25,void,(void))
1853 #ifdef DYNGEN_IMPL
1854 #define HAVE_gen_op_load_T2_GPR25
1855 {
1856 static const uint8 op_load_T2_GPR25_code[] = {
1857 0x8b, 0x7d, 0x74
1858 };
1859 copy_block(op_load_T2_GPR25_code, 3);
1860 inc_code_ptr(3);
1861 }
1862 #endif
1863
1864 DEFINE_GEN(gen_op_store_T2_GPR25,void,(void))
1865 #ifdef DYNGEN_IMPL
1866 #define HAVE_gen_op_store_T2_GPR25
1867 {
1868 static const uint8 op_store_T2_GPR25_code[] = {
1869 0x89, 0x7d, 0x74
1870 };
1871 copy_block(op_store_T2_GPR25_code, 3);
1872 inc_code_ptr(3);
1873 }
1874 #endif
1875
1876 DEFINE_GEN(gen_op_load_T0_GPR26,void,(void))
1877 #ifdef DYNGEN_IMPL
1878 #define HAVE_gen_op_load_T0_GPR26
1879 {
1880 static const uint8 op_load_T0_GPR26_code[] = {
1881 0x8b, 0x5d, 0x78
1882 };
1883 copy_block(op_load_T0_GPR26_code, 3);
1884 inc_code_ptr(3);
1885 }
1886 #endif
1887
1888 DEFINE_GEN(gen_op_store_T0_GPR26,void,(void))
1889 #ifdef DYNGEN_IMPL
1890 #define HAVE_gen_op_store_T0_GPR26
1891 {
1892 static const uint8 op_store_T0_GPR26_code[] = {
1893 0x89, 0x5d, 0x78
1894 };
1895 copy_block(op_store_T0_GPR26_code, 3);
1896 inc_code_ptr(3);
1897 }
1898 #endif
1899
1900 DEFINE_GEN(gen_op_load_T1_GPR26,void,(void))
1901 #ifdef DYNGEN_IMPL
1902 #define HAVE_gen_op_load_T1_GPR26
1903 {
1904 static const uint8 op_load_T1_GPR26_code[] = {
1905 0x8b, 0x75, 0x78
1906 };
1907 copy_block(op_load_T1_GPR26_code, 3);
1908 inc_code_ptr(3);
1909 }
1910 #endif
1911
1912 DEFINE_GEN(gen_op_store_T1_GPR26,void,(void))
1913 #ifdef DYNGEN_IMPL
1914 #define HAVE_gen_op_store_T1_GPR26
1915 {
1916 static const uint8 op_store_T1_GPR26_code[] = {
1917 0x89, 0x75, 0x78
1918 };
1919 copy_block(op_store_T1_GPR26_code, 3);
1920 inc_code_ptr(3);
1921 }
1922 #endif
1923
1924 DEFINE_GEN(gen_op_load_T2_GPR26,void,(void))
1925 #ifdef DYNGEN_IMPL
1926 #define HAVE_gen_op_load_T2_GPR26
1927 {
1928 static const uint8 op_load_T2_GPR26_code[] = {
1929 0x8b, 0x7d, 0x78
1930 };
1931 copy_block(op_load_T2_GPR26_code, 3);
1932 inc_code_ptr(3);
1933 }
1934 #endif
1935
1936 DEFINE_GEN(gen_op_store_T2_GPR26,void,(void))
1937 #ifdef DYNGEN_IMPL
1938 #define HAVE_gen_op_store_T2_GPR26
1939 {
1940 static const uint8 op_store_T2_GPR26_code[] = {
1941 0x89, 0x7d, 0x78
1942 };
1943 copy_block(op_store_T2_GPR26_code, 3);
1944 inc_code_ptr(3);
1945 }
1946 #endif
1947
1948 DEFINE_GEN(gen_op_load_T0_GPR27,void,(void))
1949 #ifdef DYNGEN_IMPL
1950 #define HAVE_gen_op_load_T0_GPR27
1951 {
1952 static const uint8 op_load_T0_GPR27_code[] = {
1953 0x8b, 0x5d, 0x7c
1954 };
1955 copy_block(op_load_T0_GPR27_code, 3);
1956 inc_code_ptr(3);
1957 }
1958 #endif
1959
1960 DEFINE_GEN(gen_op_store_T0_GPR27,void,(void))
1961 #ifdef DYNGEN_IMPL
1962 #define HAVE_gen_op_store_T0_GPR27
1963 {
1964 static const uint8 op_store_T0_GPR27_code[] = {
1965 0x89, 0x5d, 0x7c
1966 };
1967 copy_block(op_store_T0_GPR27_code, 3);
1968 inc_code_ptr(3);
1969 }
1970 #endif
1971
1972 DEFINE_GEN(gen_op_load_T1_GPR27,void,(void))
1973 #ifdef DYNGEN_IMPL
1974 #define HAVE_gen_op_load_T1_GPR27
1975 {
1976 static const uint8 op_load_T1_GPR27_code[] = {
1977 0x8b, 0x75, 0x7c
1978 };
1979 copy_block(op_load_T1_GPR27_code, 3);
1980 inc_code_ptr(3);
1981 }
1982 #endif
1983
1984 DEFINE_GEN(gen_op_store_T1_GPR27,void,(void))
1985 #ifdef DYNGEN_IMPL
1986 #define HAVE_gen_op_store_T1_GPR27
1987 {
1988 static const uint8 op_store_T1_GPR27_code[] = {
1989 0x89, 0x75, 0x7c
1990 };
1991 copy_block(op_store_T1_GPR27_code, 3);
1992 inc_code_ptr(3);
1993 }
1994 #endif
1995
1996 DEFINE_GEN(gen_op_load_T2_GPR27,void,(void))
1997 #ifdef DYNGEN_IMPL
1998 #define HAVE_gen_op_load_T2_GPR27
1999 {
2000 static const uint8 op_load_T2_GPR27_code[] = {
2001 0x8b, 0x7d, 0x7c
2002 };
2003 copy_block(op_load_T2_GPR27_code, 3);
2004 inc_code_ptr(3);
2005 }
2006 #endif
2007
2008 DEFINE_GEN(gen_op_store_T2_GPR27,void,(void))
2009 #ifdef DYNGEN_IMPL
2010 #define HAVE_gen_op_store_T2_GPR27
2011 {
2012 static const uint8 op_store_T2_GPR27_code[] = {
2013 0x89, 0x7d, 0x7c
2014 };
2015 copy_block(op_store_T2_GPR27_code, 3);
2016 inc_code_ptr(3);
2017 }
2018 #endif
2019
2020 DEFINE_GEN(gen_op_load_T0_GPR28,void,(void))
2021 #ifdef DYNGEN_IMPL
2022 #define HAVE_gen_op_load_T0_GPR28
2023 {
2024 static const uint8 op_load_T0_GPR28_code[] = {
2025 0x8b, 0x9d, 0x80, 0x00, 0x00, 0x00
2026 };
2027 copy_block(op_load_T0_GPR28_code, 6);
2028 inc_code_ptr(6);
2029 }
2030 #endif
2031
2032 DEFINE_GEN(gen_op_store_T0_GPR28,void,(void))
2033 #ifdef DYNGEN_IMPL
2034 #define HAVE_gen_op_store_T0_GPR28
2035 {
2036 static const uint8 op_store_T0_GPR28_code[] = {
2037 0x89, 0x9d, 0x80, 0x00, 0x00, 0x00
2038 };
2039 copy_block(op_store_T0_GPR28_code, 6);
2040 inc_code_ptr(6);
2041 }
2042 #endif
2043
2044 DEFINE_GEN(gen_op_load_T1_GPR28,void,(void))
2045 #ifdef DYNGEN_IMPL
2046 #define HAVE_gen_op_load_T1_GPR28
2047 {
2048 static const uint8 op_load_T1_GPR28_code[] = {
2049 0x8b, 0xb5, 0x80, 0x00, 0x00, 0x00
2050 };
2051 copy_block(op_load_T1_GPR28_code, 6);
2052 inc_code_ptr(6);
2053 }
2054 #endif
2055
2056 DEFINE_GEN(gen_op_store_T1_GPR28,void,(void))
2057 #ifdef DYNGEN_IMPL
2058 #define HAVE_gen_op_store_T1_GPR28
2059 {
2060 static const uint8 op_store_T1_GPR28_code[] = {
2061 0x89, 0xb5, 0x80, 0x00, 0x00, 0x00
2062 };
2063 copy_block(op_store_T1_GPR28_code, 6);
2064 inc_code_ptr(6);
2065 }
2066 #endif
2067
2068 DEFINE_GEN(gen_op_load_T2_GPR28,void,(void))
2069 #ifdef DYNGEN_IMPL
2070 #define HAVE_gen_op_load_T2_GPR28
2071 {
2072 static const uint8 op_load_T2_GPR28_code[] = {
2073 0x8b, 0xbd, 0x80, 0x00, 0x00, 0x00
2074 };
2075 copy_block(op_load_T2_GPR28_code, 6);
2076 inc_code_ptr(6);
2077 }
2078 #endif
2079
2080 DEFINE_GEN(gen_op_store_T2_GPR28,void,(void))
2081 #ifdef DYNGEN_IMPL
2082 #define HAVE_gen_op_store_T2_GPR28
2083 {
2084 static const uint8 op_store_T2_GPR28_code[] = {
2085 0x89, 0xbd, 0x80, 0x00, 0x00, 0x00
2086 };
2087 copy_block(op_store_T2_GPR28_code, 6);
2088 inc_code_ptr(6);
2089 }
2090 #endif
2091
2092 DEFINE_GEN(gen_op_load_T0_GPR29,void,(void))
2093 #ifdef DYNGEN_IMPL
2094 #define HAVE_gen_op_load_T0_GPR29
2095 {
2096 static const uint8 op_load_T0_GPR29_code[] = {
2097 0x8b, 0x9d, 0x84, 0x00, 0x00, 0x00
2098 };
2099 copy_block(op_load_T0_GPR29_code, 6);
2100 inc_code_ptr(6);
2101 }
2102 #endif
2103
2104 DEFINE_GEN(gen_op_store_T0_GPR29,void,(void))
2105 #ifdef DYNGEN_IMPL
2106 #define HAVE_gen_op_store_T0_GPR29
2107 {
2108 static const uint8 op_store_T0_GPR29_code[] = {
2109 0x89, 0x9d, 0x84, 0x00, 0x00, 0x00
2110 };
2111 copy_block(op_store_T0_GPR29_code, 6);
2112 inc_code_ptr(6);
2113 }
2114 #endif
2115
2116 DEFINE_GEN(gen_op_load_T1_GPR29,void,(void))
2117 #ifdef DYNGEN_IMPL
2118 #define HAVE_gen_op_load_T1_GPR29
2119 {
2120 static const uint8 op_load_T1_GPR29_code[] = {
2121 0x8b, 0xb5, 0x84, 0x00, 0x00, 0x00
2122 };
2123 copy_block(op_load_T1_GPR29_code, 6);
2124 inc_code_ptr(6);
2125 }
2126 #endif
2127
2128 DEFINE_GEN(gen_op_store_T1_GPR29,void,(void))
2129 #ifdef DYNGEN_IMPL
2130 #define HAVE_gen_op_store_T1_GPR29
2131 {
2132 static const uint8 op_store_T1_GPR29_code[] = {
2133 0x89, 0xb5, 0x84, 0x00, 0x00, 0x00
2134 };
2135 copy_block(op_store_T1_GPR29_code, 6);
2136 inc_code_ptr(6);
2137 }
2138 #endif
2139
2140 DEFINE_GEN(gen_op_load_T2_GPR29,void,(void))
2141 #ifdef DYNGEN_IMPL
2142 #define HAVE_gen_op_load_T2_GPR29
2143 {
2144 static const uint8 op_load_T2_GPR29_code[] = {
2145 0x8b, 0xbd, 0x84, 0x00, 0x00, 0x00
2146 };
2147 copy_block(op_load_T2_GPR29_code, 6);
2148 inc_code_ptr(6);
2149 }
2150 #endif
2151
2152 DEFINE_GEN(gen_op_store_T2_GPR29,void,(void))
2153 #ifdef DYNGEN_IMPL
2154 #define HAVE_gen_op_store_T2_GPR29
2155 {
2156 static const uint8 op_store_T2_GPR29_code[] = {
2157 0x89, 0xbd, 0x84, 0x00, 0x00, 0x00
2158 };
2159 copy_block(op_store_T2_GPR29_code, 6);
2160 inc_code_ptr(6);
2161 }
2162 #endif
2163
2164 DEFINE_GEN(gen_op_load_T0_GPR30,void,(void))
2165 #ifdef DYNGEN_IMPL
2166 #define HAVE_gen_op_load_T0_GPR30
2167 {
2168 static const uint8 op_load_T0_GPR30_code[] = {
2169 0x8b, 0x9d, 0x88, 0x00, 0x00, 0x00
2170 };
2171 copy_block(op_load_T0_GPR30_code, 6);
2172 inc_code_ptr(6);
2173 }
2174 #endif
2175
2176 DEFINE_GEN(gen_op_store_T0_GPR30,void,(void))
2177 #ifdef DYNGEN_IMPL
2178 #define HAVE_gen_op_store_T0_GPR30
2179 {
2180 static const uint8 op_store_T0_GPR30_code[] = {
2181 0x89, 0x9d, 0x88, 0x00, 0x00, 0x00
2182 };
2183 copy_block(op_store_T0_GPR30_code, 6);
2184 inc_code_ptr(6);
2185 }
2186 #endif
2187
2188 DEFINE_GEN(gen_op_load_T1_GPR30,void,(void))
2189 #ifdef DYNGEN_IMPL
2190 #define HAVE_gen_op_load_T1_GPR30
2191 {
2192 static const uint8 op_load_T1_GPR30_code[] = {
2193 0x8b, 0xb5, 0x88, 0x00, 0x00, 0x00
2194 };
2195 copy_block(op_load_T1_GPR30_code, 6);
2196 inc_code_ptr(6);
2197 }
2198 #endif
2199
2200 DEFINE_GEN(gen_op_store_T1_GPR30,void,(void))
2201 #ifdef DYNGEN_IMPL
2202 #define HAVE_gen_op_store_T1_GPR30
2203 {
2204 static const uint8 op_store_T1_GPR30_code[] = {
2205 0x89, 0xb5, 0x88, 0x00, 0x00, 0x00
2206 };
2207 copy_block(op_store_T1_GPR30_code, 6);
2208 inc_code_ptr(6);
2209 }
2210 #endif
2211
2212 DEFINE_GEN(gen_op_load_T2_GPR30,void,(void))
2213 #ifdef DYNGEN_IMPL
2214 #define HAVE_gen_op_load_T2_GPR30
2215 {
2216 static const uint8 op_load_T2_GPR30_code[] = {
2217 0x8b, 0xbd, 0x88, 0x00, 0x00, 0x00
2218 };
2219 copy_block(op_load_T2_GPR30_code, 6);
2220 inc_code_ptr(6);
2221 }
2222 #endif
2223
2224 DEFINE_GEN(gen_op_store_T2_GPR30,void,(void))
2225 #ifdef DYNGEN_IMPL
2226 #define HAVE_gen_op_store_T2_GPR30
2227 {
2228 static const uint8 op_store_T2_GPR30_code[] = {
2229 0x89, 0xbd, 0x88, 0x00, 0x00, 0x00
2230 };
2231 copy_block(op_store_T2_GPR30_code, 6);
2232 inc_code_ptr(6);
2233 }
2234 #endif
2235
2236 DEFINE_GEN(gen_op_load_T0_GPR31,void,(void))
2237 #ifdef DYNGEN_IMPL
2238 #define HAVE_gen_op_load_T0_GPR31
2239 {
2240 static const uint8 op_load_T0_GPR31_code[] = {
2241 0x8b, 0x9d, 0x8c, 0x00, 0x00, 0x00
2242 };
2243 copy_block(op_load_T0_GPR31_code, 6);
2244 inc_code_ptr(6);
2245 }
2246 #endif
2247
2248 DEFINE_GEN(gen_op_store_T0_GPR31,void,(void))
2249 #ifdef DYNGEN_IMPL
2250 #define HAVE_gen_op_store_T0_GPR31
2251 {
2252 static const uint8 op_store_T0_GPR31_code[] = {
2253 0x89, 0x9d, 0x8c, 0x00, 0x00, 0x00
2254 };
2255 copy_block(op_store_T0_GPR31_code, 6);
2256 inc_code_ptr(6);
2257 }
2258 #endif
2259
2260 DEFINE_GEN(gen_op_load_T1_GPR31,void,(void))
2261 #ifdef DYNGEN_IMPL
2262 #define HAVE_gen_op_load_T1_GPR31
2263 {
2264 static const uint8 op_load_T1_GPR31_code[] = {
2265 0x8b, 0xb5, 0x8c, 0x00, 0x00, 0x00
2266 };
2267 copy_block(op_load_T1_GPR31_code, 6);
2268 inc_code_ptr(6);
2269 }
2270 #endif
2271
2272 DEFINE_GEN(gen_op_store_T1_GPR31,void,(void))
2273 #ifdef DYNGEN_IMPL
2274 #define HAVE_gen_op_store_T1_GPR31
2275 {
2276 static const uint8 op_store_T1_GPR31_code[] = {
2277 0x89, 0xb5, 0x8c, 0x00, 0x00, 0x00
2278 };
2279 copy_block(op_store_T1_GPR31_code, 6);
2280 inc_code_ptr(6);
2281 }
2282 #endif
2283
2284 DEFINE_GEN(gen_op_load_T2_GPR31,void,(void))
2285 #ifdef DYNGEN_IMPL
2286 #define HAVE_gen_op_load_T2_GPR31
2287 {
2288 static const uint8 op_load_T2_GPR31_code[] = {
2289 0x8b, 0xbd, 0x8c, 0x00, 0x00, 0x00
2290 };
2291 copy_block(op_load_T2_GPR31_code, 6);
2292 inc_code_ptr(6);
2293 }
2294 #endif
2295
2296 DEFINE_GEN(gen_op_store_T2_GPR31,void,(void))
2297 #ifdef DYNGEN_IMPL
2298 #define HAVE_gen_op_store_T2_GPR31
2299 {
2300 static const uint8 op_store_T2_GPR31_code[] = {
2301 0x89, 0xbd, 0x8c, 0x00, 0x00, 0x00
2302 };
2303 copy_block(op_store_T2_GPR31_code, 6);
2304 inc_code_ptr(6);
2305 }
2306 #endif
2307
2308 DEFINE_GEN(gen_op_load_F0_FPR0,void,(void))
2309 #ifdef DYNGEN_IMPL
2310 #define HAVE_gen_op_load_F0_FPR0
2311 {
2312 static const uint8 op_load_F0_FPR0_code[] = {
2313 0x8d, 0x9d, 0x90, 0x00, 0x00, 0x00
2314 };
2315 copy_block(op_load_F0_FPR0_code, 6);
2316 inc_code_ptr(6);
2317 }
2318 #endif
2319
2320 DEFINE_GEN(gen_op_store_F0_FPR0,void,(void))
2321 #ifdef DYNGEN_IMPL
2322 #define HAVE_gen_op_store_F0_FPR0
2323 {
2324 static const uint8 op_store_F0_FPR0_code[] = {
2325 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x90, 0x00, 0x00, 0x00, 0x89,
2326 0x95, 0x94, 0x00, 0x00, 0x00
2327 };
2328 copy_block(op_store_F0_FPR0_code, 17);
2329 inc_code_ptr(17);
2330 }
2331 #endif
2332
2333 DEFINE_GEN(gen_op_load_F1_FPR0,void,(void))
2334 #ifdef DYNGEN_IMPL
2335 #define HAVE_gen_op_load_F1_FPR0
2336 {
2337 static const uint8 op_load_F1_FPR0_code[] = {
2338 0x8d, 0xb5, 0x90, 0x00, 0x00, 0x00
2339 };
2340 copy_block(op_load_F1_FPR0_code, 6);
2341 inc_code_ptr(6);
2342 }
2343 #endif
2344
2345 DEFINE_GEN(gen_op_store_F1_FPR0,void,(void))
2346 #ifdef DYNGEN_IMPL
2347 #define HAVE_gen_op_store_F1_FPR0
2348 {
2349 static const uint8 op_store_F1_FPR0_code[] = {
2350 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x90, 0x00, 0x00, 0x00, 0x89,
2351 0x95, 0x94, 0x00, 0x00, 0x00
2352 };
2353 copy_block(op_store_F1_FPR0_code, 17);
2354 inc_code_ptr(17);
2355 }
2356 #endif
2357
2358 DEFINE_GEN(gen_op_load_F2_FPR0,void,(void))
2359 #ifdef DYNGEN_IMPL
2360 #define HAVE_gen_op_load_F2_FPR0
2361 {
2362 static const uint8 op_load_F2_FPR0_code[] = {
2363 0x8d, 0xbd, 0x90, 0x00, 0x00, 0x00
2364 };
2365 copy_block(op_load_F2_FPR0_code, 6);
2366 inc_code_ptr(6);
2367 }
2368 #endif
2369
2370 DEFINE_GEN(gen_op_store_F2_FPR0,void,(void))
2371 #ifdef DYNGEN_IMPL
2372 #define HAVE_gen_op_store_F2_FPR0
2373 {
2374 static const uint8 op_store_F2_FPR0_code[] = {
2375 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x90, 0x00, 0x00, 0x00, 0x89,
2376 0x95, 0x94, 0x00, 0x00, 0x00
2377 };
2378 copy_block(op_store_F2_FPR0_code, 17);
2379 inc_code_ptr(17);
2380 }
2381 #endif
2382
2383 DEFINE_GEN(gen_op_store_FD_FPR0,void,(void))
2384 #ifdef DYNGEN_IMPL
2385 #define HAVE_gen_op_store_FD_FPR0
2386 {
2387 static const uint8 op_store_FD_FPR0_code[] = {
2388 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
2389 0x89, 0x85, 0x90, 0x00, 0x00, 0x00, 0x89, 0x95, 0x94, 0x00, 0x00, 0x00
2390 };
2391 copy_block(op_store_FD_FPR0_code, 24);
2392 inc_code_ptr(24);
2393 }
2394 #endif
2395
2396 DEFINE_GEN(gen_op_load_F0_FPR1,void,(void))
2397 #ifdef DYNGEN_IMPL
2398 #define HAVE_gen_op_load_F0_FPR1
2399 {
2400 static const uint8 op_load_F0_FPR1_code[] = {
2401 0x8d, 0x9d, 0x98, 0x00, 0x00, 0x00
2402 };
2403 copy_block(op_load_F0_FPR1_code, 6);
2404 inc_code_ptr(6);
2405 }
2406 #endif
2407
2408 DEFINE_GEN(gen_op_store_F0_FPR1,void,(void))
2409 #ifdef DYNGEN_IMPL
2410 #define HAVE_gen_op_store_F0_FPR1
2411 {
2412 static const uint8 op_store_F0_FPR1_code[] = {
2413 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x98, 0x00, 0x00, 0x00, 0x89,
2414 0x95, 0x9c, 0x00, 0x00, 0x00
2415 };
2416 copy_block(op_store_F0_FPR1_code, 17);
2417 inc_code_ptr(17);
2418 }
2419 #endif
2420
2421 DEFINE_GEN(gen_op_load_F1_FPR1,void,(void))
2422 #ifdef DYNGEN_IMPL
2423 #define HAVE_gen_op_load_F1_FPR1
2424 {
2425 static const uint8 op_load_F1_FPR1_code[] = {
2426 0x8d, 0xb5, 0x98, 0x00, 0x00, 0x00
2427 };
2428 copy_block(op_load_F1_FPR1_code, 6);
2429 inc_code_ptr(6);
2430 }
2431 #endif
2432
2433 DEFINE_GEN(gen_op_store_F1_FPR1,void,(void))
2434 #ifdef DYNGEN_IMPL
2435 #define HAVE_gen_op_store_F1_FPR1
2436 {
2437 static const uint8 op_store_F1_FPR1_code[] = {
2438 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x98, 0x00, 0x00, 0x00, 0x89,
2439 0x95, 0x9c, 0x00, 0x00, 0x00
2440 };
2441 copy_block(op_store_F1_FPR1_code, 17);
2442 inc_code_ptr(17);
2443 }
2444 #endif
2445
2446 DEFINE_GEN(gen_op_load_F2_FPR1,void,(void))
2447 #ifdef DYNGEN_IMPL
2448 #define HAVE_gen_op_load_F2_FPR1
2449 {
2450 static const uint8 op_load_F2_FPR1_code[] = {
2451 0x8d, 0xbd, 0x98, 0x00, 0x00, 0x00
2452 };
2453 copy_block(op_load_F2_FPR1_code, 6);
2454 inc_code_ptr(6);
2455 }
2456 #endif
2457
2458 DEFINE_GEN(gen_op_store_F2_FPR1,void,(void))
2459 #ifdef DYNGEN_IMPL
2460 #define HAVE_gen_op_store_F2_FPR1
2461 {
2462 static const uint8 op_store_F2_FPR1_code[] = {
2463 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x98, 0x00, 0x00, 0x00, 0x89,
2464 0x95, 0x9c, 0x00, 0x00, 0x00
2465 };
2466 copy_block(op_store_F2_FPR1_code, 17);
2467 inc_code_ptr(17);
2468 }
2469 #endif
2470
2471 DEFINE_GEN(gen_op_store_FD_FPR1,void,(void))
2472 #ifdef DYNGEN_IMPL
2473 #define HAVE_gen_op_store_FD_FPR1
2474 {
2475 static const uint8 op_store_FD_FPR1_code[] = {
2476 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
2477 0x89, 0x85, 0x98, 0x00, 0x00, 0x00, 0x89, 0x95, 0x9c, 0x00, 0x00, 0x00
2478 };
2479 copy_block(op_store_FD_FPR1_code, 24);
2480 inc_code_ptr(24);
2481 }
2482 #endif
2483
2484 DEFINE_GEN(gen_op_load_F0_FPR2,void,(void))
2485 #ifdef DYNGEN_IMPL
2486 #define HAVE_gen_op_load_F0_FPR2
2487 {
2488 static const uint8 op_load_F0_FPR2_code[] = {
2489 0x8d, 0x9d, 0xa0, 0x00, 0x00, 0x00
2490 };
2491 copy_block(op_load_F0_FPR2_code, 6);
2492 inc_code_ptr(6);
2493 }
2494 #endif
2495
2496 DEFINE_GEN(gen_op_store_F0_FPR2,void,(void))
2497 #ifdef DYNGEN_IMPL
2498 #define HAVE_gen_op_store_F0_FPR2
2499 {
2500 static const uint8 op_store_F0_FPR2_code[] = {
2501 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xa0, 0x00, 0x00, 0x00, 0x89,
2502 0x95, 0xa4, 0x00, 0x00, 0x00
2503 };
2504 copy_block(op_store_F0_FPR2_code, 17);
2505 inc_code_ptr(17);
2506 }
2507 #endif
2508
2509 DEFINE_GEN(gen_op_load_F1_FPR2,void,(void))
2510 #ifdef DYNGEN_IMPL
2511 #define HAVE_gen_op_load_F1_FPR2
2512 {
2513 static const uint8 op_load_F1_FPR2_code[] = {
2514 0x8d, 0xb5, 0xa0, 0x00, 0x00, 0x00
2515 };
2516 copy_block(op_load_F1_FPR2_code, 6);
2517 inc_code_ptr(6);
2518 }
2519 #endif
2520
2521 DEFINE_GEN(gen_op_store_F1_FPR2,void,(void))
2522 #ifdef DYNGEN_IMPL
2523 #define HAVE_gen_op_store_F1_FPR2
2524 {
2525 static const uint8 op_store_F1_FPR2_code[] = {
2526 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xa0, 0x00, 0x00, 0x00, 0x89,
2527 0x95, 0xa4, 0x00, 0x00, 0x00
2528 };
2529 copy_block(op_store_F1_FPR2_code, 17);
2530 inc_code_ptr(17);
2531 }
2532 #endif
2533
2534 DEFINE_GEN(gen_op_load_F2_FPR2,void,(void))
2535 #ifdef DYNGEN_IMPL
2536 #define HAVE_gen_op_load_F2_FPR2
2537 {
2538 static const uint8 op_load_F2_FPR2_code[] = {
2539 0x8d, 0xbd, 0xa0, 0x00, 0x00, 0x00
2540 };
2541 copy_block(op_load_F2_FPR2_code, 6);
2542 inc_code_ptr(6);
2543 }
2544 #endif
2545
2546 DEFINE_GEN(gen_op_store_F2_FPR2,void,(void))
2547 #ifdef DYNGEN_IMPL
2548 #define HAVE_gen_op_store_F2_FPR2
2549 {
2550 static const uint8 op_store_F2_FPR2_code[] = {
2551 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xa0, 0x00, 0x00, 0x00, 0x89,
2552 0x95, 0xa4, 0x00, 0x00, 0x00
2553 };
2554 copy_block(op_store_F2_FPR2_code, 17);
2555 inc_code_ptr(17);
2556 }
2557 #endif
2558
2559 DEFINE_GEN(gen_op_store_FD_FPR2,void,(void))
2560 #ifdef DYNGEN_IMPL
2561 #define HAVE_gen_op_store_FD_FPR2
2562 {
2563 static const uint8 op_store_FD_FPR2_code[] = {
2564 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
2565 0x89, 0x85, 0xa0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xa4, 0x00, 0x00, 0x00
2566 };
2567 copy_block(op_store_FD_FPR2_code, 24);
2568 inc_code_ptr(24);
2569 }
2570 #endif
2571
2572 DEFINE_GEN(gen_op_load_F0_FPR3,void,(void))
2573 #ifdef DYNGEN_IMPL
2574 #define HAVE_gen_op_load_F0_FPR3
2575 {
2576 static const uint8 op_load_F0_FPR3_code[] = {
2577 0x8d, 0x9d, 0xa8, 0x00, 0x00, 0x00
2578 };
2579 copy_block(op_load_F0_FPR3_code, 6);
2580 inc_code_ptr(6);
2581 }
2582 #endif
2583
2584 DEFINE_GEN(gen_op_store_F0_FPR3,void,(void))
2585 #ifdef DYNGEN_IMPL
2586 #define HAVE_gen_op_store_F0_FPR3
2587 {
2588 static const uint8 op_store_F0_FPR3_code[] = {
2589 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xa8, 0x00, 0x00, 0x00, 0x89,
2590 0x95, 0xac, 0x00, 0x00, 0x00
2591 };
2592 copy_block(op_store_F0_FPR3_code, 17);
2593 inc_code_ptr(17);
2594 }
2595 #endif
2596
2597 DEFINE_GEN(gen_op_load_F1_FPR3,void,(void))
2598 #ifdef DYNGEN_IMPL
2599 #define HAVE_gen_op_load_F1_FPR3
2600 {
2601 static const uint8 op_load_F1_FPR3_code[] = {
2602 0x8d, 0xb5, 0xa8, 0x00, 0x00, 0x00
2603 };
2604 copy_block(op_load_F1_FPR3_code, 6);
2605 inc_code_ptr(6);
2606 }
2607 #endif
2608
2609 DEFINE_GEN(gen_op_store_F1_FPR3,void,(void))
2610 #ifdef DYNGEN_IMPL
2611 #define HAVE_gen_op_store_F1_FPR3
2612 {
2613 static const uint8 op_store_F1_FPR3_code[] = {
2614 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xa8, 0x00, 0x00, 0x00, 0x89,
2615 0x95, 0xac, 0x00, 0x00, 0x00
2616 };
2617 copy_block(op_store_F1_FPR3_code, 17);
2618 inc_code_ptr(17);
2619 }
2620 #endif
2621
2622 DEFINE_GEN(gen_op_load_F2_FPR3,void,(void))
2623 #ifdef DYNGEN_IMPL
2624 #define HAVE_gen_op_load_F2_FPR3
2625 {
2626 static const uint8 op_load_F2_FPR3_code[] = {
2627 0x8d, 0xbd, 0xa8, 0x00, 0x00, 0x00
2628 };
2629 copy_block(op_load_F2_FPR3_code, 6);
2630 inc_code_ptr(6);
2631 }
2632 #endif
2633
2634 DEFINE_GEN(gen_op_store_F2_FPR3,void,(void))
2635 #ifdef DYNGEN_IMPL
2636 #define HAVE_gen_op_store_F2_FPR3
2637 {
2638 static const uint8 op_store_F2_FPR3_code[] = {
2639 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xa8, 0x00, 0x00, 0x00, 0x89,
2640 0x95, 0xac, 0x00, 0x00, 0x00
2641 };
2642 copy_block(op_store_F2_FPR3_code, 17);
2643 inc_code_ptr(17);
2644 }
2645 #endif
2646
2647 DEFINE_GEN(gen_op_store_FD_FPR3,void,(void))
2648 #ifdef DYNGEN_IMPL
2649 #define HAVE_gen_op_store_FD_FPR3
2650 {
2651 static const uint8 op_store_FD_FPR3_code[] = {
2652 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
2653 0x89, 0x85, 0xa8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xac, 0x00, 0x00, 0x00
2654 };
2655 copy_block(op_store_FD_FPR3_code, 24);
2656 inc_code_ptr(24);
2657 }
2658 #endif
2659
2660 DEFINE_GEN(gen_op_load_F0_FPR4,void,(void))
2661 #ifdef DYNGEN_IMPL
2662 #define HAVE_gen_op_load_F0_FPR4
2663 {
2664 static const uint8 op_load_F0_FPR4_code[] = {
2665 0x8d, 0x9d, 0xb0, 0x00, 0x00, 0x00
2666 };
2667 copy_block(op_load_F0_FPR4_code, 6);
2668 inc_code_ptr(6);
2669 }
2670 #endif
2671
2672 DEFINE_GEN(gen_op_store_F0_FPR4,void,(void))
2673 #ifdef DYNGEN_IMPL
2674 #define HAVE_gen_op_store_F0_FPR4
2675 {
2676 static const uint8 op_store_F0_FPR4_code[] = {
2677 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xb0, 0x00, 0x00, 0x00, 0x89,
2678 0x95, 0xb4, 0x00, 0x00, 0x00
2679 };
2680 copy_block(op_store_F0_FPR4_code, 17);
2681 inc_code_ptr(17);
2682 }
2683 #endif
2684
2685 DEFINE_GEN(gen_op_load_F1_FPR4,void,(void))
2686 #ifdef DYNGEN_IMPL
2687 #define HAVE_gen_op_load_F1_FPR4
2688 {
2689 static const uint8 op_load_F1_FPR4_code[] = {
2690 0x8d, 0xb5, 0xb0, 0x00, 0x00, 0x00
2691 };
2692 copy_block(op_load_F1_FPR4_code, 6);
2693 inc_code_ptr(6);
2694 }
2695 #endif
2696
2697 DEFINE_GEN(gen_op_store_F1_FPR4,void,(void))
2698 #ifdef DYNGEN_IMPL
2699 #define HAVE_gen_op_store_F1_FPR4
2700 {
2701 static const uint8 op_store_F1_FPR4_code[] = {
2702 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xb0, 0x00, 0x00, 0x00, 0x89,
2703 0x95, 0xb4, 0x00, 0x00, 0x00
2704 };
2705 copy_block(op_store_F1_FPR4_code, 17);
2706 inc_code_ptr(17);
2707 }
2708 #endif
2709
2710 DEFINE_GEN(gen_op_load_F2_FPR4,void,(void))
2711 #ifdef DYNGEN_IMPL
2712 #define HAVE_gen_op_load_F2_FPR4
2713 {
2714 static const uint8 op_load_F2_FPR4_code[] = {
2715 0x8d, 0xbd, 0xb0, 0x00, 0x00, 0x00
2716 };
2717 copy_block(op_load_F2_FPR4_code, 6);
2718 inc_code_ptr(6);
2719 }
2720 #endif
2721
2722 DEFINE_GEN(gen_op_store_F2_FPR4,void,(void))
2723 #ifdef DYNGEN_IMPL
2724 #define HAVE_gen_op_store_F2_FPR4
2725 {
2726 static const uint8 op_store_F2_FPR4_code[] = {
2727 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xb0, 0x00, 0x00, 0x00, 0x89,
2728 0x95, 0xb4, 0x00, 0x00, 0x00
2729 };
2730 copy_block(op_store_F2_FPR4_code, 17);
2731 inc_code_ptr(17);
2732 }
2733 #endif
2734
2735 DEFINE_GEN(gen_op_store_FD_FPR4,void,(void))
2736 #ifdef DYNGEN_IMPL
2737 #define HAVE_gen_op_store_FD_FPR4
2738 {
2739 static const uint8 op_store_FD_FPR4_code[] = {
2740 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
2741 0x89, 0x85, 0xb0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xb4, 0x00, 0x00, 0x00
2742 };
2743 copy_block(op_store_FD_FPR4_code, 24);
2744 inc_code_ptr(24);
2745 }
2746 #endif
2747
2748 DEFINE_GEN(gen_op_load_F0_FPR5,void,(void))
2749 #ifdef DYNGEN_IMPL
2750 #define HAVE_gen_op_load_F0_FPR5
2751 {
2752 static const uint8 op_load_F0_FPR5_code[] = {
2753 0x8d, 0x9d, 0xb8, 0x00, 0x00, 0x00
2754 };
2755 copy_block(op_load_F0_FPR5_code, 6);
2756 inc_code_ptr(6);
2757 }
2758 #endif
2759
2760 DEFINE_GEN(gen_op_store_F0_FPR5,void,(void))
2761 #ifdef DYNGEN_IMPL
2762 #define HAVE_gen_op_store_F0_FPR5
2763 {
2764 static const uint8 op_store_F0_FPR5_code[] = {
2765 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xb8, 0x00, 0x00, 0x00, 0x89,
2766 0x95, 0xbc, 0x00, 0x00, 0x00
2767 };
2768 copy_block(op_store_F0_FPR5_code, 17);
2769 inc_code_ptr(17);
2770 }
2771 #endif
2772
2773 DEFINE_GEN(gen_op_load_F1_FPR5,void,(void))
2774 #ifdef DYNGEN_IMPL
2775 #define HAVE_gen_op_load_F1_FPR5
2776 {
2777 static const uint8 op_load_F1_FPR5_code[] = {
2778 0x8d, 0xb5, 0xb8, 0x00, 0x00, 0x00
2779 };
2780 copy_block(op_load_F1_FPR5_code, 6);
2781 inc_code_ptr(6);
2782 }
2783 #endif
2784
2785 DEFINE_GEN(gen_op_store_F1_FPR5,void,(void))
2786 #ifdef DYNGEN_IMPL
2787 #define HAVE_gen_op_store_F1_FPR5
2788 {
2789 static const uint8 op_store_F1_FPR5_code[] = {
2790 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xb8, 0x00, 0x00, 0x00, 0x89,
2791 0x95, 0xbc, 0x00, 0x00, 0x00
2792 };
2793 copy_block(op_store_F1_FPR5_code, 17);
2794 inc_code_ptr(17);
2795 }
2796 #endif
2797
2798 DEFINE_GEN(gen_op_load_F2_FPR5,void,(void))
2799 #ifdef DYNGEN_IMPL
2800 #define HAVE_gen_op_load_F2_FPR5
2801 {
2802 static const uint8 op_load_F2_FPR5_code[] = {
2803 0x8d, 0xbd, 0xb8, 0x00, 0x00, 0x00
2804 };
2805 copy_block(op_load_F2_FPR5_code, 6);
2806 inc_code_ptr(6);
2807 }
2808 #endif
2809
2810 DEFINE_GEN(gen_op_store_F2_FPR5,void,(void))
2811 #ifdef DYNGEN_IMPL
2812 #define HAVE_gen_op_store_F2_FPR5
2813 {
2814 static const uint8 op_store_F2_FPR5_code[] = {
2815 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xb8, 0x00, 0x00, 0x00, 0x89,
2816 0x95, 0xbc, 0x00, 0x00, 0x00
2817 };
2818 copy_block(op_store_F2_FPR5_code, 17);
2819 inc_code_ptr(17);
2820 }
2821 #endif
2822
2823 DEFINE_GEN(gen_op_store_FD_FPR5,void,(void))
2824 #ifdef DYNGEN_IMPL
2825 #define HAVE_gen_op_store_FD_FPR5
2826 {
2827 static const uint8 op_store_FD_FPR5_code[] = {
2828 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
2829 0x89, 0x85, 0xb8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xbc, 0x00, 0x00, 0x00
2830 };
2831 copy_block(op_store_FD_FPR5_code, 24);
2832 inc_code_ptr(24);
2833 }
2834 #endif
2835
2836 DEFINE_GEN(gen_op_load_F0_FPR6,void,(void))
2837 #ifdef DYNGEN_IMPL
2838 #define HAVE_gen_op_load_F0_FPR6
2839 {
2840 static const uint8 op_load_F0_FPR6_code[] = {
2841 0x8d, 0x9d, 0xc0, 0x00, 0x00, 0x00
2842 };
2843 copy_block(op_load_F0_FPR6_code, 6);
2844 inc_code_ptr(6);
2845 }
2846 #endif
2847
2848 DEFINE_GEN(gen_op_store_F0_FPR6,void,(void))
2849 #ifdef DYNGEN_IMPL
2850 #define HAVE_gen_op_store_F0_FPR6
2851 {
2852 static const uint8 op_store_F0_FPR6_code[] = {
2853 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xc0, 0x00, 0x00, 0x00, 0x89,
2854 0x95, 0xc4, 0x00, 0x00, 0x00
2855 };
2856 copy_block(op_store_F0_FPR6_code, 17);
2857 inc_code_ptr(17);
2858 }
2859 #endif
2860
2861 DEFINE_GEN(gen_op_load_F1_FPR6,void,(void))
2862 #ifdef DYNGEN_IMPL
2863 #define HAVE_gen_op_load_F1_FPR6
2864 {
2865 static const uint8 op_load_F1_FPR6_code[] = {
2866 0x8d, 0xb5, 0xc0, 0x00, 0x00, 0x00
2867 };
2868 copy_block(op_load_F1_FPR6_code, 6);
2869 inc_code_ptr(6);
2870 }
2871 #endif
2872
2873 DEFINE_GEN(gen_op_store_F1_FPR6,void,(void))
2874 #ifdef DYNGEN_IMPL
2875 #define HAVE_gen_op_store_F1_FPR6
2876 {
2877 static const uint8 op_store_F1_FPR6_code[] = {
2878 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xc0, 0x00, 0x00, 0x00, 0x89,
2879 0x95, 0xc4, 0x00, 0x00, 0x00
2880 };
2881 copy_block(op_store_F1_FPR6_code, 17);
2882 inc_code_ptr(17);
2883 }
2884 #endif
2885
2886 DEFINE_GEN(gen_op_load_F2_FPR6,void,(void))
2887 #ifdef DYNGEN_IMPL
2888 #define HAVE_gen_op_load_F2_FPR6
2889 {
2890 static const uint8 op_load_F2_FPR6_code[] = {
2891 0x8d, 0xbd, 0xc0, 0x00, 0x00, 0x00
2892 };
2893 copy_block(op_load_F2_FPR6_code, 6);
2894 inc_code_ptr(6);
2895 }
2896 #endif
2897
2898 DEFINE_GEN(gen_op_store_F2_FPR6,void,(void))
2899 #ifdef DYNGEN_IMPL
2900 #define HAVE_gen_op_store_F2_FPR6
2901 {
2902 static const uint8 op_store_F2_FPR6_code[] = {
2903 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xc0, 0x00, 0x00, 0x00, 0x89,
2904 0x95, 0xc4, 0x00, 0x00, 0x00
2905 };
2906 copy_block(op_store_F2_FPR6_code, 17);
2907 inc_code_ptr(17);
2908 }
2909 #endif
2910
2911 DEFINE_GEN(gen_op_store_FD_FPR6,void,(void))
2912 #ifdef DYNGEN_IMPL
2913 #define HAVE_gen_op_store_FD_FPR6
2914 {
2915 static const uint8 op_store_FD_FPR6_code[] = {
2916 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
2917 0x89, 0x85, 0xc0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xc4, 0x00, 0x00, 0x00
2918 };
2919 copy_block(op_store_FD_FPR6_code, 24);
2920 inc_code_ptr(24);
2921 }
2922 #endif
2923
2924 DEFINE_GEN(gen_op_load_F0_FPR7,void,(void))
2925 #ifdef DYNGEN_IMPL
2926 #define HAVE_gen_op_load_F0_FPR7
2927 {
2928 static const uint8 op_load_F0_FPR7_code[] = {
2929 0x8d, 0x9d, 0xc8, 0x00, 0x00, 0x00
2930 };
2931 copy_block(op_load_F0_FPR7_code, 6);
2932 inc_code_ptr(6);
2933 }
2934 #endif
2935
2936 DEFINE_GEN(gen_op_store_F0_FPR7,void,(void))
2937 #ifdef DYNGEN_IMPL
2938 #define HAVE_gen_op_store_F0_FPR7
2939 {
2940 static const uint8 op_store_F0_FPR7_code[] = {
2941 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xc8, 0x00, 0x00, 0x00, 0x89,
2942 0x95, 0xcc, 0x00, 0x00, 0x00
2943 };
2944 copy_block(op_store_F0_FPR7_code, 17);
2945 inc_code_ptr(17);
2946 }
2947 #endif
2948
2949 DEFINE_GEN(gen_op_load_F1_FPR7,void,(void))
2950 #ifdef DYNGEN_IMPL
2951 #define HAVE_gen_op_load_F1_FPR7
2952 {
2953 static const uint8 op_load_F1_FPR7_code[] = {
2954 0x8d, 0xb5, 0xc8, 0x00, 0x00, 0x00
2955 };
2956 copy_block(op_load_F1_FPR7_code, 6);
2957 inc_code_ptr(6);
2958 }
2959 #endif
2960
2961 DEFINE_GEN(gen_op_store_F1_FPR7,void,(void))
2962 #ifdef DYNGEN_IMPL
2963 #define HAVE_gen_op_store_F1_FPR7
2964 {
2965 static const uint8 op_store_F1_FPR7_code[] = {
2966 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xc8, 0x00, 0x00, 0x00, 0x89,
2967 0x95, 0xcc, 0x00, 0x00, 0x00
2968 };
2969 copy_block(op_store_F1_FPR7_code, 17);
2970 inc_code_ptr(17);
2971 }
2972 #endif
2973
2974 DEFINE_GEN(gen_op_load_F2_FPR7,void,(void))
2975 #ifdef DYNGEN_IMPL
2976 #define HAVE_gen_op_load_F2_FPR7
2977 {
2978 static const uint8 op_load_F2_FPR7_code[] = {
2979 0x8d, 0xbd, 0xc8, 0x00, 0x00, 0x00
2980 };
2981 copy_block(op_load_F2_FPR7_code, 6);
2982 inc_code_ptr(6);
2983 }
2984 #endif
2985
2986 DEFINE_GEN(gen_op_store_F2_FPR7,void,(void))
2987 #ifdef DYNGEN_IMPL
2988 #define HAVE_gen_op_store_F2_FPR7
2989 {
2990 static const uint8 op_store_F2_FPR7_code[] = {
2991 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xc8, 0x00, 0x00, 0x00, 0x89,
2992 0x95, 0xcc, 0x00, 0x00, 0x00
2993 };
2994 copy_block(op_store_F2_FPR7_code, 17);
2995 inc_code_ptr(17);
2996 }
2997 #endif
2998
2999 DEFINE_GEN(gen_op_store_FD_FPR7,void,(void))
3000 #ifdef DYNGEN_IMPL
3001 #define HAVE_gen_op_store_FD_FPR7
3002 {
3003 static const uint8 op_store_FD_FPR7_code[] = {
3004 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3005 0x89, 0x85, 0xc8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xcc, 0x00, 0x00, 0x00
3006 };
3007 copy_block(op_store_FD_FPR7_code, 24);
3008 inc_code_ptr(24);
3009 }
3010 #endif
3011
3012 DEFINE_GEN(gen_op_load_F0_FPR8,void,(void))
3013 #ifdef DYNGEN_IMPL
3014 #define HAVE_gen_op_load_F0_FPR8
3015 {
3016 static const uint8 op_load_F0_FPR8_code[] = {
3017 0x8d, 0x9d, 0xd0, 0x00, 0x00, 0x00
3018 };
3019 copy_block(op_load_F0_FPR8_code, 6);
3020 inc_code_ptr(6);
3021 }
3022 #endif
3023
3024 DEFINE_GEN(gen_op_store_F0_FPR8,void,(void))
3025 #ifdef DYNGEN_IMPL
3026 #define HAVE_gen_op_store_F0_FPR8
3027 {
3028 static const uint8 op_store_F0_FPR8_code[] = {
3029 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xd0, 0x00, 0x00, 0x00, 0x89,
3030 0x95, 0xd4, 0x00, 0x00, 0x00
3031 };
3032 copy_block(op_store_F0_FPR8_code, 17);
3033 inc_code_ptr(17);
3034 }
3035 #endif
3036
3037 DEFINE_GEN(gen_op_load_F1_FPR8,void,(void))
3038 #ifdef DYNGEN_IMPL
3039 #define HAVE_gen_op_load_F1_FPR8
3040 {
3041 static const uint8 op_load_F1_FPR8_code[] = {
3042 0x8d, 0xb5, 0xd0, 0x00, 0x00, 0x00
3043 };
3044 copy_block(op_load_F1_FPR8_code, 6);
3045 inc_code_ptr(6);
3046 }
3047 #endif
3048
3049 DEFINE_GEN(gen_op_store_F1_FPR8,void,(void))
3050 #ifdef DYNGEN_IMPL
3051 #define HAVE_gen_op_store_F1_FPR8
3052 {
3053 static const uint8 op_store_F1_FPR8_code[] = {
3054 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xd0, 0x00, 0x00, 0x00, 0x89,
3055 0x95, 0xd4, 0x00, 0x00, 0x00
3056 };
3057 copy_block(op_store_F1_FPR8_code, 17);
3058 inc_code_ptr(17);
3059 }
3060 #endif
3061
3062 DEFINE_GEN(gen_op_load_F2_FPR8,void,(void))
3063 #ifdef DYNGEN_IMPL
3064 #define HAVE_gen_op_load_F2_FPR8
3065 {
3066 static const uint8 op_load_F2_FPR8_code[] = {
3067 0x8d, 0xbd, 0xd0, 0x00, 0x00, 0x00
3068 };
3069 copy_block(op_load_F2_FPR8_code, 6);
3070 inc_code_ptr(6);
3071 }
3072 #endif
3073
3074 DEFINE_GEN(gen_op_store_F2_FPR8,void,(void))
3075 #ifdef DYNGEN_IMPL
3076 #define HAVE_gen_op_store_F2_FPR8
3077 {
3078 static const uint8 op_store_F2_FPR8_code[] = {
3079 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xd0, 0x00, 0x00, 0x00, 0x89,
3080 0x95, 0xd4, 0x00, 0x00, 0x00
3081 };
3082 copy_block(op_store_F2_FPR8_code, 17);
3083 inc_code_ptr(17);
3084 }
3085 #endif
3086
3087 DEFINE_GEN(gen_op_store_FD_FPR8,void,(void))
3088 #ifdef DYNGEN_IMPL
3089 #define HAVE_gen_op_store_FD_FPR8
3090 {
3091 static const uint8 op_store_FD_FPR8_code[] = {
3092 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3093 0x89, 0x85, 0xd0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xd4, 0x00, 0x00, 0x00
3094 };
3095 copy_block(op_store_FD_FPR8_code, 24);
3096 inc_code_ptr(24);
3097 }
3098 #endif
3099
3100 DEFINE_GEN(gen_op_load_F0_FPR9,void,(void))
3101 #ifdef DYNGEN_IMPL
3102 #define HAVE_gen_op_load_F0_FPR9
3103 {
3104 static const uint8 op_load_F0_FPR9_code[] = {
3105 0x8d, 0x9d, 0xd8, 0x00, 0x00, 0x00
3106 };
3107 copy_block(op_load_F0_FPR9_code, 6);
3108 inc_code_ptr(6);
3109 }
3110 #endif
3111
3112 DEFINE_GEN(gen_op_store_F0_FPR9,void,(void))
3113 #ifdef DYNGEN_IMPL
3114 #define HAVE_gen_op_store_F0_FPR9
3115 {
3116 static const uint8 op_store_F0_FPR9_code[] = {
3117 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xd8, 0x00, 0x00, 0x00, 0x89,
3118 0x95, 0xdc, 0x00, 0x00, 0x00
3119 };
3120 copy_block(op_store_F0_FPR9_code, 17);
3121 inc_code_ptr(17);
3122 }
3123 #endif
3124
3125 DEFINE_GEN(gen_op_load_F1_FPR9,void,(void))
3126 #ifdef DYNGEN_IMPL
3127 #define HAVE_gen_op_load_F1_FPR9
3128 {
3129 static const uint8 op_load_F1_FPR9_code[] = {
3130 0x8d, 0xb5, 0xd8, 0x00, 0x00, 0x00
3131 };
3132 copy_block(op_load_F1_FPR9_code, 6);
3133 inc_code_ptr(6);
3134 }
3135 #endif
3136
3137 DEFINE_GEN(gen_op_store_F1_FPR9,void,(void))
3138 #ifdef DYNGEN_IMPL
3139 #define HAVE_gen_op_store_F1_FPR9
3140 {
3141 static const uint8 op_store_F1_FPR9_code[] = {
3142 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xd8, 0x00, 0x00, 0x00, 0x89,
3143 0x95, 0xdc, 0x00, 0x00, 0x00
3144 };
3145 copy_block(op_store_F1_FPR9_code, 17);
3146 inc_code_ptr(17);
3147 }
3148 #endif
3149
3150 DEFINE_GEN(gen_op_load_F2_FPR9,void,(void))
3151 #ifdef DYNGEN_IMPL
3152 #define HAVE_gen_op_load_F2_FPR9
3153 {
3154 static const uint8 op_load_F2_FPR9_code[] = {
3155 0x8d, 0xbd, 0xd8, 0x00, 0x00, 0x00
3156 };
3157 copy_block(op_load_F2_FPR9_code, 6);
3158 inc_code_ptr(6);
3159 }
3160 #endif
3161
3162 DEFINE_GEN(gen_op_store_F2_FPR9,void,(void))
3163 #ifdef DYNGEN_IMPL
3164 #define HAVE_gen_op_store_F2_FPR9
3165 {
3166 static const uint8 op_store_F2_FPR9_code[] = {
3167 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xd8, 0x00, 0x00, 0x00, 0x89,
3168 0x95, 0xdc, 0x00, 0x00, 0x00
3169 };
3170 copy_block(op_store_F2_FPR9_code, 17);
3171 inc_code_ptr(17);
3172 }
3173 #endif
3174
3175 DEFINE_GEN(gen_op_store_FD_FPR9,void,(void))
3176 #ifdef DYNGEN_IMPL
3177 #define HAVE_gen_op_store_FD_FPR9
3178 {
3179 static const uint8 op_store_FD_FPR9_code[] = {
3180 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3181 0x89, 0x85, 0xd8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xdc, 0x00, 0x00, 0x00
3182 };
3183 copy_block(op_store_FD_FPR9_code, 24);
3184 inc_code_ptr(24);
3185 }
3186 #endif
3187
3188 DEFINE_GEN(gen_op_load_F0_FPR10,void,(void))
3189 #ifdef DYNGEN_IMPL
3190 #define HAVE_gen_op_load_F0_FPR10
3191 {
3192 static const uint8 op_load_F0_FPR10_code[] = {
3193 0x8d, 0x9d, 0xe0, 0x00, 0x00, 0x00
3194 };
3195 copy_block(op_load_F0_FPR10_code, 6);
3196 inc_code_ptr(6);
3197 }
3198 #endif
3199
3200 DEFINE_GEN(gen_op_store_F0_FPR10,void,(void))
3201 #ifdef DYNGEN_IMPL
3202 #define HAVE_gen_op_store_F0_FPR10
3203 {
3204 static const uint8 op_store_F0_FPR10_code[] = {
3205 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xe0, 0x00, 0x00, 0x00, 0x89,
3206 0x95, 0xe4, 0x00, 0x00, 0x00
3207 };
3208 copy_block(op_store_F0_FPR10_code, 17);
3209 inc_code_ptr(17);
3210 }
3211 #endif
3212
3213 DEFINE_GEN(gen_op_load_F1_FPR10,void,(void))
3214 #ifdef DYNGEN_IMPL
3215 #define HAVE_gen_op_load_F1_FPR10
3216 {
3217 static const uint8 op_load_F1_FPR10_code[] = {
3218 0x8d, 0xb5, 0xe0, 0x00, 0x00, 0x00
3219 };
3220 copy_block(op_load_F1_FPR10_code, 6);
3221 inc_code_ptr(6);
3222 }
3223 #endif
3224
3225 DEFINE_GEN(gen_op_store_F1_FPR10,void,(void))
3226 #ifdef DYNGEN_IMPL
3227 #define HAVE_gen_op_store_F1_FPR10
3228 {
3229 static const uint8 op_store_F1_FPR10_code[] = {
3230 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xe0, 0x00, 0x00, 0x00, 0x89,
3231 0x95, 0xe4, 0x00, 0x00, 0x00
3232 };
3233 copy_block(op_store_F1_FPR10_code, 17);
3234 inc_code_ptr(17);
3235 }
3236 #endif
3237
3238 DEFINE_GEN(gen_op_load_F2_FPR10,void,(void))
3239 #ifdef DYNGEN_IMPL
3240 #define HAVE_gen_op_load_F2_FPR10
3241 {
3242 static const uint8 op_load_F2_FPR10_code[] = {
3243 0x8d, 0xbd, 0xe0, 0x00, 0x00, 0x00
3244 };
3245 copy_block(op_load_F2_FPR10_code, 6);
3246 inc_code_ptr(6);
3247 }
3248 #endif
3249
3250 DEFINE_GEN(gen_op_store_F2_FPR10,void,(void))
3251 #ifdef DYNGEN_IMPL
3252 #define HAVE_gen_op_store_F2_FPR10
3253 {
3254 static const uint8 op_store_F2_FPR10_code[] = {
3255 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xe0, 0x00, 0x00, 0x00, 0x89,
3256 0x95, 0xe4, 0x00, 0x00, 0x00
3257 };
3258 copy_block(op_store_F2_FPR10_code, 17);
3259 inc_code_ptr(17);
3260 }
3261 #endif
3262
3263 DEFINE_GEN(gen_op_store_FD_FPR10,void,(void))
3264 #ifdef DYNGEN_IMPL
3265 #define HAVE_gen_op_store_FD_FPR10
3266 {
3267 static const uint8 op_store_FD_FPR10_code[] = {
3268 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3269 0x89, 0x85, 0xe0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xe4, 0x00, 0x00, 0x00
3270 };
3271 copy_block(op_store_FD_FPR10_code, 24);
3272 inc_code_ptr(24);
3273 }
3274 #endif
3275
3276 DEFINE_GEN(gen_op_load_F0_FPR11,void,(void))
3277 #ifdef DYNGEN_IMPL
3278 #define HAVE_gen_op_load_F0_FPR11
3279 {
3280 static const uint8 op_load_F0_FPR11_code[] = {
3281 0x8d, 0x9d, 0xe8, 0x00, 0x00, 0x00
3282 };
3283 copy_block(op_load_F0_FPR11_code, 6);
3284 inc_code_ptr(6);
3285 }
3286 #endif
3287
3288 DEFINE_GEN(gen_op_store_F0_FPR11,void,(void))
3289 #ifdef DYNGEN_IMPL
3290 #define HAVE_gen_op_store_F0_FPR11
3291 {
3292 static const uint8 op_store_F0_FPR11_code[] = {
3293 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xe8, 0x00, 0x00, 0x00, 0x89,
3294 0x95, 0xec, 0x00, 0x00, 0x00
3295 };
3296 copy_block(op_store_F0_FPR11_code, 17);
3297 inc_code_ptr(17);
3298 }
3299 #endif
3300
3301 DEFINE_GEN(gen_op_load_F1_FPR11,void,(void))
3302 #ifdef DYNGEN_IMPL
3303 #define HAVE_gen_op_load_F1_FPR11
3304 {
3305 static const uint8 op_load_F1_FPR11_code[] = {
3306 0x8d, 0xb5, 0xe8, 0x00, 0x00, 0x00
3307 };
3308 copy_block(op_load_F1_FPR11_code, 6);
3309 inc_code_ptr(6);
3310 }
3311 #endif
3312
3313 DEFINE_GEN(gen_op_store_F1_FPR11,void,(void))
3314 #ifdef DYNGEN_IMPL
3315 #define HAVE_gen_op_store_F1_FPR11
3316 {
3317 static const uint8 op_store_F1_FPR11_code[] = {
3318 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xe8, 0x00, 0x00, 0x00, 0x89,
3319 0x95, 0xec, 0x00, 0x00, 0x00
3320 };
3321 copy_block(op_store_F1_FPR11_code, 17);
3322 inc_code_ptr(17);
3323 }
3324 #endif
3325
3326 DEFINE_GEN(gen_op_load_F2_FPR11,void,(void))
3327 #ifdef DYNGEN_IMPL
3328 #define HAVE_gen_op_load_F2_FPR11
3329 {
3330 static const uint8 op_load_F2_FPR11_code[] = {
3331 0x8d, 0xbd, 0xe8, 0x00, 0x00, 0x00
3332 };
3333 copy_block(op_load_F2_FPR11_code, 6);
3334 inc_code_ptr(6);
3335 }
3336 #endif
3337
3338 DEFINE_GEN(gen_op_store_F2_FPR11,void,(void))
3339 #ifdef DYNGEN_IMPL
3340 #define HAVE_gen_op_store_F2_FPR11
3341 {
3342 static const uint8 op_store_F2_FPR11_code[] = {
3343 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xe8, 0x00, 0x00, 0x00, 0x89,
3344 0x95, 0xec, 0x00, 0x00, 0x00
3345 };
3346 copy_block(op_store_F2_FPR11_code, 17);
3347 inc_code_ptr(17);
3348 }
3349 #endif
3350
3351 DEFINE_GEN(gen_op_store_FD_FPR11,void,(void))
3352 #ifdef DYNGEN_IMPL
3353 #define HAVE_gen_op_store_FD_FPR11
3354 {
3355 static const uint8 op_store_FD_FPR11_code[] = {
3356 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3357 0x89, 0x85, 0xe8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xec, 0x00, 0x00, 0x00
3358 };
3359 copy_block(op_store_FD_FPR11_code, 24);
3360 inc_code_ptr(24);
3361 }
3362 #endif
3363
3364 DEFINE_GEN(gen_op_load_F0_FPR12,void,(void))
3365 #ifdef DYNGEN_IMPL
3366 #define HAVE_gen_op_load_F0_FPR12
3367 {
3368 static const uint8 op_load_F0_FPR12_code[] = {
3369 0x8d, 0x9d, 0xf0, 0x00, 0x00, 0x00
3370 };
3371 copy_block(op_load_F0_FPR12_code, 6);
3372 inc_code_ptr(6);
3373 }
3374 #endif
3375
3376 DEFINE_GEN(gen_op_store_F0_FPR12,void,(void))
3377 #ifdef DYNGEN_IMPL
3378 #define HAVE_gen_op_store_F0_FPR12
3379 {
3380 static const uint8 op_store_F0_FPR12_code[] = {
3381 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xf0, 0x00, 0x00, 0x00, 0x89,
3382 0x95, 0xf4, 0x00, 0x00, 0x00
3383 };
3384 copy_block(op_store_F0_FPR12_code, 17);
3385 inc_code_ptr(17);
3386 }
3387 #endif
3388
3389 DEFINE_GEN(gen_op_load_F1_FPR12,void,(void))
3390 #ifdef DYNGEN_IMPL
3391 #define HAVE_gen_op_load_F1_FPR12
3392 {
3393 static const uint8 op_load_F1_FPR12_code[] = {
3394 0x8d, 0xb5, 0xf0, 0x00, 0x00, 0x00
3395 };
3396 copy_block(op_load_F1_FPR12_code, 6);
3397 inc_code_ptr(6);
3398 }
3399 #endif
3400
3401 DEFINE_GEN(gen_op_store_F1_FPR12,void,(void))
3402 #ifdef DYNGEN_IMPL
3403 #define HAVE_gen_op_store_F1_FPR12
3404 {
3405 static const uint8 op_store_F1_FPR12_code[] = {
3406 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xf0, 0x00, 0x00, 0x00, 0x89,
3407 0x95, 0xf4, 0x00, 0x00, 0x00
3408 };
3409 copy_block(op_store_F1_FPR12_code, 17);
3410 inc_code_ptr(17);
3411 }
3412 #endif
3413
3414 DEFINE_GEN(gen_op_load_F2_FPR12,void,(void))
3415 #ifdef DYNGEN_IMPL
3416 #define HAVE_gen_op_load_F2_FPR12
3417 {
3418 static const uint8 op_load_F2_FPR12_code[] = {
3419 0x8d, 0xbd, 0xf0, 0x00, 0x00, 0x00
3420 };
3421 copy_block(op_load_F2_FPR12_code, 6);
3422 inc_code_ptr(6);
3423 }
3424 #endif
3425
3426 DEFINE_GEN(gen_op_store_F2_FPR12,void,(void))
3427 #ifdef DYNGEN_IMPL
3428 #define HAVE_gen_op_store_F2_FPR12
3429 {
3430 static const uint8 op_store_F2_FPR12_code[] = {
3431 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xf0, 0x00, 0x00, 0x00, 0x89,
3432 0x95, 0xf4, 0x00, 0x00, 0x00
3433 };
3434 copy_block(op_store_F2_FPR12_code, 17);
3435 inc_code_ptr(17);
3436 }
3437 #endif
3438
3439 DEFINE_GEN(gen_op_store_FD_FPR12,void,(void))
3440 #ifdef DYNGEN_IMPL
3441 #define HAVE_gen_op_store_FD_FPR12
3442 {
3443 static const uint8 op_store_FD_FPR12_code[] = {
3444 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3445 0x89, 0x85, 0xf0, 0x00, 0x00, 0x00, 0x89, 0x95, 0xf4, 0x00, 0x00, 0x00
3446 };
3447 copy_block(op_store_FD_FPR12_code, 24);
3448 inc_code_ptr(24);
3449 }
3450 #endif
3451
3452 DEFINE_GEN(gen_op_load_F0_FPR13,void,(void))
3453 #ifdef DYNGEN_IMPL
3454 #define HAVE_gen_op_load_F0_FPR13
3455 {
3456 static const uint8 op_load_F0_FPR13_code[] = {
3457 0x8d, 0x9d, 0xf8, 0x00, 0x00, 0x00
3458 };
3459 copy_block(op_load_F0_FPR13_code, 6);
3460 inc_code_ptr(6);
3461 }
3462 #endif
3463
3464 DEFINE_GEN(gen_op_store_F0_FPR13,void,(void))
3465 #ifdef DYNGEN_IMPL
3466 #define HAVE_gen_op_store_F0_FPR13
3467 {
3468 static const uint8 op_store_F0_FPR13_code[] = {
3469 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0xf8, 0x00, 0x00, 0x00, 0x89,
3470 0x95, 0xfc, 0x00, 0x00, 0x00
3471 };
3472 copy_block(op_store_F0_FPR13_code, 17);
3473 inc_code_ptr(17);
3474 }
3475 #endif
3476
3477 DEFINE_GEN(gen_op_load_F1_FPR13,void,(void))
3478 #ifdef DYNGEN_IMPL
3479 #define HAVE_gen_op_load_F1_FPR13
3480 {
3481 static const uint8 op_load_F1_FPR13_code[] = {
3482 0x8d, 0xb5, 0xf8, 0x00, 0x00, 0x00
3483 };
3484 copy_block(op_load_F1_FPR13_code, 6);
3485 inc_code_ptr(6);
3486 }
3487 #endif
3488
3489 DEFINE_GEN(gen_op_store_F1_FPR13,void,(void))
3490 #ifdef DYNGEN_IMPL
3491 #define HAVE_gen_op_store_F1_FPR13
3492 {
3493 static const uint8 op_store_F1_FPR13_code[] = {
3494 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0xf8, 0x00, 0x00, 0x00, 0x89,
3495 0x95, 0xfc, 0x00, 0x00, 0x00
3496 };
3497 copy_block(op_store_F1_FPR13_code, 17);
3498 inc_code_ptr(17);
3499 }
3500 #endif
3501
3502 DEFINE_GEN(gen_op_load_F2_FPR13,void,(void))
3503 #ifdef DYNGEN_IMPL
3504 #define HAVE_gen_op_load_F2_FPR13
3505 {
3506 static const uint8 op_load_F2_FPR13_code[] = {
3507 0x8d, 0xbd, 0xf8, 0x00, 0x00, 0x00
3508 };
3509 copy_block(op_load_F2_FPR13_code, 6);
3510 inc_code_ptr(6);
3511 }
3512 #endif
3513
3514 DEFINE_GEN(gen_op_store_F2_FPR13,void,(void))
3515 #ifdef DYNGEN_IMPL
3516 #define HAVE_gen_op_store_F2_FPR13
3517 {
3518 static const uint8 op_store_F2_FPR13_code[] = {
3519 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0xf8, 0x00, 0x00, 0x00, 0x89,
3520 0x95, 0xfc, 0x00, 0x00, 0x00
3521 };
3522 copy_block(op_store_F2_FPR13_code, 17);
3523 inc_code_ptr(17);
3524 }
3525 #endif
3526
3527 DEFINE_GEN(gen_op_store_FD_FPR13,void,(void))
3528 #ifdef DYNGEN_IMPL
3529 #define HAVE_gen_op_store_FD_FPR13
3530 {
3531 static const uint8 op_store_FD_FPR13_code[] = {
3532 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3533 0x89, 0x85, 0xf8, 0x00, 0x00, 0x00, 0x89, 0x95, 0xfc, 0x00, 0x00, 0x00
3534 };
3535 copy_block(op_store_FD_FPR13_code, 24);
3536 inc_code_ptr(24);
3537 }
3538 #endif
3539
3540 DEFINE_GEN(gen_op_load_F0_FPR14,void,(void))
3541 #ifdef DYNGEN_IMPL
3542 #define HAVE_gen_op_load_F0_FPR14
3543 {
3544 static const uint8 op_load_F0_FPR14_code[] = {
3545 0x8d, 0x9d, 0x00, 0x01, 0x00, 0x00
3546 };
3547 copy_block(op_load_F0_FPR14_code, 6);
3548 inc_code_ptr(6);
3549 }
3550 #endif
3551
3552 DEFINE_GEN(gen_op_store_F0_FPR14,void,(void))
3553 #ifdef DYNGEN_IMPL
3554 #define HAVE_gen_op_store_F0_FPR14
3555 {
3556 static const uint8 op_store_F0_FPR14_code[] = {
3557 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x00, 0x01, 0x00, 0x00, 0x89,
3558 0x95, 0x04, 0x01, 0x00, 0x00
3559 };
3560 copy_block(op_store_F0_FPR14_code, 17);
3561 inc_code_ptr(17);
3562 }
3563 #endif
3564
3565 DEFINE_GEN(gen_op_load_F1_FPR14,void,(void))
3566 #ifdef DYNGEN_IMPL
3567 #define HAVE_gen_op_load_F1_FPR14
3568 {
3569 static const uint8 op_load_F1_FPR14_code[] = {
3570 0x8d, 0xb5, 0x00, 0x01, 0x00, 0x00
3571 };
3572 copy_block(op_load_F1_FPR14_code, 6);
3573 inc_code_ptr(6);
3574 }
3575 #endif
3576
3577 DEFINE_GEN(gen_op_store_F1_FPR14,void,(void))
3578 #ifdef DYNGEN_IMPL
3579 #define HAVE_gen_op_store_F1_FPR14
3580 {
3581 static const uint8 op_store_F1_FPR14_code[] = {
3582 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x00, 0x01, 0x00, 0x00, 0x89,
3583 0x95, 0x04, 0x01, 0x00, 0x00
3584 };
3585 copy_block(op_store_F1_FPR14_code, 17);
3586 inc_code_ptr(17);
3587 }
3588 #endif
3589
3590 DEFINE_GEN(gen_op_load_F2_FPR14,void,(void))
3591 #ifdef DYNGEN_IMPL
3592 #define HAVE_gen_op_load_F2_FPR14
3593 {
3594 static const uint8 op_load_F2_FPR14_code[] = {
3595 0x8d, 0xbd, 0x00, 0x01, 0x00, 0x00
3596 };
3597 copy_block(op_load_F2_FPR14_code, 6);
3598 inc_code_ptr(6);
3599 }
3600 #endif
3601
3602 DEFINE_GEN(gen_op_store_F2_FPR14,void,(void))
3603 #ifdef DYNGEN_IMPL
3604 #define HAVE_gen_op_store_F2_FPR14
3605 {
3606 static const uint8 op_store_F2_FPR14_code[] = {
3607 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x00, 0x01, 0x00, 0x00, 0x89,
3608 0x95, 0x04, 0x01, 0x00, 0x00
3609 };
3610 copy_block(op_store_F2_FPR14_code, 17);
3611 inc_code_ptr(17);
3612 }
3613 #endif
3614
3615 DEFINE_GEN(gen_op_store_FD_FPR14,void,(void))
3616 #ifdef DYNGEN_IMPL
3617 #define HAVE_gen_op_store_FD_FPR14
3618 {
3619 static const uint8 op_store_FD_FPR14_code[] = {
3620 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3621 0x89, 0x85, 0x00, 0x01, 0x00, 0x00, 0x89, 0x95, 0x04, 0x01, 0x00, 0x00
3622 };
3623 copy_block(op_store_FD_FPR14_code, 24);
3624 inc_code_ptr(24);
3625 }
3626 #endif
3627
3628 DEFINE_GEN(gen_op_load_F0_FPR15,void,(void))
3629 #ifdef DYNGEN_IMPL
3630 #define HAVE_gen_op_load_F0_FPR15
3631 {
3632 static const uint8 op_load_F0_FPR15_code[] = {
3633 0x8d, 0x9d, 0x08, 0x01, 0x00, 0x00
3634 };
3635 copy_block(op_load_F0_FPR15_code, 6);
3636 inc_code_ptr(6);
3637 }
3638 #endif
3639
3640 DEFINE_GEN(gen_op_store_F0_FPR15,void,(void))
3641 #ifdef DYNGEN_IMPL
3642 #define HAVE_gen_op_store_F0_FPR15
3643 {
3644 static const uint8 op_store_F0_FPR15_code[] = {
3645 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x08, 0x01, 0x00, 0x00, 0x89,
3646 0x95, 0x0c, 0x01, 0x00, 0x00
3647 };
3648 copy_block(op_store_F0_FPR15_code, 17);
3649 inc_code_ptr(17);
3650 }
3651 #endif
3652
3653 DEFINE_GEN(gen_op_load_F1_FPR15,void,(void))
3654 #ifdef DYNGEN_IMPL
3655 #define HAVE_gen_op_load_F1_FPR15
3656 {
3657 static const uint8 op_load_F1_FPR15_code[] = {
3658 0x8d, 0xb5, 0x08, 0x01, 0x00, 0x00
3659 };
3660 copy_block(op_load_F1_FPR15_code, 6);
3661 inc_code_ptr(6);
3662 }
3663 #endif
3664
3665 DEFINE_GEN(gen_op_store_F1_FPR15,void,(void))
3666 #ifdef DYNGEN_IMPL
3667 #define HAVE_gen_op_store_F1_FPR15
3668 {
3669 static const uint8 op_store_F1_FPR15_code[] = {
3670 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x08, 0x01, 0x00, 0x00, 0x89,
3671 0x95, 0x0c, 0x01, 0x00, 0x00
3672 };
3673 copy_block(op_store_F1_FPR15_code, 17);
3674 inc_code_ptr(17);
3675 }
3676 #endif
3677
3678 DEFINE_GEN(gen_op_load_F2_FPR15,void,(void))
3679 #ifdef DYNGEN_IMPL
3680 #define HAVE_gen_op_load_F2_FPR15
3681 {
3682 static const uint8 op_load_F2_FPR15_code[] = {
3683 0x8d, 0xbd, 0x08, 0x01, 0x00, 0x00
3684 };
3685 copy_block(op_load_F2_FPR15_code, 6);
3686 inc_code_ptr(6);
3687 }
3688 #endif
3689
3690 DEFINE_GEN(gen_op_store_F2_FPR15,void,(void))
3691 #ifdef DYNGEN_IMPL
3692 #define HAVE_gen_op_store_F2_FPR15
3693 {
3694 static const uint8 op_store_F2_FPR15_code[] = {
3695 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x08, 0x01, 0x00, 0x00, 0x89,
3696 0x95, 0x0c, 0x01, 0x00, 0x00
3697 };
3698 copy_block(op_store_F2_FPR15_code, 17);
3699 inc_code_ptr(17);
3700 }
3701 #endif
3702
3703 DEFINE_GEN(gen_op_store_FD_FPR15,void,(void))
3704 #ifdef DYNGEN_IMPL
3705 #define HAVE_gen_op_store_FD_FPR15
3706 {
3707 static const uint8 op_store_FD_FPR15_code[] = {
3708 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3709 0x89, 0x85, 0x08, 0x01, 0x00, 0x00, 0x89, 0x95, 0x0c, 0x01, 0x00, 0x00
3710 };
3711 copy_block(op_store_FD_FPR15_code, 24);
3712 inc_code_ptr(24);
3713 }
3714 #endif
3715
3716 DEFINE_GEN(gen_op_load_F0_FPR16,void,(void))
3717 #ifdef DYNGEN_IMPL
3718 #define HAVE_gen_op_load_F0_FPR16
3719 {
3720 static const uint8 op_load_F0_FPR16_code[] = {
3721 0x8d, 0x9d, 0x10, 0x01, 0x00, 0x00
3722 };
3723 copy_block(op_load_F0_FPR16_code, 6);
3724 inc_code_ptr(6);
3725 }
3726 #endif
3727
3728 DEFINE_GEN(gen_op_store_F0_FPR16,void,(void))
3729 #ifdef DYNGEN_IMPL
3730 #define HAVE_gen_op_store_F0_FPR16
3731 {
3732 static const uint8 op_store_F0_FPR16_code[] = {
3733 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x10, 0x01, 0x00, 0x00, 0x89,
3734 0x95, 0x14, 0x01, 0x00, 0x00
3735 };
3736 copy_block(op_store_F0_FPR16_code, 17);
3737 inc_code_ptr(17);
3738 }
3739 #endif
3740
3741 DEFINE_GEN(gen_op_load_F1_FPR16,void,(void))
3742 #ifdef DYNGEN_IMPL
3743 #define HAVE_gen_op_load_F1_FPR16
3744 {
3745 static const uint8 op_load_F1_FPR16_code[] = {
3746 0x8d, 0xb5, 0x10, 0x01, 0x00, 0x00
3747 };
3748 copy_block(op_load_F1_FPR16_code, 6);
3749 inc_code_ptr(6);
3750 }
3751 #endif
3752
3753 DEFINE_GEN(gen_op_store_F1_FPR16,void,(void))
3754 #ifdef DYNGEN_IMPL
3755 #define HAVE_gen_op_store_F1_FPR16
3756 {
3757 static const uint8 op_store_F1_FPR16_code[] = {
3758 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x10, 0x01, 0x00, 0x00, 0x89,
3759 0x95, 0x14, 0x01, 0x00, 0x00
3760 };
3761 copy_block(op_store_F1_FPR16_code, 17);
3762 inc_code_ptr(17);
3763 }
3764 #endif
3765
3766 DEFINE_GEN(gen_op_load_F2_FPR16,void,(void))
3767 #ifdef DYNGEN_IMPL
3768 #define HAVE_gen_op_load_F2_FPR16
3769 {
3770 static const uint8 op_load_F2_FPR16_code[] = {
3771 0x8d, 0xbd, 0x10, 0x01, 0x00, 0x00
3772 };
3773 copy_block(op_load_F2_FPR16_code, 6);
3774 inc_code_ptr(6);
3775 }
3776 #endif
3777
3778 DEFINE_GEN(gen_op_store_F2_FPR16,void,(void))
3779 #ifdef DYNGEN_IMPL
3780 #define HAVE_gen_op_store_F2_FPR16
3781 {
3782 static const uint8 op_store_F2_FPR16_code[] = {
3783 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x10, 0x01, 0x00, 0x00, 0x89,
3784 0x95, 0x14, 0x01, 0x00, 0x00
3785 };
3786 copy_block(op_store_F2_FPR16_code, 17);
3787 inc_code_ptr(17);
3788 }
3789 #endif
3790
3791 DEFINE_GEN(gen_op_store_FD_FPR16,void,(void))
3792 #ifdef DYNGEN_IMPL
3793 #define HAVE_gen_op_store_FD_FPR16
3794 {
3795 static const uint8 op_store_FD_FPR16_code[] = {
3796 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3797 0x89, 0x85, 0x10, 0x01, 0x00, 0x00, 0x89, 0x95, 0x14, 0x01, 0x00, 0x00
3798 };
3799 copy_block(op_store_FD_FPR16_code, 24);
3800 inc_code_ptr(24);
3801 }
3802 #endif
3803
3804 DEFINE_GEN(gen_op_load_F0_FPR17,void,(void))
3805 #ifdef DYNGEN_IMPL
3806 #define HAVE_gen_op_load_F0_FPR17
3807 {
3808 static const uint8 op_load_F0_FPR17_code[] = {
3809 0x8d, 0x9d, 0x18, 0x01, 0x00, 0x00
3810 };
3811 copy_block(op_load_F0_FPR17_code, 6);
3812 inc_code_ptr(6);
3813 }
3814 #endif
3815
3816 DEFINE_GEN(gen_op_store_F0_FPR17,void,(void))
3817 #ifdef DYNGEN_IMPL
3818 #define HAVE_gen_op_store_F0_FPR17
3819 {
3820 static const uint8 op_store_F0_FPR17_code[] = {
3821 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x18, 0x01, 0x00, 0x00, 0x89,
3822 0x95, 0x1c, 0x01, 0x00, 0x00
3823 };
3824 copy_block(op_store_F0_FPR17_code, 17);
3825 inc_code_ptr(17);
3826 }
3827 #endif
3828
3829 DEFINE_GEN(gen_op_load_F1_FPR17,void,(void))
3830 #ifdef DYNGEN_IMPL
3831 #define HAVE_gen_op_load_F1_FPR17
3832 {
3833 static const uint8 op_load_F1_FPR17_code[] = {
3834 0x8d, 0xb5, 0x18, 0x01, 0x00, 0x00
3835 };
3836 copy_block(op_load_F1_FPR17_code, 6);
3837 inc_code_ptr(6);
3838 }
3839 #endif
3840
3841 DEFINE_GEN(gen_op_store_F1_FPR17,void,(void))
3842 #ifdef DYNGEN_IMPL
3843 #define HAVE_gen_op_store_F1_FPR17
3844 {
3845 static const uint8 op_store_F1_FPR17_code[] = {
3846 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x18, 0x01, 0x00, 0x00, 0x89,
3847 0x95, 0x1c, 0x01, 0x00, 0x00
3848 };
3849 copy_block(op_store_F1_FPR17_code, 17);
3850 inc_code_ptr(17);
3851 }
3852 #endif
3853
3854 DEFINE_GEN(gen_op_load_F2_FPR17,void,(void))
3855 #ifdef DYNGEN_IMPL
3856 #define HAVE_gen_op_load_F2_FPR17
3857 {
3858 static const uint8 op_load_F2_FPR17_code[] = {
3859 0x8d, 0xbd, 0x18, 0x01, 0x00, 0x00
3860 };
3861 copy_block(op_load_F2_FPR17_code, 6);
3862 inc_code_ptr(6);
3863 }
3864 #endif
3865
3866 DEFINE_GEN(gen_op_store_F2_FPR17,void,(void))
3867 #ifdef DYNGEN_IMPL
3868 #define HAVE_gen_op_store_F2_FPR17
3869 {
3870 static const uint8 op_store_F2_FPR17_code[] = {
3871 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x18, 0x01, 0x00, 0x00, 0x89,
3872 0x95, 0x1c, 0x01, 0x00, 0x00
3873 };
3874 copy_block(op_store_F2_FPR17_code, 17);
3875 inc_code_ptr(17);
3876 }
3877 #endif
3878
3879 DEFINE_GEN(gen_op_store_FD_FPR17,void,(void))
3880 #ifdef DYNGEN_IMPL
3881 #define HAVE_gen_op_store_FD_FPR17
3882 {
3883 static const uint8 op_store_FD_FPR17_code[] = {
3884 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3885 0x89, 0x85, 0x18, 0x01, 0x00, 0x00, 0x89, 0x95, 0x1c, 0x01, 0x00, 0x00
3886 };
3887 copy_block(op_store_FD_FPR17_code, 24);
3888 inc_code_ptr(24);
3889 }
3890 #endif
3891
3892 DEFINE_GEN(gen_op_load_F0_FPR18,void,(void))
3893 #ifdef DYNGEN_IMPL
3894 #define HAVE_gen_op_load_F0_FPR18
3895 {
3896 static const uint8 op_load_F0_FPR18_code[] = {
3897 0x8d, 0x9d, 0x20, 0x01, 0x00, 0x00
3898 };
3899 copy_block(op_load_F0_FPR18_code, 6);
3900 inc_code_ptr(6);
3901 }
3902 #endif
3903
3904 DEFINE_GEN(gen_op_store_F0_FPR18,void,(void))
3905 #ifdef DYNGEN_IMPL
3906 #define HAVE_gen_op_store_F0_FPR18
3907 {
3908 static const uint8 op_store_F0_FPR18_code[] = {
3909 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x20, 0x01, 0x00, 0x00, 0x89,
3910 0x95, 0x24, 0x01, 0x00, 0x00
3911 };
3912 copy_block(op_store_F0_FPR18_code, 17);
3913 inc_code_ptr(17);
3914 }
3915 #endif
3916
3917 DEFINE_GEN(gen_op_load_F1_FPR18,void,(void))
3918 #ifdef DYNGEN_IMPL
3919 #define HAVE_gen_op_load_F1_FPR18
3920 {
3921 static const uint8 op_load_F1_FPR18_code[] = {
3922 0x8d, 0xb5, 0x20, 0x01, 0x00, 0x00
3923 };
3924 copy_block(op_load_F1_FPR18_code, 6);
3925 inc_code_ptr(6);
3926 }
3927 #endif
3928
3929 DEFINE_GEN(gen_op_store_F1_FPR18,void,(void))
3930 #ifdef DYNGEN_IMPL
3931 #define HAVE_gen_op_store_F1_FPR18
3932 {
3933 static const uint8 op_store_F1_FPR18_code[] = {
3934 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x20, 0x01, 0x00, 0x00, 0x89,
3935 0x95, 0x24, 0x01, 0x00, 0x00
3936 };
3937 copy_block(op_store_F1_FPR18_code, 17);
3938 inc_code_ptr(17);
3939 }
3940 #endif
3941
3942 DEFINE_GEN(gen_op_load_F2_FPR18,void,(void))
3943 #ifdef DYNGEN_IMPL
3944 #define HAVE_gen_op_load_F2_FPR18
3945 {
3946 static const uint8 op_load_F2_FPR18_code[] = {
3947 0x8d, 0xbd, 0x20, 0x01, 0x00, 0x00
3948 };
3949 copy_block(op_load_F2_FPR18_code, 6);
3950 inc_code_ptr(6);
3951 }
3952 #endif
3953
3954 DEFINE_GEN(gen_op_store_F2_FPR18,void,(void))
3955 #ifdef DYNGEN_IMPL
3956 #define HAVE_gen_op_store_F2_FPR18
3957 {
3958 static const uint8 op_store_F2_FPR18_code[] = {
3959 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x20, 0x01, 0x00, 0x00, 0x89,
3960 0x95, 0x24, 0x01, 0x00, 0x00
3961 };
3962 copy_block(op_store_F2_FPR18_code, 17);
3963 inc_code_ptr(17);
3964 }
3965 #endif
3966
3967 DEFINE_GEN(gen_op_store_FD_FPR18,void,(void))
3968 #ifdef DYNGEN_IMPL
3969 #define HAVE_gen_op_store_FD_FPR18
3970 {
3971 static const uint8 op_store_FD_FPR18_code[] = {
3972 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
3973 0x89, 0x85, 0x20, 0x01, 0x00, 0x00, 0x89, 0x95, 0x24, 0x01, 0x00, 0x00
3974 };
3975 copy_block(op_store_FD_FPR18_code, 24);
3976 inc_code_ptr(24);
3977 }
3978 #endif
3979
3980 DEFINE_GEN(gen_op_load_F0_FPR19,void,(void))
3981 #ifdef DYNGEN_IMPL
3982 #define HAVE_gen_op_load_F0_FPR19
3983 {
3984 static const uint8 op_load_F0_FPR19_code[] = {
3985 0x8d, 0x9d, 0x28, 0x01, 0x00, 0x00
3986 };
3987 copy_block(op_load_F0_FPR19_code, 6);
3988 inc_code_ptr(6);
3989 }
3990 #endif
3991
3992 DEFINE_GEN(gen_op_store_F0_FPR19,void,(void))
3993 #ifdef DYNGEN_IMPL
3994 #define HAVE_gen_op_store_F0_FPR19
3995 {
3996 static const uint8 op_store_F0_FPR19_code[] = {
3997 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x28, 0x01, 0x00, 0x00, 0x89,
3998 0x95, 0x2c, 0x01, 0x00, 0x00
3999 };
4000 copy_block(op_store_F0_FPR19_code, 17);
4001 inc_code_ptr(17);
4002 }
4003 #endif
4004
4005 DEFINE_GEN(gen_op_load_F1_FPR19,void,(void))
4006 #ifdef DYNGEN_IMPL
4007 #define HAVE_gen_op_load_F1_FPR19
4008 {
4009 static const uint8 op_load_F1_FPR19_code[] = {
4010 0x8d, 0xb5, 0x28, 0x01, 0x00, 0x00
4011 };
4012 copy_block(op_load_F1_FPR19_code, 6);
4013 inc_code_ptr(6);
4014 }
4015 #endif
4016
4017 DEFINE_GEN(gen_op_store_F1_FPR19,void,(void))
4018 #ifdef DYNGEN_IMPL
4019 #define HAVE_gen_op_store_F1_FPR19
4020 {
4021 static const uint8 op_store_F1_FPR19_code[] = {
4022 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x28, 0x01, 0x00, 0x00, 0x89,
4023 0x95, 0x2c, 0x01, 0x00, 0x00
4024 };
4025 copy_block(op_store_F1_FPR19_code, 17);
4026 inc_code_ptr(17);
4027 }
4028 #endif
4029
4030 DEFINE_GEN(gen_op_load_F2_FPR19,void,(void))
4031 #ifdef DYNGEN_IMPL
4032 #define HAVE_gen_op_load_F2_FPR19
4033 {
4034 static const uint8 op_load_F2_FPR19_code[] = {
4035 0x8d, 0xbd, 0x28, 0x01, 0x00, 0x00
4036 };
4037 copy_block(op_load_F2_FPR19_code, 6);
4038 inc_code_ptr(6);
4039 }
4040 #endif
4041
4042 DEFINE_GEN(gen_op_store_F2_FPR19,void,(void))
4043 #ifdef DYNGEN_IMPL
4044 #define HAVE_gen_op_store_F2_FPR19
4045 {
4046 static const uint8 op_store_F2_FPR19_code[] = {
4047 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x28, 0x01, 0x00, 0x00, 0x89,
4048 0x95, 0x2c, 0x01, 0x00, 0x00
4049 };
4050 copy_block(op_store_F2_FPR19_code, 17);
4051 inc_code_ptr(17);
4052 }
4053 #endif
4054
4055 DEFINE_GEN(gen_op_store_FD_FPR19,void,(void))
4056 #ifdef DYNGEN_IMPL
4057 #define HAVE_gen_op_store_FD_FPR19
4058 {
4059 static const uint8 op_store_FD_FPR19_code[] = {
4060 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4061 0x89, 0x85, 0x28, 0x01, 0x00, 0x00, 0x89, 0x95, 0x2c, 0x01, 0x00, 0x00
4062 };
4063 copy_block(op_store_FD_FPR19_code, 24);
4064 inc_code_ptr(24);
4065 }
4066 #endif
4067
4068 DEFINE_GEN(gen_op_load_F0_FPR20,void,(void))
4069 #ifdef DYNGEN_IMPL
4070 #define HAVE_gen_op_load_F0_FPR20
4071 {
4072 static const uint8 op_load_F0_FPR20_code[] = {
4073 0x8d, 0x9d, 0x30, 0x01, 0x00, 0x00
4074 };
4075 copy_block(op_load_F0_FPR20_code, 6);
4076 inc_code_ptr(6);
4077 }
4078 #endif
4079
4080 DEFINE_GEN(gen_op_store_F0_FPR20,void,(void))
4081 #ifdef DYNGEN_IMPL
4082 #define HAVE_gen_op_store_F0_FPR20
4083 {
4084 static const uint8 op_store_F0_FPR20_code[] = {
4085 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x30, 0x01, 0x00, 0x00, 0x89,
4086 0x95, 0x34, 0x01, 0x00, 0x00
4087 };
4088 copy_block(op_store_F0_FPR20_code, 17);
4089 inc_code_ptr(17);
4090 }
4091 #endif
4092
4093 DEFINE_GEN(gen_op_load_F1_FPR20,void,(void))
4094 #ifdef DYNGEN_IMPL
4095 #define HAVE_gen_op_load_F1_FPR20
4096 {
4097 static const uint8 op_load_F1_FPR20_code[] = {
4098 0x8d, 0xb5, 0x30, 0x01, 0x00, 0x00
4099 };
4100 copy_block(op_load_F1_FPR20_code, 6);
4101 inc_code_ptr(6);
4102 }
4103 #endif
4104
4105 DEFINE_GEN(gen_op_store_F1_FPR20,void,(void))
4106 #ifdef DYNGEN_IMPL
4107 #define HAVE_gen_op_store_F1_FPR20
4108 {
4109 static const uint8 op_store_F1_FPR20_code[] = {
4110 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x30, 0x01, 0x00, 0x00, 0x89,
4111 0x95, 0x34, 0x01, 0x00, 0x00
4112 };
4113 copy_block(op_store_F1_FPR20_code, 17);
4114 inc_code_ptr(17);
4115 }
4116 #endif
4117
4118 DEFINE_GEN(gen_op_load_F2_FPR20,void,(void))
4119 #ifdef DYNGEN_IMPL
4120 #define HAVE_gen_op_load_F2_FPR20
4121 {
4122 static const uint8 op_load_F2_FPR20_code[] = {
4123 0x8d, 0xbd, 0x30, 0x01, 0x00, 0x00
4124 };
4125 copy_block(op_load_F2_FPR20_code, 6);
4126 inc_code_ptr(6);
4127 }
4128 #endif
4129
4130 DEFINE_GEN(gen_op_store_F2_FPR20,void,(void))
4131 #ifdef DYNGEN_IMPL
4132 #define HAVE_gen_op_store_F2_FPR20
4133 {
4134 static const uint8 op_store_F2_FPR20_code[] = {
4135 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x30, 0x01, 0x00, 0x00, 0x89,
4136 0x95, 0x34, 0x01, 0x00, 0x00
4137 };
4138 copy_block(op_store_F2_FPR20_code, 17);
4139 inc_code_ptr(17);
4140 }
4141 #endif
4142
4143 DEFINE_GEN(gen_op_store_FD_FPR20,void,(void))
4144 #ifdef DYNGEN_IMPL
4145 #define HAVE_gen_op_store_FD_FPR20
4146 {
4147 static const uint8 op_store_FD_FPR20_code[] = {
4148 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4149 0x89, 0x85, 0x30, 0x01, 0x00, 0x00, 0x89, 0x95, 0x34, 0x01, 0x00, 0x00
4150 };
4151 copy_block(op_store_FD_FPR20_code, 24);
4152 inc_code_ptr(24);
4153 }
4154 #endif
4155
4156 DEFINE_GEN(gen_op_load_F0_FPR21,void,(void))
4157 #ifdef DYNGEN_IMPL
4158 #define HAVE_gen_op_load_F0_FPR21
4159 {
4160 static const uint8 op_load_F0_FPR21_code[] = {
4161 0x8d, 0x9d, 0x38, 0x01, 0x00, 0x00
4162 };
4163 copy_block(op_load_F0_FPR21_code, 6);
4164 inc_code_ptr(6);
4165 }
4166 #endif
4167
4168 DEFINE_GEN(gen_op_store_F0_FPR21,void,(void))
4169 #ifdef DYNGEN_IMPL
4170 #define HAVE_gen_op_store_F0_FPR21
4171 {
4172 static const uint8 op_store_F0_FPR21_code[] = {
4173 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x38, 0x01, 0x00, 0x00, 0x89,
4174 0x95, 0x3c, 0x01, 0x00, 0x00
4175 };
4176 copy_block(op_store_F0_FPR21_code, 17);
4177 inc_code_ptr(17);
4178 }
4179 #endif
4180
4181 DEFINE_GEN(gen_op_load_F1_FPR21,void,(void))
4182 #ifdef DYNGEN_IMPL
4183 #define HAVE_gen_op_load_F1_FPR21
4184 {
4185 static const uint8 op_load_F1_FPR21_code[] = {
4186 0x8d, 0xb5, 0x38, 0x01, 0x00, 0x00
4187 };
4188 copy_block(op_load_F1_FPR21_code, 6);
4189 inc_code_ptr(6);
4190 }
4191 #endif
4192
4193 DEFINE_GEN(gen_op_store_F1_FPR21,void,(void))
4194 #ifdef DYNGEN_IMPL
4195 #define HAVE_gen_op_store_F1_FPR21
4196 {
4197 static const uint8 op_store_F1_FPR21_code[] = {
4198 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x38, 0x01, 0x00, 0x00, 0x89,
4199 0x95, 0x3c, 0x01, 0x00, 0x00
4200 };
4201 copy_block(op_store_F1_FPR21_code, 17);
4202 inc_code_ptr(17);
4203 }
4204 #endif
4205
4206 DEFINE_GEN(gen_op_load_F2_FPR21,void,(void))
4207 #ifdef DYNGEN_IMPL
4208 #define HAVE_gen_op_load_F2_FPR21
4209 {
4210 static const uint8 op_load_F2_FPR21_code[] = {
4211 0x8d, 0xbd, 0x38, 0x01, 0x00, 0x00
4212 };
4213 copy_block(op_load_F2_FPR21_code, 6);
4214 inc_code_ptr(6);
4215 }
4216 #endif
4217
4218 DEFINE_GEN(gen_op_store_F2_FPR21,void,(void))
4219 #ifdef DYNGEN_IMPL
4220 #define HAVE_gen_op_store_F2_FPR21
4221 {
4222 static const uint8 op_store_F2_FPR21_code[] = {
4223 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x38, 0x01, 0x00, 0x00, 0x89,
4224 0x95, 0x3c, 0x01, 0x00, 0x00
4225 };
4226 copy_block(op_store_F2_FPR21_code, 17);
4227 inc_code_ptr(17);
4228 }
4229 #endif
4230
4231 DEFINE_GEN(gen_op_store_FD_FPR21,void,(void))
4232 #ifdef DYNGEN_IMPL
4233 #define HAVE_gen_op_store_FD_FPR21
4234 {
4235 static const uint8 op_store_FD_FPR21_code[] = {
4236 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4237 0x89, 0x85, 0x38, 0x01, 0x00, 0x00, 0x89, 0x95, 0x3c, 0x01, 0x00, 0x00
4238 };
4239 copy_block(op_store_FD_FPR21_code, 24);
4240 inc_code_ptr(24);
4241 }
4242 #endif
4243
4244 DEFINE_GEN(gen_op_load_F0_FPR22,void,(void))
4245 #ifdef DYNGEN_IMPL
4246 #define HAVE_gen_op_load_F0_FPR22
4247 {
4248 static const uint8 op_load_F0_FPR22_code[] = {
4249 0x8d, 0x9d, 0x40, 0x01, 0x00, 0x00
4250 };
4251 copy_block(op_load_F0_FPR22_code, 6);
4252 inc_code_ptr(6);
4253 }
4254 #endif
4255
4256 DEFINE_GEN(gen_op_store_F0_FPR22,void,(void))
4257 #ifdef DYNGEN_IMPL
4258 #define HAVE_gen_op_store_F0_FPR22
4259 {
4260 static const uint8 op_store_F0_FPR22_code[] = {
4261 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x40, 0x01, 0x00, 0x00, 0x89,
4262 0x95, 0x44, 0x01, 0x00, 0x00
4263 };
4264 copy_block(op_store_F0_FPR22_code, 17);
4265 inc_code_ptr(17);
4266 }
4267 #endif
4268
4269 DEFINE_GEN(gen_op_load_F1_FPR22,void,(void))
4270 #ifdef DYNGEN_IMPL
4271 #define HAVE_gen_op_load_F1_FPR22
4272 {
4273 static const uint8 op_load_F1_FPR22_code[] = {
4274 0x8d, 0xb5, 0x40, 0x01, 0x00, 0x00
4275 };
4276 copy_block(op_load_F1_FPR22_code, 6);
4277 inc_code_ptr(6);
4278 }
4279 #endif
4280
4281 DEFINE_GEN(gen_op_store_F1_FPR22,void,(void))
4282 #ifdef DYNGEN_IMPL
4283 #define HAVE_gen_op_store_F1_FPR22
4284 {
4285 static const uint8 op_store_F1_FPR22_code[] = {
4286 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x40, 0x01, 0x00, 0x00, 0x89,
4287 0x95, 0x44, 0x01, 0x00, 0x00
4288 };
4289 copy_block(op_store_F1_FPR22_code, 17);
4290 inc_code_ptr(17);
4291 }
4292 #endif
4293
4294 DEFINE_GEN(gen_op_load_F2_FPR22,void,(void))
4295 #ifdef DYNGEN_IMPL
4296 #define HAVE_gen_op_load_F2_FPR22
4297 {
4298 static const uint8 op_load_F2_FPR22_code[] = {
4299 0x8d, 0xbd, 0x40, 0x01, 0x00, 0x00
4300 };
4301 copy_block(op_load_F2_FPR22_code, 6);
4302 inc_code_ptr(6);
4303 }
4304 #endif
4305
4306 DEFINE_GEN(gen_op_store_F2_FPR22,void,(void))
4307 #ifdef DYNGEN_IMPL
4308 #define HAVE_gen_op_store_F2_FPR22
4309 {
4310 static const uint8 op_store_F2_FPR22_code[] = {
4311 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x40, 0x01, 0x00, 0x00, 0x89,
4312 0x95, 0x44, 0x01, 0x00, 0x00
4313 };
4314 copy_block(op_store_F2_FPR22_code, 17);
4315 inc_code_ptr(17);
4316 }
4317 #endif
4318
4319 DEFINE_GEN(gen_op_store_FD_FPR22,void,(void))
4320 #ifdef DYNGEN_IMPL
4321 #define HAVE_gen_op_store_FD_FPR22
4322 {
4323 static const uint8 op_store_FD_FPR22_code[] = {
4324 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4325 0x89, 0x85, 0x40, 0x01, 0x00, 0x00, 0x89, 0x95, 0x44, 0x01, 0x00, 0x00
4326 };
4327 copy_block(op_store_FD_FPR22_code, 24);
4328 inc_code_ptr(24);
4329 }
4330 #endif
4331
4332 DEFINE_GEN(gen_op_load_F0_FPR23,void,(void))
4333 #ifdef DYNGEN_IMPL
4334 #define HAVE_gen_op_load_F0_FPR23
4335 {
4336 static const uint8 op_load_F0_FPR23_code[] = {
4337 0x8d, 0x9d, 0x48, 0x01, 0x00, 0x00
4338 };
4339 copy_block(op_load_F0_FPR23_code, 6);
4340 inc_code_ptr(6);
4341 }
4342 #endif
4343
4344 DEFINE_GEN(gen_op_store_F0_FPR23,void,(void))
4345 #ifdef DYNGEN_IMPL
4346 #define HAVE_gen_op_store_F0_FPR23
4347 {
4348 static const uint8 op_store_F0_FPR23_code[] = {
4349 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x48, 0x01, 0x00, 0x00, 0x89,
4350 0x95, 0x4c, 0x01, 0x00, 0x00
4351 };
4352 copy_block(op_store_F0_FPR23_code, 17);
4353 inc_code_ptr(17);
4354 }
4355 #endif
4356
4357 DEFINE_GEN(gen_op_load_F1_FPR23,void,(void))
4358 #ifdef DYNGEN_IMPL
4359 #define HAVE_gen_op_load_F1_FPR23
4360 {
4361 static const uint8 op_load_F1_FPR23_code[] = {
4362 0x8d, 0xb5, 0x48, 0x01, 0x00, 0x00
4363 };
4364 copy_block(op_load_F1_FPR23_code, 6);
4365 inc_code_ptr(6);
4366 }
4367 #endif
4368
4369 DEFINE_GEN(gen_op_store_F1_FPR23,void,(void))
4370 #ifdef DYNGEN_IMPL
4371 #define HAVE_gen_op_store_F1_FPR23
4372 {
4373 static const uint8 op_store_F1_FPR23_code[] = {
4374 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x48, 0x01, 0x00, 0x00, 0x89,
4375 0x95, 0x4c, 0x01, 0x00, 0x00
4376 };
4377 copy_block(op_store_F1_FPR23_code, 17);
4378 inc_code_ptr(17);
4379 }
4380 #endif
4381
4382 DEFINE_GEN(gen_op_load_F2_FPR23,void,(void))
4383 #ifdef DYNGEN_IMPL
4384 #define HAVE_gen_op_load_F2_FPR23
4385 {
4386 static const uint8 op_load_F2_FPR23_code[] = {
4387 0x8d, 0xbd, 0x48, 0x01, 0x00, 0x00
4388 };
4389 copy_block(op_load_F2_FPR23_code, 6);
4390 inc_code_ptr(6);
4391 }
4392 #endif
4393
4394 DEFINE_GEN(gen_op_store_F2_FPR23,void,(void))
4395 #ifdef DYNGEN_IMPL
4396 #define HAVE_gen_op_store_F2_FPR23
4397 {
4398 static const uint8 op_store_F2_FPR23_code[] = {
4399 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x48, 0x01, 0x00, 0x00, 0x89,
4400 0x95, 0x4c, 0x01, 0x00, 0x00
4401 };
4402 copy_block(op_store_F2_FPR23_code, 17);
4403 inc_code_ptr(17);
4404 }
4405 #endif
4406
4407 DEFINE_GEN(gen_op_store_FD_FPR23,void,(void))
4408 #ifdef DYNGEN_IMPL
4409 #define HAVE_gen_op_store_FD_FPR23
4410 {
4411 static const uint8 op_store_FD_FPR23_code[] = {
4412 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4413 0x89, 0x85, 0x48, 0x01, 0x00, 0x00, 0x89, 0x95, 0x4c, 0x01, 0x00, 0x00
4414 };
4415 copy_block(op_store_FD_FPR23_code, 24);
4416 inc_code_ptr(24);
4417 }
4418 #endif
4419
4420 DEFINE_GEN(gen_op_load_F0_FPR24,void,(void))
4421 #ifdef DYNGEN_IMPL
4422 #define HAVE_gen_op_load_F0_FPR24
4423 {
4424 static const uint8 op_load_F0_FPR24_code[] = {
4425 0x8d, 0x9d, 0x50, 0x01, 0x00, 0x00
4426 };
4427 copy_block(op_load_F0_FPR24_code, 6);
4428 inc_code_ptr(6);
4429 }
4430 #endif
4431
4432 DEFINE_GEN(gen_op_store_F0_FPR24,void,(void))
4433 #ifdef DYNGEN_IMPL
4434 #define HAVE_gen_op_store_F0_FPR24
4435 {
4436 static const uint8 op_store_F0_FPR24_code[] = {
4437 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x50, 0x01, 0x00, 0x00, 0x89,
4438 0x95, 0x54, 0x01, 0x00, 0x00
4439 };
4440 copy_block(op_store_F0_FPR24_code, 17);
4441 inc_code_ptr(17);
4442 }
4443 #endif
4444
4445 DEFINE_GEN(gen_op_load_F1_FPR24,void,(void))
4446 #ifdef DYNGEN_IMPL
4447 #define HAVE_gen_op_load_F1_FPR24
4448 {
4449 static const uint8 op_load_F1_FPR24_code[] = {
4450 0x8d, 0xb5, 0x50, 0x01, 0x00, 0x00
4451 };
4452 copy_block(op_load_F1_FPR24_code, 6);
4453 inc_code_ptr(6);
4454 }
4455 #endif
4456
4457 DEFINE_GEN(gen_op_store_F1_FPR24,void,(void))
4458 #ifdef DYNGEN_IMPL
4459 #define HAVE_gen_op_store_F1_FPR24
4460 {
4461 static const uint8 op_store_F1_FPR24_code[] = {
4462 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x50, 0x01, 0x00, 0x00, 0x89,
4463 0x95, 0x54, 0x01, 0x00, 0x00
4464 };
4465 copy_block(op_store_F1_FPR24_code, 17);
4466 inc_code_ptr(17);
4467 }
4468 #endif
4469
4470 DEFINE_GEN(gen_op_load_F2_FPR24,void,(void))
4471 #ifdef DYNGEN_IMPL
4472 #define HAVE_gen_op_load_F2_FPR24
4473 {
4474 static const uint8 op_load_F2_FPR24_code[] = {
4475 0x8d, 0xbd, 0x50, 0x01, 0x00, 0x00
4476 };
4477 copy_block(op_load_F2_FPR24_code, 6);
4478 inc_code_ptr(6);
4479 }
4480 #endif
4481
4482 DEFINE_GEN(gen_op_store_F2_FPR24,void,(void))
4483 #ifdef DYNGEN_IMPL
4484 #define HAVE_gen_op_store_F2_FPR24
4485 {
4486 static const uint8 op_store_F2_FPR24_code[] = {
4487 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x50, 0x01, 0x00, 0x00, 0x89,
4488 0x95, 0x54, 0x01, 0x00, 0x00
4489 };
4490 copy_block(op_store_F2_FPR24_code, 17);
4491 inc_code_ptr(17);
4492 }
4493 #endif
4494
4495 DEFINE_GEN(gen_op_store_FD_FPR24,void,(void))
4496 #ifdef DYNGEN_IMPL
4497 #define HAVE_gen_op_store_FD_FPR24
4498 {
4499 static const uint8 op_store_FD_FPR24_code[] = {
4500 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4501 0x89, 0x85, 0x50, 0x01, 0x00, 0x00, 0x89, 0x95, 0x54, 0x01, 0x00, 0x00
4502 };
4503 copy_block(op_store_FD_FPR24_code, 24);
4504 inc_code_ptr(24);
4505 }
4506 #endif
4507
4508 DEFINE_GEN(gen_op_load_F0_FPR25,void,(void))
4509 #ifdef DYNGEN_IMPL
4510 #define HAVE_gen_op_load_F0_FPR25
4511 {
4512 static const uint8 op_load_F0_FPR25_code[] = {
4513 0x8d, 0x9d, 0x58, 0x01, 0x00, 0x00
4514 };
4515 copy_block(op_load_F0_FPR25_code, 6);
4516 inc_code_ptr(6);
4517 }
4518 #endif
4519
4520 DEFINE_GEN(gen_op_store_F0_FPR25,void,(void))
4521 #ifdef DYNGEN_IMPL
4522 #define HAVE_gen_op_store_F0_FPR25
4523 {
4524 static const uint8 op_store_F0_FPR25_code[] = {
4525 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x58, 0x01, 0x00, 0x00, 0x89,
4526 0x95, 0x5c, 0x01, 0x00, 0x00
4527 };
4528 copy_block(op_store_F0_FPR25_code, 17);
4529 inc_code_ptr(17);
4530 }
4531 #endif
4532
4533 DEFINE_GEN(gen_op_load_F1_FPR25,void,(void))
4534 #ifdef DYNGEN_IMPL
4535 #define HAVE_gen_op_load_F1_FPR25
4536 {
4537 static const uint8 op_load_F1_FPR25_code[] = {
4538 0x8d, 0xb5, 0x58, 0x01, 0x00, 0x00
4539 };
4540 copy_block(op_load_F1_FPR25_code, 6);
4541 inc_code_ptr(6);
4542 }
4543 #endif
4544
4545 DEFINE_GEN(gen_op_store_F1_FPR25,void,(void))
4546 #ifdef DYNGEN_IMPL
4547 #define HAVE_gen_op_store_F1_FPR25
4548 {
4549 static const uint8 op_store_F1_FPR25_code[] = {
4550 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x58, 0x01, 0x00, 0x00, 0x89,
4551 0x95, 0x5c, 0x01, 0x00, 0x00
4552 };
4553 copy_block(op_store_F1_FPR25_code, 17);
4554 inc_code_ptr(17);
4555 }
4556 #endif
4557
4558 DEFINE_GEN(gen_op_load_F2_FPR25,void,(void))
4559 #ifdef DYNGEN_IMPL
4560 #define HAVE_gen_op_load_F2_FPR25
4561 {
4562 static const uint8 op_load_F2_FPR25_code[] = {
4563 0x8d, 0xbd, 0x58, 0x01, 0x00, 0x00
4564 };
4565 copy_block(op_load_F2_FPR25_code, 6);
4566 inc_code_ptr(6);
4567 }
4568 #endif
4569
4570 DEFINE_GEN(gen_op_store_F2_FPR25,void,(void))
4571 #ifdef DYNGEN_IMPL
4572 #define HAVE_gen_op_store_F2_FPR25
4573 {
4574 static const uint8 op_store_F2_FPR25_code[] = {
4575 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x58, 0x01, 0x00, 0x00, 0x89,
4576 0x95, 0x5c, 0x01, 0x00, 0x00
4577 };
4578 copy_block(op_store_F2_FPR25_code, 17);
4579 inc_code_ptr(17);
4580 }
4581 #endif
4582
4583 DEFINE_GEN(gen_op_store_FD_FPR25,void,(void))
4584 #ifdef DYNGEN_IMPL
4585 #define HAVE_gen_op_store_FD_FPR25
4586 {
4587 static const uint8 op_store_FD_FPR25_code[] = {
4588 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4589 0x89, 0x85, 0x58, 0x01, 0x00, 0x00, 0x89, 0x95, 0x5c, 0x01, 0x00, 0x00
4590 };
4591 copy_block(op_store_FD_FPR25_code, 24);
4592 inc_code_ptr(24);
4593 }
4594 #endif
4595
4596 DEFINE_GEN(gen_op_load_F0_FPR26,void,(void))
4597 #ifdef DYNGEN_IMPL
4598 #define HAVE_gen_op_load_F0_FPR26
4599 {
4600 static const uint8 op_load_F0_FPR26_code[] = {
4601 0x8d, 0x9d, 0x60, 0x01, 0x00, 0x00
4602 };
4603 copy_block(op_load_F0_FPR26_code, 6);
4604 inc_code_ptr(6);
4605 }
4606 #endif
4607
4608 DEFINE_GEN(gen_op_store_F0_FPR26,void,(void))
4609 #ifdef DYNGEN_IMPL
4610 #define HAVE_gen_op_store_F0_FPR26
4611 {
4612 static const uint8 op_store_F0_FPR26_code[] = {
4613 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x60, 0x01, 0x00, 0x00, 0x89,
4614 0x95, 0x64, 0x01, 0x00, 0x00
4615 };
4616 copy_block(op_store_F0_FPR26_code, 17);
4617 inc_code_ptr(17);
4618 }
4619 #endif
4620
4621 DEFINE_GEN(gen_op_load_F1_FPR26,void,(void))
4622 #ifdef DYNGEN_IMPL
4623 #define HAVE_gen_op_load_F1_FPR26
4624 {
4625 static const uint8 op_load_F1_FPR26_code[] = {
4626 0x8d, 0xb5, 0x60, 0x01, 0x00, 0x00
4627 };
4628 copy_block(op_load_F1_FPR26_code, 6);
4629 inc_code_ptr(6);
4630 }
4631 #endif
4632
4633 DEFINE_GEN(gen_op_store_F1_FPR26,void,(void))
4634 #ifdef DYNGEN_IMPL
4635 #define HAVE_gen_op_store_F1_FPR26
4636 {
4637 static const uint8 op_store_F1_FPR26_code[] = {
4638 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x60, 0x01, 0x00, 0x00, 0x89,
4639 0x95, 0x64, 0x01, 0x00, 0x00
4640 };
4641 copy_block(op_store_F1_FPR26_code, 17);
4642 inc_code_ptr(17);
4643 }
4644 #endif
4645
4646 DEFINE_GEN(gen_op_load_F2_FPR26,void,(void))
4647 #ifdef DYNGEN_IMPL
4648 #define HAVE_gen_op_load_F2_FPR26
4649 {
4650 static const uint8 op_load_F2_FPR26_code[] = {
4651 0x8d, 0xbd, 0x60, 0x01, 0x00, 0x00
4652 };
4653 copy_block(op_load_F2_FPR26_code, 6);
4654 inc_code_ptr(6);
4655 }
4656 #endif
4657
4658 DEFINE_GEN(gen_op_store_F2_FPR26,void,(void))
4659 #ifdef DYNGEN_IMPL
4660 #define HAVE_gen_op_store_F2_FPR26
4661 {
4662 static const uint8 op_store_F2_FPR26_code[] = {
4663 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x60, 0x01, 0x00, 0x00, 0x89,
4664 0x95, 0x64, 0x01, 0x00, 0x00
4665 };
4666 copy_block(op_store_F2_FPR26_code, 17);
4667 inc_code_ptr(17);
4668 }
4669 #endif
4670
4671 DEFINE_GEN(gen_op_store_FD_FPR26,void,(void))
4672 #ifdef DYNGEN_IMPL
4673 #define HAVE_gen_op_store_FD_FPR26
4674 {
4675 static const uint8 op_store_FD_FPR26_code[] = {
4676 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4677 0x89, 0x85, 0x60, 0x01, 0x00, 0x00, 0x89, 0x95, 0x64, 0x01, 0x00, 0x00
4678 };
4679 copy_block(op_store_FD_FPR26_code, 24);
4680 inc_code_ptr(24);
4681 }
4682 #endif
4683
4684 DEFINE_GEN(gen_op_load_F0_FPR27,void,(void))
4685 #ifdef DYNGEN_IMPL
4686 #define HAVE_gen_op_load_F0_FPR27
4687 {
4688 static const uint8 op_load_F0_FPR27_code[] = {
4689 0x8d, 0x9d, 0x68, 0x01, 0x00, 0x00
4690 };
4691 copy_block(op_load_F0_FPR27_code, 6);
4692 inc_code_ptr(6);
4693 }
4694 #endif
4695
4696 DEFINE_GEN(gen_op_store_F0_FPR27,void,(void))
4697 #ifdef DYNGEN_IMPL
4698 #define HAVE_gen_op_store_F0_FPR27
4699 {
4700 static const uint8 op_store_F0_FPR27_code[] = {
4701 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x68, 0x01, 0x00, 0x00, 0x89,
4702 0x95, 0x6c, 0x01, 0x00, 0x00
4703 };
4704 copy_block(op_store_F0_FPR27_code, 17);
4705 inc_code_ptr(17);
4706 }
4707 #endif
4708
4709 DEFINE_GEN(gen_op_load_F1_FPR27,void,(void))
4710 #ifdef DYNGEN_IMPL
4711 #define HAVE_gen_op_load_F1_FPR27
4712 {
4713 static const uint8 op_load_F1_FPR27_code[] = {
4714 0x8d, 0xb5, 0x68, 0x01, 0x00, 0x00
4715 };
4716 copy_block(op_load_F1_FPR27_code, 6);
4717 inc_code_ptr(6);
4718 }
4719 #endif
4720
4721 DEFINE_GEN(gen_op_store_F1_FPR27,void,(void))
4722 #ifdef DYNGEN_IMPL
4723 #define HAVE_gen_op_store_F1_FPR27
4724 {
4725 static const uint8 op_store_F1_FPR27_code[] = {
4726 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x68, 0x01, 0x00, 0x00, 0x89,
4727 0x95, 0x6c, 0x01, 0x00, 0x00
4728 };
4729 copy_block(op_store_F1_FPR27_code, 17);
4730 inc_code_ptr(17);
4731 }
4732 #endif
4733
4734 DEFINE_GEN(gen_op_load_F2_FPR27,void,(void))
4735 #ifdef DYNGEN_IMPL
4736 #define HAVE_gen_op_load_F2_FPR27
4737 {
4738 static const uint8 op_load_F2_FPR27_code[] = {
4739 0x8d, 0xbd, 0x68, 0x01, 0x00, 0x00
4740 };
4741 copy_block(op_load_F2_FPR27_code, 6);
4742 inc_code_ptr(6);
4743 }
4744 #endif
4745
4746 DEFINE_GEN(gen_op_store_F2_FPR27,void,(void))
4747 #ifdef DYNGEN_IMPL
4748 #define HAVE_gen_op_store_F2_FPR27
4749 {
4750 static const uint8 op_store_F2_FPR27_code[] = {
4751 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x68, 0x01, 0x00, 0x00, 0x89,
4752 0x95, 0x6c, 0x01, 0x00, 0x00
4753 };
4754 copy_block(op_store_F2_FPR27_code, 17);
4755 inc_code_ptr(17);
4756 }
4757 #endif
4758
4759 DEFINE_GEN(gen_op_store_FD_FPR27,void,(void))
4760 #ifdef DYNGEN_IMPL
4761 #define HAVE_gen_op_store_FD_FPR27
4762 {
4763 static const uint8 op_store_FD_FPR27_code[] = {
4764 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4765 0x89, 0x85, 0x68, 0x01, 0x00, 0x00, 0x89, 0x95, 0x6c, 0x01, 0x00, 0x00
4766 };
4767 copy_block(op_store_FD_FPR27_code, 24);
4768 inc_code_ptr(24);
4769 }
4770 #endif
4771
4772 DEFINE_GEN(gen_op_load_F0_FPR28,void,(void))
4773 #ifdef DYNGEN_IMPL
4774 #define HAVE_gen_op_load_F0_FPR28
4775 {
4776 static const uint8 op_load_F0_FPR28_code[] = {
4777 0x8d, 0x9d, 0x70, 0x01, 0x00, 0x00
4778 };
4779 copy_block(op_load_F0_FPR28_code, 6);
4780 inc_code_ptr(6);
4781 }
4782 #endif
4783
4784 DEFINE_GEN(gen_op_store_F0_FPR28,void,(void))
4785 #ifdef DYNGEN_IMPL
4786 #define HAVE_gen_op_store_F0_FPR28
4787 {
4788 static const uint8 op_store_F0_FPR28_code[] = {
4789 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x70, 0x01, 0x00, 0x00, 0x89,
4790 0x95, 0x74, 0x01, 0x00, 0x00
4791 };
4792 copy_block(op_store_F0_FPR28_code, 17);
4793 inc_code_ptr(17);
4794 }
4795 #endif
4796
4797 DEFINE_GEN(gen_op_load_F1_FPR28,void,(void))
4798 #ifdef DYNGEN_IMPL
4799 #define HAVE_gen_op_load_F1_FPR28
4800 {
4801 static const uint8 op_load_F1_FPR28_code[] = {
4802 0x8d, 0xb5, 0x70, 0x01, 0x00, 0x00
4803 };
4804 copy_block(op_load_F1_FPR28_code, 6);
4805 inc_code_ptr(6);
4806 }
4807 #endif
4808
4809 DEFINE_GEN(gen_op_store_F1_FPR28,void,(void))
4810 #ifdef DYNGEN_IMPL
4811 #define HAVE_gen_op_store_F1_FPR28
4812 {
4813 static const uint8 op_store_F1_FPR28_code[] = {
4814 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x70, 0x01, 0x00, 0x00, 0x89,
4815 0x95, 0x74, 0x01, 0x00, 0x00
4816 };
4817 copy_block(op_store_F1_FPR28_code, 17);
4818 inc_code_ptr(17);
4819 }
4820 #endif
4821
4822 DEFINE_GEN(gen_op_load_F2_FPR28,void,(void))
4823 #ifdef DYNGEN_IMPL
4824 #define HAVE_gen_op_load_F2_FPR28
4825 {
4826 static const uint8 op_load_F2_FPR28_code[] = {
4827 0x8d, 0xbd, 0x70, 0x01, 0x00, 0x00
4828 };
4829 copy_block(op_load_F2_FPR28_code, 6);
4830 inc_code_ptr(6);
4831 }
4832 #endif
4833
4834 DEFINE_GEN(gen_op_store_F2_FPR28,void,(void))
4835 #ifdef DYNGEN_IMPL
4836 #define HAVE_gen_op_store_F2_FPR28
4837 {
4838 static const uint8 op_store_F2_FPR28_code[] = {
4839 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x70, 0x01, 0x00, 0x00, 0x89,
4840 0x95, 0x74, 0x01, 0x00, 0x00
4841 };
4842 copy_block(op_store_F2_FPR28_code, 17);
4843 inc_code_ptr(17);
4844 }
4845 #endif
4846
4847 DEFINE_GEN(gen_op_store_FD_FPR28,void,(void))
4848 #ifdef DYNGEN_IMPL
4849 #define HAVE_gen_op_store_FD_FPR28
4850 {
4851 static const uint8 op_store_FD_FPR28_code[] = {
4852 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4853 0x89, 0x85, 0x70, 0x01, 0x00, 0x00, 0x89, 0x95, 0x74, 0x01, 0x00, 0x00
4854 };
4855 copy_block(op_store_FD_FPR28_code, 24);
4856 inc_code_ptr(24);
4857 }
4858 #endif
4859
4860 DEFINE_GEN(gen_op_load_F0_FPR29,void,(void))
4861 #ifdef DYNGEN_IMPL
4862 #define HAVE_gen_op_load_F0_FPR29
4863 {
4864 static const uint8 op_load_F0_FPR29_code[] = {
4865 0x8d, 0x9d, 0x78, 0x01, 0x00, 0x00
4866 };
4867 copy_block(op_load_F0_FPR29_code, 6);
4868 inc_code_ptr(6);
4869 }
4870 #endif
4871
4872 DEFINE_GEN(gen_op_store_F0_FPR29,void,(void))
4873 #ifdef DYNGEN_IMPL
4874 #define HAVE_gen_op_store_F0_FPR29
4875 {
4876 static const uint8 op_store_F0_FPR29_code[] = {
4877 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x78, 0x01, 0x00, 0x00, 0x89,
4878 0x95, 0x7c, 0x01, 0x00, 0x00
4879 };
4880 copy_block(op_store_F0_FPR29_code, 17);
4881 inc_code_ptr(17);
4882 }
4883 #endif
4884
4885 DEFINE_GEN(gen_op_load_F1_FPR29,void,(void))
4886 #ifdef DYNGEN_IMPL
4887 #define HAVE_gen_op_load_F1_FPR29
4888 {
4889 static const uint8 op_load_F1_FPR29_code[] = {
4890 0x8d, 0xb5, 0x78, 0x01, 0x00, 0x00
4891 };
4892 copy_block(op_load_F1_FPR29_code, 6);
4893 inc_code_ptr(6);
4894 }
4895 #endif
4896
4897 DEFINE_GEN(gen_op_store_F1_FPR29,void,(void))
4898 #ifdef DYNGEN_IMPL
4899 #define HAVE_gen_op_store_F1_FPR29
4900 {
4901 static const uint8 op_store_F1_FPR29_code[] = {
4902 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x78, 0x01, 0x00, 0x00, 0x89,
4903 0x95, 0x7c, 0x01, 0x00, 0x00
4904 };
4905 copy_block(op_store_F1_FPR29_code, 17);
4906 inc_code_ptr(17);
4907 }
4908 #endif
4909
4910 DEFINE_GEN(gen_op_load_F2_FPR29,void,(void))
4911 #ifdef DYNGEN_IMPL
4912 #define HAVE_gen_op_load_F2_FPR29
4913 {
4914 static const uint8 op_load_F2_FPR29_code[] = {
4915 0x8d, 0xbd, 0x78, 0x01, 0x00, 0x00
4916 };
4917 copy_block(op_load_F2_FPR29_code, 6);
4918 inc_code_ptr(6);
4919 }
4920 #endif
4921
4922 DEFINE_GEN(gen_op_store_F2_FPR29,void,(void))
4923 #ifdef DYNGEN_IMPL
4924 #define HAVE_gen_op_store_F2_FPR29
4925 {
4926 static const uint8 op_store_F2_FPR29_code[] = {
4927 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x78, 0x01, 0x00, 0x00, 0x89,
4928 0x95, 0x7c, 0x01, 0x00, 0x00
4929 };
4930 copy_block(op_store_F2_FPR29_code, 17);
4931 inc_code_ptr(17);
4932 }
4933 #endif
4934
4935 DEFINE_GEN(gen_op_store_FD_FPR29,void,(void))
4936 #ifdef DYNGEN_IMPL
4937 #define HAVE_gen_op_store_FD_FPR29
4938 {
4939 static const uint8 op_store_FD_FPR29_code[] = {
4940 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
4941 0x89, 0x85, 0x78, 0x01, 0x00, 0x00, 0x89, 0x95, 0x7c, 0x01, 0x00, 0x00
4942 };
4943 copy_block(op_store_FD_FPR29_code, 24);
4944 inc_code_ptr(24);
4945 }
4946 #endif
4947
4948 DEFINE_GEN(gen_op_load_F0_FPR30,void,(void))
4949 #ifdef DYNGEN_IMPL
4950 #define HAVE_gen_op_load_F0_FPR30
4951 {
4952 static const uint8 op_load_F0_FPR30_code[] = {
4953 0x8d, 0x9d, 0x80, 0x01, 0x00, 0x00
4954 };
4955 copy_block(op_load_F0_FPR30_code, 6);
4956 inc_code_ptr(6);
4957 }
4958 #endif
4959
4960 DEFINE_GEN(gen_op_store_F0_FPR30,void,(void))
4961 #ifdef DYNGEN_IMPL
4962 #define HAVE_gen_op_store_F0_FPR30
4963 {
4964 static const uint8 op_store_F0_FPR30_code[] = {
4965 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x80, 0x01, 0x00, 0x00, 0x89,
4966 0x95, 0x84, 0x01, 0x00, 0x00
4967 };
4968 copy_block(op_store_F0_FPR30_code, 17);
4969 inc_code_ptr(17);
4970 }
4971 #endif
4972
4973 DEFINE_GEN(gen_op_load_F1_FPR30,void,(void))
4974 #ifdef DYNGEN_IMPL
4975 #define HAVE_gen_op_load_F1_FPR30
4976 {
4977 static const uint8 op_load_F1_FPR30_code[] = {
4978 0x8d, 0xb5, 0x80, 0x01, 0x00, 0x00
4979 };
4980 copy_block(op_load_F1_FPR30_code, 6);
4981 inc_code_ptr(6);
4982 }
4983 #endif
4984
4985 DEFINE_GEN(gen_op_store_F1_FPR30,void,(void))
4986 #ifdef DYNGEN_IMPL
4987 #define HAVE_gen_op_store_F1_FPR30
4988 {
4989 static const uint8 op_store_F1_FPR30_code[] = {
4990 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x80, 0x01, 0x00, 0x00, 0x89,
4991 0x95, 0x84, 0x01, 0x00, 0x00
4992 };
4993 copy_block(op_store_F1_FPR30_code, 17);
4994 inc_code_ptr(17);
4995 }
4996 #endif
4997
4998 DEFINE_GEN(gen_op_load_F2_FPR30,void,(void))
4999 #ifdef DYNGEN_IMPL
5000 #define HAVE_gen_op_load_F2_FPR30
5001 {
5002 static const uint8 op_load_F2_FPR30_code[] = {
5003 0x8d, 0xbd, 0x80, 0x01, 0x00, 0x00
5004 };
5005 copy_block(op_load_F2_FPR30_code, 6);
5006 inc_code_ptr(6);
5007 }
5008 #endif
5009
5010 DEFINE_GEN(gen_op_store_F2_FPR30,void,(void))
5011 #ifdef DYNGEN_IMPL
5012 #define HAVE_gen_op_store_F2_FPR30
5013 {
5014 static const uint8 op_store_F2_FPR30_code[] = {
5015 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x80, 0x01, 0x00, 0x00, 0x89,
5016 0x95, 0x84, 0x01, 0x00, 0x00
5017 };
5018 copy_block(op_store_F2_FPR30_code, 17);
5019 inc_code_ptr(17);
5020 }
5021 #endif
5022
5023 DEFINE_GEN(gen_op_store_FD_FPR30,void,(void))
5024 #ifdef DYNGEN_IMPL
5025 #define HAVE_gen_op_store_FD_FPR30
5026 {
5027 static const uint8 op_store_FD_FPR30_code[] = {
5028 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
5029 0x89, 0x85, 0x80, 0x01, 0x00, 0x00, 0x89, 0x95, 0x84, 0x01, 0x00, 0x00
5030 };
5031 copy_block(op_store_FD_FPR30_code, 24);
5032 inc_code_ptr(24);
5033 }
5034 #endif
5035
5036 DEFINE_GEN(gen_op_load_F0_FPR31,void,(void))
5037 #ifdef DYNGEN_IMPL
5038 #define HAVE_gen_op_load_F0_FPR31
5039 {
5040 static const uint8 op_load_F0_FPR31_code[] = {
5041 0x8d, 0x9d, 0x88, 0x01, 0x00, 0x00
5042 };
5043 copy_block(op_load_F0_FPR31_code, 6);
5044 inc_code_ptr(6);
5045 }
5046 #endif
5047
5048 DEFINE_GEN(gen_op_store_F0_FPR31,void,(void))
5049 #ifdef DYNGEN_IMPL
5050 #define HAVE_gen_op_store_F0_FPR31
5051 {
5052 static const uint8 op_store_F0_FPR31_code[] = {
5053 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x88, 0x01, 0x00, 0x00, 0x89,
5054 0x95, 0x8c, 0x01, 0x00, 0x00
5055 };
5056 copy_block(op_store_F0_FPR31_code, 17);
5057 inc_code_ptr(17);
5058 }
5059 #endif
5060
5061 DEFINE_GEN(gen_op_load_F1_FPR31,void,(void))
5062 #ifdef DYNGEN_IMPL
5063 #define HAVE_gen_op_load_F1_FPR31
5064 {
5065 static const uint8 op_load_F1_FPR31_code[] = {
5066 0x8d, 0xb5, 0x88, 0x01, 0x00, 0x00
5067 };
5068 copy_block(op_load_F1_FPR31_code, 6);
5069 inc_code_ptr(6);
5070 }
5071 #endif
5072
5073 DEFINE_GEN(gen_op_store_F1_FPR31,void,(void))
5074 #ifdef DYNGEN_IMPL
5075 #define HAVE_gen_op_store_F1_FPR31
5076 {
5077 static const uint8 op_store_F1_FPR31_code[] = {
5078 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x88, 0x01, 0x00, 0x00, 0x89,
5079 0x95, 0x8c, 0x01, 0x00, 0x00
5080 };
5081 copy_block(op_store_F1_FPR31_code, 17);
5082 inc_code_ptr(17);
5083 }
5084 #endif
5085
5086 DEFINE_GEN(gen_op_load_F2_FPR31,void,(void))
5087 #ifdef DYNGEN_IMPL
5088 #define HAVE_gen_op_load_F2_FPR31
5089 {
5090 static const uint8 op_load_F2_FPR31_code[] = {
5091 0x8d, 0xbd, 0x88, 0x01, 0x00, 0x00
5092 };
5093 copy_block(op_load_F2_FPR31_code, 6);
5094 inc_code_ptr(6);
5095 }
5096 #endif
5097
5098 DEFINE_GEN(gen_op_store_F2_FPR31,void,(void))
5099 #ifdef DYNGEN_IMPL
5100 #define HAVE_gen_op_store_F2_FPR31
5101 {
5102 static const uint8 op_store_F2_FPR31_code[] = {
5103 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x88, 0x01, 0x00, 0x00, 0x89,
5104 0x95, 0x8c, 0x01, 0x00, 0x00
5105 };
5106 copy_block(op_store_F2_FPR31_code, 17);
5107 inc_code_ptr(17);
5108 }
5109 #endif
5110
5111 DEFINE_GEN(gen_op_store_FD_FPR31,void,(void))
5112 #ifdef DYNGEN_IMPL
5113 #define HAVE_gen_op_store_FD_FPR31
5114 {
5115 static const uint8 op_store_FD_FPR31_code[] = {
5116 0x8b, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x95, 0x44, 0x08, 0x0e, 0x00,
5117 0x89, 0x85, 0x88, 0x01, 0x00, 0x00, 0x89, 0x95, 0x8c, 0x01, 0x00, 0x00
5118 };
5119 copy_block(op_store_FD_FPR31_code, 24);
5120 inc_code_ptr(24);
5121 }
5122 #endif
5123
5124 DEFINE_GEN(gen_op_load_double_FD_T1_0,void,(void))
5125 #ifdef DYNGEN_IMPL
5126 #define HAVE_gen_op_load_double_FD_T1_0
5127 {
5128 static const uint8 op_load_double_FD_T1_0_code[] = {
5129 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x96, 0x00, 0x00, 0x00, 0x11,
5130 0x0f, 0xca, 0x89, 0x50, 0x04, 0x8b, 0x96, 0x04, 0x00, 0x00, 0x11, 0x0f,
5131 0xca, 0x89, 0x10
5132 };
5133 copy_block(op_load_double_FD_T1_0_code, 27);
5134 inc_code_ptr(27);
5135 }
5136 #endif
5137
5138 DEFINE_GEN(gen_op_load_single_FD_T1_0,void,(void))
5139 #ifdef DYNGEN_IMPL
5140 #define HAVE_gen_op_load_single_FD_T1_0
5141 {
5142 static const uint8 op_load_single_FD_T1_0_code[] = {
5143 0x83, 0xec, 0x08, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x96, 0x00,
5144 0x00, 0x00, 0x11, 0x0f, 0xca, 0x89, 0x14, 0x24, 0x31, 0xc9, 0xd9, 0x04,
5145 0x24, 0x89, 0x4c, 0x24, 0x04, 0xdd, 0x1c, 0x24, 0x8b, 0x14, 0x24, 0x8b,
5146 0x4c, 0x24, 0x04, 0x89, 0x10, 0x89, 0x48, 0x04, 0x83, 0xc4, 0x08
5147 };
5148 copy_block(op_load_single_FD_T1_0_code, 47);
5149 inc_code_ptr(47);
5150 }
5151 #endif
5152
5153 DEFINE_GEN(gen_op_store_double_F0_T1_0,void,(void))
5154 #ifdef DYNGEN_IMPL
5155 #define HAVE_gen_op_store_double_F0_T1_0
5156 {
5157 static const uint8 op_store_double_F0_T1_0_code[] = {
5158 0x8b, 0x43, 0x04, 0x0f, 0xc8, 0x89, 0x86, 0x00, 0x00, 0x00, 0x11, 0x8d,
5159 0x56, 0x04, 0x8b, 0x03, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, 0x00, 0x11
5160 };
5161 copy_block(op_store_double_F0_T1_0_code, 24);
5162 inc_code_ptr(24);
5163 }
5164 #endif
5165
5166 DEFINE_GEN(gen_op_store_single_F0_T1_0,void,(void))
5167 #ifdef DYNGEN_IMPL
5168 #define HAVE_gen_op_store_single_F0_T1_0
5169 {
5170 static const uint8 op_store_single_F0_T1_0_code[] = {
5171 0x83, 0xec, 0x18, 0x89, 0xf1, 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x44,
5172 0x24, 0x0c, 0x89, 0xd0, 0xc1, 0xe8, 0x14, 0x89, 0x54, 0x24, 0x10, 0x25,
5173 0xff, 0x07, 0x00, 0x00, 0x2d, 0x6a, 0x03, 0x00, 0x00, 0x83, 0xf8, 0x16,
5174 0x76, 0x3a, 0x8b, 0x54, 0x24, 0x10, 0x89, 0xd0, 0x25, 0x00, 0x00, 0x00,
5175 0xc0, 0x89, 0x04, 0x24, 0x8b, 0x54, 0x24, 0x10, 0x8b, 0x44, 0x24, 0x0c,
5176 0x0f, 0xac, 0xd0, 0x1d, 0xc1, 0xea, 0x1d, 0x89, 0x44, 0x24, 0x0c, 0x8b,
5177 0x44, 0x24, 0x0c, 0x89, 0x54, 0x24, 0x10, 0x25, 0xff, 0xff, 0xff, 0x3f,
5178 0x09, 0x04, 0x24, 0xeb, 0x26, 0x8d, 0xb4, 0x26, 0x00, 0x00, 0x00, 0x00,
5179 0x8b, 0x44, 0x24, 0x0c, 0x8b, 0x54, 0x24, 0x10, 0x89, 0x44, 0x24, 0x04,
5180 0x89, 0x54, 0x24, 0x08, 0xdd, 0x44, 0x24, 0x04, 0xd9, 0x5c, 0x24, 0x14,
5181 0x8b, 0x44, 0x24, 0x14, 0x89, 0x04, 0x24, 0x8b, 0x04, 0x24, 0x0f, 0xc8,
5182 0x89, 0x81, 0x00, 0x00, 0x00, 0x11, 0x83, 0xc4, 0x18
5183 };
5184 copy_block(op_store_single_F0_T1_0_code, 141);
5185 inc_code_ptr(141);
5186 }
5187 #endif
5188
5189 DEFINE_GEN(gen_op_load_double_FD_T1_im,void,(long param1))
5190 #ifdef DYNGEN_IMPL
5191 #define HAVE_gen_op_load_double_FD_T1_im
5192 {
5193 static const uint8 op_load_double_FD_T1_im_code[] = {
5194 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x96, 0x00, 0x00, 0x00, 0x11,
5195 0x0f, 0xca, 0x89, 0x50, 0x04, 0x8b, 0x96, 0x04, 0x00, 0x00, 0x11, 0x0f,
5196 0xca, 0x89, 0x10
5197 };
5198 copy_block(op_load_double_FD_T1_im_code, 27);
5199 *(uint32_t *)(code_ptr() + 8) = param1 + 285212672;
5200 *(uint32_t *)(code_ptr() + 19) = param1 + 285212676;
5201 inc_code_ptr(27);
5202 }
5203 #endif
5204
5205 DEFINE_GEN(gen_op_load_single_FD_T1_im,void,(long param1))
5206 #ifdef DYNGEN_IMPL
5207 #define HAVE_gen_op_load_single_FD_T1_im
5208 {
5209 static const uint8 op_load_single_FD_T1_im_code[] = {
5210 0x83, 0xec, 0x08, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x96, 0x00,
5211 0x00, 0x00, 0x11, 0x0f, 0xca, 0x89, 0x14, 0x24, 0x31, 0xc9, 0xd9, 0x04,
5212 0x24, 0x89, 0x4c, 0x24, 0x04, 0xdd, 0x1c, 0x24, 0x8b, 0x14, 0x24, 0x8b,
5213 0x4c, 0x24, 0x04, 0x89, 0x10, 0x89, 0x48, 0x04, 0x83, 0xc4, 0x08
5214 };
5215 copy_block(op_load_single_FD_T1_im_code, 47);
5216 *(uint32_t *)(code_ptr() + 11) = param1 + 285212672;
5217 inc_code_ptr(47);
5218 }
5219 #endif
5220
5221 DEFINE_GEN(gen_op_store_double_F0_T1_im,void,(long param1))
5222 #ifdef DYNGEN_IMPL
5223 #define HAVE_gen_op_store_double_F0_T1_im
5224 {
5225 static const uint8 op_store_double_F0_T1_im_code[] = {
5226 0x8d, 0x96, 0x00, 0x00, 0x00, 0x00, 0x8b, 0x43, 0x04, 0x0f, 0xc8, 0x89,
5227 0x82, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x03, 0x8d, 0x96, 0x04, 0x00, 0x00,
5228 0x00, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, 0x00, 0x11
5229 };
5230 copy_block(op_store_double_F0_T1_im_code, 33);
5231 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
5232 *(uint32_t *)(code_ptr() + 21) = param1 + 4;
5233 inc_code_ptr(33);
5234 }
5235 #endif
5236
5237 DEFINE_GEN(gen_op_store_single_F0_T1_im,void,(long param1))
5238 #ifdef DYNGEN_IMPL
5239 #define HAVE_gen_op_store_single_F0_T1_im
5240 {
5241 static const uint8 op_store_single_F0_T1_im_code[] = {
5242 0x83, 0xec, 0x18, 0x8d, 0x8e, 0x00, 0x00, 0x00, 0x00, 0x8b, 0x03, 0x8b,
5243 0x53, 0x04, 0x89, 0x44, 0x24, 0x0c, 0x89, 0xd0, 0xc1, 0xe8, 0x14, 0x89,
5244 0x54, 0x24, 0x10, 0x25, 0xff, 0x07, 0x00, 0x00, 0x2d, 0x6a, 0x03, 0x00,
5245 0x00, 0x83, 0xf8, 0x16, 0x76, 0x36, 0x8b, 0x54, 0x24, 0x10, 0x89, 0xd0,
5246 0x25, 0x00, 0x00, 0x00, 0xc0, 0x89, 0x04, 0x24, 0x8b, 0x54, 0x24, 0x10,
5247 0x8b, 0x44, 0x24, 0x0c, 0x0f, 0xac, 0xd0, 0x1d, 0xc1, 0xea, 0x1d, 0x89,
5248 0x44, 0x24, 0x0c, 0x8b, 0x44, 0x24, 0x0c, 0x89, 0x54, 0x24, 0x10, 0x25,
5249 0xff, 0xff, 0xff, 0x3f, 0x09, 0x04, 0x24, 0xeb, 0x22, 0x8d, 0x76, 0x00,
5250 0x8b, 0x44, 0x24, 0x0c, 0x8b, 0x54, 0x24, 0x10, 0x89, 0x44, 0x24, 0x04,
5251 0x89, 0x54, 0x24, 0x08, 0xdd, 0x44, 0x24, 0x04, 0xd9, 0x5c, 0x24, 0x14,
5252 0x8b, 0x44, 0x24, 0x14, 0x89, 0x04, 0x24, 0x8b, 0x04, 0x24, 0x0f, 0xc8,
5253 0x89, 0x81, 0x00, 0x00, 0x00, 0x11, 0x83, 0xc4, 0x18
5254 };
5255 copy_block(op_store_single_F0_T1_im_code, 141);
5256 *(uint32_t *)(code_ptr() + 5) = param1 + 0;
5257 inc_code_ptr(141);
5258 }
5259 #endif
5260
5261 DEFINE_GEN(gen_op_load_double_FD_T1_T2,void,(void))
5262 #ifdef DYNGEN_IMPL
5263 #define HAVE_gen_op_load_double_FD_T1_T2
5264 {
5265 static const uint8 op_load_double_FD_T1_T2_code[] = {
5266 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x94, 0x3e, 0x00, 0x00, 0x00,
5267 0x11, 0x0f, 0xca, 0x89, 0x50, 0x04, 0x8b, 0x94, 0x3e, 0x04, 0x00, 0x00,
5268 0x11, 0x0f, 0xca, 0x89, 0x10
5269 };
5270 copy_block(op_load_double_FD_T1_T2_code, 29);
5271 inc_code_ptr(29);
5272 }
5273 #endif
5274
5275 DEFINE_GEN(gen_op_load_single_FD_T1_T2,void,(void))
5276 #ifdef DYNGEN_IMPL
5277 #define HAVE_gen_op_load_single_FD_T1_T2
5278 {
5279 static const uint8 op_load_single_FD_T1_T2_code[] = {
5280 0x83, 0xec, 0x08, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x8b, 0x94, 0x3e,
5281 0x00, 0x00, 0x00, 0x11, 0x0f, 0xca, 0x89, 0x14, 0x24, 0x31, 0xc9, 0xd9,
5282 0x04, 0x24, 0x89, 0x4c, 0x24, 0x04, 0xdd, 0x1c, 0x24, 0x8b, 0x14, 0x24,
5283 0x8b, 0x4c, 0x24, 0x04, 0x89, 0x10, 0x89, 0x48, 0x04, 0x83, 0xc4, 0x08
5284 };
5285 copy_block(op_load_single_FD_T1_T2_code, 48);
5286 inc_code_ptr(48);
5287 }
5288 #endif
5289
5290 DEFINE_GEN(gen_op_store_double_F0_T1_T2,void,(void))
5291 #ifdef DYNGEN_IMPL
5292 #define HAVE_gen_op_store_double_F0_T1_T2
5293 {
5294 static const uint8 op_store_double_F0_T1_T2_code[] = {
5295 0x8d, 0x14, 0x3e, 0x8b, 0x43, 0x04, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00,
5296 0x00, 0x11, 0x8b, 0x03, 0x0f, 0xc8, 0x89, 0x82, 0x04, 0x00, 0x00, 0x11
5297 };
5298 copy_block(op_store_double_F0_T1_T2_code, 24);
5299 inc_code_ptr(24);
5300 }
5301 #endif
5302
5303 DEFINE_GEN(gen_op_store_single_F0_T1_T2,void,(void))
5304 #ifdef DYNGEN_IMPL
5305 #define HAVE_gen_op_store_single_F0_T1_T2
5306 {
5307 static const uint8 op_store_single_F0_T1_T2_code[] = {
5308 0x83, 0xec, 0x18, 0x8d, 0x0c, 0x3e, 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89,
5309 0x44, 0x24, 0x0c, 0x89, 0xd0, 0xc1, 0xe8, 0x14, 0x89, 0x54, 0x24, 0x10,
5310 0x25, 0xff, 0x07, 0x00, 0x00, 0x2d, 0x6a, 0x03, 0x00, 0x00, 0x83, 0xf8,
5311 0x16, 0x76, 0x39, 0x8b, 0x54, 0x24, 0x10, 0x89, 0xd0, 0x25, 0x00, 0x00,
5312 0x00, 0xc0, 0x89, 0x04, 0x24, 0x8b, 0x54, 0x24, 0x10, 0x8b, 0x44, 0x24,
5313 0x0c, 0x0f, 0xac, 0xd0, 0x1d, 0xc1, 0xea, 0x1d, 0x89, 0x44, 0x24, 0x0c,
5314 0x8b, 0x44, 0x24, 0x0c, 0x89, 0x54, 0x24, 0x10, 0x25, 0xff, 0xff, 0xff,
5315 0x3f, 0x09, 0x04, 0x24, 0xeb, 0x25, 0x8d, 0xb6, 0x00, 0x00, 0x00, 0x00,
5316 0x8b, 0x44, 0x24, 0x0c, 0x8b, 0x54, 0x24, 0x10, 0x89, 0x44, 0x24, 0x04,
5317 0x89, 0x54, 0x24, 0x08, 0xdd, 0x44, 0x24, 0x04, 0xd9, 0x5c, 0x24, 0x14,
5318 0x8b, 0x44, 0x24, 0x14, 0x89, 0x04, 0x24, 0x8b, 0x04, 0x24, 0x0f, 0xc8,
5319 0x89, 0x81, 0x00, 0x00, 0x00, 0x11, 0x83, 0xc4, 0x18
5320 };
5321 copy_block(op_store_single_F0_T1_T2_code, 141);
5322 inc_code_ptr(141);
5323 }
5324 #endif
5325
5326 DEFINE_GEN(gen_op_lwarx_T0_T1,void,(void))
5327 #ifdef DYNGEN_IMPL
5328 #define HAVE_gen_op_lwarx_T0_T1
5329 {
5330 static const uint8 op_lwarx_T0_T1_code[] = {
5331 0x8b, 0x86, 0x00, 0x00, 0x00, 0x11, 0x89, 0xc3, 0x0f, 0xcb, 0x89, 0xb5,
5332 0xbc, 0x03, 0x00, 0x00, 0xb8, 0x01, 0x00, 0x00, 0x00, 0x89, 0x85, 0xb8,
5333 0x03, 0x00, 0x00
5334 };
5335 copy_block(op_lwarx_T0_T1_code, 27);
5336 inc_code_ptr(27);
5337 }
5338 #endif
5339
5340 DEFINE_GEN(gen_op_stwcx_T0_T1,void,(void))
5341 #ifdef DYNGEN_IMPL
5342 #define HAVE_gen_op_stwcx_T0_T1
5343 {
5344 static const uint8 op_stwcx_T0_T1_code[] = {
5345 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x8b, 0x8d, 0x90, 0x03, 0x00,
5346 0x00, 0xc1, 0xe0, 0x1c, 0x81, 0xe1, 0xff, 0xff, 0xff, 0x0f, 0x09, 0xc1,
5347 0x8d, 0x45, 0x10, 0x8b, 0x90, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xd2, 0x74,
5348 0x2b, 0x31, 0xd2, 0x39, 0xb0, 0xac, 0x03, 0x00, 0x00, 0x89, 0x90, 0xa8,
5349 0x03, 0x00, 0x00, 0x75, 0x1b, 0x89, 0xd8, 0x0f, 0xc8, 0x89, 0x86, 0x00,
5350 0x00, 0x00, 0x11, 0x81, 0xc9, 0x00, 0x00, 0x00, 0x20, 0x8d, 0x74, 0x26,
5351 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x89, 0x8d, 0x90, 0x03,
5352 0x00, 0x00
5353 };
5354 copy_block(op_stwcx_T0_T1_code, 86);
5355 inc_code_ptr(86);
5356 }
5357 #endif
5358
5359 DEFINE_GEN(gen_op_load_T0_CR,void,(void))
5360 #ifdef DYNGEN_IMPL
5361 #define HAVE_gen_op_load_T0_CR
5362 {
5363 static const uint8 op_load_T0_CR_code[] = {
5364 0x8b, 0x9d, 0x90, 0x03, 0x00, 0x00
5365 };
5366 copy_block(op_load_T0_CR_code, 6);
5367 inc_code_ptr(6);
5368 }
5369 #endif
5370
5371 DEFINE_GEN(gen_op_store_T0_CR,void,(void))
5372 #ifdef DYNGEN_IMPL
5373 #define HAVE_gen_op_store_T0_CR
5374 {
5375 static const uint8 op_store_T0_CR_code[] = {
5376 0x89, 0x9d, 0x90, 0x03, 0x00, 0x00
5377 };
5378 copy_block(op_store_T0_CR_code, 6);
5379 inc_code_ptr(6);
5380 }
5381 #endif
5382
5383 DEFINE_GEN(gen_op_load_T0_crb0,void,(void))
5384 #ifdef DYNGEN_IMPL
5385 #define HAVE_gen_op_load_T0_crb0
5386 {
5387 static const uint8 op_load_T0_crb0_code[] = {
5388 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xc3, 0xc1, 0xeb, 0x1f
5389 };
5390 copy_block(op_load_T0_crb0_code, 11);
5391 inc_code_ptr(11);
5392 }
5393 #endif
5394
5395 DEFINE_GEN(gen_op_store_T0_crb0,void,(void))
5396 #ifdef DYNGEN_IMPL
5397 #define HAVE_gen_op_store_T0_crb0
5398 {
5399 static const uint8 op_store_T0_crb0_code[] = {
5400 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xda, 0xc1, 0xe2, 0x1f, 0x25,
5401 0xff, 0xff, 0xff, 0x7f, 0x09, 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00
5402 };
5403 copy_block(op_store_T0_crb0_code, 24);
5404 inc_code_ptr(24);
5405 }
5406 #endif
5407
5408 DEFINE_GEN(gen_op_load_T1_crb0,void,(void))
5409 #ifdef DYNGEN_IMPL
5410 #define HAVE_gen_op_load_T1_crb0
5411 {
5412 static const uint8 op_load_T1_crb0_code[] = {
5413 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xc6, 0xc1, 0xee, 0x1f
5414 };
5415 copy_block(op_load_T1_crb0_code, 11);
5416 inc_code_ptr(11);
5417 }
5418 #endif
5419
5420 DEFINE_GEN(gen_op_store_T1_crb0,void,(void))
5421 #ifdef DYNGEN_IMPL
5422 #define HAVE_gen_op_store_T1_crb0
5423 {
5424 static const uint8 op_store_T1_crb0_code[] = {
5425 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf2, 0xc1, 0xe2, 0x1f, 0x25,
5426 0xff, 0xff, 0xff, 0x7f, 0x09, 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00
5427 };
5428 copy_block(op_store_T1_crb0_code, 24);
5429 inc_code_ptr(24);
5430 }
5431 #endif
5432
5433 DEFINE_GEN(gen_op_load_T0_crb1,void,(void))
5434 #ifdef DYNGEN_IMPL
5435 #define HAVE_gen_op_load_T0_crb1
5436 {
5437 static const uint8 op_load_T0_crb1_code[] = {
5438 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1e, 0x89, 0xc3, 0x83,
5439 0xe3, 0x01
5440 };
5441 copy_block(op_load_T0_crb1_code, 14);
5442 inc_code_ptr(14);
5443 }
5444 #endif
5445
5446 DEFINE_GEN(gen_op_store_T0_crb1,void,(void))
5447 #ifdef DYNGEN_IMPL
5448 #define HAVE_gen_op_store_T0_crb1
5449 {
5450 static const uint8 op_store_T0_crb1_code[] = {
5451 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5452 0xe0, 0x1e, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xbf, 0x09, 0xc2, 0x89, 0x95,
5453 0x90, 0x03, 0x00, 0x00
5454 };
5455 copy_block(op_store_T0_crb1_code, 28);
5456 inc_code_ptr(28);
5457 }
5458 #endif
5459
5460 DEFINE_GEN(gen_op_load_T1_crb1,void,(void))
5461 #ifdef DYNGEN_IMPL
5462 #define HAVE_gen_op_load_T1_crb1
5463 {
5464 static const uint8 op_load_T1_crb1_code[] = {
5465 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1e, 0x89, 0xc6, 0x83,
5466 0xe6, 0x01
5467 };
5468 copy_block(op_load_T1_crb1_code, 14);
5469 inc_code_ptr(14);
5470 }
5471 #endif
5472
5473 DEFINE_GEN(gen_op_store_T1_crb1,void,(void))
5474 #ifdef DYNGEN_IMPL
5475 #define HAVE_gen_op_store_T1_crb1
5476 {
5477 static const uint8 op_store_T1_crb1_code[] = {
5478 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5479 0xe0, 0x1e, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xbf, 0x09, 0xc2, 0x89, 0x95,
5480 0x90, 0x03, 0x00, 0x00
5481 };
5482 copy_block(op_store_T1_crb1_code, 28);
5483 inc_code_ptr(28);
5484 }
5485 #endif
5486
5487 DEFINE_GEN(gen_op_load_T0_crb2,void,(void))
5488 #ifdef DYNGEN_IMPL
5489 #define HAVE_gen_op_load_T0_crb2
5490 {
5491 static const uint8 op_load_T0_crb2_code[] = {
5492 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1d, 0x89, 0xc3, 0x83,
5493 0xe3, 0x01
5494 };
5495 copy_block(op_load_T0_crb2_code, 14);
5496 inc_code_ptr(14);
5497 }
5498 #endif
5499
5500 DEFINE_GEN(gen_op_store_T0_crb2,void,(void))
5501 #ifdef DYNGEN_IMPL
5502 #define HAVE_gen_op_store_T0_crb2
5503 {
5504 static const uint8 op_store_T0_crb2_code[] = {
5505 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5506 0xe0, 0x1d, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xdf, 0x09, 0xc2, 0x89, 0x95,
5507 0x90, 0x03, 0x00, 0x00
5508 };
5509 copy_block(op_store_T0_crb2_code, 28);
5510 inc_code_ptr(28);
5511 }
5512 #endif
5513
5514 DEFINE_GEN(gen_op_load_T1_crb2,void,(void))
5515 #ifdef DYNGEN_IMPL
5516 #define HAVE_gen_op_load_T1_crb2
5517 {
5518 static const uint8 op_load_T1_crb2_code[] = {
5519 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1d, 0x89, 0xc6, 0x83,
5520 0xe6, 0x01
5521 };
5522 copy_block(op_load_T1_crb2_code, 14);
5523 inc_code_ptr(14);
5524 }
5525 #endif
5526
5527 DEFINE_GEN(gen_op_store_T1_crb2,void,(void))
5528 #ifdef DYNGEN_IMPL
5529 #define HAVE_gen_op_store_T1_crb2
5530 {
5531 static const uint8 op_store_T1_crb2_code[] = {
5532 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5533 0xe0, 0x1d, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xdf, 0x09, 0xc2, 0x89, 0x95,
5534 0x90, 0x03, 0x00, 0x00
5535 };
5536 copy_block(op_store_T1_crb2_code, 28);
5537 inc_code_ptr(28);
5538 }
5539 #endif
5540
5541 DEFINE_GEN(gen_op_load_T0_crb3,void,(void))
5542 #ifdef DYNGEN_IMPL
5543 #define HAVE_gen_op_load_T0_crb3
5544 {
5545 static const uint8 op_load_T0_crb3_code[] = {
5546 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1c, 0x89, 0xc3, 0x83,
5547 0xe3, 0x01
5548 };
5549 copy_block(op_load_T0_crb3_code, 14);
5550 inc_code_ptr(14);
5551 }
5552 #endif
5553
5554 DEFINE_GEN(gen_op_store_T0_crb3,void,(void))
5555 #ifdef DYNGEN_IMPL
5556 #define HAVE_gen_op_store_T0_crb3
5557 {
5558 static const uint8 op_store_T0_crb3_code[] = {
5559 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5560 0xe0, 0x1c, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xef, 0x09, 0xc2, 0x89, 0x95,
5561 0x90, 0x03, 0x00, 0x00
5562 };
5563 copy_block(op_store_T0_crb3_code, 28);
5564 inc_code_ptr(28);
5565 }
5566 #endif
5567
5568 DEFINE_GEN(gen_op_load_T1_crb3,void,(void))
5569 #ifdef DYNGEN_IMPL
5570 #define HAVE_gen_op_load_T1_crb3
5571 {
5572 static const uint8 op_load_T1_crb3_code[] = {
5573 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1c, 0x89, 0xc6, 0x83,
5574 0xe6, 0x01
5575 };
5576 copy_block(op_load_T1_crb3_code, 14);
5577 inc_code_ptr(14);
5578 }
5579 #endif
5580
5581 DEFINE_GEN(gen_op_store_T1_crb3,void,(void))
5582 #ifdef DYNGEN_IMPL
5583 #define HAVE_gen_op_store_T1_crb3
5584 {
5585 static const uint8 op_store_T1_crb3_code[] = {
5586 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5587 0xe0, 0x1c, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xef, 0x09, 0xc2, 0x89, 0x95,
5588 0x90, 0x03, 0x00, 0x00
5589 };
5590 copy_block(op_store_T1_crb3_code, 28);
5591 inc_code_ptr(28);
5592 }
5593 #endif
5594
5595 DEFINE_GEN(gen_op_load_T0_crb4,void,(void))
5596 #ifdef DYNGEN_IMPL
5597 #define HAVE_gen_op_load_T0_crb4
5598 {
5599 static const uint8 op_load_T0_crb4_code[] = {
5600 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1b, 0x89, 0xc3, 0x83,
5601 0xe3, 0x01
5602 };
5603 copy_block(op_load_T0_crb4_code, 14);
5604 inc_code_ptr(14);
5605 }
5606 #endif
5607
5608 DEFINE_GEN(gen_op_store_T0_crb4,void,(void))
5609 #ifdef DYNGEN_IMPL
5610 #define HAVE_gen_op_store_T0_crb4
5611 {
5612 static const uint8 op_store_T0_crb4_code[] = {
5613 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5614 0xe0, 0x1b, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xf7, 0x09, 0xc2, 0x89, 0x95,
5615 0x90, 0x03, 0x00, 0x00
5616 };
5617 copy_block(op_store_T0_crb4_code, 28);
5618 inc_code_ptr(28);
5619 }
5620 #endif
5621
5622 DEFINE_GEN(gen_op_load_T1_crb4,void,(void))
5623 #ifdef DYNGEN_IMPL
5624 #define HAVE_gen_op_load_T1_crb4
5625 {
5626 static const uint8 op_load_T1_crb4_code[] = {
5627 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1b, 0x89, 0xc6, 0x83,
5628 0xe6, 0x01
5629 };
5630 copy_block(op_load_T1_crb4_code, 14);
5631 inc_code_ptr(14);
5632 }
5633 #endif
5634
5635 DEFINE_GEN(gen_op_store_T1_crb4,void,(void))
5636 #ifdef DYNGEN_IMPL
5637 #define HAVE_gen_op_store_T1_crb4
5638 {
5639 static const uint8 op_store_T1_crb4_code[] = {
5640 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5641 0xe0, 0x1b, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xf7, 0x09, 0xc2, 0x89, 0x95,
5642 0x90, 0x03, 0x00, 0x00
5643 };
5644 copy_block(op_store_T1_crb4_code, 28);
5645 inc_code_ptr(28);
5646 }
5647 #endif
5648
5649 DEFINE_GEN(gen_op_load_T0_crb5,void,(void))
5650 #ifdef DYNGEN_IMPL
5651 #define HAVE_gen_op_load_T0_crb5
5652 {
5653 static const uint8 op_load_T0_crb5_code[] = {
5654 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1a, 0x89, 0xc3, 0x83,
5655 0xe3, 0x01
5656 };
5657 copy_block(op_load_T0_crb5_code, 14);
5658 inc_code_ptr(14);
5659 }
5660 #endif
5661
5662 DEFINE_GEN(gen_op_store_T0_crb5,void,(void))
5663 #ifdef DYNGEN_IMPL
5664 #define HAVE_gen_op_store_T0_crb5
5665 {
5666 static const uint8 op_store_T0_crb5_code[] = {
5667 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5668 0xe0, 0x1a, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfb, 0x09, 0xc2, 0x89, 0x95,
5669 0x90, 0x03, 0x00, 0x00
5670 };
5671 copy_block(op_store_T0_crb5_code, 28);
5672 inc_code_ptr(28);
5673 }
5674 #endif
5675
5676 DEFINE_GEN(gen_op_load_T1_crb5,void,(void))
5677 #ifdef DYNGEN_IMPL
5678 #define HAVE_gen_op_load_T1_crb5
5679 {
5680 static const uint8 op_load_T1_crb5_code[] = {
5681 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x1a, 0x89, 0xc6, 0x83,
5682 0xe6, 0x01
5683 };
5684 copy_block(op_load_T1_crb5_code, 14);
5685 inc_code_ptr(14);
5686 }
5687 #endif
5688
5689 DEFINE_GEN(gen_op_store_T1_crb5,void,(void))
5690 #ifdef DYNGEN_IMPL
5691 #define HAVE_gen_op_store_T1_crb5
5692 {
5693 static const uint8 op_store_T1_crb5_code[] = {
5694 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5695 0xe0, 0x1a, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfb, 0x09, 0xc2, 0x89, 0x95,
5696 0x90, 0x03, 0x00, 0x00
5697 };
5698 copy_block(op_store_T1_crb5_code, 28);
5699 inc_code_ptr(28);
5700 }
5701 #endif
5702
5703 DEFINE_GEN(gen_op_load_T0_crb6,void,(void))
5704 #ifdef DYNGEN_IMPL
5705 #define HAVE_gen_op_load_T0_crb6
5706 {
5707 static const uint8 op_load_T0_crb6_code[] = {
5708 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x19, 0x89, 0xc3, 0x83,
5709 0xe3, 0x01
5710 };
5711 copy_block(op_load_T0_crb6_code, 14);
5712 inc_code_ptr(14);
5713 }
5714 #endif
5715
5716 DEFINE_GEN(gen_op_store_T0_crb6,void,(void))
5717 #ifdef DYNGEN_IMPL
5718 #define HAVE_gen_op_store_T0_crb6
5719 {
5720 static const uint8 op_store_T0_crb6_code[] = {
5721 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5722 0xe0, 0x19, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfd, 0x09, 0xc2, 0x89, 0x95,
5723 0x90, 0x03, 0x00, 0x00
5724 };
5725 copy_block(op_store_T0_crb6_code, 28);
5726 inc_code_ptr(28);
5727 }
5728 #endif
5729
5730 DEFINE_GEN(gen_op_load_T1_crb6,void,(void))
5731 #ifdef DYNGEN_IMPL
5732 #define HAVE_gen_op_load_T1_crb6
5733 {
5734 static const uint8 op_load_T1_crb6_code[] = {
5735 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x19, 0x89, 0xc6, 0x83,
5736 0xe6, 0x01
5737 };
5738 copy_block(op_load_T1_crb6_code, 14);
5739 inc_code_ptr(14);
5740 }
5741 #endif
5742
5743 DEFINE_GEN(gen_op_store_T1_crb6,void,(void))
5744 #ifdef DYNGEN_IMPL
5745 #define HAVE_gen_op_store_T1_crb6
5746 {
5747 static const uint8 op_store_T1_crb6_code[] = {
5748 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5749 0xe0, 0x19, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfd, 0x09, 0xc2, 0x89, 0x95,
5750 0x90, 0x03, 0x00, 0x00
5751 };
5752 copy_block(op_store_T1_crb6_code, 28);
5753 inc_code_ptr(28);
5754 }
5755 #endif
5756
5757 DEFINE_GEN(gen_op_load_T0_crb7,void,(void))
5758 #ifdef DYNGEN_IMPL
5759 #define HAVE_gen_op_load_T0_crb7
5760 {
5761 static const uint8 op_load_T0_crb7_code[] = {
5762 0x0f, 0xb6, 0x85, 0x93, 0x03, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xe3, 0x01
5763 };
5764 copy_block(op_load_T0_crb7_code, 12);
5765 inc_code_ptr(12);
5766 }
5767 #endif
5768
5769 DEFINE_GEN(gen_op_store_T0_crb7,void,(void))
5770 #ifdef DYNGEN_IMPL
5771 #define HAVE_gen_op_store_T0_crb7
5772 {
5773 static const uint8 op_store_T0_crb7_code[] = {
5774 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5775 0xe0, 0x18, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfe, 0x09, 0xc2, 0x89, 0x95,
5776 0x90, 0x03, 0x00, 0x00
5777 };
5778 copy_block(op_store_T0_crb7_code, 28);
5779 inc_code_ptr(28);
5780 }
5781 #endif
5782
5783 DEFINE_GEN(gen_op_load_T1_crb7,void,(void))
5784 #ifdef DYNGEN_IMPL
5785 #define HAVE_gen_op_load_T1_crb7
5786 {
5787 static const uint8 op_load_T1_crb7_code[] = {
5788 0x0f, 0xb6, 0x85, 0x93, 0x03, 0x00, 0x00, 0x89, 0xc6, 0x83, 0xe6, 0x01
5789 };
5790 copy_block(op_load_T1_crb7_code, 12);
5791 inc_code_ptr(12);
5792 }
5793 #endif
5794
5795 DEFINE_GEN(gen_op_store_T1_crb7,void,(void))
5796 #ifdef DYNGEN_IMPL
5797 #define HAVE_gen_op_store_T1_crb7
5798 {
5799 static const uint8 op_store_T1_crb7_code[] = {
5800 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5801 0xe0, 0x18, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xfe, 0x09, 0xc2, 0x89, 0x95,
5802 0x90, 0x03, 0x00, 0x00
5803 };
5804 copy_block(op_store_T1_crb7_code, 28);
5805 inc_code_ptr(28);
5806 }
5807 #endif
5808
5809 DEFINE_GEN(gen_op_load_T0_crb8,void,(void))
5810 #ifdef DYNGEN_IMPL
5811 #define HAVE_gen_op_load_T0_crb8
5812 {
5813 static const uint8 op_load_T0_crb8_code[] = {
5814 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x17, 0x89, 0xc3, 0x83,
5815 0xe3, 0x01
5816 };
5817 copy_block(op_load_T0_crb8_code, 14);
5818 inc_code_ptr(14);
5819 }
5820 #endif
5821
5822 DEFINE_GEN(gen_op_store_T0_crb8,void,(void))
5823 #ifdef DYNGEN_IMPL
5824 #define HAVE_gen_op_store_T0_crb8
5825 {
5826 static const uint8 op_store_T0_crb8_code[] = {
5827 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5828 0xe0, 0x17, 0x81, 0xe2, 0xff, 0xff, 0x7f, 0xff, 0x09, 0xc2, 0x89, 0x95,
5829 0x90, 0x03, 0x00, 0x00
5830 };
5831 copy_block(op_store_T0_crb8_code, 28);
5832 inc_code_ptr(28);
5833 }
5834 #endif
5835
5836 DEFINE_GEN(gen_op_load_T1_crb8,void,(void))
5837 #ifdef DYNGEN_IMPL
5838 #define HAVE_gen_op_load_T1_crb8
5839 {
5840 static const uint8 op_load_T1_crb8_code[] = {
5841 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x17, 0x89, 0xc6, 0x83,
5842 0xe6, 0x01
5843 };
5844 copy_block(op_load_T1_crb8_code, 14);
5845 inc_code_ptr(14);
5846 }
5847 #endif
5848
5849 DEFINE_GEN(gen_op_store_T1_crb8,void,(void))
5850 #ifdef DYNGEN_IMPL
5851 #define HAVE_gen_op_store_T1_crb8
5852 {
5853 static const uint8 op_store_T1_crb8_code[] = {
5854 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5855 0xe0, 0x17, 0x81, 0xe2, 0xff, 0xff, 0x7f, 0xff, 0x09, 0xc2, 0x89, 0x95,
5856 0x90, 0x03, 0x00, 0x00
5857 };
5858 copy_block(op_store_T1_crb8_code, 28);
5859 inc_code_ptr(28);
5860 }
5861 #endif
5862
5863 DEFINE_GEN(gen_op_load_T0_crb9,void,(void))
5864 #ifdef DYNGEN_IMPL
5865 #define HAVE_gen_op_load_T0_crb9
5866 {
5867 static const uint8 op_load_T0_crb9_code[] = {
5868 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x16, 0x89, 0xc3, 0x83,
5869 0xe3, 0x01
5870 };
5871 copy_block(op_load_T0_crb9_code, 14);
5872 inc_code_ptr(14);
5873 }
5874 #endif
5875
5876 DEFINE_GEN(gen_op_store_T0_crb9,void,(void))
5877 #ifdef DYNGEN_IMPL
5878 #define HAVE_gen_op_store_T0_crb9
5879 {
5880 static const uint8 op_store_T0_crb9_code[] = {
5881 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5882 0xe0, 0x16, 0x81, 0xe2, 0xff, 0xff, 0xbf, 0xff, 0x09, 0xc2, 0x89, 0x95,
5883 0x90, 0x03, 0x00, 0x00
5884 };
5885 copy_block(op_store_T0_crb9_code, 28);
5886 inc_code_ptr(28);
5887 }
5888 #endif
5889
5890 DEFINE_GEN(gen_op_load_T1_crb9,void,(void))
5891 #ifdef DYNGEN_IMPL
5892 #define HAVE_gen_op_load_T1_crb9
5893 {
5894 static const uint8 op_load_T1_crb9_code[] = {
5895 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x16, 0x89, 0xc6, 0x83,
5896 0xe6, 0x01
5897 };
5898 copy_block(op_load_T1_crb9_code, 14);
5899 inc_code_ptr(14);
5900 }
5901 #endif
5902
5903 DEFINE_GEN(gen_op_store_T1_crb9,void,(void))
5904 #ifdef DYNGEN_IMPL
5905 #define HAVE_gen_op_store_T1_crb9
5906 {
5907 static const uint8 op_store_T1_crb9_code[] = {
5908 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5909 0xe0, 0x16, 0x81, 0xe2, 0xff, 0xff, 0xbf, 0xff, 0x09, 0xc2, 0x89, 0x95,
5910 0x90, 0x03, 0x00, 0x00
5911 };
5912 copy_block(op_store_T1_crb9_code, 28);
5913 inc_code_ptr(28);
5914 }
5915 #endif
5916
5917 DEFINE_GEN(gen_op_load_T0_crb10,void,(void))
5918 #ifdef DYNGEN_IMPL
5919 #define HAVE_gen_op_load_T0_crb10
5920 {
5921 static const uint8 op_load_T0_crb10_code[] = {
5922 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x15, 0x89, 0xc3, 0x83,
5923 0xe3, 0x01
5924 };
5925 copy_block(op_load_T0_crb10_code, 14);
5926 inc_code_ptr(14);
5927 }
5928 #endif
5929
5930 DEFINE_GEN(gen_op_store_T0_crb10,void,(void))
5931 #ifdef DYNGEN_IMPL
5932 #define HAVE_gen_op_store_T0_crb10
5933 {
5934 static const uint8 op_store_T0_crb10_code[] = {
5935 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5936 0xe0, 0x15, 0x81, 0xe2, 0xff, 0xff, 0xdf, 0xff, 0x09, 0xc2, 0x89, 0x95,
5937 0x90, 0x03, 0x00, 0x00
5938 };
5939 copy_block(op_store_T0_crb10_code, 28);
5940 inc_code_ptr(28);
5941 }
5942 #endif
5943
5944 DEFINE_GEN(gen_op_load_T1_crb10,void,(void))
5945 #ifdef DYNGEN_IMPL
5946 #define HAVE_gen_op_load_T1_crb10
5947 {
5948 static const uint8 op_load_T1_crb10_code[] = {
5949 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x15, 0x89, 0xc6, 0x83,
5950 0xe6, 0x01
5951 };
5952 copy_block(op_load_T1_crb10_code, 14);
5953 inc_code_ptr(14);
5954 }
5955 #endif
5956
5957 DEFINE_GEN(gen_op_store_T1_crb10,void,(void))
5958 #ifdef DYNGEN_IMPL
5959 #define HAVE_gen_op_store_T1_crb10
5960 {
5961 static const uint8 op_store_T1_crb10_code[] = {
5962 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
5963 0xe0, 0x15, 0x81, 0xe2, 0xff, 0xff, 0xdf, 0xff, 0x09, 0xc2, 0x89, 0x95,
5964 0x90, 0x03, 0x00, 0x00
5965 };
5966 copy_block(op_store_T1_crb10_code, 28);
5967 inc_code_ptr(28);
5968 }
5969 #endif
5970
5971 DEFINE_GEN(gen_op_load_T0_crb11,void,(void))
5972 #ifdef DYNGEN_IMPL
5973 #define HAVE_gen_op_load_T0_crb11
5974 {
5975 static const uint8 op_load_T0_crb11_code[] = {
5976 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x14, 0x89, 0xc3, 0x83,
5977 0xe3, 0x01
5978 };
5979 copy_block(op_load_T0_crb11_code, 14);
5980 inc_code_ptr(14);
5981 }
5982 #endif
5983
5984 DEFINE_GEN(gen_op_store_T0_crb11,void,(void))
5985 #ifdef DYNGEN_IMPL
5986 #define HAVE_gen_op_store_T0_crb11
5987 {
5988 static const uint8 op_store_T0_crb11_code[] = {
5989 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
5990 0xe0, 0x14, 0x81, 0xe2, 0xff, 0xff, 0xef, 0xff, 0x09, 0xc2, 0x89, 0x95,
5991 0x90, 0x03, 0x00, 0x00
5992 };
5993 copy_block(op_store_T0_crb11_code, 28);
5994 inc_code_ptr(28);
5995 }
5996 #endif
5997
5998 DEFINE_GEN(gen_op_load_T1_crb11,void,(void))
5999 #ifdef DYNGEN_IMPL
6000 #define HAVE_gen_op_load_T1_crb11
6001 {
6002 static const uint8 op_load_T1_crb11_code[] = {
6003 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x14, 0x89, 0xc6, 0x83,
6004 0xe6, 0x01
6005 };
6006 copy_block(op_load_T1_crb11_code, 14);
6007 inc_code_ptr(14);
6008 }
6009 #endif
6010
6011 DEFINE_GEN(gen_op_store_T1_crb11,void,(void))
6012 #ifdef DYNGEN_IMPL
6013 #define HAVE_gen_op_store_T1_crb11
6014 {
6015 static const uint8 op_store_T1_crb11_code[] = {
6016 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6017 0xe0, 0x14, 0x81, 0xe2, 0xff, 0xff, 0xef, 0xff, 0x09, 0xc2, 0x89, 0x95,
6018 0x90, 0x03, 0x00, 0x00
6019 };
6020 copy_block(op_store_T1_crb11_code, 28);
6021 inc_code_ptr(28);
6022 }
6023 #endif
6024
6025 DEFINE_GEN(gen_op_load_T0_crb12,void,(void))
6026 #ifdef DYNGEN_IMPL
6027 #define HAVE_gen_op_load_T0_crb12
6028 {
6029 static const uint8 op_load_T0_crb12_code[] = {
6030 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x13, 0x89, 0xc3, 0x83,
6031 0xe3, 0x01
6032 };
6033 copy_block(op_load_T0_crb12_code, 14);
6034 inc_code_ptr(14);
6035 }
6036 #endif
6037
6038 DEFINE_GEN(gen_op_store_T0_crb12,void,(void))
6039 #ifdef DYNGEN_IMPL
6040 #define HAVE_gen_op_store_T0_crb12
6041 {
6042 static const uint8 op_store_T0_crb12_code[] = {
6043 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6044 0xe0, 0x13, 0x81, 0xe2, 0xff, 0xff, 0xf7, 0xff, 0x09, 0xc2, 0x89, 0x95,
6045 0x90, 0x03, 0x00, 0x00
6046 };
6047 copy_block(op_store_T0_crb12_code, 28);
6048 inc_code_ptr(28);
6049 }
6050 #endif
6051
6052 DEFINE_GEN(gen_op_load_T1_crb12,void,(void))
6053 #ifdef DYNGEN_IMPL
6054 #define HAVE_gen_op_load_T1_crb12
6055 {
6056 static const uint8 op_load_T1_crb12_code[] = {
6057 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x13, 0x89, 0xc6, 0x83,
6058 0xe6, 0x01
6059 };
6060 copy_block(op_load_T1_crb12_code, 14);
6061 inc_code_ptr(14);
6062 }
6063 #endif
6064
6065 DEFINE_GEN(gen_op_store_T1_crb12,void,(void))
6066 #ifdef DYNGEN_IMPL
6067 #define HAVE_gen_op_store_T1_crb12
6068 {
6069 static const uint8 op_store_T1_crb12_code[] = {
6070 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6071 0xe0, 0x13, 0x81, 0xe2, 0xff, 0xff, 0xf7, 0xff, 0x09, 0xc2, 0x89, 0x95,
6072 0x90, 0x03, 0x00, 0x00
6073 };
6074 copy_block(op_store_T1_crb12_code, 28);
6075 inc_code_ptr(28);
6076 }
6077 #endif
6078
6079 DEFINE_GEN(gen_op_load_T0_crb13,void,(void))
6080 #ifdef DYNGEN_IMPL
6081 #define HAVE_gen_op_load_T0_crb13
6082 {
6083 static const uint8 op_load_T0_crb13_code[] = {
6084 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x12, 0x89, 0xc3, 0x83,
6085 0xe3, 0x01
6086 };
6087 copy_block(op_load_T0_crb13_code, 14);
6088 inc_code_ptr(14);
6089 }
6090 #endif
6091
6092 DEFINE_GEN(gen_op_store_T0_crb13,void,(void))
6093 #ifdef DYNGEN_IMPL
6094 #define HAVE_gen_op_store_T0_crb13
6095 {
6096 static const uint8 op_store_T0_crb13_code[] = {
6097 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6098 0xe0, 0x12, 0x81, 0xe2, 0xff, 0xff, 0xfb, 0xff, 0x09, 0xc2, 0x89, 0x95,
6099 0x90, 0x03, 0x00, 0x00
6100 };
6101 copy_block(op_store_T0_crb13_code, 28);
6102 inc_code_ptr(28);
6103 }
6104 #endif
6105
6106 DEFINE_GEN(gen_op_load_T1_crb13,void,(void))
6107 #ifdef DYNGEN_IMPL
6108 #define HAVE_gen_op_load_T1_crb13
6109 {
6110 static const uint8 op_load_T1_crb13_code[] = {
6111 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x12, 0x89, 0xc6, 0x83,
6112 0xe6, 0x01
6113 };
6114 copy_block(op_load_T1_crb13_code, 14);
6115 inc_code_ptr(14);
6116 }
6117 #endif
6118
6119 DEFINE_GEN(gen_op_store_T1_crb13,void,(void))
6120 #ifdef DYNGEN_IMPL
6121 #define HAVE_gen_op_store_T1_crb13
6122 {
6123 static const uint8 op_store_T1_crb13_code[] = {
6124 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6125 0xe0, 0x12, 0x81, 0xe2, 0xff, 0xff, 0xfb, 0xff, 0x09, 0xc2, 0x89, 0x95,
6126 0x90, 0x03, 0x00, 0x00
6127 };
6128 copy_block(op_store_T1_crb13_code, 28);
6129 inc_code_ptr(28);
6130 }
6131 #endif
6132
6133 DEFINE_GEN(gen_op_load_T0_crb14,void,(void))
6134 #ifdef DYNGEN_IMPL
6135 #define HAVE_gen_op_load_T0_crb14
6136 {
6137 static const uint8 op_load_T0_crb14_code[] = {
6138 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x11, 0x89, 0xc3, 0x83,
6139 0xe3, 0x01
6140 };
6141 copy_block(op_load_T0_crb14_code, 14);
6142 inc_code_ptr(14);
6143 }
6144 #endif
6145
6146 DEFINE_GEN(gen_op_store_T0_crb14,void,(void))
6147 #ifdef DYNGEN_IMPL
6148 #define HAVE_gen_op_store_T0_crb14
6149 {
6150 static const uint8 op_store_T0_crb14_code[] = {
6151 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6152 0xe0, 0x11, 0x81, 0xe2, 0xff, 0xff, 0xfd, 0xff, 0x09, 0xc2, 0x89, 0x95,
6153 0x90, 0x03, 0x00, 0x00
6154 };
6155 copy_block(op_store_T0_crb14_code, 28);
6156 inc_code_ptr(28);
6157 }
6158 #endif
6159
6160 DEFINE_GEN(gen_op_load_T1_crb14,void,(void))
6161 #ifdef DYNGEN_IMPL
6162 #define HAVE_gen_op_load_T1_crb14
6163 {
6164 static const uint8 op_load_T1_crb14_code[] = {
6165 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x11, 0x89, 0xc6, 0x83,
6166 0xe6, 0x01
6167 };
6168 copy_block(op_load_T1_crb14_code, 14);
6169 inc_code_ptr(14);
6170 }
6171 #endif
6172
6173 DEFINE_GEN(gen_op_store_T1_crb14,void,(void))
6174 #ifdef DYNGEN_IMPL
6175 #define HAVE_gen_op_store_T1_crb14
6176 {
6177 static const uint8 op_store_T1_crb14_code[] = {
6178 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6179 0xe0, 0x11, 0x81, 0xe2, 0xff, 0xff, 0xfd, 0xff, 0x09, 0xc2, 0x89, 0x95,
6180 0x90, 0x03, 0x00, 0x00
6181 };
6182 copy_block(op_store_T1_crb14_code, 28);
6183 inc_code_ptr(28);
6184 }
6185 #endif
6186
6187 DEFINE_GEN(gen_op_load_T0_crb15,void,(void))
6188 #ifdef DYNGEN_IMPL
6189 #define HAVE_gen_op_load_T0_crb15
6190 {
6191 static const uint8 op_load_T0_crb15_code[] = {
6192 0x0f, 0xb7, 0x85, 0x92, 0x03, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xe3, 0x01
6193 };
6194 copy_block(op_load_T0_crb15_code, 12);
6195 inc_code_ptr(12);
6196 }
6197 #endif
6198
6199 DEFINE_GEN(gen_op_store_T0_crb15,void,(void))
6200 #ifdef DYNGEN_IMPL
6201 #define HAVE_gen_op_store_T0_crb15
6202 {
6203 static const uint8 op_store_T0_crb15_code[] = {
6204 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6205 0xe0, 0x10, 0x81, 0xe2, 0xff, 0xff, 0xfe, 0xff, 0x09, 0xc2, 0x89, 0x95,
6206 0x90, 0x03, 0x00, 0x00
6207 };
6208 copy_block(op_store_T0_crb15_code, 28);
6209 inc_code_ptr(28);
6210 }
6211 #endif
6212
6213 DEFINE_GEN(gen_op_load_T1_crb15,void,(void))
6214 #ifdef DYNGEN_IMPL
6215 #define HAVE_gen_op_load_T1_crb15
6216 {
6217 static const uint8 op_load_T1_crb15_code[] = {
6218 0x0f, 0xb7, 0x85, 0x92, 0x03, 0x00, 0x00, 0x89, 0xc6, 0x83, 0xe6, 0x01
6219 };
6220 copy_block(op_load_T1_crb15_code, 12);
6221 inc_code_ptr(12);
6222 }
6223 #endif
6224
6225 DEFINE_GEN(gen_op_store_T1_crb15,void,(void))
6226 #ifdef DYNGEN_IMPL
6227 #define HAVE_gen_op_store_T1_crb15
6228 {
6229 static const uint8 op_store_T1_crb15_code[] = {
6230 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6231 0xe0, 0x10, 0x81, 0xe2, 0xff, 0xff, 0xfe, 0xff, 0x09, 0xc2, 0x89, 0x95,
6232 0x90, 0x03, 0x00, 0x00
6233 };
6234 copy_block(op_store_T1_crb15_code, 28);
6235 inc_code_ptr(28);
6236 }
6237 #endif
6238
6239 DEFINE_GEN(gen_op_load_T0_crb16,void,(void))
6240 #ifdef DYNGEN_IMPL
6241 #define HAVE_gen_op_load_T0_crb16
6242 {
6243 static const uint8 op_load_T0_crb16_code[] = {
6244 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0f, 0x89, 0xc3, 0x83,
6245 0xe3, 0x01
6246 };
6247 copy_block(op_load_T0_crb16_code, 14);
6248 inc_code_ptr(14);
6249 }
6250 #endif
6251
6252 DEFINE_GEN(gen_op_store_T0_crb16,void,(void))
6253 #ifdef DYNGEN_IMPL
6254 #define HAVE_gen_op_store_T0_crb16
6255 {
6256 static const uint8 op_store_T0_crb16_code[] = {
6257 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6258 0xe0, 0x0f, 0x81, 0xe2, 0xff, 0x7f, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6259 0x90, 0x03, 0x00, 0x00
6260 };
6261 copy_block(op_store_T0_crb16_code, 28);
6262 inc_code_ptr(28);
6263 }
6264 #endif
6265
6266 DEFINE_GEN(gen_op_load_T1_crb16,void,(void))
6267 #ifdef DYNGEN_IMPL
6268 #define HAVE_gen_op_load_T1_crb16
6269 {
6270 static const uint8 op_load_T1_crb16_code[] = {
6271 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0f, 0x89, 0xc6, 0x83,
6272 0xe6, 0x01
6273 };
6274 copy_block(op_load_T1_crb16_code, 14);
6275 inc_code_ptr(14);
6276 }
6277 #endif
6278
6279 DEFINE_GEN(gen_op_store_T1_crb16,void,(void))
6280 #ifdef DYNGEN_IMPL
6281 #define HAVE_gen_op_store_T1_crb16
6282 {
6283 static const uint8 op_store_T1_crb16_code[] = {
6284 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6285 0xe0, 0x0f, 0x81, 0xe2, 0xff, 0x7f, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6286 0x90, 0x03, 0x00, 0x00
6287 };
6288 copy_block(op_store_T1_crb16_code, 28);
6289 inc_code_ptr(28);
6290 }
6291 #endif
6292
6293 DEFINE_GEN(gen_op_load_T0_crb17,void,(void))
6294 #ifdef DYNGEN_IMPL
6295 #define HAVE_gen_op_load_T0_crb17
6296 {
6297 static const uint8 op_load_T0_crb17_code[] = {
6298 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0e, 0x89, 0xc3, 0x83,
6299 0xe3, 0x01
6300 };
6301 copy_block(op_load_T0_crb17_code, 14);
6302 inc_code_ptr(14);
6303 }
6304 #endif
6305
6306 DEFINE_GEN(gen_op_store_T0_crb17,void,(void))
6307 #ifdef DYNGEN_IMPL
6308 #define HAVE_gen_op_store_T0_crb17
6309 {
6310 static const uint8 op_store_T0_crb17_code[] = {
6311 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6312 0xe0, 0x0e, 0x81, 0xe2, 0xff, 0xbf, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6313 0x90, 0x03, 0x00, 0x00
6314 };
6315 copy_block(op_store_T0_crb17_code, 28);
6316 inc_code_ptr(28);
6317 }
6318 #endif
6319
6320 DEFINE_GEN(gen_op_load_T1_crb17,void,(void))
6321 #ifdef DYNGEN_IMPL
6322 #define HAVE_gen_op_load_T1_crb17
6323 {
6324 static const uint8 op_load_T1_crb17_code[] = {
6325 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0e, 0x89, 0xc6, 0x83,
6326 0xe6, 0x01
6327 };
6328 copy_block(op_load_T1_crb17_code, 14);
6329 inc_code_ptr(14);
6330 }
6331 #endif
6332
6333 DEFINE_GEN(gen_op_store_T1_crb17,void,(void))
6334 #ifdef DYNGEN_IMPL
6335 #define HAVE_gen_op_store_T1_crb17
6336 {
6337 static const uint8 op_store_T1_crb17_code[] = {
6338 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6339 0xe0, 0x0e, 0x81, 0xe2, 0xff, 0xbf, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6340 0x90, 0x03, 0x00, 0x00
6341 };
6342 copy_block(op_store_T1_crb17_code, 28);
6343 inc_code_ptr(28);
6344 }
6345 #endif
6346
6347 DEFINE_GEN(gen_op_load_T0_crb18,void,(void))
6348 #ifdef DYNGEN_IMPL
6349 #define HAVE_gen_op_load_T0_crb18
6350 {
6351 static const uint8 op_load_T0_crb18_code[] = {
6352 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0d, 0x89, 0xc3, 0x83,
6353 0xe3, 0x01
6354 };
6355 copy_block(op_load_T0_crb18_code, 14);
6356 inc_code_ptr(14);
6357 }
6358 #endif
6359
6360 DEFINE_GEN(gen_op_store_T0_crb18,void,(void))
6361 #ifdef DYNGEN_IMPL
6362 #define HAVE_gen_op_store_T0_crb18
6363 {
6364 static const uint8 op_store_T0_crb18_code[] = {
6365 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6366 0xe0, 0x0d, 0x81, 0xe2, 0xff, 0xdf, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6367 0x90, 0x03, 0x00, 0x00
6368 };
6369 copy_block(op_store_T0_crb18_code, 28);
6370 inc_code_ptr(28);
6371 }
6372 #endif
6373
6374 DEFINE_GEN(gen_op_load_T1_crb18,void,(void))
6375 #ifdef DYNGEN_IMPL
6376 #define HAVE_gen_op_load_T1_crb18
6377 {
6378 static const uint8 op_load_T1_crb18_code[] = {
6379 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0d, 0x89, 0xc6, 0x83,
6380 0xe6, 0x01
6381 };
6382 copy_block(op_load_T1_crb18_code, 14);
6383 inc_code_ptr(14);
6384 }
6385 #endif
6386
6387 DEFINE_GEN(gen_op_store_T1_crb18,void,(void))
6388 #ifdef DYNGEN_IMPL
6389 #define HAVE_gen_op_store_T1_crb18
6390 {
6391 static const uint8 op_store_T1_crb18_code[] = {
6392 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6393 0xe0, 0x0d, 0x81, 0xe2, 0xff, 0xdf, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6394 0x90, 0x03, 0x00, 0x00
6395 };
6396 copy_block(op_store_T1_crb18_code, 28);
6397 inc_code_ptr(28);
6398 }
6399 #endif
6400
6401 DEFINE_GEN(gen_op_load_T0_crb19,void,(void))
6402 #ifdef DYNGEN_IMPL
6403 #define HAVE_gen_op_load_T0_crb19
6404 {
6405 static const uint8 op_load_T0_crb19_code[] = {
6406 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0c, 0x89, 0xc3, 0x83,
6407 0xe3, 0x01
6408 };
6409 copy_block(op_load_T0_crb19_code, 14);
6410 inc_code_ptr(14);
6411 }
6412 #endif
6413
6414 DEFINE_GEN(gen_op_store_T0_crb19,void,(void))
6415 #ifdef DYNGEN_IMPL
6416 #define HAVE_gen_op_store_T0_crb19
6417 {
6418 static const uint8 op_store_T0_crb19_code[] = {
6419 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6420 0xe0, 0x0c, 0x81, 0xe2, 0xff, 0xef, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6421 0x90, 0x03, 0x00, 0x00
6422 };
6423 copy_block(op_store_T0_crb19_code, 28);
6424 inc_code_ptr(28);
6425 }
6426 #endif
6427
6428 DEFINE_GEN(gen_op_load_T1_crb19,void,(void))
6429 #ifdef DYNGEN_IMPL
6430 #define HAVE_gen_op_load_T1_crb19
6431 {
6432 static const uint8 op_load_T1_crb19_code[] = {
6433 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0c, 0x89, 0xc6, 0x83,
6434 0xe6, 0x01
6435 };
6436 copy_block(op_load_T1_crb19_code, 14);
6437 inc_code_ptr(14);
6438 }
6439 #endif
6440
6441 DEFINE_GEN(gen_op_store_T1_crb19,void,(void))
6442 #ifdef DYNGEN_IMPL
6443 #define HAVE_gen_op_store_T1_crb19
6444 {
6445 static const uint8 op_store_T1_crb19_code[] = {
6446 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6447 0xe0, 0x0c, 0x81, 0xe2, 0xff, 0xef, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6448 0x90, 0x03, 0x00, 0x00
6449 };
6450 copy_block(op_store_T1_crb19_code, 28);
6451 inc_code_ptr(28);
6452 }
6453 #endif
6454
6455 DEFINE_GEN(gen_op_load_T0_crb20,void,(void))
6456 #ifdef DYNGEN_IMPL
6457 #define HAVE_gen_op_load_T0_crb20
6458 {
6459 static const uint8 op_load_T0_crb20_code[] = {
6460 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0b, 0x89, 0xc3, 0x83,
6461 0xe3, 0x01
6462 };
6463 copy_block(op_load_T0_crb20_code, 14);
6464 inc_code_ptr(14);
6465 }
6466 #endif
6467
6468 DEFINE_GEN(gen_op_store_T0_crb20,void,(void))
6469 #ifdef DYNGEN_IMPL
6470 #define HAVE_gen_op_store_T0_crb20
6471 {
6472 static const uint8 op_store_T0_crb20_code[] = {
6473 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6474 0xe0, 0x0b, 0x81, 0xe2, 0xff, 0xf7, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6475 0x90, 0x03, 0x00, 0x00
6476 };
6477 copy_block(op_store_T0_crb20_code, 28);
6478 inc_code_ptr(28);
6479 }
6480 #endif
6481
6482 DEFINE_GEN(gen_op_load_T1_crb20,void,(void))
6483 #ifdef DYNGEN_IMPL
6484 #define HAVE_gen_op_load_T1_crb20
6485 {
6486 static const uint8 op_load_T1_crb20_code[] = {
6487 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0b, 0x89, 0xc6, 0x83,
6488 0xe6, 0x01
6489 };
6490 copy_block(op_load_T1_crb20_code, 14);
6491 inc_code_ptr(14);
6492 }
6493 #endif
6494
6495 DEFINE_GEN(gen_op_store_T1_crb20,void,(void))
6496 #ifdef DYNGEN_IMPL
6497 #define HAVE_gen_op_store_T1_crb20
6498 {
6499 static const uint8 op_store_T1_crb20_code[] = {
6500 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6501 0xe0, 0x0b, 0x81, 0xe2, 0xff, 0xf7, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6502 0x90, 0x03, 0x00, 0x00
6503 };
6504 copy_block(op_store_T1_crb20_code, 28);
6505 inc_code_ptr(28);
6506 }
6507 #endif
6508
6509 DEFINE_GEN(gen_op_load_T0_crb21,void,(void))
6510 #ifdef DYNGEN_IMPL
6511 #define HAVE_gen_op_load_T0_crb21
6512 {
6513 static const uint8 op_load_T0_crb21_code[] = {
6514 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0a, 0x89, 0xc3, 0x83,
6515 0xe3, 0x01
6516 };
6517 copy_block(op_load_T0_crb21_code, 14);
6518 inc_code_ptr(14);
6519 }
6520 #endif
6521
6522 DEFINE_GEN(gen_op_store_T0_crb21,void,(void))
6523 #ifdef DYNGEN_IMPL
6524 #define HAVE_gen_op_store_T0_crb21
6525 {
6526 static const uint8 op_store_T0_crb21_code[] = {
6527 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6528 0xe0, 0x0a, 0x81, 0xe2, 0xff, 0xfb, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6529 0x90, 0x03, 0x00, 0x00
6530 };
6531 copy_block(op_store_T0_crb21_code, 28);
6532 inc_code_ptr(28);
6533 }
6534 #endif
6535
6536 DEFINE_GEN(gen_op_load_T1_crb21,void,(void))
6537 #ifdef DYNGEN_IMPL
6538 #define HAVE_gen_op_load_T1_crb21
6539 {
6540 static const uint8 op_load_T1_crb21_code[] = {
6541 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0a, 0x89, 0xc6, 0x83,
6542 0xe6, 0x01
6543 };
6544 copy_block(op_load_T1_crb21_code, 14);
6545 inc_code_ptr(14);
6546 }
6547 #endif
6548
6549 DEFINE_GEN(gen_op_store_T1_crb21,void,(void))
6550 #ifdef DYNGEN_IMPL
6551 #define HAVE_gen_op_store_T1_crb21
6552 {
6553 static const uint8 op_store_T1_crb21_code[] = {
6554 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6555 0xe0, 0x0a, 0x81, 0xe2, 0xff, 0xfb, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6556 0x90, 0x03, 0x00, 0x00
6557 };
6558 copy_block(op_store_T1_crb21_code, 28);
6559 inc_code_ptr(28);
6560 }
6561 #endif
6562
6563 DEFINE_GEN(gen_op_load_T0_crb22,void,(void))
6564 #ifdef DYNGEN_IMPL
6565 #define HAVE_gen_op_load_T0_crb22
6566 {
6567 static const uint8 op_load_T0_crb22_code[] = {
6568 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x09, 0x89, 0xc3, 0x83,
6569 0xe3, 0x01
6570 };
6571 copy_block(op_load_T0_crb22_code, 14);
6572 inc_code_ptr(14);
6573 }
6574 #endif
6575
6576 DEFINE_GEN(gen_op_store_T0_crb22,void,(void))
6577 #ifdef DYNGEN_IMPL
6578 #define HAVE_gen_op_store_T0_crb22
6579 {
6580 static const uint8 op_store_T0_crb22_code[] = {
6581 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6582 0xe0, 0x09, 0x81, 0xe2, 0xff, 0xfd, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6583 0x90, 0x03, 0x00, 0x00
6584 };
6585 copy_block(op_store_T0_crb22_code, 28);
6586 inc_code_ptr(28);
6587 }
6588 #endif
6589
6590 DEFINE_GEN(gen_op_load_T1_crb22,void,(void))
6591 #ifdef DYNGEN_IMPL
6592 #define HAVE_gen_op_load_T1_crb22
6593 {
6594 static const uint8 op_load_T1_crb22_code[] = {
6595 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x09, 0x89, 0xc6, 0x83,
6596 0xe6, 0x01
6597 };
6598 copy_block(op_load_T1_crb22_code, 14);
6599 inc_code_ptr(14);
6600 }
6601 #endif
6602
6603 DEFINE_GEN(gen_op_store_T1_crb22,void,(void))
6604 #ifdef DYNGEN_IMPL
6605 #define HAVE_gen_op_store_T1_crb22
6606 {
6607 static const uint8 op_store_T1_crb22_code[] = {
6608 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6609 0xe0, 0x09, 0x81, 0xe2, 0xff, 0xfd, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6610 0x90, 0x03, 0x00, 0x00
6611 };
6612 copy_block(op_store_T1_crb22_code, 28);
6613 inc_code_ptr(28);
6614 }
6615 #endif
6616
6617 DEFINE_GEN(gen_op_load_T0_crb23,void,(void))
6618 #ifdef DYNGEN_IMPL
6619 #define HAVE_gen_op_load_T0_crb23
6620 {
6621 static const uint8 op_load_T0_crb23_code[] = {
6622 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x08, 0x89, 0xc3, 0x83,
6623 0xe3, 0x01
6624 };
6625 copy_block(op_load_T0_crb23_code, 14);
6626 inc_code_ptr(14);
6627 }
6628 #endif
6629
6630 DEFINE_GEN(gen_op_store_T0_crb23,void,(void))
6631 #ifdef DYNGEN_IMPL
6632 #define HAVE_gen_op_store_T0_crb23
6633 {
6634 static const uint8 op_store_T0_crb23_code[] = {
6635 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6636 0xe0, 0x08, 0x81, 0xe2, 0xff, 0xfe, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6637 0x90, 0x03, 0x00, 0x00
6638 };
6639 copy_block(op_store_T0_crb23_code, 28);
6640 inc_code_ptr(28);
6641 }
6642 #endif
6643
6644 DEFINE_GEN(gen_op_load_T1_crb23,void,(void))
6645 #ifdef DYNGEN_IMPL
6646 #define HAVE_gen_op_load_T1_crb23
6647 {
6648 static const uint8 op_load_T1_crb23_code[] = {
6649 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x08, 0x89, 0xc6, 0x83,
6650 0xe6, 0x01
6651 };
6652 copy_block(op_load_T1_crb23_code, 14);
6653 inc_code_ptr(14);
6654 }
6655 #endif
6656
6657 DEFINE_GEN(gen_op_store_T1_crb23,void,(void))
6658 #ifdef DYNGEN_IMPL
6659 #define HAVE_gen_op_store_T1_crb23
6660 {
6661 static const uint8 op_store_T1_crb23_code[] = {
6662 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6663 0xe0, 0x08, 0x81, 0xe2, 0xff, 0xfe, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6664 0x90, 0x03, 0x00, 0x00
6665 };
6666 copy_block(op_store_T1_crb23_code, 28);
6667 inc_code_ptr(28);
6668 }
6669 #endif
6670
6671 DEFINE_GEN(gen_op_load_T0_crb24,void,(void))
6672 #ifdef DYNGEN_IMPL
6673 #define HAVE_gen_op_load_T0_crb24
6674 {
6675 static const uint8 op_load_T0_crb24_code[] = {
6676 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x07, 0x89, 0xc3, 0x83,
6677 0xe3, 0x01
6678 };
6679 copy_block(op_load_T0_crb24_code, 14);
6680 inc_code_ptr(14);
6681 }
6682 #endif
6683
6684 DEFINE_GEN(gen_op_store_T0_crb24,void,(void))
6685 #ifdef DYNGEN_IMPL
6686 #define HAVE_gen_op_store_T0_crb24
6687 {
6688 static const uint8 op_store_T0_crb24_code[] = {
6689 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6690 0xe0, 0x07, 0x81, 0xe2, 0x7f, 0xff, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6691 0x90, 0x03, 0x00, 0x00
6692 };
6693 copy_block(op_store_T0_crb24_code, 28);
6694 inc_code_ptr(28);
6695 }
6696 #endif
6697
6698 DEFINE_GEN(gen_op_load_T1_crb24,void,(void))
6699 #ifdef DYNGEN_IMPL
6700 #define HAVE_gen_op_load_T1_crb24
6701 {
6702 static const uint8 op_load_T1_crb24_code[] = {
6703 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x07, 0x89, 0xc6, 0x83,
6704 0xe6, 0x01
6705 };
6706 copy_block(op_load_T1_crb24_code, 14);
6707 inc_code_ptr(14);
6708 }
6709 #endif
6710
6711 DEFINE_GEN(gen_op_store_T1_crb24,void,(void))
6712 #ifdef DYNGEN_IMPL
6713 #define HAVE_gen_op_store_T1_crb24
6714 {
6715 static const uint8 op_store_T1_crb24_code[] = {
6716 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6717 0xe0, 0x07, 0x81, 0xe2, 0x7f, 0xff, 0xff, 0xff, 0x09, 0xc2, 0x89, 0x95,
6718 0x90, 0x03, 0x00, 0x00
6719 };
6720 copy_block(op_store_T1_crb24_code, 28);
6721 inc_code_ptr(28);
6722 }
6723 #endif
6724
6725 DEFINE_GEN(gen_op_load_T0_crb25,void,(void))
6726 #ifdef DYNGEN_IMPL
6727 #define HAVE_gen_op_load_T0_crb25
6728 {
6729 static const uint8 op_load_T0_crb25_code[] = {
6730 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x06, 0x89, 0xc3, 0x83,
6731 0xe3, 0x01
6732 };
6733 copy_block(op_load_T0_crb25_code, 14);
6734 inc_code_ptr(14);
6735 }
6736 #endif
6737
6738 DEFINE_GEN(gen_op_store_T0_crb25,void,(void))
6739 #ifdef DYNGEN_IMPL
6740 #define HAVE_gen_op_store_T0_crb25
6741 {
6742 static const uint8 op_store_T0_crb25_code[] = {
6743 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6744 0xe0, 0x06, 0x83, 0xe2, 0xbf, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6745 0x00
6746 };
6747 copy_block(op_store_T0_crb25_code, 25);
6748 inc_code_ptr(25);
6749 }
6750 #endif
6751
6752 DEFINE_GEN(gen_op_load_T1_crb25,void,(void))
6753 #ifdef DYNGEN_IMPL
6754 #define HAVE_gen_op_load_T1_crb25
6755 {
6756 static const uint8 op_load_T1_crb25_code[] = {
6757 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x06, 0x89, 0xc6, 0x83,
6758 0xe6, 0x01
6759 };
6760 copy_block(op_load_T1_crb25_code, 14);
6761 inc_code_ptr(14);
6762 }
6763 #endif
6764
6765 DEFINE_GEN(gen_op_store_T1_crb25,void,(void))
6766 #ifdef DYNGEN_IMPL
6767 #define HAVE_gen_op_store_T1_crb25
6768 {
6769 static const uint8 op_store_T1_crb25_code[] = {
6770 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6771 0xe0, 0x06, 0x83, 0xe2, 0xbf, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6772 0x00
6773 };
6774 copy_block(op_store_T1_crb25_code, 25);
6775 inc_code_ptr(25);
6776 }
6777 #endif
6778
6779 DEFINE_GEN(gen_op_load_T0_crb26,void,(void))
6780 #ifdef DYNGEN_IMPL
6781 #define HAVE_gen_op_load_T0_crb26
6782 {
6783 static const uint8 op_load_T0_crb26_code[] = {
6784 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x05, 0x89, 0xc3, 0x83,
6785 0xe3, 0x01
6786 };
6787 copy_block(op_load_T0_crb26_code, 14);
6788 inc_code_ptr(14);
6789 }
6790 #endif
6791
6792 DEFINE_GEN(gen_op_store_T0_crb26,void,(void))
6793 #ifdef DYNGEN_IMPL
6794 #define HAVE_gen_op_store_T0_crb26
6795 {
6796 static const uint8 op_store_T0_crb26_code[] = {
6797 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6798 0xe0, 0x05, 0x83, 0xe2, 0xdf, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6799 0x00
6800 };
6801 copy_block(op_store_T0_crb26_code, 25);
6802 inc_code_ptr(25);
6803 }
6804 #endif
6805
6806 DEFINE_GEN(gen_op_load_T1_crb26,void,(void))
6807 #ifdef DYNGEN_IMPL
6808 #define HAVE_gen_op_load_T1_crb26
6809 {
6810 static const uint8 op_load_T1_crb26_code[] = {
6811 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x05, 0x89, 0xc6, 0x83,
6812 0xe6, 0x01
6813 };
6814 copy_block(op_load_T1_crb26_code, 14);
6815 inc_code_ptr(14);
6816 }
6817 #endif
6818
6819 DEFINE_GEN(gen_op_store_T1_crb26,void,(void))
6820 #ifdef DYNGEN_IMPL
6821 #define HAVE_gen_op_store_T1_crb26
6822 {
6823 static const uint8 op_store_T1_crb26_code[] = {
6824 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6825 0xe0, 0x05, 0x83, 0xe2, 0xdf, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6826 0x00
6827 };
6828 copy_block(op_store_T1_crb26_code, 25);
6829 inc_code_ptr(25);
6830 }
6831 #endif
6832
6833 DEFINE_GEN(gen_op_load_T0_crb27,void,(void))
6834 #ifdef DYNGEN_IMPL
6835 #define HAVE_gen_op_load_T0_crb27
6836 {
6837 static const uint8 op_load_T0_crb27_code[] = {
6838 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x04, 0x89, 0xc3, 0x83,
6839 0xe3, 0x01
6840 };
6841 copy_block(op_load_T0_crb27_code, 14);
6842 inc_code_ptr(14);
6843 }
6844 #endif
6845
6846 DEFINE_GEN(gen_op_store_T0_crb27,void,(void))
6847 #ifdef DYNGEN_IMPL
6848 #define HAVE_gen_op_store_T0_crb27
6849 {
6850 static const uint8 op_store_T0_crb27_code[] = {
6851 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6852 0xe0, 0x04, 0x83, 0xe2, 0xef, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6853 0x00
6854 };
6855 copy_block(op_store_T0_crb27_code, 25);
6856 inc_code_ptr(25);
6857 }
6858 #endif
6859
6860 DEFINE_GEN(gen_op_load_T1_crb27,void,(void))
6861 #ifdef DYNGEN_IMPL
6862 #define HAVE_gen_op_load_T1_crb27
6863 {
6864 static const uint8 op_load_T1_crb27_code[] = {
6865 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x04, 0x89, 0xc6, 0x83,
6866 0xe6, 0x01
6867 };
6868 copy_block(op_load_T1_crb27_code, 14);
6869 inc_code_ptr(14);
6870 }
6871 #endif
6872
6873 DEFINE_GEN(gen_op_store_T1_crb27,void,(void))
6874 #ifdef DYNGEN_IMPL
6875 #define HAVE_gen_op_store_T1_crb27
6876 {
6877 static const uint8 op_store_T1_crb27_code[] = {
6878 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6879 0xe0, 0x04, 0x83, 0xe2, 0xef, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6880 0x00
6881 };
6882 copy_block(op_store_T1_crb27_code, 25);
6883 inc_code_ptr(25);
6884 }
6885 #endif
6886
6887 DEFINE_GEN(gen_op_load_T0_crb28,void,(void))
6888 #ifdef DYNGEN_IMPL
6889 #define HAVE_gen_op_load_T0_crb28
6890 {
6891 static const uint8 op_load_T0_crb28_code[] = {
6892 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x03, 0x89, 0xc3, 0x83,
6893 0xe3, 0x01
6894 };
6895 copy_block(op_load_T0_crb28_code, 14);
6896 inc_code_ptr(14);
6897 }
6898 #endif
6899
6900 DEFINE_GEN(gen_op_store_T0_crb28,void,(void))
6901 #ifdef DYNGEN_IMPL
6902 #define HAVE_gen_op_store_T0_crb28
6903 {
6904 static const uint8 op_store_T0_crb28_code[] = {
6905 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6906 0xe0, 0x03, 0x83, 0xe2, 0xf7, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6907 0x00
6908 };
6909 copy_block(op_store_T0_crb28_code, 25);
6910 inc_code_ptr(25);
6911 }
6912 #endif
6913
6914 DEFINE_GEN(gen_op_load_T1_crb28,void,(void))
6915 #ifdef DYNGEN_IMPL
6916 #define HAVE_gen_op_load_T1_crb28
6917 {
6918 static const uint8 op_load_T1_crb28_code[] = {
6919 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x03, 0x89, 0xc6, 0x83,
6920 0xe6, 0x01
6921 };
6922 copy_block(op_load_T1_crb28_code, 14);
6923 inc_code_ptr(14);
6924 }
6925 #endif
6926
6927 DEFINE_GEN(gen_op_store_T1_crb28,void,(void))
6928 #ifdef DYNGEN_IMPL
6929 #define HAVE_gen_op_store_T1_crb28
6930 {
6931 static const uint8 op_store_T1_crb28_code[] = {
6932 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6933 0xe0, 0x03, 0x83, 0xe2, 0xf7, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6934 0x00
6935 };
6936 copy_block(op_store_T1_crb28_code, 25);
6937 inc_code_ptr(25);
6938 }
6939 #endif
6940
6941 DEFINE_GEN(gen_op_load_T0_crb29,void,(void))
6942 #ifdef DYNGEN_IMPL
6943 #define HAVE_gen_op_load_T0_crb29
6944 {
6945 static const uint8 op_load_T0_crb29_code[] = {
6946 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x02, 0x89, 0xc3, 0x83,
6947 0xe3, 0x01
6948 };
6949 copy_block(op_load_T0_crb29_code, 14);
6950 inc_code_ptr(14);
6951 }
6952 #endif
6953
6954 DEFINE_GEN(gen_op_store_T0_crb29,void,(void))
6955 #ifdef DYNGEN_IMPL
6956 #define HAVE_gen_op_store_T0_crb29
6957 {
6958 static const uint8 op_store_T0_crb29_code[] = {
6959 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0xc1,
6960 0xe0, 0x02, 0x83, 0xe2, 0xfb, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6961 0x00
6962 };
6963 copy_block(op_store_T0_crb29_code, 25);
6964 inc_code_ptr(25);
6965 }
6966 #endif
6967
6968 DEFINE_GEN(gen_op_load_T1_crb29,void,(void))
6969 #ifdef DYNGEN_IMPL
6970 #define HAVE_gen_op_load_T1_crb29
6971 {
6972 static const uint8 op_load_T1_crb29_code[] = {
6973 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x02, 0x89, 0xc6, 0x83,
6974 0xe6, 0x01
6975 };
6976 copy_block(op_load_T1_crb29_code, 14);
6977 inc_code_ptr(14);
6978 }
6979 #endif
6980
6981 DEFINE_GEN(gen_op_store_T1_crb29,void,(void))
6982 #ifdef DYNGEN_IMPL
6983 #define HAVE_gen_op_store_T1_crb29
6984 {
6985 static const uint8 op_store_T1_crb29_code[] = {
6986 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0xc1,
6987 0xe0, 0x02, 0x83, 0xe2, 0xfb, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00,
6988 0x00
6989 };
6990 copy_block(op_store_T1_crb29_code, 25);
6991 inc_code_ptr(25);
6992 }
6993 #endif
6994
6995 DEFINE_GEN(gen_op_load_T0_crb30,void,(void))
6996 #ifdef DYNGEN_IMPL
6997 #define HAVE_gen_op_load_T0_crb30
6998 {
6999 static const uint8 op_load_T0_crb30_code[] = {
7000 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xd1, 0xe8, 0x89, 0xc3, 0x83, 0xe3,
7001 0x01
7002 };
7003 copy_block(op_load_T0_crb30_code, 13);
7004 inc_code_ptr(13);
7005 }
7006 #endif
7007
7008 DEFINE_GEN(gen_op_store_T0_crb30,void,(void))
7009 #ifdef DYNGEN_IMPL
7010 #define HAVE_gen_op_store_T0_crb30
7011 {
7012 static const uint8 op_store_T0_crb30_code[] = {
7013 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x83, 0xe0, 0x01, 0x01,
7014 0xc0, 0x83, 0xe2, 0xfd, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, 0x00
7015 };
7016 copy_block(op_store_T0_crb30_code, 24);
7017 inc_code_ptr(24);
7018 }
7019 #endif
7020
7021 DEFINE_GEN(gen_op_load_T1_crb30,void,(void))
7022 #ifdef DYNGEN_IMPL
7023 #define HAVE_gen_op_load_T1_crb30
7024 {
7025 static const uint8 op_load_T1_crb30_code[] = {
7026 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xd1, 0xe8, 0x89, 0xc6, 0x83, 0xe6,
7027 0x01
7028 };
7029 copy_block(op_load_T1_crb30_code, 13);
7030 inc_code_ptr(13);
7031 }
7032 #endif
7033
7034 DEFINE_GEN(gen_op_store_T1_crb30,void,(void))
7035 #ifdef DYNGEN_IMPL
7036 #define HAVE_gen_op_store_T1_crb30
7037 {
7038 static const uint8 op_store_T1_crb30_code[] = {
7039 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf0, 0x83, 0xe0, 0x01, 0x01,
7040 0xc0, 0x83, 0xe2, 0xfd, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, 0x00
7041 };
7042 copy_block(op_store_T1_crb30_code, 24);
7043 inc_code_ptr(24);
7044 }
7045 #endif
7046
7047 DEFINE_GEN(gen_op_load_T0_crb31,void,(void))
7048 #ifdef DYNGEN_IMPL
7049 #define HAVE_gen_op_load_T0_crb31
7050 {
7051 static const uint8 op_load_T0_crb31_code[] = {
7052 0x8b, 0x9d, 0x90, 0x03, 0x00, 0x00, 0x83, 0xe3, 0x01
7053 };
7054 copy_block(op_load_T0_crb31_code, 9);
7055 inc_code_ptr(9);
7056 }
7057 #endif
7058
7059 DEFINE_GEN(gen_op_store_T0_crb31,void,(void))
7060 #ifdef DYNGEN_IMPL
7061 #define HAVE_gen_op_store_T0_crb31
7062 {
7063 static const uint8 op_store_T0_crb31_code[] = {
7064 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xda, 0x83, 0xe2, 0x01, 0x83,
7065 0xe0, 0xfe, 0x09, 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00
7066 };
7067 copy_block(op_store_T0_crb31_code, 22);
7068 inc_code_ptr(22);
7069 }
7070 #endif
7071
7072 DEFINE_GEN(gen_op_load_T1_crb31,void,(void))
7073 #ifdef DYNGEN_IMPL
7074 #define HAVE_gen_op_load_T1_crb31
7075 {
7076 static const uint8 op_load_T1_crb31_code[] = {
7077 0x8b, 0xb5, 0x90, 0x03, 0x00, 0x00, 0x83, 0xe6, 0x01
7078 };
7079 copy_block(op_load_T1_crb31_code, 9);
7080 inc_code_ptr(9);
7081 }
7082 #endif
7083
7084 DEFINE_GEN(gen_op_store_T1_crb31,void,(void))
7085 #ifdef DYNGEN_IMPL
7086 #define HAVE_gen_op_store_T1_crb31
7087 {
7088 static const uint8 op_store_T1_crb31_code[] = {
7089 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xf2, 0x83, 0xe2, 0x01, 0x83,
7090 0xe0, 0xfe, 0x09, 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00
7091 };
7092 copy_block(op_store_T1_crb31_code, 22);
7093 inc_code_ptr(22);
7094 }
7095 #endif
7096
7097 DEFINE_GEN(gen_op_load_T0_cr0,void,(void))
7098 #ifdef DYNGEN_IMPL
7099 #define HAVE_gen_op_load_T0_cr0
7100 {
7101 static const uint8 op_load_T0_cr0_code[] = {
7102 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x89, 0xc3, 0xc1, 0xeb, 0x1c
7103 };
7104 copy_block(op_load_T0_cr0_code, 11);
7105 inc_code_ptr(11);
7106 }
7107 #endif
7108
7109 DEFINE_GEN(gen_op_store_T0_cr0,void,(void))
7110 #ifdef DYNGEN_IMPL
7111 #define HAVE_gen_op_store_T0_cr0
7112 {
7113 static const uint8 op_store_T0_cr0_code[] = {
7114 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x1c, 0x81,
7115 0xe2, 0xff, 0xff, 0xff, 0x0f, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00,
7116 0x00
7117 };
7118 copy_block(op_store_T0_cr0_code, 25);
7119 inc_code_ptr(25);
7120 }
7121 #endif
7122
7123 DEFINE_GEN(gen_op_load_T0_cr1,void,(void))
7124 #ifdef DYNGEN_IMPL
7125 #define HAVE_gen_op_load_T0_cr1
7126 {
7127 static const uint8 op_load_T0_cr1_code[] = {
7128 0x0f, 0xb6, 0x85, 0x93, 0x03, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xe3, 0x0f
7129 };
7130 copy_block(op_load_T0_cr1_code, 12);
7131 inc_code_ptr(12);
7132 }
7133 #endif
7134
7135 DEFINE_GEN(gen_op_store_T0_cr1,void,(void))
7136 #ifdef DYNGEN_IMPL
7137 #define HAVE_gen_op_store_T0_cr1
7138 {
7139 static const uint8 op_store_T0_cr1_code[] = {
7140 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x18, 0x81,
7141 0xe2, 0xff, 0xff, 0xff, 0xf0, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00,
7142 0x00
7143 };
7144 copy_block(op_store_T0_cr1_code, 25);
7145 inc_code_ptr(25);
7146 }
7147 #endif
7148
7149 DEFINE_GEN(gen_op_load_T0_cr2,void,(void))
7150 #ifdef DYNGEN_IMPL
7151 #define HAVE_gen_op_load_T0_cr2
7152 {
7153 static const uint8 op_load_T0_cr2_code[] = {
7154 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x14, 0x89, 0xc3, 0x83,
7155 0xe3, 0x0f
7156 };
7157 copy_block(op_load_T0_cr2_code, 14);
7158 inc_code_ptr(14);
7159 }
7160 #endif
7161
7162 DEFINE_GEN(gen_op_store_T0_cr2,void,(void))
7163 #ifdef DYNGEN_IMPL
7164 #define HAVE_gen_op_store_T0_cr2
7165 {
7166 static const uint8 op_store_T0_cr2_code[] = {
7167 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x14, 0x81,
7168 0xe2, 0xff, 0xff, 0x0f, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00,
7169 0x00
7170 };
7171 copy_block(op_store_T0_cr2_code, 25);
7172 inc_code_ptr(25);
7173 }
7174 #endif
7175
7176 DEFINE_GEN(gen_op_load_T0_cr3,void,(void))
7177 #ifdef DYNGEN_IMPL
7178 #define HAVE_gen_op_load_T0_cr3
7179 {
7180 static const uint8 op_load_T0_cr3_code[] = {
7181 0x0f, 0xb7, 0x85, 0x92, 0x03, 0x00, 0x00, 0x89, 0xc3, 0x83, 0xe3, 0x0f
7182 };
7183 copy_block(op_load_T0_cr3_code, 12);
7184 inc_code_ptr(12);
7185 }
7186 #endif
7187
7188 DEFINE_GEN(gen_op_store_T0_cr3,void,(void))
7189 #ifdef DYNGEN_IMPL
7190 #define HAVE_gen_op_store_T0_cr3
7191 {
7192 static const uint8 op_store_T0_cr3_code[] = {
7193 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x10, 0x81,
7194 0xe2, 0xff, 0xff, 0xf0, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00,
7195 0x00
7196 };
7197 copy_block(op_store_T0_cr3_code, 25);
7198 inc_code_ptr(25);
7199 }
7200 #endif
7201
7202 DEFINE_GEN(gen_op_load_T0_cr4,void,(void))
7203 #ifdef DYNGEN_IMPL
7204 #define HAVE_gen_op_load_T0_cr4
7205 {
7206 static const uint8 op_load_T0_cr4_code[] = {
7207 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x0c, 0x89, 0xc3, 0x83,
7208 0xe3, 0x0f
7209 };
7210 copy_block(op_load_T0_cr4_code, 14);
7211 inc_code_ptr(14);
7212 }
7213 #endif
7214
7215 DEFINE_GEN(gen_op_store_T0_cr4,void,(void))
7216 #ifdef DYNGEN_IMPL
7217 #define HAVE_gen_op_store_T0_cr4
7218 {
7219 static const uint8 op_store_T0_cr4_code[] = {
7220 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x0c, 0x81,
7221 0xe2, 0xff, 0x0f, 0xff, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00,
7222 0x00
7223 };
7224 copy_block(op_store_T0_cr4_code, 25);
7225 inc_code_ptr(25);
7226 }
7227 #endif
7228
7229 DEFINE_GEN(gen_op_load_T0_cr5,void,(void))
7230 #ifdef DYNGEN_IMPL
7231 #define HAVE_gen_op_load_T0_cr5
7232 {
7233 static const uint8 op_load_T0_cr5_code[] = {
7234 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x08, 0x89, 0xc3, 0x83,
7235 0xe3, 0x0f
7236 };
7237 copy_block(op_load_T0_cr5_code, 14);
7238 inc_code_ptr(14);
7239 }
7240 #endif
7241
7242 DEFINE_GEN(gen_op_store_T0_cr5,void,(void))
7243 #ifdef DYNGEN_IMPL
7244 #define HAVE_gen_op_store_T0_cr5
7245 {
7246 static const uint8 op_store_T0_cr5_code[] = {
7247 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x08, 0x81,
7248 0xe2, 0xff, 0xf0, 0xff, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00,
7249 0x00
7250 };
7251 copy_block(op_store_T0_cr5_code, 25);
7252 inc_code_ptr(25);
7253 }
7254 #endif
7255
7256 DEFINE_GEN(gen_op_load_T0_cr6,void,(void))
7257 #ifdef DYNGEN_IMPL
7258 #define HAVE_gen_op_load_T0_cr6
7259 {
7260 static const uint8 op_load_T0_cr6_code[] = {
7261 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0xc1, 0xe8, 0x04, 0x89, 0xc3, 0x83,
7262 0xe3, 0x0f
7263 };
7264 copy_block(op_load_T0_cr6_code, 14);
7265 inc_code_ptr(14);
7266 }
7267 #endif
7268
7269 DEFINE_GEN(gen_op_store_T0_cr6,void,(void))
7270 #ifdef DYNGEN_IMPL
7271 #define HAVE_gen_op_store_T0_cr6
7272 {
7273 static const uint8 op_store_T0_cr6_code[] = {
7274 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00, 0x89, 0xd9, 0xc1, 0xe1, 0x04, 0x81,
7275 0xe2, 0x0f, 0xff, 0xff, 0xff, 0x09, 0xca, 0x89, 0x95, 0x90, 0x03, 0x00,
7276 0x00
7277 };
7278 copy_block(op_store_T0_cr6_code, 25);
7279 inc_code_ptr(25);
7280 }
7281 #endif
7282
7283 DEFINE_GEN(gen_op_load_T0_cr7,void,(void))
7284 #ifdef DYNGEN_IMPL
7285 #define HAVE_gen_op_load_T0_cr7
7286 {
7287 static const uint8 op_load_T0_cr7_code[] = {
7288 0x8b, 0x9d, 0x90, 0x03, 0x00, 0x00, 0x83, 0xe3, 0x0f
7289 };
7290 copy_block(op_load_T0_cr7_code, 9);
7291 inc_code_ptr(9);
7292 }
7293 #endif
7294
7295 DEFINE_GEN(gen_op_store_T0_cr7,void,(void))
7296 #ifdef DYNGEN_IMPL
7297 #define HAVE_gen_op_store_T0_cr7
7298 {
7299 static const uint8 op_store_T0_cr7_code[] = {
7300 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x83, 0xe0, 0xf0, 0x09, 0xd8, 0x89,
7301 0x85, 0x90, 0x03, 0x00, 0x00
7302 };
7303 copy_block(op_store_T0_cr7_code, 17);
7304 inc_code_ptr(17);
7305 }
7306 #endif
7307
7308 DEFINE_GEN(gen_op_mtcrf_T0_im,void,(long param1))
7309 #ifdef DYNGEN_IMPL
7310 #define HAVE_gen_op_mtcrf_T0_im
7311 {
7312 static const uint8 op_mtcrf_T0_im_code[] = {
7313 0x8b, 0x8d, 0x90, 0x03, 0x00, 0x00, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89,
7314 0xda, 0xf7, 0xd0, 0x81, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x21, 0xc8, 0x09,
7315 0xd0, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00
7316 };
7317 copy_block(op_mtcrf_T0_im_code, 31);
7318 *(uint32_t *)(code_ptr() + 7) = param1 + 0;
7319 *(uint32_t *)(code_ptr() + 17) = param1 + 0;
7320 inc_code_ptr(31);
7321 }
7322 #endif
7323
7324 DEFINE_GEN(gen_op_fmov_F0_F1,void,(void))
7325 #ifdef DYNGEN_IMPL
7326 #define HAVE_gen_op_fmov_F0_F1
7327 {
7328 static const uint8 op_fmov_F0_F1_code[] = {
7329 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x03, 0x89, 0x53, 0x04
7330 };
7331 copy_block(op_fmov_F0_F1_code, 10);
7332 inc_code_ptr(10);
7333 }
7334 #endif
7335
7336 DEFINE_GEN(gen_op_fmov_F0_F2,void,(void))
7337 #ifdef DYNGEN_IMPL
7338 #define HAVE_gen_op_fmov_F0_F2
7339 {
7340 static const uint8 op_fmov_F0_F2_code[] = {
7341 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x03, 0x89, 0x53, 0x04
7342 };
7343 copy_block(op_fmov_F0_F2_code, 10);
7344 inc_code_ptr(10);
7345 }
7346 #endif
7347
7348 DEFINE_GEN(gen_op_fmov_F1_F0,void,(void))
7349 #ifdef DYNGEN_IMPL
7350 #define HAVE_gen_op_fmov_F1_F0
7351 {
7352 static const uint8 op_fmov_F1_F0_code[] = {
7353 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x06, 0x89, 0x56, 0x04
7354 };
7355 copy_block(op_fmov_F1_F0_code, 10);
7356 inc_code_ptr(10);
7357 }
7358 #endif
7359
7360 DEFINE_GEN(gen_op_fmov_F1_F2,void,(void))
7361 #ifdef DYNGEN_IMPL
7362 #define HAVE_gen_op_fmov_F1_F2
7363 {
7364 static const uint8 op_fmov_F1_F2_code[] = {
7365 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x06, 0x89, 0x56, 0x04
7366 };
7367 copy_block(op_fmov_F1_F2_code, 10);
7368 inc_code_ptr(10);
7369 }
7370 #endif
7371
7372 DEFINE_GEN(gen_op_fmov_F2_F0,void,(void))
7373 #ifdef DYNGEN_IMPL
7374 #define HAVE_gen_op_fmov_F2_F0
7375 {
7376 static const uint8 op_fmov_F2_F0_code[] = {
7377 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x07, 0x89, 0x57, 0x04
7378 };
7379 copy_block(op_fmov_F2_F0_code, 10);
7380 inc_code_ptr(10);
7381 }
7382 #endif
7383
7384 DEFINE_GEN(gen_op_fmov_F2_F1,void,(void))
7385 #ifdef DYNGEN_IMPL
7386 #define HAVE_gen_op_fmov_F2_F1
7387 {
7388 static const uint8 op_fmov_F2_F1_code[] = {
7389 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x07, 0x89, 0x57, 0x04
7390 };
7391 copy_block(op_fmov_F2_F1_code, 10);
7392 inc_code_ptr(10);
7393 }
7394 #endif
7395
7396 DEFINE_GEN(gen_op_fmov_FD_F0,void,(void))
7397 #ifdef DYNGEN_IMPL
7398 #define HAVE_gen_op_fmov_FD_F0
7399 {
7400 static const uint8 op_fmov_FD_F0_code[] = {
7401 0x8b, 0x03, 0x8b, 0x53, 0x04, 0x89, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x89,
7402 0x95, 0x44, 0x08, 0x0e, 0x00
7403 };
7404 copy_block(op_fmov_FD_F0_code, 17);
7405 inc_code_ptr(17);
7406 }
7407 #endif
7408
7409 DEFINE_GEN(gen_op_fmov_FD_F1,void,(void))
7410 #ifdef DYNGEN_IMPL
7411 #define HAVE_gen_op_fmov_FD_F1
7412 {
7413 static const uint8 op_fmov_FD_F1_code[] = {
7414 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x89, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x89,
7415 0x95, 0x44, 0x08, 0x0e, 0x00
7416 };
7417 copy_block(op_fmov_FD_F1_code, 17);
7418 inc_code_ptr(17);
7419 }
7420 #endif
7421
7422 DEFINE_GEN(gen_op_fmov_FD_F2,void,(void))
7423 #ifdef DYNGEN_IMPL
7424 #define HAVE_gen_op_fmov_FD_F2
7425 {
7426 static const uint8 op_fmov_FD_F2_code[] = {
7427 0x8b, 0x07, 0x8b, 0x57, 0x04, 0x89, 0x85, 0x40, 0x08, 0x0e, 0x00, 0x89,
7428 0x95, 0x44, 0x08, 0x0e, 0x00
7429 };
7430 copy_block(op_fmov_FD_F2_code, 17);
7431 inc_code_ptr(17);
7432 }
7433 #endif
7434
7435 DEFINE_GEN(gen_op_fabs_FD_F0,void,(void))
7436 #ifdef DYNGEN_IMPL
7437 #define HAVE_gen_op_fabs_FD_F0
7438 {
7439 static const uint8 op_fabs_FD_F0_code[] = {
7440 0xdd, 0x03, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xd9, 0xe1, 0xdd, 0x18
7441 };
7442 copy_block(op_fabs_FD_F0_code, 12);
7443 inc_code_ptr(12);
7444 }
7445 #endif
7446
7447 DEFINE_GEN(gen_op_fneg_FD_F0,void,(void))
7448 #ifdef DYNGEN_IMPL
7449 #define HAVE_gen_op_fneg_FD_F0
7450 {
7451 static const uint8 op_fneg_FD_F0_code[] = {
7452 0xdd, 0x03, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xd9, 0xe0, 0xdd, 0x18
7453 };
7454 copy_block(op_fneg_FD_F0_code, 12);
7455 inc_code_ptr(12);
7456 }
7457 #endif
7458
7459 DEFINE_GEN(gen_op_fnabs_FD_F0,void,(void))
7460 #ifdef DYNGEN_IMPL
7461 #define HAVE_gen_op_fnabs_FD_F0
7462 {
7463 static const uint8 op_fnabs_FD_F0_code[] = {
7464 0xdd, 0x03, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xd9, 0xe1, 0xd9, 0xe0,
7465 0xdd, 0x18
7466 };
7467 copy_block(op_fnabs_FD_F0_code, 14);
7468 inc_code_ptr(14);
7469 }
7470 #endif
7471
7472 DEFINE_GEN(gen_op_fadd_FD_F0_F1,void,(void))
7473 #ifdef DYNGEN_IMPL
7474 #define HAVE_gen_op_fadd_FD_F0_F1
7475 {
7476 static const uint8 op_fadd_FD_F0_F1_code[] = {
7477 0xdd, 0x06, 0xdc, 0x03, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00
7478 };
7479 copy_block(op_fadd_FD_F0_F1_code, 10);
7480 inc_code_ptr(10);
7481 }
7482 #endif
7483
7484 DEFINE_GEN(gen_op_fsub_FD_F0_F1,void,(void))
7485 #ifdef DYNGEN_IMPL
7486 #define HAVE_gen_op_fsub_FD_F0_F1
7487 {
7488 static const uint8 op_fsub_FD_F0_F1_code[] = {
7489 0xdd, 0x06, 0xdc, 0x2b, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00
7490 };
7491 copy_block(op_fsub_FD_F0_F1_code, 10);
7492 inc_code_ptr(10);
7493 }
7494 #endif
7495
7496 DEFINE_GEN(gen_op_fmul_FD_F0_F1,void,(void))
7497 #ifdef DYNGEN_IMPL
7498 #define HAVE_gen_op_fmul_FD_F0_F1
7499 {
7500 static const uint8 op_fmul_FD_F0_F1_code[] = {
7501 0xdd, 0x06, 0xdc, 0x0b, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00
7502 };
7503 copy_block(op_fmul_FD_F0_F1_code, 10);
7504 inc_code_ptr(10);
7505 }
7506 #endif
7507
7508 DEFINE_GEN(gen_op_fdiv_FD_F0_F1,void,(void))
7509 #ifdef DYNGEN_IMPL
7510 #define HAVE_gen_op_fdiv_FD_F0_F1
7511 {
7512 static const uint8 op_fdiv_FD_F0_F1_code[] = {
7513 0xdd, 0x06, 0xdc, 0x3b, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00
7514 };
7515 copy_block(op_fdiv_FD_F0_F1_code, 10);
7516 inc_code_ptr(10);
7517 }
7518 #endif
7519
7520 DEFINE_GEN(gen_op_fmadd_FD_F0_F1_F2,void,(void))
7521 #ifdef DYNGEN_IMPL
7522 #define HAVE_gen_op_fmadd_FD_F0_F1_F2
7523 {
7524 static const uint8 op_fmadd_FD_F0_F1_F2_code[] = {
7525 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x07, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00
7526 };
7527 copy_block(op_fmadd_FD_F0_F1_F2_code, 12);
7528 inc_code_ptr(12);
7529 }
7530 #endif
7531
7532 DEFINE_GEN(gen_op_fmsub_FD_F0_F1_F2,void,(void))
7533 #ifdef DYNGEN_IMPL
7534 #define HAVE_gen_op_fmsub_FD_F0_F1_F2
7535 {
7536 static const uint8 op_fmsub_FD_F0_F1_F2_code[] = {
7537 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x27, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00
7538 };
7539 copy_block(op_fmsub_FD_F0_F1_F2_code, 12);
7540 inc_code_ptr(12);
7541 }
7542 #endif
7543
7544 DEFINE_GEN(gen_op_fnmadd_FD_F0_F1_F2,void,(void))
7545 #ifdef DYNGEN_IMPL
7546 #define HAVE_gen_op_fnmadd_FD_F0_F1_F2
7547 {
7548 static const uint8 op_fnmadd_FD_F0_F1_F2_code[] = {
7549 0xdd, 0x06, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xdc, 0x0b, 0xdc, 0x07,
7550 0xd9, 0xe0, 0xdd, 0x18
7551 };
7552 copy_block(op_fnmadd_FD_F0_F1_F2_code, 16);
7553 inc_code_ptr(16);
7554 }
7555 #endif
7556
7557 DEFINE_GEN(gen_op_fnmsub_FD_F0_F1_F2,void,(void))
7558 #ifdef DYNGEN_IMPL
7559 #define HAVE_gen_op_fnmsub_FD_F0_F1_F2
7560 {
7561 static const uint8 op_fnmsub_FD_F0_F1_F2_code[] = {
7562 0xdd, 0x06, 0x8d, 0x85, 0x40, 0x08, 0x0e, 0x00, 0xdc, 0x0b, 0xdc, 0x27,
7563 0xd9, 0xe0, 0xdd, 0x18
7564 };
7565 copy_block(op_fnmsub_FD_F0_F1_F2_code, 16);
7566 inc_code_ptr(16);
7567 }
7568 #endif
7569
7570 DEFINE_GEN(gen_op_fadds_FD_F0_F1,void,(void))
7571 #ifdef DYNGEN_IMPL
7572 #define HAVE_gen_op_fadds_FD_F0_F1
7573 {
7574 static const uint8 op_fadds_FD_F0_F1_code[] = {
7575 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x03, 0xd9, 0x1c, 0x24, 0xd9, 0x04,
7576 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58
7577 };
7578 copy_block(op_fadds_FD_F0_F1_code, 20);
7579 inc_code_ptr(20);
7580 }
7581 #endif
7582
7583 DEFINE_GEN(gen_op_fsubs_FD_F0_F1,void,(void))
7584 #ifdef DYNGEN_IMPL
7585 #define HAVE_gen_op_fsubs_FD_F0_F1
7586 {
7587 static const uint8 op_fsubs_FD_F0_F1_code[] = {
7588 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x2b, 0xd9, 0x1c, 0x24, 0xd9, 0x04,
7589 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58
7590 };
7591 copy_block(op_fsubs_FD_F0_F1_code, 20);
7592 inc_code_ptr(20);
7593 }
7594 #endif
7595
7596 DEFINE_GEN(gen_op_fmuls_FD_F0_F1,void,(void))
7597 #ifdef DYNGEN_IMPL
7598 #define HAVE_gen_op_fmuls_FD_F0_F1
7599 {
7600 static const uint8 op_fmuls_FD_F0_F1_code[] = {
7601 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xd9, 0x1c, 0x24, 0xd9, 0x04,
7602 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58
7603 };
7604 copy_block(op_fmuls_FD_F0_F1_code, 20);
7605 inc_code_ptr(20);
7606 }
7607 #endif
7608
7609 DEFINE_GEN(gen_op_fdivs_FD_F0_F1,void,(void))
7610 #ifdef DYNGEN_IMPL
7611 #define HAVE_gen_op_fdivs_FD_F0_F1
7612 {
7613 static const uint8 op_fdivs_FD_F0_F1_code[] = {
7614 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x3b, 0xd9, 0x1c, 0x24, 0xd9, 0x04,
7615 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58
7616 };
7617 copy_block(op_fdivs_FD_F0_F1_code, 20);
7618 inc_code_ptr(20);
7619 }
7620 #endif
7621
7622 DEFINE_GEN(gen_op_fmadds_FD_F0_F1_F2,void,(void))
7623 #ifdef DYNGEN_IMPL
7624 #define HAVE_gen_op_fmadds_FD_F0_F1_F2
7625 {
7626 static const uint8 op_fmadds_FD_F0_F1_F2_code[] = {
7627 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x07, 0xd9, 0x1c, 0x24,
7628 0xd9, 0x04, 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58
7629 };
7630 copy_block(op_fmadds_FD_F0_F1_F2_code, 22);
7631 inc_code_ptr(22);
7632 }
7633 #endif
7634
7635 DEFINE_GEN(gen_op_fmsubs_FD_F0_F1_F2,void,(void))
7636 #ifdef DYNGEN_IMPL
7637 #define HAVE_gen_op_fmsubs_FD_F0_F1_F2
7638 {
7639 static const uint8 op_fmsubs_FD_F0_F1_F2_code[] = {
7640 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x27, 0xd9, 0x1c, 0x24,
7641 0xd9, 0x04, 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x58
7642 };
7643 copy_block(op_fmsubs_FD_F0_F1_F2_code, 22);
7644 inc_code_ptr(22);
7645 }
7646 #endif
7647
7648 DEFINE_GEN(gen_op_fnmadds_FD_F0_F1_F2,void,(void))
7649 #ifdef DYNGEN_IMPL
7650 #define HAVE_gen_op_fnmadds_FD_F0_F1_F2
7651 {
7652 static const uint8 op_fnmadds_FD_F0_F1_F2_code[] = {
7653 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x07, 0xd9, 0xe0, 0xd9,
7654 0x1c, 0x24, 0xd9, 0x04, 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x5a
7655 };
7656 copy_block(op_fnmadds_FD_F0_F1_F2_code, 24);
7657 inc_code_ptr(24);
7658 }
7659 #endif
7660
7661 DEFINE_GEN(gen_op_fnmsubs_FD_F0_F1_F2,void,(void))
7662 #ifdef DYNGEN_IMPL
7663 #define HAVE_gen_op_fnmsubs_FD_F0_F1_F2
7664 {
7665 static const uint8 op_fnmsubs_FD_F0_F1_F2_code[] = {
7666 0x83, 0xec, 0x04, 0xdd, 0x06, 0xdc, 0x0b, 0xdc, 0x27, 0xd9, 0xe0, 0xd9,
7667 0x1c, 0x24, 0xd9, 0x04, 0x24, 0xdd, 0x9d, 0x40, 0x08, 0x0e, 0x00, 0x59
7668 };
7669 copy_block(op_fnmsubs_FD_F0_F1_F2_code, 24);
7670 inc_code_ptr(24);
7671 }
7672 #endif
7673
7674 DEFINE_GEN(gen_op_load_T0_VRSAVE,void,(void))
7675 #ifdef DYNGEN_IMPL
7676 #define HAVE_gen_op_load_T0_VRSAVE
7677 {
7678 static const uint8 op_load_T0_VRSAVE_code[] = {
7679 0x8b, 0x9d, 0x9c, 0x03, 0x00, 0x00
7680 };
7681 copy_block(op_load_T0_VRSAVE_code, 6);
7682 inc_code_ptr(6);
7683 }
7684 #endif
7685
7686 DEFINE_GEN(gen_op_store_T0_VRSAVE,void,(void))
7687 #ifdef DYNGEN_IMPL
7688 #define HAVE_gen_op_store_T0_VRSAVE
7689 {
7690 static const uint8 op_store_T0_VRSAVE_code[] = {
7691 0x89, 0x9d, 0x9c, 0x03, 0x00, 0x00
7692 };
7693 copy_block(op_store_T0_VRSAVE_code, 6);
7694 inc_code_ptr(6);
7695 }
7696 #endif
7697
7698 DEFINE_GEN(gen_op_load_T0_XER,void,(void))
7699 #ifdef DYNGEN_IMPL
7700 #define HAVE_gen_op_load_T0_XER
7701 {
7702 static const uint8 op_load_T0_XER_code[] = {
7703 0x0f, 0xb6, 0x95, 0x94, 0x03, 0x00, 0x00, 0x8d, 0x8d, 0x94, 0x03, 0x00,
7704 0x00, 0x0f, 0xb6, 0x41, 0x01, 0xc1, 0xe2, 0x1f, 0xc1, 0xe0, 0x1e, 0x09,
7705 0xc2, 0x0f, 0xb6, 0x41, 0x02, 0xc1, 0xe0, 0x1d, 0x09, 0xc2, 0x0f, 0xb6,
7706 0x41, 0x03, 0x89, 0xd3, 0x09, 0xc3
7707 };
7708 copy_block(op_load_T0_XER_code, 42);
7709 inc_code_ptr(42);
7710 }
7711 #endif
7712
7713 DEFINE_GEN(gen_op_load_T0_PC,void,(void))
7714 #ifdef DYNGEN_IMPL
7715 #define HAVE_gen_op_load_T0_PC
7716 {
7717 static const uint8 op_load_T0_PC_code[] = {
7718 0x8b, 0x9d, 0xac, 0x03, 0x00, 0x00
7719 };
7720 copy_block(op_load_T0_PC_code, 6);
7721 inc_code_ptr(6);
7722 }
7723 #endif
7724
7725 DEFINE_GEN(gen_op_store_T0_PC,void,(void))
7726 #ifdef DYNGEN_IMPL
7727 #define HAVE_gen_op_store_T0_PC
7728 {
7729 static const uint8 op_store_T0_PC_code[] = {
7730 0x89, 0x9d, 0xac, 0x03, 0x00, 0x00
7731 };
7732 copy_block(op_store_T0_PC_code, 6);
7733 inc_code_ptr(6);
7734 }
7735 #endif
7736
7737 DEFINE_GEN(gen_op_set_PC_im,void,(long param1))
7738 #ifdef DYNGEN_IMPL
7739 #define HAVE_gen_op_set_PC_im
7740 {
7741 static const uint8 op_set_PC_im_code[] = {
7742 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x85, 0xac, 0x03, 0x00, 0x00
7743 };
7744 copy_block(op_set_PC_im_code, 11);
7745 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
7746 inc_code_ptr(11);
7747 }
7748 #endif
7749
7750 DEFINE_GEN(gen_op_set_PC_T0,void,(void))
7751 #ifdef DYNGEN_IMPL
7752 #define HAVE_gen_op_set_PC_T0
7753 {
7754 static const uint8 op_set_PC_T0_code[] = {
7755 0x89, 0x9d, 0xac, 0x03, 0x00, 0x00
7756 };
7757 copy_block(op_set_PC_T0_code, 6);
7758 inc_code_ptr(6);
7759 }
7760 #endif
7761
7762 DEFINE_GEN(gen_op_inc_PC,void,(long param1))
7763 #ifdef DYNGEN_IMPL
7764 #define HAVE_gen_op_inc_PC
7765 {
7766 static const uint8 op_inc_PC_code[] = {
7767 0x81, 0x85, 0xac, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
7768 };
7769 copy_block(op_inc_PC_code, 10);
7770 *(uint32_t *)(code_ptr() + 6) = param1 + 0;
7771 inc_code_ptr(10);
7772 }
7773 #endif
7774
7775 DEFINE_GEN(gen_op_load_T0_LR,void,(void))
7776 #ifdef DYNGEN_IMPL
7777 #define HAVE_gen_op_load_T0_LR
7778 {
7779 static const uint8 op_load_T0_LR_code[] = {
7780 0x8b, 0x9d, 0xa4, 0x03, 0x00, 0x00
7781 };
7782 copy_block(op_load_T0_LR_code, 6);
7783 inc_code_ptr(6);
7784 }
7785 #endif
7786
7787 DEFINE_GEN(gen_op_store_T0_LR,void,(void))
7788 #ifdef DYNGEN_IMPL
7789 #define HAVE_gen_op_store_T0_LR
7790 {
7791 static const uint8 op_store_T0_LR_code[] = {
7792 0x89, 0x9d, 0xa4, 0x03, 0x00, 0x00
7793 };
7794 copy_block(op_store_T0_LR_code, 6);
7795 inc_code_ptr(6);
7796 }
7797 #endif
7798
7799 DEFINE_GEN(gen_op_load_T0_CTR,void,(void))
7800 #ifdef DYNGEN_IMPL
7801 #define HAVE_gen_op_load_T0_CTR
7802 {
7803 static const uint8 op_load_T0_CTR_code[] = {
7804 0x8b, 0x9d, 0xa8, 0x03, 0x00, 0x00
7805 };
7806 copy_block(op_load_T0_CTR_code, 6);
7807 inc_code_ptr(6);
7808 }
7809 #endif
7810
7811 DEFINE_GEN(gen_op_store_T0_CTR,void,(void))
7812 #ifdef DYNGEN_IMPL
7813 #define HAVE_gen_op_store_T0_CTR
7814 {
7815 static const uint8 op_store_T0_CTR_code[] = {
7816 0x89, 0x9d, 0xa8, 0x03, 0x00, 0x00
7817 };
7818 copy_block(op_store_T0_CTR_code, 6);
7819 inc_code_ptr(6);
7820 }
7821 #endif
7822
7823 DEFINE_GEN(gen_op_store_im_LR,void,(long param1))
7824 #ifdef DYNGEN_IMPL
7825 #define HAVE_gen_op_store_im_LR
7826 {
7827 static const uint8 op_store_im_LR_code[] = {
7828 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x85, 0xa4, 0x03, 0x00, 0x00
7829 };
7830 copy_block(op_store_im_LR_code, 11);
7831 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
7832 inc_code_ptr(11);
7833 }
7834 #endif
7835
7836 DEFINE_GEN(gen_op_load_T0_CTR_aligned,void,(void))
7837 #ifdef DYNGEN_IMPL
7838 #define HAVE_gen_op_load_T0_CTR_aligned
7839 {
7840 static const uint8 op_load_T0_CTR_aligned_code[] = {
7841 0x8b, 0x9d, 0xa8, 0x03, 0x00, 0x00, 0x83, 0xe3, 0xfc
7842 };
7843 copy_block(op_load_T0_CTR_aligned_code, 9);
7844 inc_code_ptr(9);
7845 }
7846 #endif
7847
7848 DEFINE_GEN(gen_op_load_T0_LR_aligned,void,(void))
7849 #ifdef DYNGEN_IMPL
7850 #define HAVE_gen_op_load_T0_LR_aligned
7851 {
7852 static const uint8 op_load_T0_LR_aligned_code[] = {
7853 0x8b, 0x9d, 0xa4, 0x03, 0x00, 0x00, 0x83, 0xe3, 0xfc
7854 };
7855 copy_block(op_load_T0_LR_aligned_code, 9);
7856 inc_code_ptr(9);
7857 }
7858 #endif
7859
7860 DEFINE_GEN(gen_op_spcflags_init,void,(long param1))
7861 #ifdef DYNGEN_IMPL
7862 #define HAVE_gen_op_spcflags_init
7863 {
7864 static const uint8 op_spcflags_init_code[] = {
7865 0x8d, 0x95, 0xb0, 0x03, 0x00, 0x00, 0x83, 0xec, 0x04, 0xb9, 0x01, 0x00,
7866 0x00, 0x00, 0x89, 0x14, 0x24, 0x8d, 0x95, 0xb4, 0x03, 0x00, 0x00, 0x89,
7867 0xf6, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x89, 0xc8, 0x87, 0x02,
7868 0x85, 0xc0, 0x75, 0xf8, 0x8b, 0x04, 0x24, 0x81, 0x08, 0x00, 0x00, 0x00,
7869 0x00, 0xc7, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x58
7870 };
7871 copy_block(op_spcflags_init_code, 57);
7872 *(uint32_t *)(code_ptr() + 45) = param1 + 0;
7873 inc_code_ptr(57);
7874 }
7875 #endif
7876
7877 DEFINE_GEN(gen_op_spcflags_set,void,(long param1))
7878 #ifdef DYNGEN_IMPL
7879 #define HAVE_gen_op_spcflags_set
7880 {
7881 static const uint8 op_spcflags_set_code[] = {
7882 0x8d, 0x95, 0xb0, 0x03, 0x00, 0x00, 0x83, 0xec, 0x04, 0xb9, 0x01, 0x00,
7883 0x00, 0x00, 0x89, 0x14, 0x24, 0x8d, 0x95, 0xb4, 0x03, 0x00, 0x00, 0x89,
7884 0xf6, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x89, 0xc8, 0x87, 0x02,
7885 0x85, 0xc0, 0x75, 0xf8, 0x8b, 0x04, 0x24, 0x81, 0x08, 0x00, 0x00, 0x00,
7886 0x00, 0xc7, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x58
7887 };
7888 copy_block(op_spcflags_set_code, 57);
7889 *(uint32_t *)(code_ptr() + 45) = param1 + 0;
7890 inc_code_ptr(57);
7891 }
7892 #endif
7893
7894 DEFINE_GEN(gen_op_spcflags_clear,void,(long param1))
7895 #ifdef DYNGEN_IMPL
7896 #define HAVE_gen_op_spcflags_clear
7897 {
7898 static const uint8 op_spcflags_clear_code[] = {
7899 0x83, 0xec, 0x08, 0x8d, 0x95, 0xb0, 0x03, 0x00, 0x00, 0xb9, 0x01, 0x00,
7900 0x00, 0x00, 0x89, 0x54, 0x24, 0x04, 0x8d, 0x95, 0xb4, 0x03, 0x00, 0x00,
7901 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00, 0x90, 0x89, 0xc8, 0x87, 0x02,
7902 0x85, 0xc0, 0x75, 0xf8, 0xf7, 0x14, 0x24, 0x8b, 0x44, 0x24, 0x04, 0x8b,
7903 0x14, 0x24, 0x21, 0x10, 0xc7, 0x40, 0x04, 0x00, 0x00, 0x00, 0x00, 0x83,
7904 0xc4, 0x08
7905 };
7906 copy_block(op_spcflags_clear_code, 62);
7907 *(uint32_t *)(code_ptr() + 27) = param1 + 0;
7908 inc_code_ptr(62);
7909 }
7910 #endif
7911
7912 DEFINE_GEN(gen_op_spcflags_check,void,(void))
7913 #ifdef DYNGEN_IMPL
7914 #define HAVE_gen_op_spcflags_check
7915 {
7916 static const uint8 op_spcflags_check_code[] = {
7917 0x8b, 0x85, 0xb0, 0x03, 0x00, 0x00, 0x85, 0xc0, 0x75, 0x05, 0xe9, 0x00,
7918 0x00, 0x00, 0x00
7919 };
7920 copy_block(op_spcflags_check_code, 15);
7921 jmp_addr[0] = code_ptr() + 11;
7922 inc_code_ptr(15);
7923 }
7924 #endif
7925
7926 DEFINE_GEN(gen_op_prep_branch_bo_0000,void,(void))
7927 #ifdef DYNGEN_IMPL
7928 #define HAVE_gen_op_prep_branch_bo_0000
7929 {
7930 static const uint8 op_prep_branch_bo_0000_code[] = {
7931 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xf6, 0x0f, 0x94, 0xc1, 0x31,
7932 0xd2, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x89, 0xc7,
7933 0x74, 0x16, 0x84, 0xc9, 0x74, 0x12, 0xba, 0x01, 0x00, 0x00, 0x00, 0x8d,
7934 0xb6, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00,
7935 0x89, 0xd6
7936 };
7937 copy_block(op_prep_branch_bo_0000_code, 50);
7938 inc_code_ptr(50);
7939 }
7940 #endif
7941
7942 DEFINE_GEN(gen_op_prep_branch_bo_0001,void,(void))
7943 #ifdef DYNGEN_IMPL
7944 #define HAVE_gen_op_prep_branch_bo_0001
7945 {
7946 static const uint8 op_prep_branch_bo_0001_code[] = {
7947 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xf6, 0x0f, 0x94, 0xc1, 0x31,
7948 0xd2, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x89, 0xc7,
7949 0x75, 0x16, 0x84, 0xc9, 0x74, 0x12, 0xba, 0x01, 0x00, 0x00, 0x00, 0x8d,
7950 0xb6, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00,
7951 0x89, 0xd6
7952 };
7953 copy_block(op_prep_branch_bo_0001_code, 50);
7954 inc_code_ptr(50);
7955 }
7956 #endif
7957
7958 DEFINE_GEN(gen_op_prep_branch_bo_001x,void,(void))
7959 #ifdef DYNGEN_IMPL
7960 #define HAVE_gen_op_prep_branch_bo_001x
7961 {
7962 static const uint8 op_prep_branch_bo_001x_code[] = {
7963 0x31, 0xc0, 0x85, 0xf6, 0x0f, 0x94, 0xc0, 0x89, 0xc6
7964 };
7965 copy_block(op_prep_branch_bo_001x_code, 9);
7966 inc_code_ptr(9);
7967 }
7968 #endif
7969
7970 DEFINE_GEN(gen_op_prep_branch_bo_0100,void,(void))
7971 #ifdef DYNGEN_IMPL
7972 #define HAVE_gen_op_prep_branch_bo_0100
7973 {
7974 static const uint8 op_prep_branch_bo_0100_code[] = {
7975 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xf6, 0x0f, 0x95, 0xc1, 0x31,
7976 0xd2, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x89, 0xc7,
7977 0x74, 0x16, 0x84, 0xc9, 0x74, 0x12, 0xba, 0x01, 0x00, 0x00, 0x00, 0x8d,
7978 0xb6, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00,
7979 0x89, 0xd6
7980 };
7981 copy_block(op_prep_branch_bo_0100_code, 50);
7982 inc_code_ptr(50);
7983 }
7984 #endif
7985
7986 DEFINE_GEN(gen_op_prep_branch_bo_0101,void,(void))
7987 #ifdef DYNGEN_IMPL
7988 #define HAVE_gen_op_prep_branch_bo_0101
7989 {
7990 static const uint8 op_prep_branch_bo_0101_code[] = {
7991 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x85, 0xf6, 0x0f, 0x95, 0xc1, 0x31,
7992 0xd2, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x89, 0xc7,
7993 0x75, 0x16, 0x84, 0xc9, 0x74, 0x12, 0xba, 0x01, 0x00, 0x00, 0x00, 0x8d,
7994 0xb6, 0x00, 0x00, 0x00, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00,
7995 0x89, 0xd6
7996 };
7997 copy_block(op_prep_branch_bo_0101_code, 50);
7998 inc_code_ptr(50);
7999 }
8000 #endif
8001
8002 DEFINE_GEN(gen_op_prep_branch_bo_011x,void,(void))
8003 #ifdef DYNGEN_IMPL
8004 #define HAVE_gen_op_prep_branch_bo_011x
8005 {
8006 static const uint8 op_prep_branch_bo_011x_code[] = {
8007 0x31, 0xc0, 0x85, 0xf6, 0x0f, 0x95, 0xc0, 0x89, 0xc6
8008 };
8009 copy_block(op_prep_branch_bo_011x_code, 9);
8010 inc_code_ptr(9);
8011 }
8012 #endif
8013
8014 DEFINE_GEN(gen_op_prep_branch_bo_1x00,void,(void))
8015 #ifdef DYNGEN_IMPL
8016 #define HAVE_gen_op_prep_branch_bo_1x00
8017 {
8018 static const uint8 op_prep_branch_bo_1x00_code[] = {
8019 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8,
8020 0x03, 0x00, 0x00, 0x89, 0xc7, 0x0f, 0x95, 0xc0, 0x0f, 0xb6, 0xc0, 0x89,
8021 0xc6
8022 };
8023 copy_block(op_prep_branch_bo_1x00_code, 25);
8024 inc_code_ptr(25);
8025 }
8026 #endif
8027
8028 DEFINE_GEN(gen_op_prep_branch_bo_1x01,void,(void))
8029 #ifdef DYNGEN_IMPL
8030 #define HAVE_gen_op_prep_branch_bo_1x01
8031 {
8032 static const uint8 op_prep_branch_bo_1x01_code[] = {
8033 0x8b, 0x85, 0xa8, 0x03, 0x00, 0x00, 0x48, 0x85, 0xc0, 0x89, 0x85, 0xa8,
8034 0x03, 0x00, 0x00, 0x89, 0xc7, 0x0f, 0x94, 0xc0, 0x0f, 0xb6, 0xc0, 0x89,
8035 0xc6
8036 };
8037 copy_block(op_prep_branch_bo_1x01_code, 25);
8038 inc_code_ptr(25);
8039 }
8040 #endif
8041
8042 DEFINE_GEN(gen_op_prep_branch_bo_1x1x,void,(void))
8043 #ifdef DYNGEN_IMPL
8044 #define HAVE_gen_op_prep_branch_bo_1x1x
8045 {
8046 static const uint8 op_prep_branch_bo_1x1x_code[] = {
8047 0xbe, 0x01, 0x00, 0x00, 0x00
8048 };
8049 copy_block(op_prep_branch_bo_1x1x_code, 5);
8050 inc_code_ptr(5);
8051 }
8052 #endif
8053
8054 DEFINE_GEN(gen_op_branch_chain_1,void,(void))
8055 #ifdef DYNGEN_IMPL
8056 #define HAVE_gen_op_branch_chain_1
8057 {
8058 static const uint8 op_branch_chain_1_code[] = {
8059 0xe9, 0x00, 0x00, 0x00, 0x00
8060 };
8061 copy_block(op_branch_chain_1_code, 5);
8062 jmp_addr[0] = code_ptr() + 1;
8063 inc_code_ptr(5);
8064 }
8065 #endif
8066
8067 DEFINE_GEN(gen_op_branch_chain_2,void,(void))
8068 #ifdef DYNGEN_IMPL
8069 #define HAVE_gen_op_branch_chain_2
8070 {
8071 static const uint8 op_branch_chain_2_code[] = {
8072 0x85, 0xf6, 0x74, 0x0c, 0xe9, 0x00, 0x00, 0x00, 0x00, 0xeb, 0x0a, 0x90,
8073 0x8d, 0x74, 0x26, 0x00, 0xe9, 0x00, 0x00, 0x00, 0x00
8074 };
8075 copy_block(op_branch_chain_2_code, 21);
8076 jmp_addr[0] = code_ptr() + 5;
8077 jmp_addr[1] = code_ptr() + 17;
8078 inc_code_ptr(21);
8079 }
8080 #endif
8081
8082 DEFINE_GEN(gen_op_branch_1_T0,void,(void))
8083 #ifdef DYNGEN_IMPL
8084 #define HAVE_gen_op_branch_1_T0
8085 {
8086 static const uint8 op_branch_1_T0_code[] = {
8087 0x89, 0x9d, 0xac, 0x03, 0x00, 0x00
8088 };
8089 copy_block(op_branch_1_T0_code, 6);
8090 inc_code_ptr(6);
8091 }
8092 #endif
8093
8094 DEFINE_GEN(gen_op_branch_1_im,void,(long param1))
8095 #ifdef DYNGEN_IMPL
8096 #define HAVE_gen_op_branch_1_im
8097 {
8098 static const uint8 op_branch_1_im_code[] = {
8099 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0x85, 0xac, 0x03, 0x00, 0x00
8100 };
8101 copy_block(op_branch_1_im_code, 11);
8102 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
8103 inc_code_ptr(11);
8104 }
8105 #endif
8106
8107 DEFINE_GEN(gen_op_branch_2_T0_im,void,(long param1))
8108 #ifdef DYNGEN_IMPL
8109 #define HAVE_gen_op_branch_2_T0_im
8110 {
8111 static const uint8 op_branch_2_T0_im_code[] = {
8112 0x85, 0xf6, 0x89, 0xd8, 0x75, 0x05, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89,
8113 0x85, 0xac, 0x03, 0x00, 0x00
8114 };
8115 copy_block(op_branch_2_T0_im_code, 17);
8116 *(uint32_t *)(code_ptr() + 7) = param1 + 0;
8117 inc_code_ptr(17);
8118 }
8119 #endif
8120
8121 DEFINE_GEN(gen_op_branch_2_im_im,void,(long param1, long param2))
8122 #ifdef DYNGEN_IMPL
8123 #define HAVE_gen_op_branch_2_im_im
8124 {
8125 static const uint8 op_branch_2_im_im_code[] = {
8126 0x85, 0xf6, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x75, 0x05, 0xb8, 0x00, 0x00,
8127 0x00, 0x00, 0x89, 0x85, 0xac, 0x03, 0x00, 0x00
8128 };
8129 copy_block(op_branch_2_im_im_code, 20);
8130 *(uint32_t *)(code_ptr() + 3) = param1 + 0;
8131 *(uint32_t *)(code_ptr() + 10) = param2 + 0;
8132 inc_code_ptr(20);
8133 }
8134 #endif
8135
8136 DEFINE_GEN(gen_op_record_cr0_T0,void,(void))
8137 #ifdef DYNGEN_IMPL
8138 #define HAVE_gen_op_record_cr0_T0
8139 {
8140 static const uint8 op_record_cr0_T0_code[] = {
8141 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x8b, 0x95, 0x90, 0x03, 0x00,
8142 0x00, 0xc1, 0xe0, 0x1c, 0x81, 0xe2, 0xff, 0xff, 0xff, 0x0f, 0x09, 0xc2,
8143 0x85, 0xdb, 0x7d, 0x08, 0x81, 0xca, 0x00, 0x00, 0x00, 0x80, 0xeb, 0x1c,
8144 0x7e, 0x0a, 0x81, 0xca, 0x00, 0x00, 0x00, 0x40, 0xeb, 0x12, 0x66, 0x90,
8145 0x81, 0xca, 0x00, 0x00, 0x00, 0x20, 0x8d, 0x76, 0x00, 0x8d, 0xbc, 0x27,
8146 0x00, 0x00, 0x00, 0x00, 0x89, 0x95, 0x90, 0x03, 0x00, 0x00
8147 };
8148 copy_block(op_record_cr0_T0_code, 70);
8149 inc_code_ptr(70);
8150 }
8151 #endif
8152
8153 DEFINE_GEN(gen_op_record_cr1,void,(void))
8154 #ifdef DYNGEN_IMPL
8155 #define HAVE_gen_op_record_cr1
8156 {
8157 static const uint8 op_record_cr1_code[] = {
8158 0x8b, 0x85, 0xa0, 0x03, 0x00, 0x00, 0x8b, 0x95, 0x90, 0x03, 0x00, 0x00,
8159 0xc1, 0xe8, 0x04, 0x81, 0xe2, 0xff, 0xff, 0xff, 0xf0, 0x25, 0x00, 0x00,
8160 0x00, 0x0f, 0x09, 0xc2, 0x89, 0x95, 0x90, 0x03, 0x00, 0x00
8161 };
8162 copy_block(op_record_cr1_code, 34);
8163 inc_code_ptr(34);
8164 }
8165 #endif
8166
8167 DEFINE_GEN(gen_op_compare_T0_T1,void,(void))
8168 #ifdef DYNGEN_IMPL
8169 #define HAVE_gen_op_compare_T0_T1
8170 {
8171 static const uint8 op_compare_T0_T1_code[] = {
8172 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x39, 0xf3, 0x7d, 0x07, 0x89,
8173 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1e, 0x7e, 0x0c, 0x89, 0xc3, 0x83, 0xcb,
8174 0x04, 0xeb, 0x15, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x89, 0xc3, 0x83, 0xcb,
8175 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00
8176 };
8177 copy_block(op_compare_T0_T1_code, 48);
8178 inc_code_ptr(48);
8179 }
8180 #endif
8181
8182 DEFINE_GEN(gen_op_compare_T0_im,void,(long param1))
8183 #ifdef DYNGEN_IMPL
8184 #define HAVE_gen_op_compare_T0_im
8185 {
8186 static const uint8 op_compare_T0_im_code[] = {
8187 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x81, 0xfb, 0x00, 0x00, 0x00,
8188 0x00, 0x7d, 0x07, 0x89, 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1a, 0x7e, 0x08,
8189 0x89, 0xc3, 0x83, 0xcb, 0x04, 0xeb, 0x11, 0x90, 0x89, 0xc3, 0x83, 0xcb,
8190 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00
8191 };
8192 copy_block(op_compare_T0_im_code, 48);
8193 *(uint32_t *)(code_ptr() + 9) = param1 + 0;
8194 inc_code_ptr(48);
8195 }
8196 #endif
8197
8198 DEFINE_GEN(gen_op_compare_T0_0,void,(void))
8199 #ifdef DYNGEN_IMPL
8200 #define HAVE_gen_op_compare_T0_0
8201 {
8202 static const uint8 op_compare_T0_0_code[] = {
8203 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x85, 0xdb, 0x7d, 0x07, 0x89,
8204 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1e, 0x7e, 0x0c, 0x89, 0xc3, 0x83, 0xcb,
8205 0x04, 0xeb, 0x15, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x89, 0xc3, 0x83, 0xcb,
8206 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00
8207 };
8208 copy_block(op_compare_T0_0_code, 48);
8209 inc_code_ptr(48);
8210 }
8211 #endif
8212
8213 DEFINE_GEN(gen_op_compare_logical_T0_T1,void,(void))
8214 #ifdef DYNGEN_IMPL
8215 #define HAVE_gen_op_compare_logical_T0_T1
8216 {
8217 static const uint8 op_compare_logical_T0_T1_code[] = {
8218 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x39, 0xf3, 0x73, 0x07, 0x89,
8219 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1e, 0x76, 0x0c, 0x89, 0xc3, 0x83, 0xcb,
8220 0x04, 0xeb, 0x15, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x89, 0xc3, 0x83, 0xcb,
8221 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00
8222 };
8223 copy_block(op_compare_logical_T0_T1_code, 48);
8224 inc_code_ptr(48);
8225 }
8226 #endif
8227
8228 DEFINE_GEN(gen_op_compare_logical_T0_im,void,(long param1))
8229 #ifdef DYNGEN_IMPL
8230 #define HAVE_gen_op_compare_logical_T0_im
8231 {
8232 static const uint8 op_compare_logical_T0_im_code[] = {
8233 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x81, 0xfb, 0x00, 0x00, 0x00,
8234 0x00, 0x73, 0x07, 0x89, 0xc3, 0x83, 0xcb, 0x08, 0xeb, 0x1a, 0x76, 0x08,
8235 0x89, 0xc3, 0x83, 0xcb, 0x04, 0xeb, 0x11, 0x90, 0x89, 0xc3, 0x83, 0xcb,
8236 0x02, 0x8d, 0x74, 0x26, 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00
8237 };
8238 copy_block(op_compare_logical_T0_im_code, 48);
8239 *(uint32_t *)(code_ptr() + 9) = param1 + 0;
8240 inc_code_ptr(48);
8241 }
8242 #endif
8243
8244 DEFINE_GEN(gen_op_compare_logical_T0_0,void,(void))
8245 #ifdef DYNGEN_IMPL
8246 #define HAVE_gen_op_compare_logical_T0_0
8247 {
8248 static const uint8 op_compare_logical_T0_0_code[] = {
8249 0x0f, 0xb6, 0x85, 0x94, 0x03, 0x00, 0x00, 0x85, 0xdb, 0x74, 0x07, 0x89,
8250 0xc3, 0x83, 0xcb, 0x04, 0xeb, 0x05, 0x89, 0xc3, 0x83, 0xcb, 0x02
8251 };
8252 copy_block(op_compare_logical_T0_0_code, 23);
8253 inc_code_ptr(23);
8254 }
8255 #endif
8256
8257 DEFINE_GEN(gen_op_divw_T0_T1,void,(void))
8258 #ifdef DYNGEN_IMPL
8259 #define HAVE_gen_op_divw_T0_T1
8260 {
8261 static const uint8 op_divw_T0_T1_code[] = {
8262 0x83, 0xec, 0x04, 0x85, 0xf6, 0x89, 0x1c, 0x24, 0x74, 0x13, 0x81, 0xfb,
8263 0x00, 0x00, 0x00, 0x80, 0x0f, 0x94, 0xc2, 0x83, 0xfe, 0xff, 0x0f, 0x94,
8264 0xc0, 0x84, 0xc2, 0x74, 0x08, 0x8b, 0x0c, 0x24, 0xc1, 0xf9, 0x1f, 0xeb,
8265 0x0b, 0x8b, 0x04, 0x24, 0x99, 0xf7, 0xfe, 0x89, 0xc1, 0x8d, 0x76, 0x00,
8266 0x5a, 0x89, 0xcb
8267 };
8268 copy_block(op_divw_T0_T1_code, 51);
8269 inc_code_ptr(51);
8270 }
8271 #endif
8272
8273 DEFINE_GEN(gen_op_divwo_T0_T1,void,(void))
8274 #ifdef DYNGEN_IMPL
8275 #define HAVE_gen_op_divwo_T0_T1
8276 {
8277 static const uint8 op_divwo_T0_T1_code[] = {
8278 0x83, 0xec, 0x04, 0x85, 0xf6, 0x89, 0x1c, 0x24, 0x74, 0x13, 0x81, 0xfb,
8279 0x00, 0x00, 0x00, 0x80, 0x0f, 0x94, 0xc2, 0x83, 0xfe, 0xff, 0x0f, 0x94,
8280 0xc0, 0x84, 0xc2, 0x74, 0x16, 0x80, 0x8d, 0x94, 0x03, 0x00, 0x00, 0x01,
8281 0x8b, 0x0c, 0x24, 0xc6, 0x85, 0x95, 0x03, 0x00, 0x00, 0x01, 0xc1, 0xf9,
8282 0x1f, 0xeb, 0x1d, 0xc6, 0x85, 0x95, 0x03, 0x00, 0x00, 0x00, 0x8b, 0x04,
8283 0x24, 0x99, 0xf7, 0xfe, 0x89, 0xc1, 0x8d, 0xb4, 0x26, 0x00, 0x00, 0x00,
8284 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x89, 0xcb, 0x59
8285 };
8286 copy_block(op_divwo_T0_T1_code, 83);
8287 inc_code_ptr(83);
8288 }
8289 #endif
8290
8291 DEFINE_GEN(gen_op_divwu_T0_T1,void,(void))
8292 #ifdef DYNGEN_IMPL
8293 #define HAVE_gen_op_divwu_T0_T1
8294 {
8295 static const uint8 op_divwu_T0_T1_code[] = {
8296 0x83, 0xec, 0x04, 0x31, 0xc9, 0x85, 0xf6, 0x89, 0x34, 0x24, 0x74, 0x08,
8297 0x89, 0xd8, 0x31, 0xd2, 0xf7, 0xf6, 0x89, 0xc1, 0x58, 0x89, 0xcb
8298 };
8299 copy_block(op_divwu_T0_T1_code, 23);
8300 inc_code_ptr(23);
8301 }
8302 #endif
8303
8304 DEFINE_GEN(gen_op_divwuo_T0_T1,void,(void))
8305 #ifdef DYNGEN_IMPL
8306 #define HAVE_gen_op_divwuo_T0_T1
8307 {
8308 static const uint8 op_divwuo_T0_T1_code[] = {
8309 0x85, 0xf6, 0x89, 0xf1, 0x75, 0x10, 0x80, 0x8d, 0x94, 0x03, 0x00, 0x00,
8310 0x01, 0xc6, 0x85, 0x95, 0x03, 0x00, 0x00, 0x01, 0xeb, 0x0f, 0xc6, 0x85,
8311 0x95, 0x03, 0x00, 0x00, 0x00, 0x89, 0xd8, 0x31, 0xd2, 0xf7, 0xf6, 0x89,
8312 0xc1, 0x89, 0xcb
8313 };
8314 copy_block(op_divwuo_T0_T1_code, 39);
8315 inc_code_ptr(39);
8316 }
8317 #endif
8318
8319 DEFINE_GEN(gen_op_mulhw_T0_T1,void,(void))
8320 #ifdef DYNGEN_IMPL
8321 #define HAVE_gen_op_mulhw_T0_T1
8322 {
8323 static const uint8 op_mulhw_T0_T1_code[] = {
8324 0x89, 0xda, 0x89, 0xf0, 0xf7, 0xea, 0x89, 0xd3
8325 };
8326 copy_block(op_mulhw_T0_T1_code, 8);
8327 inc_code_ptr(8);
8328 }
8329 #endif
8330
8331 DEFINE_GEN(gen_op_mulhwu_T0_T1,void,(void))
8332 #ifdef DYNGEN_IMPL
8333 #define HAVE_gen_op_mulhwu_T0_T1
8334 {
8335 static const uint8 op_mulhwu_T0_T1_code[] = {
8336 0x89, 0xda, 0x89, 0xf0, 0xf7, 0xe2, 0x89, 0xd3
8337 };
8338 copy_block(op_mulhwu_T0_T1_code, 8);
8339 inc_code_ptr(8);
8340 }
8341 #endif
8342
8343 DEFINE_GEN(gen_op_mulli_T0_im,void,(long param1))
8344 #ifdef DYNGEN_IMPL
8345 #define HAVE_gen_op_mulli_T0_im
8346 {
8347 static const uint8 op_mulli_T0_im_code[] = {
8348 0x69, 0xdb, 0x00, 0x00, 0x00, 0x00
8349 };
8350 copy_block(op_mulli_T0_im_code, 6);
8351 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
8352 inc_code_ptr(6);
8353 }
8354 #endif
8355
8356 DEFINE_GEN(gen_op_mullwo_T0_T1,void,(void))
8357 #ifdef DYNGEN_IMPL
8358 #define HAVE_gen_op_mullwo_T0_T1
8359 {
8360 static const uint8 op_mullwo_T0_T1_code[] = {
8361 0x89, 0xd8, 0x83, 0xec, 0x08, 0xf7, 0xee, 0x89, 0x04, 0x24, 0x8b, 0x04,
8362 0x24, 0x89, 0x54, 0x24, 0x04, 0x8b, 0x1c, 0x24, 0x99, 0x33, 0x54, 0x24,
8363 0x04, 0x33, 0x04, 0x24, 0x09, 0xd0, 0x0f, 0x95, 0xc0, 0x0f, 0xb6, 0xc0,
8364 0x88, 0x85, 0x95, 0x03, 0x00, 0x00, 0x08, 0x85, 0x94, 0x03, 0x00, 0x00,
8365 0x83, 0xc4, 0x08
8366 };
8367 copy_block(op_mullwo_T0_T1_code, 51);
8368 inc_code_ptr(51);
8369 }
8370 #endif
8371
8372 DEFINE_GEN(gen_op_slw_T0_T1,void,(void))
8373 #ifdef DYNGEN_IMPL
8374 #define HAVE_gen_op_slw_T0_T1
8375 {
8376 static const uint8 op_slw_T0_T1_code[] = {
8377 0x89, 0xf0, 0x89, 0xf1, 0xd3, 0xe3, 0xa8, 0x20, 0x74, 0x02, 0x31, 0xdb
8378 };
8379 copy_block(op_slw_T0_T1_code, 12);
8380 inc_code_ptr(12);
8381 }
8382 #endif
8383
8384 DEFINE_GEN(gen_op_srw_T0_T1,void,(void))
8385 #ifdef DYNGEN_IMPL
8386 #define HAVE_gen_op_srw_T0_T1
8387 {
8388 static const uint8 op_srw_T0_T1_code[] = {
8389 0x89, 0xf0, 0x89, 0xf1, 0xd3, 0xeb, 0xa8, 0x20, 0x74, 0x02, 0x31, 0xdb
8390 };
8391 copy_block(op_srw_T0_T1_code, 12);
8392 inc_code_ptr(12);
8393 }
8394 #endif
8395
8396 DEFINE_GEN(gen_op_sraw_T0_T1,void,(void))
8397 #ifdef DYNGEN_IMPL
8398 #define HAVE_gen_op_sraw_T0_T1
8399 {
8400 static const uint8 op_sraw_T0_T1_code[] = {
8401 0x89, 0xf0, 0x83, 0xec, 0x04, 0x83, 0xe0, 0x3f, 0x89, 0xc6, 0xc1, 0xe8,
8402 0x05, 0x84, 0xc0, 0x74, 0x11, 0x89, 0xd8, 0xc1, 0xe8, 0x1f, 0x89, 0xc3,
8403 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0xf7, 0xdb, 0xeb, 0x3b, 0xc6, 0x44,
8404 0x24, 0x03, 0x00, 0x89, 0xf1, 0x89, 0xda, 0xd3, 0xfa, 0x85, 0xdb, 0x79,
8405 0x1f, 0xb8, 0xff, 0xff, 0xff, 0xff, 0xd3, 0xe0, 0xf7, 0xd0, 0x85, 0xd8,
8406 0x74, 0x12, 0xc6, 0x44, 0x24, 0x03, 0x01, 0x8d, 0xb6, 0x00, 0x00, 0x00,
8407 0x00, 0x8d, 0xbc, 0x27, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xb6, 0x44, 0x24,
8408 0x03, 0x89, 0xd3, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x58
8409 };
8410 copy_block(op_sraw_T0_T1_code, 94);
8411 inc_code_ptr(94);
8412 }
8413 #endif
8414
8415 DEFINE_GEN(gen_op_sraw_T0_im,void,(long param1))
8416 #ifdef DYNGEN_IMPL
8417 #define HAVE_gen_op_sraw_T0_im
8418 {
8419 static const uint8 op_sraw_T0_im_code[] = {
8420 0xb8, 0x00, 0x00, 0x00, 0x00, 0x89, 0xda, 0x88, 0xc1, 0x83, 0xec, 0x04,
8421 0xd3, 0xfa, 0x85, 0xdb, 0xc6, 0x44, 0x24, 0x03, 0x00, 0x79, 0x19, 0xb8,
8422 0xff, 0xff, 0xff, 0xff, 0xd3, 0xe0, 0xf7, 0xd0, 0x85, 0xc3, 0x74, 0x0c,
8423 0xc6, 0x44, 0x24, 0x03, 0x01, 0x8d, 0xb4, 0x26, 0x00, 0x00, 0x00, 0x00,
8424 0x0f, 0xb6, 0x44, 0x24, 0x03, 0x89, 0xd3, 0x88, 0x85, 0x96, 0x03, 0x00,
8425 0x00, 0x5a
8426 };
8427 copy_block(op_sraw_T0_im_code, 62);
8428 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
8429 inc_code_ptr(62);
8430 }
8431 #endif
8432
8433 DEFINE_GEN(gen_op_rlwimi_T0_T1,void,(long param1, long param2))
8434 #ifdef DYNGEN_IMPL
8435 #define HAVE_gen_op_rlwimi_T0_T1
8436 {
8437 static const uint8 op_rlwimi_T0_T1_code[] = {
8438 0xb9, 0x00, 0x00, 0x00, 0x00, 0x89, 0xf2, 0xb8, 0x00, 0x00, 0x00, 0x00,
8439 0xd3, 0xc2, 0x21, 0xc2, 0xf7, 0xd0, 0x21, 0xd8, 0x89, 0xd3, 0x09, 0xc3
8440 };
8441 copy_block(op_rlwimi_T0_T1_code, 24);
8442 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
8443 *(uint32_t *)(code_ptr() + 8) = param2 + 0;
8444 inc_code_ptr(24);
8445 }
8446 #endif
8447
8448 DEFINE_GEN(gen_op_rlwinm_T0_T1,void,(long param1, long param2))
8449 #ifdef DYNGEN_IMPL
8450 #define HAVE_gen_op_rlwinm_T0_T1
8451 {
8452 static const uint8 op_rlwinm_T0_T1_code[] = {
8453 0x89, 0xd8, 0xb9, 0x00, 0x00, 0x00, 0x00, 0xd3, 0xc0, 0x89, 0xc3, 0x81,
8454 0xe3, 0x00, 0x00, 0x00, 0x00
8455 };
8456 copy_block(op_rlwinm_T0_T1_code, 17);
8457 *(uint32_t *)(code_ptr() + 3) = param1 + 0;
8458 *(uint32_t *)(code_ptr() + 13) = param2 + 0;
8459 inc_code_ptr(17);
8460 }
8461 #endif
8462
8463 DEFINE_GEN(gen_op_rlwnm_T0_T1,void,(long param1))
8464 #ifdef DYNGEN_IMPL
8465 #define HAVE_gen_op_rlwnm_T0_T1
8466 {
8467 static const uint8 op_rlwnm_T0_T1_code[] = {
8468 0x89, 0xd8, 0x89, 0xf1, 0xd3, 0xc0, 0x89, 0xc3, 0x81, 0xe3, 0x00, 0x00,
8469 0x00, 0x00
8470 };
8471 copy_block(op_rlwnm_T0_T1_code, 14);
8472 *(uint32_t *)(code_ptr() + 10) = param1 + 0;
8473 inc_code_ptr(14);
8474 }
8475 #endif
8476
8477 DEFINE_GEN(gen_op_cntlzw_32_T0,void,(void))
8478 #ifdef DYNGEN_IMPL
8479 #define HAVE_gen_op_cntlzw_32_T0
8480 {
8481 static const uint8 op_cntlzw_32_T0_code[] = {
8482 0xb8, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xbd, 0xc3, 0xba, 0x1f, 0x00, 0x00,
8483 0x00, 0x89, 0xd3, 0x29, 0xc3
8484 };
8485 copy_block(op_cntlzw_32_T0_code, 17);
8486 inc_code_ptr(17);
8487 }
8488 #endif
8489
8490 DEFINE_GEN(gen_op_addo_T0_T1,void,(void))
8491 #ifdef DYNGEN_IMPL
8492 #define HAVE_gen_op_addo_T0_T1
8493 {
8494 static const uint8 op_addo_T0_T1_code[] = {
8495 0x01, 0xf3, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, 0x00, 0x00, 0x88,
8496 0x95, 0x95, 0x03, 0x00, 0x00
8497 };
8498 copy_block(op_addo_T0_T1_code, 17);
8499 inc_code_ptr(17);
8500 }
8501 #endif
8502
8503 DEFINE_GEN(gen_op_addc_T0_im,void,(long param1))
8504 #ifdef DYNGEN_IMPL
8505 #define HAVE_gen_op_addc_T0_im
8506 {
8507 static const uint8 op_addc_T0_im_code[] = {
8508 0x8d, 0x93, 0x00, 0x00, 0x00, 0x00, 0x39, 0xda, 0x0f, 0x92, 0x85, 0x96,
8509 0x03, 0x00, 0x00, 0x89, 0xd3
8510 };
8511 copy_block(op_addc_T0_im_code, 17);
8512 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
8513 inc_code_ptr(17);
8514 }
8515 #endif
8516
8517 DEFINE_GEN(gen_op_addc_T0_T1,void,(void))
8518 #ifdef DYNGEN_IMPL
8519 #define HAVE_gen_op_addc_T0_T1
8520 {
8521 static const uint8 op_addc_T0_T1_code[] = {
8522 0x01, 0xf3, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00
8523 };
8524 copy_block(op_addc_T0_T1_code, 11);
8525 inc_code_ptr(11);
8526 }
8527 #endif
8528
8529 DEFINE_GEN(gen_op_addco_T0_T1,void,(void))
8530 #ifdef DYNGEN_IMPL
8531 #define HAVE_gen_op_addco_T0_T1
8532 {
8533 static const uint8 op_addco_T0_T1_code[] = {
8534 0x01, 0xf3, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03,
8535 0x00, 0x00, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x88, 0x95, 0x95, 0x03,
8536 0x00, 0x00
8537 };
8538 copy_block(op_addco_T0_T1_code, 26);
8539 inc_code_ptr(26);
8540 }
8541 #endif
8542
8543 DEFINE_GEN(gen_op_adde_T0_T1,void,(void))
8544 #ifdef DYNGEN_IMPL
8545 #define HAVE_gen_op_adde_T0_T1
8546 {
8547 static const uint8 op_adde_T0_T1_code[] = {
8548 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x11,
8549 0xf3, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00
8550 };
8551 copy_block(op_adde_T0_T1_code, 22);
8552 inc_code_ptr(22);
8553 }
8554 #endif
8555
8556 DEFINE_GEN(gen_op_addeo_T0_T1,void,(void))
8557 #ifdef DYNGEN_IMPL
8558 #define HAVE_gen_op_addeo_T0_T1
8559 {
8560 static const uint8 op_addeo_T0_T1_code[] = {
8561 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x11,
8562 0xf3, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, 0x00,
8563 0x00, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x88, 0x95, 0x95, 0x03, 0x00,
8564 0x00
8565 };
8566 copy_block(op_addeo_T0_T1_code, 37);
8567 inc_code_ptr(37);
8568 }
8569 #endif
8570
8571 DEFINE_GEN(gen_op_addme_T0,void,(void))
8572 #ifdef DYNGEN_IMPL
8573 #define HAVE_gen_op_addme_T0
8574 {
8575 static const uint8 op_addme_T0_code[] = {
8576 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x83,
8577 0xd3, 0xff, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00
8578 };
8579 copy_block(op_addme_T0_code, 23);
8580 inc_code_ptr(23);
8581 }
8582 #endif
8583
8584 DEFINE_GEN(gen_op_addmeo_T0,void,(void))
8585 #ifdef DYNGEN_IMPL
8586 #define HAVE_gen_op_addmeo_T0
8587 {
8588 static const uint8 op_addmeo_T0_code[] = {
8589 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x83,
8590 0xd3, 0xff, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03,
8591 0x00, 0x00, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x88, 0x95, 0x95, 0x03,
8592 0x00, 0x00
8593 };
8594 copy_block(op_addmeo_T0_code, 38);
8595 inc_code_ptr(38);
8596 }
8597 #endif
8598
8599 DEFINE_GEN(gen_op_addze_T0,void,(void))
8600 #ifdef DYNGEN_IMPL
8601 #define HAVE_gen_op_addze_T0
8602 {
8603 static const uint8 op_addze_T0_code[] = {
8604 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x83,
8605 0xd3, 0x00, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00
8606 };
8607 copy_block(op_addze_T0_code, 23);
8608 inc_code_ptr(23);
8609 }
8610 #endif
8611
8612 DEFINE_GEN(gen_op_addzeo_T0,void,(void))
8613 #ifdef DYNGEN_IMPL
8614 #define HAVE_gen_op_addzeo_T0
8615 {
8616 static const uint8 op_addzeo_T0_code[] = {
8617 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x0f, 0xba, 0xe0, 0x00, 0x83,
8618 0xd3, 0x00, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03,
8619 0x00, 0x00, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x88, 0x95, 0x95, 0x03,
8620 0x00, 0x00
8621 };
8622 copy_block(op_addzeo_T0_code, 38);
8623 inc_code_ptr(38);
8624 }
8625 #endif
8626
8627 DEFINE_GEN(gen_op_subf_T0_T1,void,(void))
8628 #ifdef DYNGEN_IMPL
8629 #define HAVE_gen_op_subf_T0_T1
8630 {
8631 static const uint8 op_subf_T0_T1_code[] = {
8632 0x89, 0xf0, 0x29, 0xd8, 0x89, 0xc3
8633 };
8634 copy_block(op_subf_T0_T1_code, 6);
8635 inc_code_ptr(6);
8636 }
8637 #endif
8638
8639 DEFINE_GEN(gen_op_subfo_T0_T1,void,(void))
8640 #ifdef DYNGEN_IMPL
8641 #define HAVE_gen_op_subfo_T0_T1
8642 {
8643 static const uint8 op_subfo_T0_T1_code[] = {
8644 0x89, 0xf0, 0x29, 0xd8, 0x0f, 0x90, 0xc2, 0x08, 0x95, 0x94, 0x03, 0x00,
8645 0x00, 0x89, 0xc3, 0x88, 0x95, 0x95, 0x03, 0x00, 0x00
8646 };
8647 copy_block(op_subfo_T0_T1_code, 21);
8648 inc_code_ptr(21);
8649 }
8650 #endif
8651
8652 DEFINE_GEN(gen_op_subfc_T0_im,void,(long param1))
8653 #ifdef DYNGEN_IMPL
8654 #define HAVE_gen_op_subfc_T0_im
8655 {
8656 static const uint8 op_subfc_T0_im_code[] = {
8657 0xb8, 0x00, 0x00, 0x00, 0x00, 0x29, 0xd8, 0x3d, 0x00, 0x00, 0x00, 0x00,
8658 0x0f, 0x96, 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xc3
8659 };
8660 copy_block(op_subfc_T0_im_code, 21);
8661 *(uint32_t *)(code_ptr() + 1) = param1 + 0;
8662 *(uint32_t *)(code_ptr() + 8) = param1 + 0;
8663 inc_code_ptr(21);
8664 }
8665 #endif
8666
8667 DEFINE_GEN(gen_op_subfc_T0_T1,void,(void))
8668 #ifdef DYNGEN_IMPL
8669 #define HAVE_gen_op_subfc_T0_T1
8670 {
8671 static const uint8 op_subfc_T0_T1_code[] = {
8672 0x89, 0xf2, 0x29, 0xda, 0xf5, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03,
8673 0x00, 0x00, 0x89, 0xd3
8674 };
8675 copy_block(op_subfc_T0_T1_code, 16);
8676 inc_code_ptr(16);
8677 }
8678 #endif
8679
8680 DEFINE_GEN(gen_op_subfco_T0_T1,void,(void))
8681 #ifdef DYNGEN_IMPL
8682 #define HAVE_gen_op_subfco_T0_T1
8683 {
8684 static const uint8 op_subfco_T0_T1_code[] = {
8685 0x89, 0xf1, 0x29, 0xd9, 0xf5, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08,
8686 0x95, 0x94, 0x03, 0x00, 0x00, 0x89, 0xcb, 0x88, 0x85, 0x96, 0x03, 0x00,
8687 0x00, 0x88, 0x95, 0x95, 0x03, 0x00, 0x00
8688 };
8689 copy_block(op_subfco_T0_T1_code, 31);
8690 inc_code_ptr(31);
8691 }
8692 #endif
8693
8694 DEFINE_GEN(gen_op_subfe_T0_T1,void,(void))
8695 #ifdef DYNGEN_IMPL
8696 #define HAVE_gen_op_subfe_T0_T1
8697 {
8698 static const uint8 op_subfe_T0_T1_code[] = {
8699 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xf2, 0x0f, 0xba, 0xe0,
8700 0x00, 0xf5, 0x19, 0xda, 0xf5, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03,
8701 0x00, 0x00, 0x89, 0xd3
8702 };
8703 copy_block(op_subfe_T0_T1_code, 28);
8704 inc_code_ptr(28);
8705 }
8706 #endif
8707
8708 DEFINE_GEN(gen_op_subfeo_T0_T1,void,(void))
8709 #ifdef DYNGEN_IMPL
8710 #define HAVE_gen_op_subfeo_T0_T1
8711 {
8712 static const uint8 op_subfeo_T0_T1_code[] = {
8713 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xf1, 0x0f, 0xba, 0xe0,
8714 0x00, 0xf5, 0x19, 0xd9, 0xf5, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x08,
8715 0x95, 0x94, 0x03, 0x00, 0x00, 0x89, 0xcb, 0x88, 0x85, 0x96, 0x03, 0x00,
8716 0x00, 0x88, 0x95, 0x95, 0x03, 0x00, 0x00
8717 };
8718 copy_block(op_subfeo_T0_T1_code, 43);
8719 inc_code_ptr(43);
8720 }
8721 #endif
8722
8723 DEFINE_GEN(gen_op_subfme_T0,void,(void))
8724 #ifdef DYNGEN_IMPL
8725 #define HAVE_gen_op_subfme_T0
8726 {
8727 static const uint8 op_subfme_T0_code[] = {
8728 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0xba, 0xff, 0xff, 0xff, 0xff,
8729 0x0f, 0xba, 0xe0, 0x00, 0xf5, 0x19, 0xda, 0xf5, 0x0f, 0x92, 0xc0, 0x88,
8730 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xd3
8731 };
8732 copy_block(op_subfme_T0_code, 31);
8733 inc_code_ptr(31);
8734 }
8735 #endif
8736
8737 DEFINE_GEN(gen_op_subfmeo_T0,void,(void))
8738 #ifdef DYNGEN_IMPL
8739 #define HAVE_gen_op_subfmeo_T0
8740 {
8741 static const uint8 op_subfmeo_T0_code[] = {
8742 0x83, 0xec, 0x04, 0xb9, 0xff, 0xff, 0xff, 0xff, 0x0f, 0xb6, 0x95, 0x96,
8743 0x03, 0x00, 0x00, 0x89, 0xd0, 0x0f, 0xba, 0xe0, 0x00, 0xf5, 0x19, 0xd9,
8744 0xf5, 0x0f, 0x92, 0xc0, 0x0f, 0x90, 0xc2, 0x88, 0x85, 0x96, 0x03, 0x00,
8745 0x00, 0x89, 0xcb, 0x88, 0x95, 0x95, 0x03, 0x00, 0x00, 0x08, 0x95, 0x94,
8746 0x03, 0x00, 0x00, 0x59
8747 };
8748 copy_block(op_subfmeo_T0_code, 52);
8749 inc_code_ptr(52);
8750 }
8751 #endif
8752
8753 DEFINE_GEN(gen_op_subfze_T0,void,(void))
8754 #ifdef DYNGEN_IMPL
8755 #define HAVE_gen_op_subfze_T0
8756 {
8757 static const uint8 op_subfze_T0_code[] = {
8758 0x0f, 0xb6, 0x85, 0x96, 0x03, 0x00, 0x00, 0x31, 0xd2, 0x0f, 0xba, 0xe0,
8759 0x00, 0xf5, 0x19, 0xda, 0xf5, 0x0f, 0x92, 0xc0, 0x88, 0x85, 0x96, 0x03,
8760 0x00, 0x00, 0x89, 0xd3
8761 };
8762 copy_block(op_subfze_T0_code, 28);
8763 inc_code_ptr(28);
8764 }
8765 #endif
8766
8767 DEFINE_GEN(gen_op_subfzeo_T0,void,(void))
8768 #ifdef DYNGEN_IMPL
8769 #define HAVE_gen_op_subfzeo_T0
8770 {
8771 static const uint8 op_subfzeo_T0_code[] = {
8772 0x83, 0xec, 0x04, 0x31, 0xc9, 0x0f, 0xb6, 0x95, 0x96, 0x03, 0x00, 0x00,
8773 0x89, 0xd0, 0x0f, 0xba, 0xe0, 0x00, 0xf5, 0x19, 0xd9, 0xf5, 0x0f, 0x92,
8774 0xc0, 0x0f, 0x90, 0xc2, 0x88, 0x85, 0x96, 0x03, 0x00, 0x00, 0x89, 0xcb,
8775 0x88, 0x95, 0x95, 0x03, 0x00, 0x00, 0x08, 0x95, 0x94, 0x03, 0x00, 0x00,
8776 0x58
8777 };
8778 copy_block(op_subfzeo_T0_code, 49);
8779 inc_code_ptr(49);
8780 }
8781 #endif
8782
8783 DEFINE_GEN(gen_op_inc_32_mem,void,(long param1))
8784 #ifdef DYNGEN_IMPL
8785 #define HAVE_gen_op_inc_32_mem
8786 {
8787 static const uint8 op_inc_32_mem_code[] = {
8788 0xff, 0x05, 0x00, 0x00, 0x00, 0x00
8789 };
8790 copy_block(op_inc_32_mem_code, 6);
8791 *(uint32_t *)(code_ptr() + 2) = param1 + 0;
8792 inc_code_ptr(6);
8793 }
8794 #endif
8795
8796 DEFINE_GEN(gen_op_nego_T0,void,(void))
8797 #ifdef DYNGEN_IMPL
8798 #define HAVE_gen_op_nego_T0
8799 {
8800 static const uint8 op_nego_T0_code[] = {
8801 0x31, 0xd2, 0x81, 0xfb, 0x00, 0x00, 0x00, 0x80, 0x0f, 0x94, 0xc2, 0x08,
8802 0x95, 0x94, 0x03, 0x00, 0x00, 0xf7, 0xdb, 0x88, 0x95, 0x95, 0x03, 0x00,
8803 0x00
8804 };
8805 copy_block(op_nego_T0_code, 25);
8806 inc_code_ptr(25);
8807 }
8808 #endif
8809
8810 DEFINE_GEN(gen_op_dcbz_T0,void,(void))
8811 #ifdef DYNGEN_IMPL
8812 #define HAVE_gen_op_dcbz_T0
8813 {
8814 static const uint8 op_dcbz_T0_code[] = {
8815 0x83, 0xe3, 0xe0, 0x31, 0xc9, 0x8d, 0x83, 0x00, 0x00, 0x00, 0x11, 0x89,
8816 0x8b, 0x00, 0x00, 0x00, 0x11, 0x31, 0xc9, 0x89, 0x8b, 0x04, 0x00, 0x00,
8817 0x11, 0xc7, 0x40, 0x08, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x40, 0x0c, 0x00,
8818 0x00, 0x00, 0x00, 0xc7, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x40,
8819 0x14, 0x00, 0x00, 0x00, 0x00, 0xc7, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00,
8820 0xc7, 0x40, 0x1c, 0x00, 0x00, 0x00, 0x00
8821 };
8822 copy_block(op_dcbz_T0_code, 67);
8823 inc_code_ptr(67);
8824 }
8825 #endif
8826
8827 DEFINE_GEN(gen_op_lmw_T0_im,void,(long param1))
8828 #ifdef DYNGEN_IMPL
8829 #define HAVE_gen_op_lmw_T0_im
8830 {
8831 static const uint8 op_lmw_T0_im_code[] = {
8832 0x83, 0xec, 0x04, 0x89, 0xd9, 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00,
8833 0x83, 0x3c, 0x24, 0x1f, 0x77, 0x27, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x8d,
8834 0x54, 0x85, 0x10, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x8b, 0x81, 0x00, 0x00,
8835 0x00, 0x11, 0x0f, 0xc8, 0xff, 0x04, 0x24, 0x83, 0xc1, 0x04, 0x89, 0x02,
8836 0x83, 0xc2, 0x04, 0x83, 0x3c, 0x24, 0x1f, 0x76, 0xe7, 0x58
8837 };
8838 copy_block(op_lmw_T0_im_code, 58);
8839 *(uint32_t *)(code_ptr() + 8) = param1 + 0;
8840 *(uint32_t *)(code_ptr() + 19) = param1 + 0;
8841 inc_code_ptr(58);
8842 }
8843 #endif
8844
8845 DEFINE_GEN(gen_op_stmw_T0_im,void,(long param1))
8846 #ifdef DYNGEN_IMPL
8847 #define HAVE_gen_op_stmw_T0_im
8848 {
8849 static const uint8 op_stmw_T0_im_code[] = {
8850 0x83, 0xec, 0x04, 0x89, 0xd9, 0xc7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00,
8851 0x83, 0x3c, 0x24, 0x1f, 0x77, 0x27, 0xb8, 0x00, 0x00, 0x00, 0x00, 0x8d,
8852 0x54, 0x85, 0x10, 0x90, 0x8d, 0x74, 0x26, 0x00, 0x8b, 0x02, 0x0f, 0xc8,
8853 0xff, 0x04, 0x24, 0x83, 0xc2, 0x04, 0x89, 0x81, 0x00, 0x00, 0x00, 0x11,
8854 0x83, 0xc1, 0x04, 0x83, 0x3c, 0x24, 0x1f, 0x76, 0xe7, 0x58
8855 };
8856 copy_block(op_stmw_T0_im_code, 58);
8857 *(uint32_t *)(code_ptr() + 8) = param1 + 0;
8858 *(uint32_t *)(code_ptr() + 19) = param1 + 0;
8859 inc_code_ptr(58);
8860 }
8861 #endif
8862
8863 DEFINE_GEN(gen_op_lmw_T0_29,void,(void))
8864 #ifdef DYNGEN_IMPL
8865 #define HAVE_gen_op_lmw_T0_29
8866 {
8867 static const uint8 op_lmw_T0_29_code[] = {
8868 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x84, 0x00,
8869 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f,
8870 0xc8, 0x89, 0x85, 0x88, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83,
8871 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x8c, 0x00, 0x00, 0x00
8872 };
8873 copy_block(op_lmw_T0_29_code, 48);
8874 inc_code_ptr(48);
8875 }
8876 #endif
8877
8878 DEFINE_GEN(gen_op_lmw_T0_28,void,(void))
8879 #ifdef DYNGEN_IMPL
8880 #define HAVE_gen_op_lmw_T0_28
8881 {
8882 static const uint8 op_lmw_T0_28_code[] = {
8883 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x80, 0x00,
8884 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f,
8885 0xc8, 0x89, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83,
8886 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x88, 0x00, 0x00, 0x00,
8887 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89,
8888 0x85, 0x8c, 0x00, 0x00, 0x00
8889 };
8890 copy_block(op_lmw_T0_28_code, 65);
8891 inc_code_ptr(65);
8892 }
8893 #endif
8894
8895 DEFINE_GEN(gen_op_lmw_T0_27,void,(void))
8896 #ifdef DYNGEN_IMPL
8897 #define HAVE_gen_op_lmw_T0_27
8898 {
8899 static const uint8 op_lmw_T0_27_code[] = {
8900 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x45, 0x7c, 0x83,
8901 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85,
8902 0x80, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00,
8903 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04,
8904 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x88, 0x00,
8905 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f,
8906 0xc8, 0x89, 0x85, 0x8c, 0x00, 0x00, 0x00
8907 };
8908 copy_block(op_lmw_T0_27_code, 79);
8909 inc_code_ptr(79);
8910 }
8911 #endif
8912
8913 DEFINE_GEN(gen_op_lmw_T0_26,void,(void))
8914 #ifdef DYNGEN_IMPL
8915 #define HAVE_gen_op_lmw_T0_26
8916 {
8917 static const uint8 op_lmw_T0_26_code[] = {
8918 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x45, 0x78, 0x83,
8919 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x45,
8920 0x7c, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8,
8921 0x89, 0x85, 0x80, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00,
8922 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83,
8923 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85,
8924 0x88, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00,
8925 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x8c, 0x00, 0x00, 0x00
8926 };
8927 copy_block(op_lmw_T0_26_code, 93);
8928 inc_code_ptr(93);
8929 }
8930 #endif
8931
8932 DEFINE_GEN(gen_op_lmw_T0_30,void,(void))
8933 #ifdef DYNGEN_IMPL
8934 #define HAVE_gen_op_lmw_T0_30
8935 {
8936 static const uint8 op_lmw_T0_30_code[] = {
8937 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x88, 0x00,
8938 0x00, 0x00, 0x83, 0xc3, 0x04, 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f,
8939 0xc8, 0x89, 0x85, 0x8c, 0x00, 0x00, 0x00
8940 };
8941 copy_block(op_lmw_T0_30_code, 31);
8942 inc_code_ptr(31);
8943 }
8944 #endif
8945
8946 DEFINE_GEN(gen_op_stmw_T0_29,void,(void))
8947 #ifdef DYNGEN_IMPL
8948 #define HAVE_gen_op_stmw_T0_29
8949 {
8950 static const uint8 op_stmw_T0_29_code[] = {
8951 0x8b, 0x85, 0x84, 0x00, 0x00, 0x00, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00,
8952 0x00, 0x11, 0x8b, 0x85, 0x88, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f,
8953 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x8c, 0x00, 0x00,
8954 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11
8955 };
8956 copy_block(op_stmw_T0_29_code, 48);
8957 inc_code_ptr(48);
8958 }
8959 #endif
8960
8961 DEFINE_GEN(gen_op_stmw_T0_28,void,(void))
8962 #ifdef DYNGEN_IMPL
8963 #define HAVE_gen_op_stmw_T0_28
8964 {
8965 static const uint8 op_stmw_T0_28_code[] = {
8966 0x8b, 0x85, 0x80, 0x00, 0x00, 0x00, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00,
8967 0x00, 0x11, 0x8b, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f,
8968 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x88, 0x00, 0x00,
8969 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11,
8970 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89,
8971 0x83, 0x00, 0x00, 0x00, 0x11
8972 };
8973 copy_block(op_stmw_T0_28_code, 65);
8974 inc_code_ptr(65);
8975 }
8976 #endif
8977
8978 DEFINE_GEN(gen_op_stmw_T0_27,void,(void))
8979 #ifdef DYNGEN_IMPL
8980 #define HAVE_gen_op_stmw_T0_27
8981 {
8982 static const uint8 op_stmw_T0_27_code[] = {
8983 0x8b, 0x45, 0x7c, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b,
8984 0x85, 0x80, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83,
8985 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x84, 0x00, 0x00, 0x00, 0x83, 0xc3,
8986 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x88,
8987 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00,
8988 0x00, 0x11, 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f,
8989 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11
8990 };
8991 copy_block(op_stmw_T0_27_code, 79);
8992 inc_code_ptr(79);
8993 }
8994 #endif
8995
8996 DEFINE_GEN(gen_op_stmw_T0_26,void,(void))
8997 #ifdef DYNGEN_IMPL
8998 #define HAVE_gen_op_stmw_T0_26
8999 {
9000 static const uint8 op_stmw_T0_26_code[] = {
9001 0x8b, 0x45, 0x78, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b,
9002 0x45, 0x7c, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00,
9003 0x11, 0x8b, 0x85, 0x80, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8,
9004 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x84, 0x00, 0x00, 0x00,
9005 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11, 0x8b,
9006 0x85, 0x88, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f, 0xc8, 0x89, 0x83,
9007 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x83, 0xc3,
9008 0x04, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11
9009 };
9010 copy_block(op_stmw_T0_26_code, 93);
9011 inc_code_ptr(93);
9012 }
9013 #endif
9014
9015 DEFINE_GEN(gen_op_stmw_T0_30,void,(void))
9016 #ifdef DYNGEN_IMPL
9017 #define HAVE_gen_op_stmw_T0_30
9018 {
9019 static const uint8 op_stmw_T0_30_code[] = {
9020 0x8b, 0x85, 0x88, 0x00, 0x00, 0x00, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00,
9021 0x00, 0x11, 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x83, 0xc3, 0x04, 0x0f,
9022 0xc8, 0x89, 0x83, 0x00, 0x00, 0x00, 0x11
9023 };
9024 copy_block(op_stmw_T0_30_code, 31);
9025 inc_code_ptr(31);
9026 }
9027 #endif
9028
9029 DEFINE_GEN(gen_op_lmw_T0_31,void,(void))
9030 #ifdef DYNGEN_IMPL
9031 #define HAVE_gen_op_lmw_T0_31
9032 {
9033 static const uint8 op_lmw_T0_31_code[] = {
9034 0x8b, 0x83, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x85, 0x8c, 0x00,
9035 0x00, 0x00
9036 };
9037 copy_block(op_lmw_T0_31_code, 14);
9038 inc_code_ptr(14);
9039 }
9040 #endif
9041
9042 DEFINE_GEN(gen_op_stmw_T0_31,void,(void))
9043 #ifdef DYNGEN_IMPL
9044 #define HAVE_gen_op_stmw_T0_31
9045 {
9046 static const uint8 op_stmw_T0_31_code[] = {
9047 0x8b, 0x85, 0x8c, 0x00, 0x00, 0x00, 0x0f, 0xc8, 0x89, 0x83, 0x00, 0x00,
9048 0x00, 0x11
9049 };
9050 copy_block(op_stmw_T0_31_code, 14);
9051 inc_code_ptr(14);
9052 }
9053 #endif
9054
9055 DEFINE_GEN(gen_op_load_ad_VD_VR0,void,(void))
9056 #ifdef DYNGEN_IMPL
9057 #define HAVE_gen_op_load_ad_VD_VR0
9058 {
9059 static const uint8 op_load_ad_VD_VR0_code[] = {
9060 0x8d, 0x85, 0x90, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9061 };
9062 copy_block(op_load_ad_VD_VR0_code, 12);
9063 inc_code_ptr(12);
9064 }
9065 #endif
9066
9067 DEFINE_GEN(gen_op_load_ad_V0_VR0,void,(void))
9068 #ifdef DYNGEN_IMPL
9069 #define HAVE_gen_op_load_ad_V0_VR0
9070 {
9071 static const uint8 op_load_ad_V0_VR0_code[] = {
9072 0x8d, 0x9d, 0x90, 0x01, 0x00, 0x00
9073 };
9074 copy_block(op_load_ad_V0_VR0_code, 6);
9075 inc_code_ptr(6);
9076 }
9077 #endif
9078
9079 DEFINE_GEN(gen_op_load_ad_V1_VR0,void,(void))
9080 #ifdef DYNGEN_IMPL
9081 #define HAVE_gen_op_load_ad_V1_VR0
9082 {
9083 static const uint8 op_load_ad_V1_VR0_code[] = {
9084 0x8d, 0xb5, 0x90, 0x01, 0x00, 0x00
9085 };
9086 copy_block(op_load_ad_V1_VR0_code, 6);
9087 inc_code_ptr(6);
9088 }
9089 #endif
9090
9091 DEFINE_GEN(gen_op_load_ad_V2_VR0,void,(void))
9092 #ifdef DYNGEN_IMPL
9093 #define HAVE_gen_op_load_ad_V2_VR0
9094 {
9095 static const uint8 op_load_ad_V2_VR0_code[] = {
9096 0x8d, 0xbd, 0x90, 0x01, 0x00, 0x00
9097 };
9098 copy_block(op_load_ad_V2_VR0_code, 6);
9099 inc_code_ptr(6);
9100 }
9101 #endif
9102
9103 DEFINE_GEN(gen_op_load_ad_VD_VR1,void,(void))
9104 #ifdef DYNGEN_IMPL
9105 #define HAVE_gen_op_load_ad_VD_VR1
9106 {
9107 static const uint8 op_load_ad_VD_VR1_code[] = {
9108 0x8d, 0x85, 0xa0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9109 };
9110 copy_block(op_load_ad_VD_VR1_code, 12);
9111 inc_code_ptr(12);
9112 }
9113 #endif
9114
9115 DEFINE_GEN(gen_op_load_ad_V0_VR1,void,(void))
9116 #ifdef DYNGEN_IMPL
9117 #define HAVE_gen_op_load_ad_V0_VR1
9118 {
9119 static const uint8 op_load_ad_V0_VR1_code[] = {
9120 0x8d, 0x9d, 0xa0, 0x01, 0x00, 0x00
9121 };
9122 copy_block(op_load_ad_V0_VR1_code, 6);
9123 inc_code_ptr(6);
9124 }
9125 #endif
9126
9127 DEFINE_GEN(gen_op_load_ad_V1_VR1,void,(void))
9128 #ifdef DYNGEN_IMPL
9129 #define HAVE_gen_op_load_ad_V1_VR1
9130 {
9131 static const uint8 op_load_ad_V1_VR1_code[] = {
9132 0x8d, 0xb5, 0xa0, 0x01, 0x00, 0x00
9133 };
9134 copy_block(op_load_ad_V1_VR1_code, 6);
9135 inc_code_ptr(6);
9136 }
9137 #endif
9138
9139 DEFINE_GEN(gen_op_load_ad_V2_VR1,void,(void))
9140 #ifdef DYNGEN_IMPL
9141 #define HAVE_gen_op_load_ad_V2_VR1
9142 {
9143 static const uint8 op_load_ad_V2_VR1_code[] = {
9144 0x8d, 0xbd, 0xa0, 0x01, 0x00, 0x00
9145 };
9146 copy_block(op_load_ad_V2_VR1_code, 6);
9147 inc_code_ptr(6);
9148 }
9149 #endif
9150
9151 DEFINE_GEN(gen_op_load_ad_VD_VR2,void,(void))
9152 #ifdef DYNGEN_IMPL
9153 #define HAVE_gen_op_load_ad_VD_VR2
9154 {
9155 static const uint8 op_load_ad_VD_VR2_code[] = {
9156 0x8d, 0x85, 0xb0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9157 };
9158 copy_block(op_load_ad_VD_VR2_code, 12);
9159 inc_code_ptr(12);
9160 }
9161 #endif
9162
9163 DEFINE_GEN(gen_op_load_ad_V0_VR2,void,(void))
9164 #ifdef DYNGEN_IMPL
9165 #define HAVE_gen_op_load_ad_V0_VR2
9166 {
9167 static const uint8 op_load_ad_V0_VR2_code[] = {
9168 0x8d, 0x9d, 0xb0, 0x01, 0x00, 0x00
9169 };
9170 copy_block(op_load_ad_V0_VR2_code, 6);
9171 inc_code_ptr(6);
9172 }
9173 #endif
9174
9175 DEFINE_GEN(gen_op_load_ad_V1_VR2,void,(void))
9176 #ifdef DYNGEN_IMPL
9177 #define HAVE_gen_op_load_ad_V1_VR2
9178 {
9179 static const uint8 op_load_ad_V1_VR2_code[] = {
9180 0x8d, 0xb5, 0xb0, 0x01, 0x00, 0x00
9181 };
9182 copy_block(op_load_ad_V1_VR2_code, 6);
9183 inc_code_ptr(6);
9184 }
9185 #endif
9186
9187 DEFINE_GEN(gen_op_load_ad_V2_VR2,void,(void))
9188 #ifdef DYNGEN_IMPL
9189 #define HAVE_gen_op_load_ad_V2_VR2
9190 {
9191 static const uint8 op_load_ad_V2_VR2_code[] = {
9192 0x8d, 0xbd, 0xb0, 0x01, 0x00, 0x00
9193 };
9194 copy_block(op_load_ad_V2_VR2_code, 6);
9195 inc_code_ptr(6);
9196 }
9197 #endif
9198
9199 DEFINE_GEN(gen_op_load_ad_VD_VR3,void,(void))
9200 #ifdef DYNGEN_IMPL
9201 #define HAVE_gen_op_load_ad_VD_VR3
9202 {
9203 static const uint8 op_load_ad_VD_VR3_code[] = {
9204 0x8d, 0x85, 0xc0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9205 };
9206 copy_block(op_load_ad_VD_VR3_code, 12);
9207 inc_code_ptr(12);
9208 }
9209 #endif
9210
9211 DEFINE_GEN(gen_op_load_ad_V0_VR3,void,(void))
9212 #ifdef DYNGEN_IMPL
9213 #define HAVE_gen_op_load_ad_V0_VR3
9214 {
9215 static const uint8 op_load_ad_V0_VR3_code[] = {
9216 0x8d, 0x9d, 0xc0, 0x01, 0x00, 0x00
9217 };
9218 copy_block(op_load_ad_V0_VR3_code, 6);
9219 inc_code_ptr(6);
9220 }
9221 #endif
9222
9223 DEFINE_GEN(gen_op_load_ad_V1_VR3,void,(void))
9224 #ifdef DYNGEN_IMPL
9225 #define HAVE_gen_op_load_ad_V1_VR3
9226 {
9227 static const uint8 op_load_ad_V1_VR3_code[] = {
9228 0x8d, 0xb5, 0xc0, 0x01, 0x00, 0x00
9229 };
9230 copy_block(op_load_ad_V1_VR3_code, 6);
9231 inc_code_ptr(6);
9232 }
9233 #endif
9234
9235 DEFINE_GEN(gen_op_load_ad_V2_VR3,void,(void))
9236 #ifdef DYNGEN_IMPL
9237 #define HAVE_gen_op_load_ad_V2_VR3
9238 {
9239 static const uint8 op_load_ad_V2_VR3_code[] = {
9240 0x8d, 0xbd, 0xc0, 0x01, 0x00, 0x00
9241 };
9242 copy_block(op_load_ad_V2_VR3_code, 6);
9243 inc_code_ptr(6);
9244 }
9245 #endif
9246
9247 DEFINE_GEN(gen_op_load_ad_VD_VR4,void,(void))
9248 #ifdef DYNGEN_IMPL
9249 #define HAVE_gen_op_load_ad_VD_VR4
9250 {
9251 static const uint8 op_load_ad_VD_VR4_code[] = {
9252 0x8d, 0x85, 0xd0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9253 };
9254 copy_block(op_load_ad_VD_VR4_code, 12);
9255 inc_code_ptr(12);
9256 }
9257 #endif
9258
9259 DEFINE_GEN(gen_op_load_ad_V0_VR4,void,(void))
9260 #ifdef DYNGEN_IMPL
9261 #define HAVE_gen_op_load_ad_V0_VR4
9262 {
9263 static const uint8 op_load_ad_V0_VR4_code[] = {
9264 0x8d, 0x9d, 0xd0, 0x01, 0x00, 0x00
9265 };
9266 copy_block(op_load_ad_V0_VR4_code, 6);
9267 inc_code_ptr(6);
9268 }
9269 #endif
9270
9271 DEFINE_GEN(gen_op_load_ad_V1_VR4,void,(void))
9272 #ifdef DYNGEN_IMPL
9273 #define HAVE_gen_op_load_ad_V1_VR4
9274 {
9275 static const uint8 op_load_ad_V1_VR4_code[] = {
9276 0x8d, 0xb5, 0xd0, 0x01, 0x00, 0x00
9277 };
9278 copy_block(op_load_ad_V1_VR4_code, 6);
9279 inc_code_ptr(6);
9280 }
9281 #endif
9282
9283 DEFINE_GEN(gen_op_load_ad_V2_VR4,void,(void))
9284 #ifdef DYNGEN_IMPL
9285 #define HAVE_gen_op_load_ad_V2_VR4
9286 {
9287 static const uint8 op_load_ad_V2_VR4_code[] = {
9288 0x8d, 0xbd, 0xd0, 0x01, 0x00, 0x00
9289 };
9290 copy_block(op_load_ad_V2_VR4_code, 6);
9291 inc_code_ptr(6);
9292 }
9293 #endif
9294
9295 DEFINE_GEN(gen_op_load_ad_VD_VR5,void,(void))
9296 #ifdef DYNGEN_IMPL
9297 #define HAVE_gen_op_load_ad_VD_VR5
9298 {
9299 static const uint8 op_load_ad_VD_VR5_code[] = {
9300 0x8d, 0x85, 0xe0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9301 };
9302 copy_block(op_load_ad_VD_VR5_code, 12);
9303 inc_code_ptr(12);
9304 }
9305 #endif
9306
9307 DEFINE_GEN(gen_op_load_ad_V0_VR5,void,(void))
9308 #ifdef DYNGEN_IMPL
9309 #define HAVE_gen_op_load_ad_V0_VR5
9310 {
9311 static const uint8 op_load_ad_V0_VR5_code[] = {
9312 0x8d, 0x9d, 0xe0, 0x01, 0x00, 0x00
9313 };
9314 copy_block(op_load_ad_V0_VR5_code, 6);
9315 inc_code_ptr(6);
9316 }
9317 #endif
9318
9319 DEFINE_GEN(gen_op_load_ad_V1_VR5,void,(void))
9320 #ifdef DYNGEN_IMPL
9321 #define HAVE_gen_op_load_ad_V1_VR5
9322 {
9323 static const uint8 op_load_ad_V1_VR5_code[] = {
9324 0x8d, 0xb5, 0xe0, 0x01, 0x00, 0x00
9325 };
9326 copy_block(op_load_ad_V1_VR5_code, 6);
9327 inc_code_ptr(6);
9328 }
9329 #endif
9330
9331 DEFINE_GEN(gen_op_load_ad_V2_VR5,void,(void))
9332 #ifdef DYNGEN_IMPL
9333 #define HAVE_gen_op_load_ad_V2_VR5
9334 {
9335 static const uint8 op_load_ad_V2_VR5_code[] = {
9336 0x8d, 0xbd, 0xe0, 0x01, 0x00, 0x00
9337 };
9338 copy_block(op_load_ad_V2_VR5_code, 6);
9339 inc_code_ptr(6);
9340 }
9341 #endif
9342
9343 DEFINE_GEN(gen_op_load_ad_VD_VR6,void,(void))
9344 #ifdef DYNGEN_IMPL
9345 #define HAVE_gen_op_load_ad_VD_VR6
9346 {
9347 static const uint8 op_load_ad_VD_VR6_code[] = {
9348 0x8d, 0x85, 0xf0, 0x01, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9349 };
9350 copy_block(op_load_ad_VD_VR6_code, 12);
9351 inc_code_ptr(12);
9352 }
9353 #endif
9354
9355 DEFINE_GEN(gen_op_load_ad_V0_VR6,void,(void))
9356 #ifdef DYNGEN_IMPL
9357 #define HAVE_gen_op_load_ad_V0_VR6
9358 {
9359 static const uint8 op_load_ad_V0_VR6_code[] = {
9360 0x8d, 0x9d, 0xf0, 0x01, 0x00, 0x00
9361 };
9362 copy_block(op_load_ad_V0_VR6_code, 6);
9363 inc_code_ptr(6);
9364 }
9365 #endif
9366
9367 DEFINE_GEN(gen_op_load_ad_V1_VR6,void,(void))
9368 #ifdef DYNGEN_IMPL
9369 #define HAVE_gen_op_load_ad_V1_VR6
9370 {
9371 static const uint8 op_load_ad_V1_VR6_code[] = {
9372 0x8d, 0xb5, 0xf0, 0x01, 0x00, 0x00
9373 };
9374 copy_block(op_load_ad_V1_VR6_code, 6);
9375 inc_code_ptr(6);
9376 }
9377 #endif
9378
9379 DEFINE_GEN(gen_op_load_ad_V2_VR6,void,(void))
9380 #ifdef DYNGEN_IMPL
9381 #define HAVE_gen_op_load_ad_V2_VR6
9382 {
9383 static const uint8 op_load_ad_V2_VR6_code[] = {
9384 0x8d, 0xbd, 0xf0, 0x01, 0x00, 0x00
9385 };
9386 copy_block(op_load_ad_V2_VR6_code, 6);
9387 inc_code_ptr(6);
9388 }
9389 #endif
9390
9391 DEFINE_GEN(gen_op_load_ad_VD_VR7,void,(void))
9392 #ifdef DYNGEN_IMPL
9393 #define HAVE_gen_op_load_ad_VD_VR7
9394 {
9395 static const uint8 op_load_ad_VD_VR7_code[] = {
9396 0x8d, 0x85, 0x00, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9397 };
9398 copy_block(op_load_ad_VD_VR7_code, 12);
9399 inc_code_ptr(12);
9400 }
9401 #endif
9402
9403 DEFINE_GEN(gen_op_load_ad_V0_VR7,void,(void))
9404 #ifdef DYNGEN_IMPL
9405 #define HAVE_gen_op_load_ad_V0_VR7
9406 {
9407 static const uint8 op_load_ad_V0_VR7_code[] = {
9408 0x8d, 0x9d, 0x00, 0x02, 0x00, 0x00
9409 };
9410 copy_block(op_load_ad_V0_VR7_code, 6);
9411 inc_code_ptr(6);
9412 }
9413 #endif
9414
9415 DEFINE_GEN(gen_op_load_ad_V1_VR7,void,(void))
9416 #ifdef DYNGEN_IMPL
9417 #define HAVE_gen_op_load_ad_V1_VR7
9418 {
9419 static const uint8 op_load_ad_V1_VR7_code[] = {
9420 0x8d, 0xb5, 0x00, 0x02, 0x00, 0x00
9421 };
9422 copy_block(op_load_ad_V1_VR7_code, 6);
9423 inc_code_ptr(6);
9424 }
9425 #endif
9426
9427 DEFINE_GEN(gen_op_load_ad_V2_VR7,void,(void))
9428 #ifdef DYNGEN_IMPL
9429 #define HAVE_gen_op_load_ad_V2_VR7
9430 {
9431 static const uint8 op_load_ad_V2_VR7_code[] = {
9432 0x8d, 0xbd, 0x00, 0x02, 0x00, 0x00
9433 };
9434 copy_block(op_load_ad_V2_VR7_code, 6);
9435 inc_code_ptr(6);
9436 }
9437 #endif
9438
9439 DEFINE_GEN(gen_op_load_ad_VD_VR8,void,(void))
9440 #ifdef DYNGEN_IMPL
9441 #define HAVE_gen_op_load_ad_VD_VR8
9442 {
9443 static const uint8 op_load_ad_VD_VR8_code[] = {
9444 0x8d, 0x85, 0x10, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9445 };
9446 copy_block(op_load_ad_VD_VR8_code, 12);
9447 inc_code_ptr(12);
9448 }
9449 #endif
9450
9451 DEFINE_GEN(gen_op_load_ad_V0_VR8,void,(void))
9452 #ifdef DYNGEN_IMPL
9453 #define HAVE_gen_op_load_ad_V0_VR8
9454 {
9455 static const uint8 op_load_ad_V0_VR8_code[] = {
9456 0x8d, 0x9d, 0x10, 0x02, 0x00, 0x00
9457 };
9458 copy_block(op_load_ad_V0_VR8_code, 6);
9459 inc_code_ptr(6);
9460 }
9461 #endif
9462
9463 DEFINE_GEN(gen_op_load_ad_V1_VR8,void,(void))
9464 #ifdef DYNGEN_IMPL
9465 #define HAVE_gen_op_load_ad_V1_VR8
9466 {
9467 static const uint8 op_load_ad_V1_VR8_code[] = {
9468 0x8d, 0xb5, 0x10, 0x02, 0x00, 0x00
9469 };
9470 copy_block(op_load_ad_V1_VR8_code, 6);
9471 inc_code_ptr(6);
9472 }
9473 #endif
9474
9475 DEFINE_GEN(gen_op_load_ad_V2_VR8,void,(void))
9476 #ifdef DYNGEN_IMPL
9477 #define HAVE_gen_op_load_ad_V2_VR8
9478 {
9479 static const uint8 op_load_ad_V2_VR8_code[] = {
9480 0x8d, 0xbd, 0x10, 0x02, 0x00, 0x00
9481 };
9482 copy_block(op_load_ad_V2_VR8_code, 6);
9483 inc_code_ptr(6);
9484 }
9485 #endif
9486
9487 DEFINE_GEN(gen_op_load_ad_VD_VR9,void,(void))
9488 #ifdef DYNGEN_IMPL
9489 #define HAVE_gen_op_load_ad_VD_VR9
9490 {
9491 static const uint8 op_load_ad_VD_VR9_code[] = {
9492 0x8d, 0x85, 0x20, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9493 };
9494 copy_block(op_load_ad_VD_VR9_code, 12);
9495 inc_code_ptr(12);
9496 }
9497 #endif
9498
9499 DEFINE_GEN(gen_op_load_ad_V0_VR9,void,(void))
9500 #ifdef DYNGEN_IMPL
9501 #define HAVE_gen_op_load_ad_V0_VR9
9502 {
9503 static const uint8 op_load_ad_V0_VR9_code[] = {
9504 0x8d, 0x9d, 0x20, 0x02, 0x00, 0x00
9505 };
9506 copy_block(op_load_ad_V0_VR9_code, 6);
9507 inc_code_ptr(6);
9508 }
9509 #endif
9510
9511 DEFINE_GEN(gen_op_load_ad_V1_VR9,void,(void))
9512 #ifdef DYNGEN_IMPL
9513 #define HAVE_gen_op_load_ad_V1_VR9
9514 {
9515 static const uint8 op_load_ad_V1_VR9_code[] = {
9516 0x8d, 0xb5, 0x20, 0x02, 0x00, 0x00
9517 };
9518 copy_block(op_load_ad_V1_VR9_code, 6);
9519 inc_code_ptr(6);
9520 }
9521 #endif
9522
9523 DEFINE_GEN(gen_op_load_ad_V2_VR9,void,(void))
9524 #ifdef DYNGEN_IMPL
9525 #define HAVE_gen_op_load_ad_V2_VR9
9526 {
9527 static const uint8 op_load_ad_V2_VR9_code[] = {
9528 0x8d, 0xbd, 0x20, 0x02, 0x00, 0x00
9529 };
9530 copy_block(op_load_ad_V2_VR9_code, 6);
9531 inc_code_ptr(6);
9532 }
9533 #endif
9534
9535 DEFINE_GEN(gen_op_load_ad_VD_VR10,void,(void))
9536 #ifdef DYNGEN_IMPL
9537 #define HAVE_gen_op_load_ad_VD_VR10
9538 {
9539 static const uint8 op_load_ad_VD_VR10_code[] = {
9540 0x8d, 0x85, 0x30, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9541 };
9542 copy_block(op_load_ad_VD_VR10_code, 12);
9543 inc_code_ptr(12);
9544 }
9545 #endif
9546
9547 DEFINE_GEN(gen_op_load_ad_V0_VR10,void,(void))
9548 #ifdef DYNGEN_IMPL
9549 #define HAVE_gen_op_load_ad_V0_VR10
9550 {
9551 static const uint8 op_load_ad_V0_VR10_code[] = {
9552 0x8d, 0x9d, 0x30, 0x02, 0x00, 0x00
9553 };
9554 copy_block(op_load_ad_V0_VR10_code, 6);
9555 inc_code_ptr(6);
9556 }
9557 #endif
9558
9559 DEFINE_GEN(gen_op_load_ad_V1_VR10,void,(void))
9560 #ifdef DYNGEN_IMPL
9561 #define HAVE_gen_op_load_ad_V1_VR10
9562 {
9563 static const uint8 op_load_ad_V1_VR10_code[] = {
9564 0x8d, 0xb5, 0x30, 0x02, 0x00, 0x00
9565 };
9566 copy_block(op_load_ad_V1_VR10_code, 6);
9567 inc_code_ptr(6);
9568 }
9569 #endif
9570
9571 DEFINE_GEN(gen_op_load_ad_V2_VR10,void,(void))
9572 #ifdef DYNGEN_IMPL
9573 #define HAVE_gen_op_load_ad_V2_VR10
9574 {
9575 static const uint8 op_load_ad_V2_VR10_code[] = {
9576 0x8d, 0xbd, 0x30, 0x02, 0x00, 0x00
9577 };
9578 copy_block(op_load_ad_V2_VR10_code, 6);
9579 inc_code_ptr(6);
9580 }
9581 #endif
9582
9583 DEFINE_GEN(gen_op_load_ad_VD_VR11,void,(void))
9584 #ifdef DYNGEN_IMPL
9585 #define HAVE_gen_op_load_ad_VD_VR11
9586 {
9587 static const uint8 op_load_ad_VD_VR11_code[] = {
9588 0x8d, 0x85, 0x40, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9589 };
9590 copy_block(op_load_ad_VD_VR11_code, 12);
9591 inc_code_ptr(12);
9592 }
9593 #endif
9594
9595 DEFINE_GEN(gen_op_load_ad_V0_VR11,void,(void))
9596 #ifdef DYNGEN_IMPL
9597 #define HAVE_gen_op_load_ad_V0_VR11
9598 {
9599 static const uint8 op_load_ad_V0_VR11_code[] = {
9600 0x8d, 0x9d, 0x40, 0x02, 0x00, 0x00
9601 };
9602 copy_block(op_load_ad_V0_VR11_code, 6);
9603 inc_code_ptr(6);
9604 }
9605 #endif
9606
9607 DEFINE_GEN(gen_op_load_ad_V1_VR11,void,(void))
9608 #ifdef DYNGEN_IMPL
9609 #define HAVE_gen_op_load_ad_V1_VR11
9610 {
9611 static const uint8 op_load_ad_V1_VR11_code[] = {
9612 0x8d, 0xb5, 0x40, 0x02, 0x00, 0x00
9613 };
9614 copy_block(op_load_ad_V1_VR11_code, 6);
9615 inc_code_ptr(6);
9616 }
9617 #endif
9618
9619 DEFINE_GEN(gen_op_load_ad_V2_VR11,void,(void))
9620 #ifdef DYNGEN_IMPL
9621 #define HAVE_gen_op_load_ad_V2_VR11
9622 {
9623 static const uint8 op_load_ad_V2_VR11_code[] = {
9624 0x8d, 0xbd, 0x40, 0x02, 0x00, 0x00
9625 };
9626 copy_block(op_load_ad_V2_VR11_code, 6);
9627 inc_code_ptr(6);
9628 }
9629 #endif
9630
9631 DEFINE_GEN(gen_op_load_ad_VD_VR12,void,(void))
9632 #ifdef DYNGEN_IMPL
9633 #define HAVE_gen_op_load_ad_VD_VR12
9634 {
9635 static const uint8 op_load_ad_VD_VR12_code[] = {
9636 0x8d, 0x85, 0x50, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9637 };
9638 copy_block(op_load_ad_VD_VR12_code, 12);
9639 inc_code_ptr(12);
9640 }
9641 #endif
9642
9643 DEFINE_GEN(gen_op_load_ad_V0_VR12,void,(void))
9644 #ifdef DYNGEN_IMPL
9645 #define HAVE_gen_op_load_ad_V0_VR12
9646 {
9647 static const uint8 op_load_ad_V0_VR12_code[] = {
9648 0x8d, 0x9d, 0x50, 0x02, 0x00, 0x00
9649 };
9650 copy_block(op_load_ad_V0_VR12_code, 6);
9651 inc_code_ptr(6);
9652 }
9653 #endif
9654
9655 DEFINE_GEN(gen_op_load_ad_V1_VR12,void,(void))
9656 #ifdef DYNGEN_IMPL
9657 #define HAVE_gen_op_load_ad_V1_VR12
9658 {
9659 static const uint8 op_load_ad_V1_VR12_code[] = {
9660 0x8d, 0xb5, 0x50, 0x02, 0x00, 0x00
9661 };
9662 copy_block(op_load_ad_V1_VR12_code, 6);
9663 inc_code_ptr(6);
9664 }
9665 #endif
9666
9667 DEFINE_GEN(gen_op_load_ad_V2_VR12,void,(void))
9668 #ifdef DYNGEN_IMPL
9669 #define HAVE_gen_op_load_ad_V2_VR12
9670 {
9671 static const uint8 op_load_ad_V2_VR12_code[] = {
9672 0x8d, 0xbd, 0x50, 0x02, 0x00, 0x00
9673 };
9674 copy_block(op_load_ad_V2_VR12_code, 6);
9675 inc_code_ptr(6);
9676 }
9677 #endif
9678
9679 DEFINE_GEN(gen_op_load_ad_VD_VR13,void,(void))
9680 #ifdef DYNGEN_IMPL
9681 #define HAVE_gen_op_load_ad_VD_VR13
9682 {
9683 static const uint8 op_load_ad_VD_VR13_code[] = {
9684 0x8d, 0x85, 0x60, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9685 };
9686 copy_block(op_load_ad_VD_VR13_code, 12);
9687 inc_code_ptr(12);
9688 }
9689 #endif
9690
9691 DEFINE_GEN(gen_op_load_ad_V0_VR13,void,(void))
9692 #ifdef DYNGEN_IMPL
9693 #define HAVE_gen_op_load_ad_V0_VR13
9694 {
9695 static const uint8 op_load_ad_V0_VR13_code[] = {
9696 0x8d, 0x9d, 0x60, 0x02, 0x00, 0x00
9697 };
9698 copy_block(op_load_ad_V0_VR13_code, 6);
9699 inc_code_ptr(6);
9700 }
9701 #endif
9702
9703 DEFINE_GEN(gen_op_load_ad_V1_VR13,void,(void))
9704 #ifdef DYNGEN_IMPL
9705 #define HAVE_gen_op_load_ad_V1_VR13
9706 {
9707 static const uint8 op_load_ad_V1_VR13_code[] = {
9708 0x8d, 0xb5, 0x60, 0x02, 0x00, 0x00
9709 };
9710 copy_block(op_load_ad_V1_VR13_code, 6);
9711 inc_code_ptr(6);
9712 }
9713 #endif
9714
9715 DEFINE_GEN(gen_op_load_ad_V2_VR13,void,(void))
9716 #ifdef DYNGEN_IMPL
9717 #define HAVE_gen_op_load_ad_V2_VR13
9718 {
9719 static const uint8 op_load_ad_V2_VR13_code[] = {
9720 0x8d, 0xbd, 0x60, 0x02, 0x00, 0x00
9721 };
9722 copy_block(op_load_ad_V2_VR13_code, 6);
9723 inc_code_ptr(6);
9724 }
9725 #endif
9726
9727 DEFINE_GEN(gen_op_load_ad_VD_VR14,void,(void))
9728 #ifdef DYNGEN_IMPL
9729 #define HAVE_gen_op_load_ad_VD_VR14
9730 {
9731 static const uint8 op_load_ad_VD_VR14_code[] = {
9732 0x8d, 0x85, 0x70, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9733 };
9734 copy_block(op_load_ad_VD_VR14_code, 12);
9735 inc_code_ptr(12);
9736 }
9737 #endif
9738
9739 DEFINE_GEN(gen_op_load_ad_V0_VR14,void,(void))
9740 #ifdef DYNGEN_IMPL
9741 #define HAVE_gen_op_load_ad_V0_VR14
9742 {
9743 static const uint8 op_load_ad_V0_VR14_code[] = {
9744 0x8d, 0x9d, 0x70, 0x02, 0x00, 0x00
9745 };
9746 copy_block(op_load_ad_V0_VR14_code, 6);
9747 inc_code_ptr(6);
9748 }
9749 #endif
9750
9751 DEFINE_GEN(gen_op_load_ad_V1_VR14,void,(void))
9752 #ifdef DYNGEN_IMPL
9753 #define HAVE_gen_op_load_ad_V1_VR14
9754 {
9755 static const uint8 op_load_ad_V1_VR14_code[] = {
9756 0x8d, 0xb5, 0x70, 0x02, 0x00, 0x00
9757 };
9758 copy_block(op_load_ad_V1_VR14_code, 6);
9759 inc_code_ptr(6);
9760 }
9761 #endif
9762
9763 DEFINE_GEN(gen_op_load_ad_V2_VR14,void,(void))
9764 #ifdef DYNGEN_IMPL
9765 #define HAVE_gen_op_load_ad_V2_VR14
9766 {
9767 static const uint8 op_load_ad_V2_VR14_code[] = {
9768 0x8d, 0xbd, 0x70, 0x02, 0x00, 0x00
9769 };
9770 copy_block(op_load_ad_V2_VR14_code, 6);
9771 inc_code_ptr(6);
9772 }
9773 #endif
9774
9775 DEFINE_GEN(gen_op_load_ad_VD_VR15,void,(void))
9776 #ifdef DYNGEN_IMPL
9777 #define HAVE_gen_op_load_ad_VD_VR15
9778 {
9779 static const uint8 op_load_ad_VD_VR15_code[] = {
9780 0x8d, 0x85, 0x80, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9781 };
9782 copy_block(op_load_ad_VD_VR15_code, 12);
9783 inc_code_ptr(12);
9784 }
9785 #endif
9786
9787 DEFINE_GEN(gen_op_load_ad_V0_VR15,void,(void))
9788 #ifdef DYNGEN_IMPL
9789 #define HAVE_gen_op_load_ad_V0_VR15
9790 {
9791 static const uint8 op_load_ad_V0_VR15_code[] = {
9792 0x8d, 0x9d, 0x80, 0x02, 0x00, 0x00
9793 };
9794 copy_block(op_load_ad_V0_VR15_code, 6);
9795 inc_code_ptr(6);
9796 }
9797 #endif
9798
9799 DEFINE_GEN(gen_op_load_ad_V1_VR15,void,(void))
9800 #ifdef DYNGEN_IMPL
9801 #define HAVE_gen_op_load_ad_V1_VR15
9802 {
9803 static const uint8 op_load_ad_V1_VR15_code[] = {
9804 0x8d, 0xb5, 0x80, 0x02, 0x00, 0x00
9805 };
9806 copy_block(op_load_ad_V1_VR15_code, 6);
9807 inc_code_ptr(6);
9808 }
9809 #endif
9810
9811 DEFINE_GEN(gen_op_load_ad_V2_VR15,void,(void))
9812 #ifdef DYNGEN_IMPL
9813 #define HAVE_gen_op_load_ad_V2_VR15
9814 {
9815 static const uint8 op_load_ad_V2_VR15_code[] = {
9816 0x8d, 0xbd, 0x80, 0x02, 0x00, 0x00
9817 };
9818 copy_block(op_load_ad_V2_VR15_code, 6);
9819 inc_code_ptr(6);
9820 }
9821 #endif
9822
9823 DEFINE_GEN(gen_op_load_ad_VD_VR16,void,(void))
9824 #ifdef DYNGEN_IMPL
9825 #define HAVE_gen_op_load_ad_VD_VR16
9826 {
9827 static const uint8 op_load_ad_VD_VR16_code[] = {
9828 0x8d, 0x85, 0x90, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9829 };
9830 copy_block(op_load_ad_VD_VR16_code, 12);
9831 inc_code_ptr(12);
9832 }
9833 #endif
9834
9835 DEFINE_GEN(gen_op_load_ad_V0_VR16,void,(void))
9836 #ifdef DYNGEN_IMPL
9837 #define HAVE_gen_op_load_ad_V0_VR16
9838 {
9839 static const uint8 op_load_ad_V0_VR16_code[] = {
9840 0x8d, 0x9d, 0x90, 0x02, 0x00, 0x00
9841 };
9842 copy_block(op_load_ad_V0_VR16_code, 6);
9843 inc_code_ptr(6);
9844 }
9845 #endif
9846
9847 DEFINE_GEN(gen_op_load_ad_V1_VR16,void,(void))
9848 #ifdef DYNGEN_IMPL
9849 #define HAVE_gen_op_load_ad_V1_VR16
9850 {
9851 static const uint8 op_load_ad_V1_VR16_code[] = {
9852 0x8d, 0xb5, 0x90, 0x02, 0x00, 0x00
9853 };
9854 copy_block(op_load_ad_V1_VR16_code, 6);
9855 inc_code_ptr(6);
9856 }
9857 #endif
9858
9859 DEFINE_GEN(gen_op_load_ad_V2_VR16,void,(void))
9860 #ifdef DYNGEN_IMPL
9861 #define HAVE_gen_op_load_ad_V2_VR16
9862 {
9863 static const uint8 op_load_ad_V2_VR16_code[] = {
9864 0x8d, 0xbd, 0x90, 0x02, 0x00, 0x00
9865 };
9866 copy_block(op_load_ad_V2_VR16_code, 6);
9867 inc_code_ptr(6);
9868 }
9869 #endif
9870
9871 DEFINE_GEN(gen_op_load_ad_VD_VR17,void,(void))
9872 #ifdef DYNGEN_IMPL
9873 #define HAVE_gen_op_load_ad_VD_VR17
9874 {
9875 static const uint8 op_load_ad_VD_VR17_code[] = {
9876 0x8d, 0x85, 0xa0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9877 };
9878 copy_block(op_load_ad_VD_VR17_code, 12);
9879 inc_code_ptr(12);
9880 }
9881 #endif
9882
9883 DEFINE_GEN(gen_op_load_ad_V0_VR17,void,(void))
9884 #ifdef DYNGEN_IMPL
9885 #define HAVE_gen_op_load_ad_V0_VR17
9886 {
9887 static const uint8 op_load_ad_V0_VR17_code[] = {
9888 0x8d, 0x9d, 0xa0, 0x02, 0x00, 0x00
9889 };
9890 copy_block(op_load_ad_V0_VR17_code, 6);
9891 inc_code_ptr(6);
9892 }
9893 #endif
9894
9895 DEFINE_GEN(gen_op_load_ad_V1_VR17,void,(void))
9896 #ifdef DYNGEN_IMPL
9897 #define HAVE_gen_op_load_ad_V1_VR17
9898 {
9899 static const uint8 op_load_ad_V1_VR17_code[] = {
9900 0x8d, 0xb5, 0xa0, 0x02, 0x00, 0x00
9901 };
9902 copy_block(op_load_ad_V1_VR17_code, 6);
9903 inc_code_ptr(6);
9904 }
9905 #endif
9906
9907 DEFINE_GEN(gen_op_load_ad_V2_VR17,void,(void))
9908 #ifdef DYNGEN_IMPL
9909 #define HAVE_gen_op_load_ad_V2_VR17
9910 {
9911 static const uint8 op_load_ad_V2_VR17_code[] = {
9912 0x8d, 0xbd, 0xa0, 0x02, 0x00, 0x00
9913 };
9914 copy_block(op_load_ad_V2_VR17_code, 6);
9915 inc_code_ptr(6);
9916 }
9917 #endif
9918
9919 DEFINE_GEN(gen_op_load_ad_VD_VR18,void,(void))
9920 #ifdef DYNGEN_IMPL
9921 #define HAVE_gen_op_load_ad_VD_VR18
9922 {
9923 static const uint8 op_load_ad_VD_VR18_code[] = {
9924 0x8d, 0x85, 0xb0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9925 };
9926 copy_block(op_load_ad_VD_VR18_code, 12);
9927 inc_code_ptr(12);
9928 }
9929 #endif
9930
9931 DEFINE_GEN(gen_op_load_ad_V0_VR18,void,(void))
9932 #ifdef DYNGEN_IMPL
9933 #define HAVE_gen_op_load_ad_V0_VR18
9934 {
9935 static const uint8 op_load_ad_V0_VR18_code[] = {
9936 0x8d, 0x9d, 0xb0, 0x02, 0x00, 0x00
9937 };
9938 copy_block(op_load_ad_V0_VR18_code, 6);
9939 inc_code_ptr(6);
9940 }
9941 #endif
9942
9943 DEFINE_GEN(gen_op_load_ad_V1_VR18,void,(void))
9944 #ifdef DYNGEN_IMPL
9945 #define HAVE_gen_op_load_ad_V1_VR18
9946 {
9947 static const uint8 op_load_ad_V1_VR18_code[] = {
9948 0x8d, 0xb5, 0xb0, 0x02, 0x00, 0x00
9949 };
9950 copy_block(op_load_ad_V1_VR18_code, 6);
9951 inc_code_ptr(6);
9952 }
9953 #endif
9954
9955 DEFINE_GEN(gen_op_load_ad_V2_VR18,void,(void))
9956 #ifdef DYNGEN_IMPL
9957 #define HAVE_gen_op_load_ad_V2_VR18
9958 {
9959 static const uint8 op_load_ad_V2_VR18_code[] = {
9960 0x8d, 0xbd, 0xb0, 0x02, 0x00, 0x00
9961 };
9962 copy_block(op_load_ad_V2_VR18_code, 6);
9963 inc_code_ptr(6);
9964 }
9965 #endif
9966
9967 DEFINE_GEN(gen_op_load_ad_VD_VR19,void,(void))
9968 #ifdef DYNGEN_IMPL
9969 #define HAVE_gen_op_load_ad_VD_VR19
9970 {
9971 static const uint8 op_load_ad_VD_VR19_code[] = {
9972 0x8d, 0x85, 0xc0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
9973 };
9974 copy_block(op_load_ad_VD_VR19_code, 12);
9975 inc_code_ptr(12);
9976 }
9977 #endif
9978
9979 DEFINE_GEN(gen_op_load_ad_V0_VR19,void,(void))
9980 #ifdef DYNGEN_IMPL
9981 #define HAVE_gen_op_load_ad_V0_VR19
9982 {
9983 static const uint8 op_load_ad_V0_VR19_code[] = {
9984 0x8d, 0x9d, 0xc0, 0x02, 0x00, 0x00
9985 };
9986 copy_block(op_load_ad_V0_VR19_code, 6);
9987 inc_code_ptr(6);
9988 }
9989 #endif
9990
9991 DEFINE_GEN(gen_op_load_ad_V1_VR19,void,(void))
9992 #ifdef DYNGEN_IMPL
9993 #define HAVE_gen_op_load_ad_V1_VR19
9994 {
9995 static const uint8 op_load_ad_V1_VR19_code[] = {
9996 0x8d, 0xb5, 0xc0, 0x02, 0x00, 0x00
9997 };
9998 copy_block(op_load_ad_V1_VR19_code, 6);
9999 inc_code_ptr(6);
10000 }
10001 #endif
10002
10003 DEFINE_GEN(gen_op_load_ad_V2_VR19,void,(void))
10004 #ifdef DYNGEN_IMPL
10005 #define HAVE_gen_op_load_ad_V2_VR19
10006 {
10007 static const uint8 op_load_ad_V2_VR19_code[] = {
10008 0x8d, 0xbd, 0xc0, 0x02, 0x00, 0x00
10009 };
10010 copy_block(op_load_ad_V2_VR19_code, 6);
10011 inc_code_ptr(6);
10012 }
10013 #endif
10014
10015 DEFINE_GEN(gen_op_load_ad_VD_VR20,void,(void))
10016 #ifdef DYNGEN_IMPL
10017 #define HAVE_gen_op_load_ad_VD_VR20
10018 {
10019 static const uint8 op_load_ad_VD_VR20_code[] = {
10020 0x8d, 0x85, 0xd0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10021 };
10022 copy_block(op_load_ad_VD_VR20_code, 12);
10023 inc_code_ptr(12);
10024 }
10025 #endif
10026
10027 DEFINE_GEN(gen_op_load_ad_V0_VR20,void,(void))
10028 #ifdef DYNGEN_IMPL
10029 #define HAVE_gen_op_load_ad_V0_VR20
10030 {
10031 static const uint8 op_load_ad_V0_VR20_code[] = {
10032 0x8d, 0x9d, 0xd0, 0x02, 0x00, 0x00
10033 };
10034 copy_block(op_load_ad_V0_VR20_code, 6);
10035 inc_code_ptr(6);
10036 }
10037 #endif
10038
10039 DEFINE_GEN(gen_op_load_ad_V1_VR20,void,(void))
10040 #ifdef DYNGEN_IMPL
10041 #define HAVE_gen_op_load_ad_V1_VR20
10042 {
10043 static const uint8 op_load_ad_V1_VR20_code[] = {
10044 0x8d, 0xb5, 0xd0, 0x02, 0x00, 0x00
10045 };
10046 copy_block(op_load_ad_V1_VR20_code, 6);
10047 inc_code_ptr(6);
10048 }
10049 #endif
10050
10051 DEFINE_GEN(gen_op_load_ad_V2_VR20,void,(void))
10052 #ifdef DYNGEN_IMPL
10053 #define HAVE_gen_op_load_ad_V2_VR20
10054 {
10055 static const uint8 op_load_ad_V2_VR20_code[] = {
10056 0x8d, 0xbd, 0xd0, 0x02, 0x00, 0x00
10057 };
10058 copy_block(op_load_ad_V2_VR20_code, 6);
10059 inc_code_ptr(6);
10060 }
10061 #endif
10062
10063 DEFINE_GEN(gen_op_load_ad_VD_VR21,void,(void))
10064 #ifdef DYNGEN_IMPL
10065 #define HAVE_gen_op_load_ad_VD_VR21
10066 {
10067 static const uint8 op_load_ad_VD_VR21_code[] = {
10068 0x8d, 0x85, 0xe0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10069 };
10070 copy_block(op_load_ad_VD_VR21_code, 12);
10071 inc_code_ptr(12);
10072 }
10073 #endif
10074
10075 DEFINE_GEN(gen_op_load_ad_V0_VR21,void,(void))
10076 #ifdef DYNGEN_IMPL
10077 #define HAVE_gen_op_load_ad_V0_VR21
10078 {
10079 static const uint8 op_load_ad_V0_VR21_code[] = {
10080 0x8d, 0x9d, 0xe0, 0x02, 0x00, 0x00
10081 };
10082 copy_block(op_load_ad_V0_VR21_code, 6);
10083 inc_code_ptr(6);
10084 }
10085 #endif
10086
10087 DEFINE_GEN(gen_op_load_ad_V1_VR21,void,(void))
10088 #ifdef DYNGEN_IMPL
10089 #define HAVE_gen_op_load_ad_V1_VR21
10090 {
10091 static const uint8 op_load_ad_V1_VR21_code[] = {
10092 0x8d, 0xb5, 0xe0, 0x02, 0x00, 0x00
10093 };
10094 copy_block(op_load_ad_V1_VR21_code, 6);
10095 inc_code_ptr(6);
10096 }
10097 #endif
10098
10099 DEFINE_GEN(gen_op_load_ad_V2_VR21,void,(void))
10100 #ifdef DYNGEN_IMPL
10101 #define HAVE_gen_op_load_ad_V2_VR21
10102 {
10103 static const uint8 op_load_ad_V2_VR21_code[] = {
10104 0x8d, 0xbd, 0xe0, 0x02, 0x00, 0x00
10105 };
10106 copy_block(op_load_ad_V2_VR21_code, 6);
10107 inc_code_ptr(6);
10108 }
10109 #endif
10110
10111 DEFINE_GEN(gen_op_load_ad_VD_VR22,void,(void))
10112 #ifdef DYNGEN_IMPL
10113 #define HAVE_gen_op_load_ad_VD_VR22
10114 {
10115 static const uint8 op_load_ad_VD_VR22_code[] = {
10116 0x8d, 0x85, 0xf0, 0x02, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10117 };
10118 copy_block(op_load_ad_VD_VR22_code, 12);
10119 inc_code_ptr(12);
10120 }
10121 #endif
10122
10123 DEFINE_GEN(gen_op_load_ad_V0_VR22,void,(void))
10124 #ifdef DYNGEN_IMPL
10125 #define HAVE_gen_op_load_ad_V0_VR22
10126 {
10127 static const uint8 op_load_ad_V0_VR22_code[] = {
10128 0x8d, 0x9d, 0xf0, 0x02, 0x00, 0x00
10129 };
10130 copy_block(op_load_ad_V0_VR22_code, 6);
10131 inc_code_ptr(6);
10132 }
10133 #endif
10134
10135 DEFINE_GEN(gen_op_load_ad_V1_VR22,void,(void))
10136 #ifdef DYNGEN_IMPL
10137 #define HAVE_gen_op_load_ad_V1_VR22
10138 {
10139 static const uint8 op_load_ad_V1_VR22_code[] = {
10140 0x8d, 0xb5, 0xf0, 0x02, 0x00, 0x00
10141 };
10142 copy_block(op_load_ad_V1_VR22_code, 6);
10143 inc_code_ptr(6);
10144 }
10145 #endif
10146
10147 DEFINE_GEN(gen_op_load_ad_V2_VR22,void,(void))
10148 #ifdef DYNGEN_IMPL
10149 #define HAVE_gen_op_load_ad_V2_VR22
10150 {
10151 static const uint8 op_load_ad_V2_VR22_code[] = {
10152 0x8d, 0xbd, 0xf0, 0x02, 0x00, 0x00
10153 };
10154 copy_block(op_load_ad_V2_VR22_code, 6);
10155 inc_code_ptr(6);
10156 }
10157 #endif
10158
10159 DEFINE_GEN(gen_op_load_ad_VD_VR23,void,(void))
10160 #ifdef DYNGEN_IMPL
10161 #define HAVE_gen_op_load_ad_VD_VR23
10162 {
10163 static const uint8 op_load_ad_VD_VR23_code[] = {
10164 0x8d, 0x85, 0x00, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10165 };
10166 copy_block(op_load_ad_VD_VR23_code, 12);
10167 inc_code_ptr(12);
10168 }
10169 #endif
10170
10171 DEFINE_GEN(gen_op_load_ad_V0_VR23,void,(void))
10172 #ifdef DYNGEN_IMPL
10173 #define HAVE_gen_op_load_ad_V0_VR23
10174 {
10175 static const uint8 op_load_ad_V0_VR23_code[] = {
10176 0x8d, 0x9d, 0x00, 0x03, 0x00, 0x00
10177 };
10178 copy_block(op_load_ad_V0_VR23_code, 6);
10179 inc_code_ptr(6);
10180 }
10181 #endif
10182
10183 DEFINE_GEN(gen_op_load_ad_V1_VR23,void,(void))
10184 #ifdef DYNGEN_IMPL
10185 #define HAVE_gen_op_load_ad_V1_VR23
10186 {
10187 static const uint8 op_load_ad_V1_VR23_code[] = {
10188 0x8d, 0xb5, 0x00, 0x03, 0x00, 0x00
10189 };
10190 copy_block(op_load_ad_V1_VR23_code, 6);
10191 inc_code_ptr(6);
10192 }
10193 #endif
10194
10195 DEFINE_GEN(gen_op_load_ad_V2_VR23,void,(void))
10196 #ifdef DYNGEN_IMPL
10197 #define HAVE_gen_op_load_ad_V2_VR23
10198 {
10199 static const uint8 op_load_ad_V2_VR23_code[] = {
10200 0x8d, 0xbd, 0x00, 0x03, 0x00, 0x00
10201 };
10202 copy_block(op_load_ad_V2_VR23_code, 6);
10203 inc_code_ptr(6);
10204 }
10205 #endif
10206
10207 DEFINE_GEN(gen_op_load_ad_VD_VR24,void,(void))
10208 #ifdef DYNGEN_IMPL
10209 #define HAVE_gen_op_load_ad_VD_VR24
10210 {
10211 static const uint8 op_load_ad_VD_VR24_code[] = {
10212 0x8d, 0x85, 0x10, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10213 };
10214 copy_block(op_load_ad_VD_VR24_code, 12);
10215 inc_code_ptr(12);
10216 }
10217 #endif
10218
10219 DEFINE_GEN(gen_op_load_ad_V0_VR24,void,(void))
10220 #ifdef DYNGEN_IMPL
10221 #define HAVE_gen_op_load_ad_V0_VR24
10222 {
10223 static const uint8 op_load_ad_V0_VR24_code[] = {
10224 0x8d, 0x9d, 0x10, 0x03, 0x00, 0x00
10225 };
10226 copy_block(op_load_ad_V0_VR24_code, 6);
10227 inc_code_ptr(6);
10228 }
10229 #endif
10230
10231 DEFINE_GEN(gen_op_load_ad_V1_VR24,void,(void))
10232 #ifdef DYNGEN_IMPL
10233 #define HAVE_gen_op_load_ad_V1_VR24
10234 {
10235 static const uint8 op_load_ad_V1_VR24_code[] = {
10236 0x8d, 0xb5, 0x10, 0x03, 0x00, 0x00
10237 };
10238 copy_block(op_load_ad_V1_VR24_code, 6);
10239 inc_code_ptr(6);
10240 }
10241 #endif
10242
10243 DEFINE_GEN(gen_op_load_ad_V2_VR24,void,(void))
10244 #ifdef DYNGEN_IMPL
10245 #define HAVE_gen_op_load_ad_V2_VR24
10246 {
10247 static const uint8 op_load_ad_V2_VR24_code[] = {
10248 0x8d, 0xbd, 0x10, 0x03, 0x00, 0x00
10249 };
10250 copy_block(op_load_ad_V2_VR24_code, 6);
10251 inc_code_ptr(6);
10252 }
10253 #endif
10254
10255 DEFINE_GEN(gen_op_load_ad_VD_VR25,void,(void))
10256 #ifdef DYNGEN_IMPL
10257 #define HAVE_gen_op_load_ad_VD_VR25
10258 {
10259 static const uint8 op_load_ad_VD_VR25_code[] = {
10260 0x8d, 0x85, 0x20, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10261 };
10262 copy_block(op_load_ad_VD_VR25_code, 12);
10263 inc_code_ptr(12);
10264 }
10265 #endif
10266
10267 DEFINE_GEN(gen_op_load_ad_V0_VR25,void,(void))
10268 #ifdef DYNGEN_IMPL
10269 #define HAVE_gen_op_load_ad_V0_VR25
10270 {
10271 static const uint8 op_load_ad_V0_VR25_code[] = {
10272 0x8d, 0x9d, 0x20, 0x03, 0x00, 0x00
10273 };
10274 copy_block(op_load_ad_V0_VR25_code, 6);
10275 inc_code_ptr(6);
10276 }
10277 #endif
10278
10279 DEFINE_GEN(gen_op_load_ad_V1_VR25,void,(void))
10280 #ifdef DYNGEN_IMPL
10281 #define HAVE_gen_op_load_ad_V1_VR25
10282 {
10283 static const uint8 op_load_ad_V1_VR25_code[] = {
10284 0x8d, 0xb5, 0x20, 0x03, 0x00, 0x00
10285 };
10286 copy_block(op_load_ad_V1_VR25_code, 6);
10287 inc_code_ptr(6);
10288 }
10289 #endif
10290
10291 DEFINE_GEN(gen_op_load_ad_V2_VR25,void,(void))
10292 #ifdef DYNGEN_IMPL
10293 #define HAVE_gen_op_load_ad_V2_VR25
10294 {
10295 static const uint8 op_load_ad_V2_VR25_code[] = {
10296 0x8d, 0xbd, 0x20, 0x03, 0x00, 0x00
10297 };
10298 copy_block(op_load_ad_V2_VR25_code, 6);
10299 inc_code_ptr(6);
10300 }
10301 #endif
10302
10303 DEFINE_GEN(gen_op_load_ad_VD_VR26,void,(void))
10304 #ifdef DYNGEN_IMPL
10305 #define HAVE_gen_op_load_ad_VD_VR26
10306 {
10307 static const uint8 op_load_ad_VD_VR26_code[] = {
10308 0x8d, 0x85, 0x30, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10309 };
10310 copy_block(op_load_ad_VD_VR26_code, 12);
10311 inc_code_ptr(12);
10312 }
10313 #endif
10314
10315 DEFINE_GEN(gen_op_load_ad_V0_VR26,void,(void))
10316 #ifdef DYNGEN_IMPL
10317 #define HAVE_gen_op_load_ad_V0_VR26
10318 {
10319 static const uint8 op_load_ad_V0_VR26_code[] = {
10320 0x8d, 0x9d, 0x30, 0x03, 0x00, 0x00
10321 };
10322 copy_block(op_load_ad_V0_VR26_code, 6);
10323 inc_code_ptr(6);
10324 }
10325 #endif
10326
10327 DEFINE_GEN(gen_op_load_ad_V1_VR26,void,(void))
10328 #ifdef DYNGEN_IMPL
10329 #define HAVE_gen_op_load_ad_V1_VR26
10330 {
10331 static const uint8 op_load_ad_V1_VR26_code[] = {
10332 0x8d, 0xb5, 0x30, 0x03, 0x00, 0x00
10333 };
10334 copy_block(op_load_ad_V1_VR26_code, 6);
10335 inc_code_ptr(6);
10336 }
10337 #endif
10338
10339 DEFINE_GEN(gen_op_load_ad_V2_VR26,void,(void))
10340 #ifdef DYNGEN_IMPL
10341 #define HAVE_gen_op_load_ad_V2_VR26
10342 {
10343 static const uint8 op_load_ad_V2_VR26_code[] = {
10344 0x8d, 0xbd, 0x30, 0x03, 0x00, 0x00
10345 };
10346 copy_block(op_load_ad_V2_VR26_code, 6);
10347 inc_code_ptr(6);
10348 }
10349 #endif
10350
10351 DEFINE_GEN(gen_op_load_ad_VD_VR27,void,(void))
10352 #ifdef DYNGEN_IMPL
10353 #define HAVE_gen_op_load_ad_VD_VR27
10354 {
10355 static const uint8 op_load_ad_VD_VR27_code[] = {
10356 0x8d, 0x85, 0x40, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10357 };
10358 copy_block(op_load_ad_VD_VR27_code, 12);
10359 inc_code_ptr(12);
10360 }
10361 #endif
10362
10363 DEFINE_GEN(gen_op_load_ad_V0_VR27,void,(void))
10364 #ifdef DYNGEN_IMPL
10365 #define HAVE_gen_op_load_ad_V0_VR27
10366 {
10367 static const uint8 op_load_ad_V0_VR27_code[] = {
10368 0x8d, 0x9d, 0x40, 0x03, 0x00, 0x00
10369 };
10370 copy_block(op_load_ad_V0_VR27_code, 6);
10371 inc_code_ptr(6);
10372 }
10373 #endif
10374
10375 DEFINE_GEN(gen_op_load_ad_V1_VR27,void,(void))
10376 #ifdef DYNGEN_IMPL
10377 #define HAVE_gen_op_load_ad_V1_VR27
10378 {
10379 static const uint8 op_load_ad_V1_VR27_code[] = {
10380 0x8d, 0xb5, 0x40, 0x03, 0x00, 0x00
10381 };
10382 copy_block(op_load_ad_V1_VR27_code, 6);
10383 inc_code_ptr(6);
10384 }
10385 #endif
10386
10387 DEFINE_GEN(gen_op_load_ad_V2_VR27,void,(void))
10388 #ifdef DYNGEN_IMPL
10389 #define HAVE_gen_op_load_ad_V2_VR27
10390 {
10391 static const uint8 op_load_ad_V2_VR27_code[] = {
10392 0x8d, 0xbd, 0x40, 0x03, 0x00, 0x00
10393 };
10394 copy_block(op_load_ad_V2_VR27_code, 6);
10395 inc_code_ptr(6);
10396 }
10397 #endif
10398
10399 DEFINE_GEN(gen_op_load_ad_VD_VR28,void,(void))
10400 #ifdef DYNGEN_IMPL
10401 #define HAVE_gen_op_load_ad_VD_VR28
10402 {
10403 static const uint8 op_load_ad_VD_VR28_code[] = {
10404 0x8d, 0x85, 0x50, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10405 };
10406 copy_block(op_load_ad_VD_VR28_code, 12);
10407 inc_code_ptr(12);
10408 }
10409 #endif
10410
10411 DEFINE_GEN(gen_op_load_ad_V0_VR28,void,(void))
10412 #ifdef DYNGEN_IMPL
10413 #define HAVE_gen_op_load_ad_V0_VR28
10414 {
10415 static const uint8 op_load_ad_V0_VR28_code[] = {
10416 0x8d, 0x9d, 0x50, 0x03, 0x00, 0x00
10417 };
10418 copy_block(op_load_ad_V0_VR28_code, 6);
10419 inc_code_ptr(6);
10420 }
10421 #endif
10422
10423 DEFINE_GEN(gen_op_load_ad_V1_VR28,void,(void))
10424 #ifdef DYNGEN_IMPL
10425 #define HAVE_gen_op_load_ad_V1_VR28
10426 {
10427 static const uint8 op_load_ad_V1_VR28_code[] = {
10428 0x8d, 0xb5, 0x50, 0x03, 0x00, 0x00
10429 };
10430 copy_block(op_load_ad_V1_VR28_code, 6);
10431 inc_code_ptr(6);
10432 }
10433 #endif
10434
10435 DEFINE_GEN(gen_op_load_ad_V2_VR28,void,(void))
10436 #ifdef DYNGEN_IMPL
10437 #define HAVE_gen_op_load_ad_V2_VR28
10438 {
10439 static const uint8 op_load_ad_V2_VR28_code[] = {
10440 0x8d, 0xbd, 0x50, 0x03, 0x00, 0x00
10441 };
10442 copy_block(op_load_ad_V2_VR28_code, 6);
10443 inc_code_ptr(6);
10444 }
10445 #endif
10446
10447 DEFINE_GEN(gen_op_load_ad_VD_VR29,void,(void))
10448 #ifdef DYNGEN_IMPL
10449 #define HAVE_gen_op_load_ad_VD_VR29
10450 {
10451 static const uint8 op_load_ad_VD_VR29_code[] = {
10452 0x8d, 0x85, 0x60, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10453 };
10454 copy_block(op_load_ad_VD_VR29_code, 12);
10455 inc_code_ptr(12);
10456 }
10457 #endif
10458
10459 DEFINE_GEN(gen_op_load_ad_V0_VR29,void,(void))
10460 #ifdef DYNGEN_IMPL
10461 #define HAVE_gen_op_load_ad_V0_VR29
10462 {
10463 static const uint8 op_load_ad_V0_VR29_code[] = {
10464 0x8d, 0x9d, 0x60, 0x03, 0x00, 0x00
10465 };
10466 copy_block(op_load_ad_V0_VR29_code, 6);
10467 inc_code_ptr(6);
10468 }
10469 #endif
10470
10471 DEFINE_GEN(gen_op_load_ad_V1_VR29,void,(void))
10472 #ifdef DYNGEN_IMPL
10473 #define HAVE_gen_op_load_ad_V1_VR29
10474 {
10475 static const uint8 op_load_ad_V1_VR29_code[] = {
10476 0x8d, 0xb5, 0x60, 0x03, 0x00, 0x00
10477 };
10478 copy_block(op_load_ad_V1_VR29_code, 6);
10479 inc_code_ptr(6);
10480 }
10481 #endif
10482
10483 DEFINE_GEN(gen_op_load_ad_V2_VR29,void,(void))
10484 #ifdef DYNGEN_IMPL
10485 #define HAVE_gen_op_load_ad_V2_VR29
10486 {
10487 static const uint8 op_load_ad_V2_VR29_code[] = {
10488 0x8d, 0xbd, 0x60, 0x03, 0x00, 0x00
10489 };
10490 copy_block(op_load_ad_V2_VR29_code, 6);
10491 inc_code_ptr(6);
10492 }
10493 #endif
10494
10495 DEFINE_GEN(gen_op_load_ad_VD_VR30,void,(void))
10496 #ifdef DYNGEN_IMPL
10497 #define HAVE_gen_op_load_ad_VD_VR30
10498 {
10499 static const uint8 op_load_ad_VD_VR30_code[] = {
10500 0x8d, 0x85, 0x70, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10501 };
10502 copy_block(op_load_ad_VD_VR30_code, 12);
10503 inc_code_ptr(12);
10504 }
10505 #endif
10506
10507 DEFINE_GEN(gen_op_load_ad_V0_VR30,void,(void))
10508 #ifdef DYNGEN_IMPL
10509 #define HAVE_gen_op_load_ad_V0_VR30
10510 {
10511 static const uint8 op_load_ad_V0_VR30_code[] = {
10512 0x8d, 0x9d, 0x70, 0x03, 0x00, 0x00
10513 };
10514 copy_block(op_load_ad_V0_VR30_code, 6);
10515 inc_code_ptr(6);
10516 }
10517 #endif
10518
10519 DEFINE_GEN(gen_op_load_ad_V1_VR30,void,(void))
10520 #ifdef DYNGEN_IMPL
10521 #define HAVE_gen_op_load_ad_V1_VR30
10522 {
10523 static const uint8 op_load_ad_V1_VR30_code[] = {
10524 0x8d, 0xb5, 0x70, 0x03, 0x00, 0x00
10525 };
10526 copy_block(op_load_ad_V1_VR30_code, 6);
10527 inc_code_ptr(6);
10528 }
10529 #endif
10530
10531 DEFINE_GEN(gen_op_load_ad_V2_VR30,void,(void))
10532 #ifdef DYNGEN_IMPL
10533 #define HAVE_gen_op_load_ad_V2_VR30
10534 {
10535 static const uint8 op_load_ad_V2_VR30_code[] = {
10536 0x8d, 0xbd, 0x70, 0x03, 0x00, 0x00
10537 };
10538 copy_block(op_load_ad_V2_VR30_code, 6);
10539 inc_code_ptr(6);
10540 }
10541 #endif
10542
10543 DEFINE_GEN(gen_op_load_ad_VD_VR31,void,(void))
10544 #ifdef DYNGEN_IMPL
10545 #define HAVE_gen_op_load_ad_VD_VR31
10546 {
10547 static const uint8 op_load_ad_VD_VR31_code[] = {
10548 0x8d, 0x85, 0x80, 0x03, 0x00, 0x00, 0x89, 0x85, 0x3c, 0x08, 0x0e, 0x00
10549 };
10550 copy_block(op_load_ad_VD_VR31_code, 12);
10551 inc_code_ptr(12);
10552 }
10553 #endif
10554
10555 DEFINE_GEN(gen_op_load_ad_V0_VR31,void,(void))
10556 #ifdef DYNGEN_IMPL
10557 #define HAVE_gen_op_load_ad_V0_VR31
10558 {
10559 static const uint8 op_load_ad_V0_VR31_code[] = {
10560 0x8d, 0x9d, 0x80, 0x03, 0x00, 0x00
10561 };
10562 copy_block(op_load_ad_V0_VR31_code, 6);
10563 inc_code_ptr(6);
10564 }
10565 #endif
10566
10567 DEFINE_GEN(gen_op_load_ad_V1_VR31,void,(void))
10568 #ifdef DYNGEN_IMPL
10569 #define HAVE_gen_op_load_ad_V1_VR31
10570 {
10571 static const uint8 op_load_ad_V1_VR31_code[] = {
10572 0x8d, 0xb5, 0x80, 0x03, 0x00, 0x00
10573 };
10574 copy_block(op_load_ad_V1_VR31_code, 6);
10575 inc_code_ptr(6);
10576 }
10577 #endif
10578
10579 DEFINE_GEN(gen_op_load_ad_V2_VR31,void,(void))
10580 #ifdef DYNGEN_IMPL
10581 #define HAVE_gen_op_load_ad_V2_VR31
10582 {
10583 static const uint8 op_load_ad_V2_VR31_code[] = {
10584 0x8d, 0xbd, 0x80, 0x03, 0x00, 0x00
10585 };
10586 copy_block(op_load_ad_V2_VR31_code, 6);
10587 inc_code_ptr(6);
10588 }
10589 #endif
10590
10591 DEFINE_GEN(gen_op_load_word_VD_T0,void,(void))
10592 #ifdef DYNGEN_IMPL
10593 #define HAVE_gen_op_load_word_VD_T0
10594 {
10595 static const uint8 op_load_word_VD_T0_code[] = {
10596 0x89, 0xd8, 0x89, 0xda, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0xc1, 0xea,
10597 0x02, 0x83, 0xe0, 0xfc, 0x83, 0xe2, 0x03, 0x8b, 0x80, 0x00, 0x00, 0x00,
10598 0x11, 0x0f, 0xc8, 0x89, 0x04, 0x91
10599 };
10600 copy_block(op_load_word_VD_T0_code, 30);
10601 inc_code_ptr(30);
10602 }
10603 #endif
10604
10605 DEFINE_GEN(gen_op_store_word_VD_T0,void,(void))
10606 #ifdef DYNGEN_IMPL
10607 #define HAVE_gen_op_store_word_VD_T0
10608 {
10609 static const uint8 op_store_word_VD_T0_code[] = {
10610 0x89, 0xd8, 0x8b, 0x95, 0x3c, 0x08, 0x0e, 0x00, 0x89, 0xd9, 0xc1, 0xe8,
10611 0x02, 0x83, 0xe1, 0xfc, 0x83, 0xe0, 0x03, 0x8b, 0x04, 0x82, 0x0f, 0xc8,
10612 0x89, 0x81, 0x00, 0x00, 0x00, 0x11
10613 };
10614 copy_block(op_store_word_VD_T0_code, 30);
10615 inc_code_ptr(30);
10616 }
10617 #endif
10618
10619 DEFINE_GEN(gen_op_load_vect_VD_T0,void,(void))
10620 #ifdef DYNGEN_IMPL
10621 #define HAVE_gen_op_load_vect_VD_T0
10622 {
10623 static const uint8 op_load_vect_VD_T0_code[] = {
10624 0x89, 0xda, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x83, 0xe2, 0xf0, 0x8b,
10625 0x82, 0x00, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x01, 0x8b, 0x8d, 0x3c,
10626 0x08, 0x0e, 0x00, 0x8b, 0x82, 0x04, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89,
10627 0x41, 0x04, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x8b, 0x82, 0x08, 0x00,
10628 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x41, 0x08, 0x8b, 0x8d, 0x3c, 0x08, 0x0e,
10629 0x00, 0x8b, 0x82, 0x0c, 0x00, 0x00, 0x11, 0x0f, 0xc8, 0x89, 0x41, 0x0c
10630 };
10631 copy_block(op_load_vect_VD_T0_code, 72);
10632 inc_code_ptr(72);
10633 }
10634 #endif
10635
10636 DEFINE_GEN(gen_op_store_vect_VD_T0,void,(void))
10637 #ifdef DYNGEN_IMPL
10638 #define HAVE_gen_op_store_vect_VD_T0
10639 {
10640 static const uint8 op_store_vect_VD_T0_code[] = {
10641 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x89, 0xda, 0x83, 0xe2, 0xf0, 0x8b,
10642 0x00, 0x0f, 0xc8, 0x89, 0x82, 0x00, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x3c,
10643 0x08, 0x0e, 0x00, 0x8b, 0x40, 0x04, 0x0f, 0xc8, 0x89, 0x82, 0x04, 0x00,
10644 0x00, 0x11, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x8b, 0x40, 0x08, 0x0f,
10645 0xc8, 0x89, 0x82, 0x08, 0x00, 0x00, 0x11, 0x8b, 0x85, 0x3c, 0x08, 0x0e,
10646 0x00, 0x8b, 0x40, 0x0c, 0x0f, 0xc8, 0x89, 0x82, 0x0c, 0x00, 0x00, 0x11
10647 };
10648 copy_block(op_store_vect_VD_T0_code, 72);
10649 inc_code_ptr(72);
10650 }
10651 #endif
10652
10653 DEFINE_GEN(gen_op_record_cr6_VD,void,(void))
10654 #ifdef DYNGEN_IMPL
10655 #define HAVE_gen_op_record_cr6_VD
10656 {
10657 static const uint8 op_record_cr6_VD_code[] = {
10658 0x83, 0xec, 0x04, 0x8b, 0x95, 0x3c, 0x08, 0x0e, 0x00, 0xc7, 0x04, 0x24,
10659 0x00, 0x00, 0x00, 0x00, 0x8b, 0x0a, 0x8b, 0x42, 0x04, 0x21, 0xc8, 0x8b,
10660 0x4a, 0x08, 0x21, 0xc8, 0x23, 0x42, 0x0c, 0x8d, 0x8d, 0x3c, 0x08, 0x0e,
10661 0x00, 0x40, 0x75, 0x09, 0xc7, 0x04, 0x24, 0x08, 0x00, 0x00, 0x00, 0xeb,
10662 0x1f, 0x8b, 0x11, 0x8b, 0x0a, 0x8b, 0x42, 0x04, 0x09, 0xc8, 0x8b, 0x4a,
10663 0x08, 0x09, 0xc8, 0x0b, 0x42, 0x0c, 0x75, 0x0c, 0xc7, 0x04, 0x24, 0x02,
10664 0x00, 0x00, 0x00, 0x90, 0x8d, 0x74, 0x26, 0x00, 0xc1, 0x24, 0x24, 0x04,
10665 0x8b, 0x85, 0x90, 0x03, 0x00, 0x00, 0x8b, 0x0c, 0x24, 0x25, 0x0f, 0xff,
10666 0xff, 0xff, 0x09, 0xc8, 0x89, 0x85, 0x90, 0x03, 0x00, 0x00, 0x58
10667 };
10668 copy_block(op_record_cr6_VD_code, 107);
10669 inc_code_ptr(107);
10670 }
10671 #endif
10672
10673 DEFINE_GEN(gen_op_mfvscr_VD,void,(void))
10674 #ifdef DYNGEN_IMPL
10675 #define HAVE_gen_op_mfvscr_VD
10676 {
10677 static const uint8 op_mfvscr_VD_code[] = {
10678 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xc7, 0x00, 0x00, 0x00, 0x00, 0x00,
10679 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xc7, 0x40, 0x04, 0x00, 0x00, 0x00,
10680 0x00, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xc7, 0x40, 0x08, 0x00, 0x00,
10681 0x00, 0x00, 0x8b, 0x95, 0x3c, 0x08, 0x0e, 0x00, 0x8b, 0x85, 0x98, 0x03,
10682 0x00, 0x00, 0x89, 0x42, 0x0c
10683 };
10684 copy_block(op_mfvscr_VD_code, 53);
10685 inc_code_ptr(53);
10686 }
10687 #endif
10688
10689 DEFINE_GEN(gen_op_mtvscr_V0,void,(void))
10690 #ifdef DYNGEN_IMPL
10691 #define HAVE_gen_op_mtvscr_V0
10692 {
10693 static const uint8 op_mtvscr_V0_code[] = {
10694 0x8b, 0x43, 0x0c, 0x89, 0x85, 0x98, 0x03, 0x00, 0x00
10695 };
10696 copy_block(op_mtvscr_V0_code, 9);
10697 inc_code_ptr(9);
10698 }
10699 #endif
10700
10701 DEFINE_GEN(gen_op_emms,void,(void))
10702 #ifdef DYNGEN_IMPL
10703 #define HAVE_gen_op_emms
10704 {
10705 static const uint8 op_emms_code[] = {
10706 0x0f, 0x77
10707 };
10708 copy_block(op_emms_code, 2);
10709 inc_code_ptr(2);
10710 }
10711 #endif
10712
10713 DEFINE_GEN(gen_op_mmx_vcmpequb,void,(void))
10714 #ifdef DYNGEN_IMPL
10715 #define HAVE_gen_op_mmx_vcmpequb
10716 {
10717 static const uint8 op_mmx_vcmpequb_code[] = {
10718 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10719 0x08, 0x0f, 0x74, 0x06, 0x0f, 0x74, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10720 0x7f, 0x48, 0x08
10721 };
10722 copy_block(op_mmx_vcmpequb_code, 27);
10723 inc_code_ptr(27);
10724 }
10725 #endif
10726
10727 DEFINE_GEN(gen_op_mmx_vcmpequh,void,(void))
10728 #ifdef DYNGEN_IMPL
10729 #define HAVE_gen_op_mmx_vcmpequh
10730 {
10731 static const uint8 op_mmx_vcmpequh_code[] = {
10732 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10733 0x08, 0x0f, 0x75, 0x06, 0x0f, 0x75, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10734 0x7f, 0x48, 0x08
10735 };
10736 copy_block(op_mmx_vcmpequh_code, 27);
10737 inc_code_ptr(27);
10738 }
10739 #endif
10740
10741 DEFINE_GEN(gen_op_mmx_vcmpequw,void,(void))
10742 #ifdef DYNGEN_IMPL
10743 #define HAVE_gen_op_mmx_vcmpequw
10744 {
10745 static const uint8 op_mmx_vcmpequw_code[] = {
10746 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10747 0x08, 0x0f, 0x76, 0x06, 0x0f, 0x76, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10748 0x7f, 0x48, 0x08
10749 };
10750 copy_block(op_mmx_vcmpequw_code, 27);
10751 inc_code_ptr(27);
10752 }
10753 #endif
10754
10755 DEFINE_GEN(gen_op_mmx_vcmpgtsb,void,(void))
10756 #ifdef DYNGEN_IMPL
10757 #define HAVE_gen_op_mmx_vcmpgtsb
10758 {
10759 static const uint8 op_mmx_vcmpgtsb_code[] = {
10760 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10761 0x08, 0x0f, 0x64, 0x06, 0x0f, 0x64, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10762 0x7f, 0x48, 0x08
10763 };
10764 copy_block(op_mmx_vcmpgtsb_code, 27);
10765 inc_code_ptr(27);
10766 }
10767 #endif
10768
10769 DEFINE_GEN(gen_op_mmx_vcmpgtsh,void,(void))
10770 #ifdef DYNGEN_IMPL
10771 #define HAVE_gen_op_mmx_vcmpgtsh
10772 {
10773 static const uint8 op_mmx_vcmpgtsh_code[] = {
10774 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10775 0x08, 0x0f, 0x65, 0x06, 0x0f, 0x65, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10776 0x7f, 0x48, 0x08
10777 };
10778 copy_block(op_mmx_vcmpgtsh_code, 27);
10779 inc_code_ptr(27);
10780 }
10781 #endif
10782
10783 DEFINE_GEN(gen_op_mmx_vcmpgtsw,void,(void))
10784 #ifdef DYNGEN_IMPL
10785 #define HAVE_gen_op_mmx_vcmpgtsw
10786 {
10787 static const uint8 op_mmx_vcmpgtsw_code[] = {
10788 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10789 0x08, 0x0f, 0x66, 0x06, 0x0f, 0x66, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10790 0x7f, 0x48, 0x08
10791 };
10792 copy_block(op_mmx_vcmpgtsw_code, 27);
10793 inc_code_ptr(27);
10794 }
10795 #endif
10796
10797 DEFINE_GEN(gen_op_mmx_vaddubm,void,(void))
10798 #ifdef DYNGEN_IMPL
10799 #define HAVE_gen_op_mmx_vaddubm
10800 {
10801 static const uint8 op_mmx_vaddubm_code[] = {
10802 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10803 0x08, 0x0f, 0xfc, 0x06, 0x0f, 0xfc, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10804 0x7f, 0x48, 0x08
10805 };
10806 copy_block(op_mmx_vaddubm_code, 27);
10807 inc_code_ptr(27);
10808 }
10809 #endif
10810
10811 DEFINE_GEN(gen_op_mmx_vadduhm,void,(void))
10812 #ifdef DYNGEN_IMPL
10813 #define HAVE_gen_op_mmx_vadduhm
10814 {
10815 static const uint8 op_mmx_vadduhm_code[] = {
10816 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10817 0x08, 0x0f, 0xfd, 0x06, 0x0f, 0xfd, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10818 0x7f, 0x48, 0x08
10819 };
10820 copy_block(op_mmx_vadduhm_code, 27);
10821 inc_code_ptr(27);
10822 }
10823 #endif
10824
10825 DEFINE_GEN(gen_op_mmx_vadduwm,void,(void))
10826 #ifdef DYNGEN_IMPL
10827 #define HAVE_gen_op_mmx_vadduwm
10828 {
10829 static const uint8 op_mmx_vadduwm_code[] = {
10830 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10831 0x08, 0x0f, 0xfe, 0x06, 0x0f, 0xfe, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10832 0x7f, 0x48, 0x08
10833 };
10834 copy_block(op_mmx_vadduwm_code, 27);
10835 inc_code_ptr(27);
10836 }
10837 #endif
10838
10839 DEFINE_GEN(gen_op_mmx_vsububm,void,(void))
10840 #ifdef DYNGEN_IMPL
10841 #define HAVE_gen_op_mmx_vsububm
10842 {
10843 static const uint8 op_mmx_vsububm_code[] = {
10844 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10845 0x08, 0x0f, 0xf8, 0x06, 0x0f, 0xf8, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10846 0x7f, 0x48, 0x08
10847 };
10848 copy_block(op_mmx_vsububm_code, 27);
10849 inc_code_ptr(27);
10850 }
10851 #endif
10852
10853 DEFINE_GEN(gen_op_mmx_vsubuhm,void,(void))
10854 #ifdef DYNGEN_IMPL
10855 #define HAVE_gen_op_mmx_vsubuhm
10856 {
10857 static const uint8 op_mmx_vsubuhm_code[] = {
10858 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10859 0x08, 0x0f, 0xf9, 0x06, 0x0f, 0xf9, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10860 0x7f, 0x48, 0x08
10861 };
10862 copy_block(op_mmx_vsubuhm_code, 27);
10863 inc_code_ptr(27);
10864 }
10865 #endif
10866
10867 DEFINE_GEN(gen_op_mmx_vsubuwm,void,(void))
10868 #ifdef DYNGEN_IMPL
10869 #define HAVE_gen_op_mmx_vsubuwm
10870 {
10871 static const uint8 op_mmx_vsubuwm_code[] = {
10872 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10873 0x08, 0x0f, 0xfa, 0x06, 0x0f, 0xfa, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10874 0x7f, 0x48, 0x08
10875 };
10876 copy_block(op_mmx_vsubuwm_code, 27);
10877 inc_code_ptr(27);
10878 }
10879 #endif
10880
10881 DEFINE_GEN(gen_op_mmx_vand,void,(void))
10882 #ifdef DYNGEN_IMPL
10883 #define HAVE_gen_op_mmx_vand
10884 {
10885 static const uint8 op_mmx_vand_code[] = {
10886 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10887 0x08, 0x0f, 0xdb, 0x06, 0x0f, 0xdb, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10888 0x7f, 0x48, 0x08
10889 };
10890 copy_block(op_mmx_vand_code, 27);
10891 inc_code_ptr(27);
10892 }
10893 #endif
10894
10895 DEFINE_GEN(gen_op_mmx_vandc,void,(void))
10896 #ifdef DYNGEN_IMPL
10897 #define HAVE_gen_op_mmx_vandc
10898 {
10899 static const uint8 op_mmx_vandc_code[] = {
10900 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x06, 0x0f, 0x6f, 0x4e,
10901 0x08, 0x0f, 0xdf, 0x03, 0x0f, 0xdf, 0x4b, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10902 0x7f, 0x48, 0x08
10903 };
10904 copy_block(op_mmx_vandc_code, 27);
10905 inc_code_ptr(27);
10906 }
10907 #endif
10908
10909 DEFINE_GEN(gen_op_mmx_vor,void,(void))
10910 #ifdef DYNGEN_IMPL
10911 #define HAVE_gen_op_mmx_vor
10912 {
10913 static const uint8 op_mmx_vor_code[] = {
10914 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10915 0x08, 0x0f, 0xeb, 0x06, 0x0f, 0xeb, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10916 0x7f, 0x48, 0x08
10917 };
10918 copy_block(op_mmx_vor_code, 27);
10919 inc_code_ptr(27);
10920 }
10921 #endif
10922
10923 DEFINE_GEN(gen_op_mmx_vxor,void,(void))
10924 #ifdef DYNGEN_IMPL
10925 #define HAVE_gen_op_mmx_vxor
10926 {
10927 static const uint8 op_mmx_vxor_code[] = {
10928 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10929 0x08, 0x0f, 0xef, 0x06, 0x0f, 0xef, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10930 0x7f, 0x48, 0x08
10931 };
10932 copy_block(op_mmx_vxor_code, 27);
10933 inc_code_ptr(27);
10934 }
10935 #endif
10936
10937 DEFINE_GEN(gen_op_mmx_vmaxub,void,(void))
10938 #ifdef DYNGEN_IMPL
10939 #define HAVE_gen_op_mmx_vmaxub
10940 {
10941 static const uint8 op_mmx_vmaxub_code[] = {
10942 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10943 0x08, 0x0f, 0xde, 0x06, 0x0f, 0xde, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10944 0x7f, 0x48, 0x08
10945 };
10946 copy_block(op_mmx_vmaxub_code, 27);
10947 inc_code_ptr(27);
10948 }
10949 #endif
10950
10951 DEFINE_GEN(gen_op_mmx_vminub,void,(void))
10952 #ifdef DYNGEN_IMPL
10953 #define HAVE_gen_op_mmx_vminub
10954 {
10955 static const uint8 op_mmx_vminub_code[] = {
10956 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10957 0x08, 0x0f, 0xda, 0x06, 0x0f, 0xda, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10958 0x7f, 0x48, 0x08
10959 };
10960 copy_block(op_mmx_vminub_code, 27);
10961 inc_code_ptr(27);
10962 }
10963 #endif
10964
10965 DEFINE_GEN(gen_op_mmx_vmaxsh,void,(void))
10966 #ifdef DYNGEN_IMPL
10967 #define HAVE_gen_op_mmx_vmaxsh
10968 {
10969 static const uint8 op_mmx_vmaxsh_code[] = {
10970 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10971 0x08, 0x0f, 0xee, 0x06, 0x0f, 0xee, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10972 0x7f, 0x48, 0x08
10973 };
10974 copy_block(op_mmx_vmaxsh_code, 27);
10975 inc_code_ptr(27);
10976 }
10977 #endif
10978
10979 DEFINE_GEN(gen_op_mmx_vminsh,void,(void))
10980 #ifdef DYNGEN_IMPL
10981 #define HAVE_gen_op_mmx_vminsh
10982 {
10983 static const uint8 op_mmx_vminsh_code[] = {
10984 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0x0f, 0x6f, 0x03, 0x0f, 0x6f, 0x4b,
10985 0x08, 0x0f, 0xea, 0x06, 0x0f, 0xea, 0x4e, 0x08, 0x0f, 0x7f, 0x00, 0x0f,
10986 0x7f, 0x48, 0x08
10987 };
10988 copy_block(op_mmx_vminsh_code, 27);
10989 inc_code_ptr(27);
10990 }
10991 #endif
10992
10993 DEFINE_GEN(gen_op_store_T0_XER,void,(void))
10994 #ifdef DYNGEN_IMPL
10995 #define HAVE_gen_op_store_T0_XER
10996 {
10997 static const uint8 op_store_T0_XER_code[] = {
10998 0x83, 0xec, 0x04, 0x8d, 0x85, 0x94, 0x03, 0x00, 0x00, 0x89, 0xda, 0x89,
10999 0x04, 0x24, 0x89, 0xd8, 0xc1, 0xe8, 0x1f, 0x88, 0x85, 0x94, 0x03, 0x00,
11000 0x00, 0x8b, 0x0c, 0x24, 0x89, 0xd8, 0xc1, 0xe8, 0x1e, 0x83, 0xe2, 0x7f,
11001 0x83, 0xe0, 0x01, 0x88, 0x41, 0x01, 0x89, 0xd8, 0xc1, 0xe8, 0x1d, 0x88,
11002 0x51, 0x03, 0x83, 0xe0, 0x01, 0x88, 0x41, 0x02, 0x58
11003 };
11004 copy_block(op_store_T0_XER_code, 57);
11005 inc_code_ptr(57);
11006 }
11007 #endif
11008
11009 DEFINE_GEN(gen_op_jump_next_A0,void,(void))
11010 #ifdef DYNGEN_IMPL
11011 #define HAVE_gen_op_jump_next_A0
11012 {
11013 static const uint8 op_jump_next_A0_code[] = {
11014 0x8b, 0x95, 0xac, 0x03, 0x00, 0x00, 0x89, 0xd8, 0x39, 0x13, 0x74, 0x24,
11015 0x89, 0xd0, 0xc1, 0xe8, 0x02, 0x25, 0xff, 0x7f, 0x00, 0x00, 0x8b, 0x84,
11016 0x85, 0xfc, 0x07, 0x0c, 0x00, 0x85, 0xc0, 0x74, 0x04, 0x39, 0x10, 0x74,
11017 0x02, 0x31, 0xc0, 0x85, 0xc0, 0x74, 0x08, 0x90, 0x8d, 0x74, 0x26, 0x00,
11018 0xff, 0x60, 0x40
11019 };
11020 copy_block(op_jump_next_A0_code, 51);
11021 inc_code_ptr(51);
11022 }
11023 #endif
11024
11025 DEFINE_GEN(gen_op_vand_VD_V0_V1,void,(void))
11026 #ifdef DYNGEN_IMPL
11027 #define HAVE_gen_op_vand_VD_V0_V1
11028 {
11029 static const uint8 op_vand_VD_V0_V1_code[] = {
11030 0x8b, 0x16, 0x8b, 0x03, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x21, 0xd0,
11031 0x8b, 0x53, 0x04, 0x23, 0x56, 0x04, 0x89, 0x01, 0x89, 0x51, 0x04, 0x8b,
11032 0x56, 0x08, 0x8b, 0x43, 0x08, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x21,
11033 0xd0, 0x8b, 0x53, 0x0c, 0x23, 0x56, 0x0c, 0x89, 0x41, 0x08, 0x89, 0x51,
11034 0x0c
11035 };
11036 copy_block(op_vand_VD_V0_V1_code, 49);
11037 inc_code_ptr(49);
11038 }
11039 #endif
11040
11041 DEFINE_GEN(gen_op_vandc_VD_V0_V1,void,(void))
11042 #ifdef DYNGEN_IMPL
11043 #define HAVE_gen_op_vandc_VD_V0_V1
11044 {
11045 static const uint8 op_vandc_VD_V0_V1_code[] = {
11046 0x8b, 0x06, 0x8b, 0x56, 0x04, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0xf7,
11047 0xd0, 0xf7, 0xd2, 0x23, 0x03, 0x23, 0x53, 0x04, 0x89, 0x01, 0x89, 0x51,
11048 0x04, 0x8b, 0x46, 0x08, 0x8b, 0x56, 0x0c, 0x8b, 0x8d, 0x3c, 0x08, 0x0e,
11049 0x00, 0xf7, 0xd0, 0xf7, 0xd2, 0x23, 0x43, 0x08, 0x23, 0x53, 0x0c, 0x89,
11050 0x41, 0x08, 0x89, 0x51, 0x0c
11051 };
11052 copy_block(op_vandc_VD_V0_V1_code, 53);
11053 inc_code_ptr(53);
11054 }
11055 #endif
11056
11057 DEFINE_GEN(gen_op_vnor_VD_V0_V1,void,(void))
11058 #ifdef DYNGEN_IMPL
11059 #define HAVE_gen_op_vnor_VD_V0_V1
11060 {
11061 static const uint8 op_vnor_VD_V0_V1_code[] = {
11062 0x8b, 0x16, 0x8b, 0x03, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x09, 0xd0,
11063 0x8b, 0x53, 0x04, 0xf7, 0xd0, 0x0b, 0x56, 0x04, 0x89, 0x01, 0xf7, 0xd2,
11064 0x89, 0x51, 0x04, 0x8b, 0x56, 0x08, 0x8b, 0x43, 0x08, 0x8b, 0x8d, 0x3c,
11065 0x08, 0x0e, 0x00, 0x09, 0xd0, 0x8b, 0x53, 0x0c, 0x0b, 0x56, 0x0c, 0xf7,
11066 0xd0, 0x89, 0x41, 0x08, 0xf7, 0xd2, 0x89, 0x51, 0x0c
11067 };
11068 copy_block(op_vnor_VD_V0_V1_code, 57);
11069 inc_code_ptr(57);
11070 }
11071 #endif
11072
11073 DEFINE_GEN(gen_op_vor_VD_V0_V1,void,(void))
11074 #ifdef DYNGEN_IMPL
11075 #define HAVE_gen_op_vor_VD_V0_V1
11076 {
11077 static const uint8 op_vor_VD_V0_V1_code[] = {
11078 0x8b, 0x16, 0x8b, 0x03, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x09, 0xd0,
11079 0x8b, 0x53, 0x04, 0x0b, 0x56, 0x04, 0x89, 0x01, 0x89, 0x51, 0x04, 0x8b,
11080 0x56, 0x08, 0x8b, 0x43, 0x08, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x09,
11081 0xd0, 0x8b, 0x53, 0x0c, 0x0b, 0x56, 0x0c, 0x89, 0x41, 0x08, 0x89, 0x51,
11082 0x0c
11083 };
11084 copy_block(op_vor_VD_V0_V1_code, 49);
11085 inc_code_ptr(49);
11086 }
11087 #endif
11088
11089 DEFINE_GEN(gen_op_vxor_VD_V0_V1,void,(void))
11090 #ifdef DYNGEN_IMPL
11091 #define HAVE_gen_op_vxor_VD_V0_V1
11092 {
11093 static const uint8 op_vxor_VD_V0_V1_code[] = {
11094 0x8b, 0x16, 0x8b, 0x03, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x31, 0xd0,
11095 0x8b, 0x53, 0x04, 0x33, 0x56, 0x04, 0x89, 0x01, 0x89, 0x51, 0x04, 0x8b,
11096 0x56, 0x08, 0x8b, 0x43, 0x08, 0x8b, 0x8d, 0x3c, 0x08, 0x0e, 0x00, 0x31,
11097 0xd0, 0x8b, 0x53, 0x0c, 0x33, 0x56, 0x0c, 0x89, 0x41, 0x08, 0x89, 0x51,
11098 0x0c
11099 };
11100 copy_block(op_vxor_VD_V0_V1_code, 49);
11101 inc_code_ptr(49);
11102 }
11103 #endif
11104
11105 DEFINE_GEN(gen_op_vaddfp_VD_V0_V1,void,(void))
11106 #ifdef DYNGEN_IMPL
11107 #define HAVE_gen_op_vaddfp_VD_V0_V1
11108 {
11109 static const uint8 op_vaddfp_VD_V0_V1_code[] = {
11110 0xd9, 0x06, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd8, 0x03, 0xd9, 0x18,
11111 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x46, 0x04, 0xd8, 0x43, 0x04,
11112 0xd9, 0x58, 0x04, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x46, 0x08,
11113 0xd8, 0x43, 0x08, 0xd9, 0x58, 0x08, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00,
11114 0xd9, 0x46, 0x0c, 0xd8, 0x43, 0x0c, 0xd9, 0x58, 0x0c
11115 };
11116 copy_block(op_vaddfp_VD_V0_V1_code, 57);
11117 inc_code_ptr(57);
11118 }
11119 #endif
11120
11121 DEFINE_GEN(gen_op_vsubfp_VD_V0_V1,void,(void))
11122 #ifdef DYNGEN_IMPL
11123 #define HAVE_gen_op_vsubfp_VD_V0_V1
11124 {
11125 static const uint8 op_vsubfp_VD_V0_V1_code[] = {
11126 0xd9, 0x06, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd8, 0x2b, 0xd9, 0x18,
11127 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x46, 0x04, 0xd8, 0x6b, 0x04,
11128 0xd9, 0x58, 0x04, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x46, 0x08,
11129 0xd8, 0x6b, 0x08, 0xd9, 0x58, 0x08, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00,
11130 0xd9, 0x46, 0x0c, 0xd8, 0x6b, 0x0c, 0xd9, 0x58, 0x0c
11131 };
11132 copy_block(op_vsubfp_VD_V0_V1_code, 57);
11133 inc_code_ptr(57);
11134 }
11135 #endif
11136
11137 DEFINE_GEN(gen_op_vmaddfp_VD_V0_V1_V2,void,(void))
11138 #ifdef DYNGEN_IMPL
11139 #define HAVE_gen_op_vmaddfp_VD_V0_V1_V2
11140 {
11141 static const uint8 op_vmaddfp_VD_V0_V1_V2_code[] = {
11142 0xd9, 0x07, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd8, 0x0b, 0xd8, 0x06,
11143 0xd9, 0x18, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x47, 0x04, 0xd8,
11144 0x4b, 0x04, 0xd8, 0x46, 0x04, 0xd9, 0x58, 0x04, 0x8b, 0x85, 0x3c, 0x08,
11145 0x0e, 0x00, 0xd9, 0x47, 0x08, 0xd8, 0x4b, 0x08, 0xd8, 0x46, 0x08, 0xd9,
11146 0x58, 0x08, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x47, 0x0c, 0xd8,
11147 0x4b, 0x0c, 0xd8, 0x46, 0x0c, 0xd9, 0x58, 0x0c
11148 };
11149 copy_block(op_vmaddfp_VD_V0_V1_V2_code, 68);
11150 inc_code_ptr(68);
11151 }
11152 #endif
11153
11154 DEFINE_GEN(gen_op_vnmsubfp_VD_V0_V1_V2,void,(void))
11155 #ifdef DYNGEN_IMPL
11156 #define HAVE_gen_op_vnmsubfp_VD_V0_V1_V2
11157 {
11158 static const uint8 op_vnmsubfp_VD_V0_V1_V2_code[] = {
11159 0xd9, 0x07, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd8, 0x0b, 0xd8, 0x26,
11160 0xd9, 0xe0, 0xd9, 0x18, 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x47,
11161 0x04, 0xd8, 0x4b, 0x04, 0xd8, 0x66, 0x04, 0xd9, 0xe0, 0xd9, 0x58, 0x04,
11162 0x8b, 0x85, 0x3c, 0x08, 0x0e, 0x00, 0xd9, 0x47, 0x08, 0xd8, 0x4b, 0x08,
11163 0xd8, 0x66, 0x08, 0xd9, 0xe0, 0xd9, 0x58, 0x08, 0x8b, 0x85, 0x3c, 0x08,
11164 0x0e, 0x00, 0xd9, 0x47, 0x0c, 0xd8, 0x4b, 0x0c, 0xd8, 0x66, 0x0c, 0xd9,
11165 0xe0, 0xd9, 0x58, 0x0c
11166 };
11167 copy_block(op_vnmsubfp_VD_V0_V1_V2_code, 76);
11168 inc_code_ptr(76);
11169 }
11170 #endif
11171
11172 #undef DEFINE_CST
11173 #undef DEFINE_GEN