Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(70)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: opcodes/rx-decode.c

Issue 11969036: Merge GDB 7.5.1 (Closed) Base URL: http://git.chromium.org/native_client/nacl-gdb.git@master
Patch Set: Created 7 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « opcodes/rl78-dis.c ('k') | opcodes/rx-decode.opc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 #line 1 "rx-decode.opc" 1 #line 1 "rx-decode.opc"
2 /* -*- c -*- */ 2 /* -*- c -*- */
3 #include "sysdep.h"
3 #include <stdio.h> 4 #include <stdio.h>
4 #include <stdlib.h> 5 #include <stdlib.h>
5 #include <string.h> 6 #include <string.h>
6
7 #include "config.h"
8 #include "ansidecl.h" 7 #include "ansidecl.h"
9 #include "opcode/rx.h" 8 #include "opcode/rx.h"
10 9
11 #define RX_OPCODE_BIG_ENDIAN 0 10 #define RX_OPCODE_BIG_ENDIAN 0
12 11
13 typedef struct 12 typedef struct
14 { 13 {
15 RX_Opcode_Decoded * rx; 14 RX_Opcode_Decoded * rx;
16 int (* getbyte)(void *); 15 int (* getbyte)(void *);
17 void * ptr; 16 void * ptr;
(...skipping 246 matching lines...) Expand 10 before | Expand all | Expand 10 after
264 case 0x00: 263 case 0x00:
265 { 264 {
266 /** 0000 0000 brk */ 265 /** 0000 0000 brk */
267 if (trace) 266 if (trace)
268 { 267 {
269 printf ("\033[33m%s\033[0m %02x\n", 268 printf ("\033[33m%s\033[0m %02x\n",
270 "/** 0000 0000 brk */", 269 "/** 0000 0000 brk */",
271 op[0]); 270 op[0]);
272 } 271 }
273 SYNTAX("brk"); 272 SYNTAX("brk");
274 #line 943 "rx-decode.opc" 273 #line 955 "rx-decode.opc"
275 ID(brk); 274 ID(brk);
276 275
277 } 276 }
278 break; 277 break;
279 case 0x01: 278 case 0x01:
280 { 279 {
281 /** 0000 0001 dbt */ 280 /** 0000 0001 dbt */
282 if (trace) 281 if (trace)
283 { 282 {
284 printf ("\033[33m%s\033[0m %02x\n", 283 printf ("\033[33m%s\033[0m %02x\n",
285 "/** 0000 0001 dbt */", 284 "/** 0000 0001 dbt */",
286 op[0]); 285 op[0]);
287 } 286 }
288 SYNTAX("dbt"); 287 SYNTAX("dbt");
289 #line 946 "rx-decode.opc" 288 #line 958 "rx-decode.opc"
290 ID(dbt); 289 ID(dbt);
291 290
292 } 291 }
293 break; 292 break;
294 case 0x02: 293 case 0x02:
295 { 294 {
296 /** 0000 0010 rts */ 295 /** 0000 0010 rts */
297 if (trace) 296 if (trace)
298 { 297 {
299 printf ("\033[33m%s\033[0m %02x\n", 298 printf ("\033[33m%s\033[0m %02x\n",
300 "/** 0000 0010 rts */", 299 "/** 0000 0010 rts */",
301 op[0]); 300 op[0]);
302 } 301 }
303 SYNTAX("rts"); 302 SYNTAX("rts");
304 #line 732 "rx-decode.opc" 303 #line 744 "rx-decode.opc"
305 ID(rts); 304 ID(rts);
306 305
307 /*---------------------------------------------------------------------- */ 306 /*---------------------------------------------------------------------- */
308 /* NOP */ 307 /* NOP */
309 308
310 } 309 }
311 break; 310 break;
312 case 0x03: 311 case 0x03:
313 { 312 {
314 /** 0000 0011 nop */ 313 /** 0000 0011 nop */
315 if (trace) 314 if (trace)
316 { 315 {
317 printf ("\033[33m%s\033[0m %02x\n", 316 printf ("\033[33m%s\033[0m %02x\n",
318 "/** 0000 0011 nop */", 317 "/** 0000 0011 nop */",
319 op[0]); 318 op[0]);
320 } 319 }
321 SYNTAX("nop"); 320 SYNTAX("nop");
322 #line 738 "rx-decode.opc" 321 #line 750 "rx-decode.opc"
323 ID(nop); 322 ID(nop);
324 323
325 /*---------------------------------------------------------------------- */ 324 /*---------------------------------------------------------------------- */
326 /* STRING FUNCTIONS */ 325 /* STRING FUNCTIONS */
327 326
328 } 327 }
329 break; 328 break;
330 case 0x04: 329 case 0x04:
331 { 330 {
332 /** 0000 0100 bra.a %a0 */ 331 /** 0000 0100 bra.a %a0 */
333 if (trace) 332 if (trace)
334 { 333 {
335 printf ("\033[33m%s\033[0m %02x\n", 334 printf ("\033[33m%s\033[0m %02x\n",
336 "/** 0000 0100 bra.a %a0 */", 335 "/** 0000 0100 bra.a %a0 */",
337 op[0]); 336 op[0]);
338 } 337 }
339 SYNTAX("bra.a %a0"); 338 SYNTAX("bra.a %a0");
340 #line 710 "rx-decode.opc" 339 #line 722 "rx-decode.opc"
341 ID(branch); DC(pc + IMMex(3)); 340 ID(branch); DC(pc + IMMex(3));
342 341
343 } 342 }
344 break; 343 break;
345 case 0x05: 344 case 0x05:
346 { 345 {
347 /** 0000 0101 bsr.a %a0 */ 346 /** 0000 0101 bsr.a %a0 */
348 if (trace) 347 if (trace)
349 { 348 {
350 printf ("\033[33m%s\033[0m %02x\n", 349 printf ("\033[33m%s\033[0m %02x\n",
351 "/** 0000 0101 bsr.a %a0 */", 350 "/** 0000 0101 bsr.a %a0 */",
352 op[0]); 351 op[0]);
353 } 352 }
354 SYNTAX("bsr.a %a0"); 353 SYNTAX("bsr.a %a0");
355 #line 726 "rx-decode.opc" 354 #line 738 "rx-decode.opc"
356 ID(jsr); DC(pc + IMMex(3)); 355 ID(jsr); DC(pc + IMMex(3));
357 356
358 } 357 }
359 break; 358 break;
360 case 0x06: 359 case 0x06:
361 GETBYTE (); 360 GETBYTE ();
362 switch (op[1] & 0xff) 361 switch (op[1] & 0xff)
363 { 362 {
364 case 0x00: 363 case 0x00:
365 GETBYTE (); 364 GETBYTE ();
366 switch (op[2] & 0x00) 365 switch (op[2] & 0x00)
367 { 366 {
368 case 0x00: 367 case 0x00:
369 op_semantics_1: 368 op_semantics_1:
370 { 369 {
371 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */ 370 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */
372 #line 506 "rx-decode.opc" 371 #line 518 "rx-decode.opc"
373 int mx AU = (op[1] >> 6) & 0x03; 372 int mx AU = (op[1] >> 6) & 0x03;
374 #line 506 "rx-decode.opc" 373 #line 518 "rx-decode.opc"
375 int ss AU = op[1] & 0x03; 374 int ss AU = op[1] & 0x03;
376 #line 506 "rx-decode.opc" 375 #line 518 "rx-decode.opc"
377 int rsrc AU = (op[2] >> 4) & 0x0f; 376 int rsrc AU = (op[2] >> 4) & 0x0f;
378 #line 506 "rx-decode.opc" 377 #line 518 "rx-decode.opc"
379 int rdst AU = op[2] & 0x0f; 378 int rdst AU = op[2] & 0x0f;
380 if (trace) 379 if (trace)
381 { 380 {
382 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 381 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
383 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */", 382 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */",
384 op[0], op[1], op[2]); 383 op[0], op[1], op[2]);
385 printf (" mx = 0x%x,", mx); 384 printf (" mx = 0x%x,", mx);
386 printf (" ss = 0x%x,", ss); 385 printf (" ss = 0x%x,", ss);
387 printf (" rsrc = 0x%x,", rsrc); 386 printf (" rsrc = 0x%x,", rsrc);
388 printf (" rdst = 0x%x\n", rdst); 387 printf (" rdst = 0x%x\n", rdst);
389 } 388 }
390 SYNTAX("sub %2%S2, %1"); 389 SYNTAX("sub %2%S2, %1");
391 #line 506 "rx-decode.opc" 390 #line 518 "rx-decode.opc"
392 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC; 391 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC;
393 392
394 } 393 }
395 break; 394 break;
396 } 395 }
397 break; 396 break;
398 case 0x01: 397 case 0x01:
399 GETBYTE (); 398 GETBYTE ();
400 switch (op[2] & 0x00) 399 switch (op[2] & 0x00)
401 { 400 {
(...skipping 21 matching lines...) Expand all
423 } 422 }
424 break; 423 break;
425 case 0x04: 424 case 0x04:
426 GETBYTE (); 425 GETBYTE ();
427 switch (op[2] & 0x00) 426 switch (op[2] & 0x00)
428 { 427 {
429 case 0x00: 428 case 0x00:
430 op_semantics_2: 429 op_semantics_2:
431 { 430 {
432 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, % 1 */ 431 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, % 1 */
433 #line 494 "rx-decode.opc" 432 #line 506 "rx-decode.opc"
434 int mx AU = (op[1] >> 6) & 0x03; 433 int mx AU = (op[1] >> 6) & 0x03;
435 #line 494 "rx-decode.opc" 434 #line 506 "rx-decode.opc"
436 int ss AU = op[1] & 0x03; 435 int ss AU = op[1] & 0x03;
437 #line 494 "rx-decode.opc" 436 #line 506 "rx-decode.opc"
438 int rsrc AU = (op[2] >> 4) & 0x0f; 437 int rsrc AU = (op[2] >> 4) & 0x0f;
439 #line 494 "rx-decode.opc" 438 #line 506 "rx-decode.opc"
440 int rdst AU = op[2] & 0x0f; 439 int rdst AU = op[2] & 0x0f;
441 if (trace) 440 if (trace)
442 { 441 {
443 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 442 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
444 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */", 443 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */",
445 op[0], op[1], op[2]); 444 op[0], op[1], op[2]);
446 printf (" mx = 0x%x,", mx); 445 printf (" mx = 0x%x,", mx);
447 printf (" ss = 0x%x,", ss); 446 printf (" ss = 0x%x,", ss);
448 printf (" rsrc = 0x%x,", rsrc); 447 printf (" rsrc = 0x%x,", rsrc);
449 printf (" rdst = 0x%x\n", rdst); 448 printf (" rdst = 0x%x\n", rdst);
450 } 449 }
451 SYNTAX("cmp %2%S2, %1"); 450 SYNTAX("cmp %2%S2, %1");
452 #line 494 "rx-decode.opc" 451 #line 506 "rx-decode.opc"
453 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC; 452 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC;
454 453
455 /*---------------------------------------------------------- ------------*/ 454 /*---------------------------------------------------------- ------------*/
456 /* SUB */ 455 /* SUB */
457 456
458 } 457 }
459 break; 458 break;
460 } 459 }
461 break; 460 break;
462 case 0x05: 461 case 0x05:
(...skipping 24 matching lines...) Expand all
487 } 486 }
488 break; 487 break;
489 case 0x08: 488 case 0x08:
490 GETBYTE (); 489 GETBYTE ();
491 switch (op[2] & 0x00) 490 switch (op[2] & 0x00)
492 { 491 {
493 case 0x00: 492 case 0x00:
494 op_semantics_3: 493 op_semantics_3:
495 { 494 {
496 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */ 495 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */
497 #line 470 "rx-decode.opc" 496 #line 482 "rx-decode.opc"
498 int mx AU = (op[1] >> 6) & 0x03; 497 int mx AU = (op[1] >> 6) & 0x03;
499 #line 470 "rx-decode.opc" 498 #line 482 "rx-decode.opc"
500 int ss AU = op[1] & 0x03; 499 int ss AU = op[1] & 0x03;
501 #line 470 "rx-decode.opc" 500 #line 482 "rx-decode.opc"
502 int rsrc AU = (op[2] >> 4) & 0x0f; 501 int rsrc AU = (op[2] >> 4) & 0x0f;
503 #line 470 "rx-decode.opc" 502 #line 482 "rx-decode.opc"
504 int rdst AU = op[2] & 0x0f; 503 int rdst AU = op[2] & 0x0f;
505 if (trace) 504 if (trace)
506 { 505 {
507 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 506 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
508 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */", 507 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */",
509 op[0], op[1], op[2]); 508 op[0], op[1], op[2]);
510 printf (" mx = 0x%x,", mx); 509 printf (" mx = 0x%x,", mx);
511 printf (" ss = 0x%x,", ss); 510 printf (" ss = 0x%x,", ss);
512 printf (" rsrc = 0x%x,", rsrc); 511 printf (" rsrc = 0x%x,", rsrc);
513 printf (" rdst = 0x%x\n", rdst); 512 printf (" rdst = 0x%x\n", rdst);
514 } 513 }
515 SYNTAX("add %1%S1, %0"); 514 SYNTAX("add %1%S1, %0");
516 #line 470 "rx-decode.opc" 515 #line 482 "rx-decode.opc"
517 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC; 516 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC;
518 517
519 } 518 }
520 break; 519 break;
521 } 520 }
522 break; 521 break;
523 case 0x09: 522 case 0x09:
524 GETBYTE (); 523 GETBYTE ();
525 switch (op[2] & 0x00) 524 switch (op[2] & 0x00)
526 { 525 {
(...skipping 21 matching lines...) Expand all
548 } 547 }
549 break; 548 break;
550 case 0x0c: 549 case 0x0c:
551 GETBYTE (); 550 GETBYTE ();
552 switch (op[2] & 0x00) 551 switch (op[2] & 0x00)
553 { 552 {
554 case 0x00: 553 case 0x00:
555 op_semantics_4: 554 op_semantics_4:
556 { 555 {
557 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */ 556 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */
558 #line 575 "rx-decode.opc" 557 #line 587 "rx-decode.opc"
559 int mx AU = (op[1] >> 6) & 0x03; 558 int mx AU = (op[1] >> 6) & 0x03;
560 #line 575 "rx-decode.opc" 559 #line 587 "rx-decode.opc"
561 int ss AU = op[1] & 0x03; 560 int ss AU = op[1] & 0x03;
562 #line 575 "rx-decode.opc" 561 #line 587 "rx-decode.opc"
563 int rsrc AU = (op[2] >> 4) & 0x0f; 562 int rsrc AU = (op[2] >> 4) & 0x0f;
564 #line 575 "rx-decode.opc" 563 #line 587 "rx-decode.opc"
565 int rdst AU = op[2] & 0x0f; 564 int rdst AU = op[2] & 0x0f;
566 if (trace) 565 if (trace)
567 { 566 {
568 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 567 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
569 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */", 568 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */",
570 op[0], op[1], op[2]); 569 op[0], op[1], op[2]);
571 printf (" mx = 0x%x,", mx); 570 printf (" mx = 0x%x,", mx);
572 printf (" ss = 0x%x,", ss); 571 printf (" ss = 0x%x,", ss);
573 printf (" rsrc = 0x%x,", rsrc); 572 printf (" rsrc = 0x%x,", rsrc);
574 printf (" rdst = 0x%x\n", rdst); 573 printf (" rdst = 0x%x\n", rdst);
575 } 574 }
576 SYNTAX("mul %1%S1, %0"); 575 SYNTAX("mul %1%S1, %0");
577 #line 575 "rx-decode.opc" 576 #line 587 "rx-decode.opc"
578 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____; 577 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____;
579 578
580 } 579 }
581 break; 580 break;
582 } 581 }
583 break; 582 break;
584 case 0x0d: 583 case 0x0d:
585 GETBYTE (); 584 GETBYTE ();
586 switch (op[2] & 0x00) 585 switch (op[2] & 0x00)
587 { 586 {
(...skipping 21 matching lines...) Expand all
609 } 608 }
610 break; 609 break;
611 case 0x10: 610 case 0x10:
612 GETBYTE (); 611 GETBYTE ();
613 switch (op[2] & 0x00) 612 switch (op[2] & 0x00)
614 { 613 {
615 case 0x00: 614 case 0x00:
616 op_semantics_5: 615 op_semantics_5:
617 { 616 {
618 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */ 617 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */
619 #line 383 "rx-decode.opc" 618 #line 395 "rx-decode.opc"
620 int mx AU = (op[1] >> 6) & 0x03; 619 int mx AU = (op[1] >> 6) & 0x03;
621 #line 383 "rx-decode.opc" 620 #line 395 "rx-decode.opc"
622 int ss AU = op[1] & 0x03; 621 int ss AU = op[1] & 0x03;
623 #line 383 "rx-decode.opc" 622 #line 395 "rx-decode.opc"
624 int rsrc AU = (op[2] >> 4) & 0x0f; 623 int rsrc AU = (op[2] >> 4) & 0x0f;
625 #line 383 "rx-decode.opc" 624 #line 395 "rx-decode.opc"
626 int rdst AU = op[2] & 0x0f; 625 int rdst AU = op[2] & 0x0f;
627 if (trace) 626 if (trace)
628 { 627 {
629 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 628 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
630 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */", 629 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */",
631 op[0], op[1], op[2]); 630 op[0], op[1], op[2]);
632 printf (" mx = 0x%x,", mx); 631 printf (" mx = 0x%x,", mx);
633 printf (" ss = 0x%x,", ss); 632 printf (" ss = 0x%x,", ss);
634 printf (" rsrc = 0x%x,", rsrc); 633 printf (" rsrc = 0x%x,", rsrc);
635 printf (" rdst = 0x%x\n", rdst); 634 printf (" rdst = 0x%x\n", rdst);
636 } 635 }
637 SYNTAX("and %1%S1, %0"); 636 SYNTAX("and %1%S1, %0");
638 #line 383 "rx-decode.opc" 637 #line 395 "rx-decode.opc"
639 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 638 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
640 639
641 } 640 }
642 break; 641 break;
643 } 642 }
644 break; 643 break;
645 case 0x11: 644 case 0x11:
646 GETBYTE (); 645 GETBYTE ();
647 switch (op[2] & 0x00) 646 switch (op[2] & 0x00)
648 { 647 {
(...skipping 21 matching lines...) Expand all
670 } 669 }
671 break; 670 break;
672 case 0x14: 671 case 0x14:
673 GETBYTE (); 672 GETBYTE ();
674 switch (op[2] & 0x00) 673 switch (op[2] & 0x00)
675 { 674 {
676 case 0x00: 675 case 0x00:
677 op_semantics_6: 676 op_semantics_6:
678 { 677 {
679 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */ 678 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */
680 #line 401 "rx-decode.opc" 679 #line 413 "rx-decode.opc"
681 int mx AU = (op[1] >> 6) & 0x03; 680 int mx AU = (op[1] >> 6) & 0x03;
682 #line 401 "rx-decode.opc" 681 #line 413 "rx-decode.opc"
683 int ss AU = op[1] & 0x03; 682 int ss AU = op[1] & 0x03;
684 #line 401 "rx-decode.opc" 683 #line 413 "rx-decode.opc"
685 int rsrc AU = (op[2] >> 4) & 0x0f; 684 int rsrc AU = (op[2] >> 4) & 0x0f;
686 #line 401 "rx-decode.opc" 685 #line 413 "rx-decode.opc"
687 int rdst AU = op[2] & 0x0f; 686 int rdst AU = op[2] & 0x0f;
688 if (trace) 687 if (trace)
689 { 688 {
690 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 689 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
691 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */", 690 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */",
692 op[0], op[1], op[2]); 691 op[0], op[1], op[2]);
693 printf (" mx = 0x%x,", mx); 692 printf (" mx = 0x%x,", mx);
694 printf (" ss = 0x%x,", ss); 693 printf (" ss = 0x%x,", ss);
695 printf (" rsrc = 0x%x,", rsrc); 694 printf (" rsrc = 0x%x,", rsrc);
696 printf (" rdst = 0x%x\n", rdst); 695 printf (" rdst = 0x%x\n", rdst);
697 } 696 }
698 SYNTAX("or %1%S1, %0"); 697 SYNTAX("or %1%S1, %0");
699 #line 401 "rx-decode.opc" 698 #line 413 "rx-decode.opc"
700 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 699 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
701 700
702 } 701 }
703 break; 702 break;
704 } 703 }
705 break; 704 break;
706 case 0x15: 705 case 0x15:
707 GETBYTE (); 706 GETBYTE ();
708 switch (op[2] & 0x00) 707 switch (op[2] & 0x00)
709 { 708 {
(...skipping 25 matching lines...) Expand all
735 switch (op[2] & 0xff) 734 switch (op[2] & 0xff)
736 { 735 {
737 case 0x00: 736 case 0x00:
738 GETBYTE (); 737 GETBYTE ();
739 switch (op[3] & 0x00) 738 switch (op[3] & 0x00)
740 { 739 {
741 case 0x00: 740 case 0x00:
742 op_semantics_7: 741 op_semantics_7:
743 { 742 {
744 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */ 743 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */
745 #line 519 "rx-decode.opc" 744 #line 531 "rx-decode.opc"
746 int mx AU = (op[1] >> 6) & 0x03; 745 int mx AU = (op[1] >> 6) & 0x03;
747 #line 519 "rx-decode.opc" 746 #line 531 "rx-decode.opc"
748 int sp AU = op[1] & 0x03; 747 int sp AU = op[1] & 0x03;
749 #line 519 "rx-decode.opc" 748 #line 531 "rx-decode.opc"
750 int rsrc AU = (op[3] >> 4) & 0x0f; 749 int rsrc AU = (op[3] >> 4) & 0x0f;
751 #line 519 "rx-decode.opc" 750 #line 531 "rx-decode.opc"
752 int rdst AU = op[3] & 0x0f; 751 int rdst AU = op[3] & 0x0f;
753 if (trace) 752 if (trace)
754 { 753 {
755 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 754 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
756 "/** 0000 0110 mx10 00sp 0000 0000 rsrc r dst sbb %1%S1, %0 */", 755 "/** 0000 0110 mx10 00sp 0000 0000 rsrc r dst sbb %1%S1, %0 */",
757 op[0], op[1], op[2], op[3]); 756 op[0], op[1], op[2], op[3]);
758 printf (" mx = 0x%x,", mx); 757 printf (" mx = 0x%x,", mx);
759 printf (" sp = 0x%x,", sp); 758 printf (" sp = 0x%x,", sp);
760 printf (" rsrc = 0x%x,", rsrc); 759 printf (" rsrc = 0x%x,", rsrc);
761 printf (" rdst = 0x%x\n", rdst); 760 printf (" rdst = 0x%x\n", rdst);
762 } 761 }
763 SYNTAX("sbb %1%S1, %0"); 762 SYNTAX("sbb %1%S1, %0");
764 #line 519 "rx-decode.opc" 763 #line 531 "rx-decode.opc"
765 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC; 764 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC;
766 765
767 /*---------------------------------------------------- ------------------*/ 766 /*---------------------------------------------------- ------------------*/
768 /* ABS */ 767 /* ABS */
769 768
770 } 769 }
771 break; 770 break;
772 } 771 }
773 break; 772 break;
774 case 0x04: 773 case 0x04:
775 GETBYTE (); 774 GETBYTE ();
776 switch (op[3] & 0x00) 775 switch (op[3] & 0x00)
777 { 776 {
778 case 0x00: 777 case 0x00:
779 op_semantics_8: 778 op_semantics_8:
780 { 779 {
781 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */ 780 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */
782 #line 548 "rx-decode.opc" 781 #line 560 "rx-decode.opc"
783 int mx AU = (op[1] >> 6) & 0x03; 782 int mx AU = (op[1] >> 6) & 0x03;
784 #line 548 "rx-decode.opc" 783 #line 560 "rx-decode.opc"
785 int ss AU = op[1] & 0x03; 784 int ss AU = op[1] & 0x03;
786 #line 548 "rx-decode.opc" 785 #line 560 "rx-decode.opc"
787 int rsrc AU = (op[3] >> 4) & 0x0f; 786 int rsrc AU = (op[3] >> 4) & 0x0f;
788 #line 548 "rx-decode.opc" 787 #line 560 "rx-decode.opc"
789 int rdst AU = op[3] & 0x0f; 788 int rdst AU = op[3] & 0x0f;
790 if (trace) 789 if (trace)
791 { 790 {
792 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 791 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
793 "/** 0000 0110 mx10 00ss 0000 0100 rsrc r dst max %1%S1, %0 */", 792 "/** 0000 0110 mx10 00ss 0000 0100 rsrc r dst max %1%S1, %0 */",
794 op[0], op[1], op[2], op[3]); 793 op[0], op[1], op[2], op[3]);
795 printf (" mx = 0x%x,", mx); 794 printf (" mx = 0x%x,", mx);
796 printf (" ss = 0x%x,", ss); 795 printf (" ss = 0x%x,", ss);
797 printf (" rsrc = 0x%x,", rsrc); 796 printf (" rsrc = 0x%x,", rsrc);
798 printf (" rdst = 0x%x\n", rdst); 797 printf (" rdst = 0x%x\n", rdst);
799 } 798 }
800 SYNTAX("max %1%S1, %0"); 799 SYNTAX("max %1%S1, %0");
801 #line 548 "rx-decode.opc" 800 #line 560 "rx-decode.opc"
802 ID(max); SPm(ss, rsrc, mx); DR(rdst); 801 ID(max); SPm(ss, rsrc, mx); DR(rdst);
803 802
804 /*---------------------------------------------------- ------------------*/ 803 /*---------------------------------------------------- ------------------*/
805 /* MIN */ 804 /* MIN */
806 805
807 } 806 }
808 break; 807 break;
809 } 808 }
810 break; 809 break;
811 case 0x05: 810 case 0x05:
812 GETBYTE (); 811 GETBYTE ();
813 switch (op[3] & 0x00) 812 switch (op[3] & 0x00)
814 { 813 {
815 case 0x00: 814 case 0x00:
816 op_semantics_9: 815 op_semantics_9:
817 { 816 {
818 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */ 817 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */
819 #line 560 "rx-decode.opc" 818 #line 572 "rx-decode.opc"
820 int mx AU = (op[1] >> 6) & 0x03; 819 int mx AU = (op[1] >> 6) & 0x03;
821 #line 560 "rx-decode.opc" 820 #line 572 "rx-decode.opc"
822 int ss AU = op[1] & 0x03; 821 int ss AU = op[1] & 0x03;
823 #line 560 "rx-decode.opc" 822 #line 572 "rx-decode.opc"
824 int rsrc AU = (op[3] >> 4) & 0x0f; 823 int rsrc AU = (op[3] >> 4) & 0x0f;
825 #line 560 "rx-decode.opc" 824 #line 572 "rx-decode.opc"
826 int rdst AU = op[3] & 0x0f; 825 int rdst AU = op[3] & 0x0f;
827 if (trace) 826 if (trace)
828 { 827 {
829 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 828 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
830 "/** 0000 0110 mx10 00ss 0000 0101 rsrc r dst min %1%S1, %0 */", 829 "/** 0000 0110 mx10 00ss 0000 0101 rsrc r dst min %1%S1, %0 */",
831 op[0], op[1], op[2], op[3]); 830 op[0], op[1], op[2], op[3]);
832 printf (" mx = 0x%x,", mx); 831 printf (" mx = 0x%x,", mx);
833 printf (" ss = 0x%x,", ss); 832 printf (" ss = 0x%x,", ss);
834 printf (" rsrc = 0x%x,", rsrc); 833 printf (" rsrc = 0x%x,", rsrc);
835 printf (" rdst = 0x%x\n", rdst); 834 printf (" rdst = 0x%x\n", rdst);
836 } 835 }
837 SYNTAX("min %1%S1, %0"); 836 SYNTAX("min %1%S1, %0");
838 #line 560 "rx-decode.opc" 837 #line 572 "rx-decode.opc"
839 ID(min); SPm(ss, rsrc, mx); DR(rdst); 838 ID(min); SPm(ss, rsrc, mx); DR(rdst);
840 839
841 /*---------------------------------------------------- ------------------*/ 840 /*---------------------------------------------------- ------------------*/
842 /* MUL */ 841 /* MUL */
843 842
844 } 843 }
845 break; 844 break;
846 } 845 }
847 break; 846 break;
848 case 0x06: 847 case 0x06:
849 GETBYTE (); 848 GETBYTE ();
850 switch (op[3] & 0x00) 849 switch (op[3] & 0x00)
851 { 850 {
852 case 0x00: 851 case 0x00:
853 op_semantics_10: 852 op_semantics_10:
854 { 853 {
855 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */ 854 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */
856 #line 590 "rx-decode.opc" 855 #line 602 "rx-decode.opc"
857 int mx AU = (op[1] >> 6) & 0x03; 856 int mx AU = (op[1] >> 6) & 0x03;
858 #line 590 "rx-decode.opc" 857 #line 602 "rx-decode.opc"
859 int ss AU = op[1] & 0x03; 858 int ss AU = op[1] & 0x03;
860 #line 590 "rx-decode.opc" 859 #line 602 "rx-decode.opc"
861 int rsrc AU = (op[3] >> 4) & 0x0f; 860 int rsrc AU = (op[3] >> 4) & 0x0f;
862 #line 590 "rx-decode.opc" 861 #line 602 "rx-decode.opc"
863 int rdst AU = op[3] & 0x0f; 862 int rdst AU = op[3] & 0x0f;
864 if (trace) 863 if (trace)
865 { 864 {
866 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 865 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
867 "/** 0000 0110 mx10 00ss 0000 0110 rsrc r dst emul %1%S1, %0 */", 866 "/** 0000 0110 mx10 00ss 0000 0110 rsrc r dst emul %1%S1, %0 */",
868 op[0], op[1], op[2], op[3]); 867 op[0], op[1], op[2], op[3]);
869 printf (" mx = 0x%x,", mx); 868 printf (" mx = 0x%x,", mx);
870 printf (" ss = 0x%x,", ss); 869 printf (" ss = 0x%x,", ss);
871 printf (" rsrc = 0x%x,", rsrc); 870 printf (" rsrc = 0x%x,", rsrc);
872 printf (" rdst = 0x%x\n", rdst); 871 printf (" rdst = 0x%x\n", rdst);
873 } 872 }
874 SYNTAX("emul %1%S1, %0"); 873 SYNTAX("emul %1%S1, %0");
875 #line 590 "rx-decode.opc" 874 #line 602 "rx-decode.opc"
876 ID(emul); SPm(ss, rsrc, mx); DR(rdst); 875 ID(emul); SPm(ss, rsrc, mx); DR(rdst);
877 876
878 /*---------------------------------------------------- ------------------*/ 877 /*---------------------------------------------------- ------------------*/
879 /* EMULU */ 878 /* EMULU */
880 879
881 } 880 }
882 break; 881 break;
883 } 882 }
884 break; 883 break;
885 case 0x07: 884 case 0x07:
886 GETBYTE (); 885 GETBYTE ();
887 switch (op[3] & 0x00) 886 switch (op[3] & 0x00)
888 { 887 {
889 case 0x00: 888 case 0x00:
890 op_semantics_11: 889 op_semantics_11:
891 { 890 {
892 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */ 891 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */
893 #line 602 "rx-decode.opc" 892 #line 614 "rx-decode.opc"
894 int mx AU = (op[1] >> 6) & 0x03; 893 int mx AU = (op[1] >> 6) & 0x03;
895 #line 602 "rx-decode.opc" 894 #line 614 "rx-decode.opc"
896 int ss AU = op[1] & 0x03; 895 int ss AU = op[1] & 0x03;
897 #line 602 "rx-decode.opc" 896 #line 614 "rx-decode.opc"
898 int rsrc AU = (op[3] >> 4) & 0x0f; 897 int rsrc AU = (op[3] >> 4) & 0x0f;
899 #line 602 "rx-decode.opc" 898 #line 614 "rx-decode.opc"
900 int rdst AU = op[3] & 0x0f; 899 int rdst AU = op[3] & 0x0f;
901 if (trace) 900 if (trace)
902 { 901 {
903 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 902 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
904 "/** 0000 0110 mx10 00ss 0000 0111 rsrc r dst emulu %1%S1, %0 */", 903 "/** 0000 0110 mx10 00ss 0000 0111 rsrc r dst emulu %1%S1, %0 */",
905 op[0], op[1], op[2], op[3]); 904 op[0], op[1], op[2], op[3]);
906 printf (" mx = 0x%x,", mx); 905 printf (" mx = 0x%x,", mx);
907 printf (" ss = 0x%x,", ss); 906 printf (" ss = 0x%x,", ss);
908 printf (" rsrc = 0x%x,", rsrc); 907 printf (" rsrc = 0x%x,", rsrc);
909 printf (" rdst = 0x%x\n", rdst); 908 printf (" rdst = 0x%x\n", rdst);
910 } 909 }
911 SYNTAX("emulu %1%S1, %0"); 910 SYNTAX("emulu %1%S1, %0");
912 #line 602 "rx-decode.opc" 911 #line 614 "rx-decode.opc"
913 ID(emulu); SPm(ss, rsrc, mx); DR(rdst); 912 ID(emulu); SPm(ss, rsrc, mx); DR(rdst);
914 913
915 /*---------------------------------------------------- ------------------*/ 914 /*---------------------------------------------------- ------------------*/
916 /* DIV */ 915 /* DIV */
917 916
918 } 917 }
919 break; 918 break;
920 } 919 }
921 break; 920 break;
922 case 0x08: 921 case 0x08:
923 GETBYTE (); 922 GETBYTE ();
924 switch (op[3] & 0x00) 923 switch (op[3] & 0x00)
925 { 924 {
926 case 0x00: 925 case 0x00:
927 op_semantics_12: 926 op_semantics_12:
928 { 927 {
929 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */ 928 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */
930 #line 614 "rx-decode.opc" 929 #line 626 "rx-decode.opc"
931 int mx AU = (op[1] >> 6) & 0x03; 930 int mx AU = (op[1] >> 6) & 0x03;
932 #line 614 "rx-decode.opc" 931 #line 626 "rx-decode.opc"
933 int ss AU = op[1] & 0x03; 932 int ss AU = op[1] & 0x03;
934 #line 614 "rx-decode.opc" 933 #line 626 "rx-decode.opc"
935 int rsrc AU = (op[3] >> 4) & 0x0f; 934 int rsrc AU = (op[3] >> 4) & 0x0f;
936 #line 614 "rx-decode.opc" 935 #line 626 "rx-decode.opc"
937 int rdst AU = op[3] & 0x0f; 936 int rdst AU = op[3] & 0x0f;
938 if (trace) 937 if (trace)
939 { 938 {
940 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 939 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
941 "/** 0000 0110 mx10 00ss 0000 1000 rsrc r dst div %1%S1, %0 */", 940 "/** 0000 0110 mx10 00ss 0000 1000 rsrc r dst div %1%S1, %0 */",
942 op[0], op[1], op[2], op[3]); 941 op[0], op[1], op[2], op[3]);
943 printf (" mx = 0x%x,", mx); 942 printf (" mx = 0x%x,", mx);
944 printf (" ss = 0x%x,", ss); 943 printf (" ss = 0x%x,", ss);
945 printf (" rsrc = 0x%x,", rsrc); 944 printf (" rsrc = 0x%x,", rsrc);
946 printf (" rdst = 0x%x\n", rdst); 945 printf (" rdst = 0x%x\n", rdst);
947 } 946 }
948 SYNTAX("div %1%S1, %0"); 947 SYNTAX("div %1%S1, %0");
949 #line 614 "rx-decode.opc" 948 #line 626 "rx-decode.opc"
950 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___; 949 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___;
951 950
952 /*---------------------------------------------------- ------------------*/ 951 /*---------------------------------------------------- ------------------*/
953 /* DIVU */ 952 /* DIVU */
954 953
955 } 954 }
956 break; 955 break;
957 } 956 }
958 break; 957 break;
959 case 0x09: 958 case 0x09:
960 GETBYTE (); 959 GETBYTE ();
961 switch (op[3] & 0x00) 960 switch (op[3] & 0x00)
962 { 961 {
963 case 0x00: 962 case 0x00:
964 op_semantics_13: 963 op_semantics_13:
965 { 964 {
966 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */ 965 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */
967 #line 626 "rx-decode.opc" 966 #line 638 "rx-decode.opc"
968 int mx AU = (op[1] >> 6) & 0x03; 967 int mx AU = (op[1] >> 6) & 0x03;
969 #line 626 "rx-decode.opc" 968 #line 638 "rx-decode.opc"
970 int ss AU = op[1] & 0x03; 969 int ss AU = op[1] & 0x03;
971 #line 626 "rx-decode.opc" 970 #line 638 "rx-decode.opc"
972 int rsrc AU = (op[3] >> 4) & 0x0f; 971 int rsrc AU = (op[3] >> 4) & 0x0f;
973 #line 626 "rx-decode.opc" 972 #line 638 "rx-decode.opc"
974 int rdst AU = op[3] & 0x0f; 973 int rdst AU = op[3] & 0x0f;
975 if (trace) 974 if (trace)
976 { 975 {
977 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 976 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
978 "/** 0000 0110 mx10 00ss 0000 1001 rsrc r dst divu %1%S1, %0 */", 977 "/** 0000 0110 mx10 00ss 0000 1001 rsrc r dst divu %1%S1, %0 */",
979 op[0], op[1], op[2], op[3]); 978 op[0], op[1], op[2], op[3]);
980 printf (" mx = 0x%x,", mx); 979 printf (" mx = 0x%x,", mx);
981 printf (" ss = 0x%x,", ss); 980 printf (" ss = 0x%x,", ss);
982 printf (" rsrc = 0x%x,", rsrc); 981 printf (" rsrc = 0x%x,", rsrc);
983 printf (" rdst = 0x%x\n", rdst); 982 printf (" rdst = 0x%x\n", rdst);
984 } 983 }
985 SYNTAX("divu %1%S1, %0"); 984 SYNTAX("divu %1%S1, %0");
986 #line 626 "rx-decode.opc" 985 #line 638 "rx-decode.opc"
987 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___; 986 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___;
988 987
989 /*---------------------------------------------------- ------------------*/ 988 /*---------------------------------------------------- ------------------*/
990 /* SHIFT */ 989 /* SHIFT */
991 990
992 } 991 }
993 break; 992 break;
994 } 993 }
995 break; 994 break;
996 case 0x0c: 995 case 0x0c:
997 GETBYTE (); 996 GETBYTE ();
998 switch (op[3] & 0x00) 997 switch (op[3] & 0x00)
999 { 998 {
1000 case 0x00: 999 case 0x00:
1001 op_semantics_14: 1000 op_semantics_14:
1002 { 1001 {
1003 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */ 1002 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */
1004 #line 437 "rx-decode.opc" 1003 #line 449 "rx-decode.opc"
1005 int mx AU = (op[1] >> 6) & 0x03; 1004 int mx AU = (op[1] >> 6) & 0x03;
1006 #line 437 "rx-decode.opc" 1005 #line 449 "rx-decode.opc"
1007 int ss AU = op[1] & 0x03; 1006 int ss AU = op[1] & 0x03;
1008 #line 437 "rx-decode.opc" 1007 #line 449 "rx-decode.opc"
1009 int rsrc AU = (op[3] >> 4) & 0x0f; 1008 int rsrc AU = (op[3] >> 4) & 0x0f;
1010 #line 437 "rx-decode.opc" 1009 #line 449 "rx-decode.opc"
1011 int rdst AU = op[3] & 0x0f; 1010 int rdst AU = op[3] & 0x0f;
1012 if (trace) 1011 if (trace)
1013 { 1012 {
1014 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 1013 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
1015 "/** 0000 0110 mx10 00ss 0000 1100 rsrc r dst tst %1%S1, %2 */", 1014 "/** 0000 0110 mx10 00ss 0000 1100 rsrc r dst tst %1%S1, %2 */",
1016 op[0], op[1], op[2], op[3]); 1015 op[0], op[1], op[2], op[3]);
1017 printf (" mx = 0x%x,", mx); 1016 printf (" mx = 0x%x,", mx);
1018 printf (" ss = 0x%x,", ss); 1017 printf (" ss = 0x%x,", ss);
1019 printf (" rsrc = 0x%x,", rsrc); 1018 printf (" rsrc = 0x%x,", rsrc);
1020 printf (" rdst = 0x%x\n", rdst); 1019 printf (" rdst = 0x%x\n", rdst);
1021 } 1020 }
1022 SYNTAX("tst %1%S1, %2"); 1021 SYNTAX("tst %1%S1, %2");
1023 #line 437 "rx-decode.opc" 1022 #line 449 "rx-decode.opc"
1024 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_; 1023 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_;
1025 1024
1026 /*---------------------------------------------------- ------------------*/ 1025 /*---------------------------------------------------- ------------------*/
1027 /* NEG */ 1026 /* NEG */
1028 1027
1029 } 1028 }
1030 break; 1029 break;
1031 } 1030 }
1032 break; 1031 break;
1033 case 0x0d: 1032 case 0x0d:
1034 GETBYTE (); 1033 GETBYTE ();
1035 switch (op[3] & 0x00) 1034 switch (op[3] & 0x00)
1036 { 1035 {
1037 case 0x00: 1036 case 0x00:
1038 op_semantics_15: 1037 op_semantics_15:
1039 { 1038 {
1040 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */ 1039 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */
1041 #line 416 "rx-decode.opc" 1040 #line 428 "rx-decode.opc"
1042 int mx AU = (op[1] >> 6) & 0x03; 1041 int mx AU = (op[1] >> 6) & 0x03;
1043 #line 416 "rx-decode.opc" 1042 #line 428 "rx-decode.opc"
1044 int ss AU = op[1] & 0x03; 1043 int ss AU = op[1] & 0x03;
1045 #line 416 "rx-decode.opc" 1044 #line 428 "rx-decode.opc"
1046 int rsrc AU = (op[3] >> 4) & 0x0f; 1045 int rsrc AU = (op[3] >> 4) & 0x0f;
1047 #line 416 "rx-decode.opc" 1046 #line 428 "rx-decode.opc"
1048 int rdst AU = op[3] & 0x0f; 1047 int rdst AU = op[3] & 0x0f;
1049 if (trace) 1048 if (trace)
1050 { 1049 {
1051 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 1050 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
1052 "/** 0000 0110 mx10 00ss 0000 1101 rsrc r dst xor %1%S1, %0 */", 1051 "/** 0000 0110 mx10 00ss 0000 1101 rsrc r dst xor %1%S1, %0 */",
1053 op[0], op[1], op[2], op[3]); 1052 op[0], op[1], op[2], op[3]);
1054 printf (" mx = 0x%x,", mx); 1053 printf (" mx = 0x%x,", mx);
1055 printf (" ss = 0x%x,", ss); 1054 printf (" ss = 0x%x,", ss);
1056 printf (" rsrc = 0x%x,", rsrc); 1055 printf (" rsrc = 0x%x,", rsrc);
1057 printf (" rdst = 0x%x\n", rdst); 1056 printf (" rdst = 0x%x\n", rdst);
1058 } 1057 }
1059 SYNTAX("xor %1%S1, %0"); 1058 SYNTAX("xor %1%S1, %0");
1060 #line 416 "rx-decode.opc" 1059 #line 428 "rx-decode.opc"
1061 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 1060 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_;
1062 1061
1063 /*---------------------------------------------------- ------------------*/ 1062 /*---------------------------------------------------- ------------------*/
1064 /* NOT */ 1063 /* NOT */
1065 1064
1066 } 1065 }
1067 break; 1066 break;
1068 } 1067 }
1069 break; 1068 break;
1070 case 0x10: 1069 case 0x10:
1071 GETBYTE (); 1070 GETBYTE ();
1072 switch (op[3] & 0x00) 1071 switch (op[3] & 0x00)
1073 { 1072 {
1074 case 0x00: 1073 case 0x00:
1075 op_semantics_16: 1074 op_semantics_16:
1076 { 1075 {
1077 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */ 1076 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */
1078 #line 350 "rx-decode.opc" 1077 #line 362 "rx-decode.opc"
1079 int mx AU = (op[1] >> 6) & 0x03; 1078 int mx AU = (op[1] >> 6) & 0x03;
1080 #line 350 "rx-decode.opc" 1079 #line 362 "rx-decode.opc"
1081 int ss AU = op[1] & 0x03; 1080 int ss AU = op[1] & 0x03;
1082 #line 350 "rx-decode.opc" 1081 #line 362 "rx-decode.opc"
1083 int rsrc AU = (op[3] >> 4) & 0x0f; 1082 int rsrc AU = (op[3] >> 4) & 0x0f;
1084 #line 350 "rx-decode.opc" 1083 #line 362 "rx-decode.opc"
1085 int rdst AU = op[3] & 0x0f; 1084 int rdst AU = op[3] & 0x0f;
1086 if (trace) 1085 if (trace)
1087 { 1086 {
1088 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 1087 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
1089 "/** 0000 0110 mx10 00ss 0001 0000 rsrc r dst xchg %1%S1, %0 */", 1088 "/** 0000 0110 mx10 00ss 0001 0000 rsrc r dst xchg %1%S1, %0 */",
1090 op[0], op[1], op[2], op[3]); 1089 op[0], op[1], op[2], op[3]);
1091 printf (" mx = 0x%x,", mx); 1090 printf (" mx = 0x%x,", mx);
1092 printf (" ss = 0x%x,", ss); 1091 printf (" ss = 0x%x,", ss);
1093 printf (" rsrc = 0x%x,", rsrc); 1092 printf (" rsrc = 0x%x,", rsrc);
1094 printf (" rdst = 0x%x\n", rdst); 1093 printf (" rdst = 0x%x\n", rdst);
1095 } 1094 }
1096 SYNTAX("xchg %1%S1, %0"); 1095 SYNTAX("xchg %1%S1, %0");
1097 #line 350 "rx-decode.opc" 1096 #line 362 "rx-decode.opc"
1098 ID(xchg); DR(rdst); SPm(ss, rsrc, mx); 1097 ID(xchg); DR(rdst); SPm(ss, rsrc, mx);
1099 1098
1100 /*---------------------------------------------------- ------------------*/ 1099 /*---------------------------------------------------- ------------------*/
1101 /* STZ/STNZ */ 1100 /* STZ/STNZ */
1102 1101
1103 } 1102 }
1104 break; 1103 break;
1105 } 1104 }
1106 break; 1105 break;
1107 case 0x11: 1106 case 0x11:
1108 GETBYTE (); 1107 GETBYTE ();
1109 switch (op[3] & 0x00) 1108 switch (op[3] & 0x00)
1110 { 1109 {
1111 case 0x00: 1110 case 0x00:
1112 op_semantics_17: 1111 op_semantics_17:
1113 { 1112 {
1114 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */ 1113 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */
1115 #line 855 "rx-decode.opc" 1114 #line 867 "rx-decode.opc"
1116 int mx AU = (op[1] >> 6) & 0x03; 1115 int mx AU = (op[1] >> 6) & 0x03;
1117 #line 855 "rx-decode.opc" 1116 #line 867 "rx-decode.opc"
1118 int sd AU = op[1] & 0x03; 1117 int sd AU = op[1] & 0x03;
1119 #line 855 "rx-decode.opc" 1118 #line 867 "rx-decode.opc"
1120 int rsrc AU = (op[3] >> 4) & 0x0f; 1119 int rsrc AU = (op[3] >> 4) & 0x0f;
1121 #line 855 "rx-decode.opc" 1120 #line 867 "rx-decode.opc"
1122 int rdst AU = op[3] & 0x0f; 1121 int rdst AU = op[3] & 0x0f;
1123 if (trace) 1122 if (trace)
1124 { 1123 {
1125 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 1124 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
1126 "/** 0000 0110 mx10 00sd 0001 0001 rsrc r dst itof %1%S1, %0 */", 1125 "/** 0000 0110 mx10 00sd 0001 0001 rsrc r dst itof %1%S1, %0 */",
1127 op[0], op[1], op[2], op[3]); 1126 op[0], op[1], op[2], op[3]);
1128 printf (" mx = 0x%x,", mx); 1127 printf (" mx = 0x%x,", mx);
1129 printf (" sd = 0x%x,", sd); 1128 printf (" sd = 0x%x,", sd);
1130 printf (" rsrc = 0x%x,", rsrc); 1129 printf (" rsrc = 0x%x,", rsrc);
1131 printf (" rdst = 0x%x\n", rdst); 1130 printf (" rdst = 0x%x\n", rdst);
1132 } 1131 }
1133 SYNTAX("itof %1%S1, %0"); 1132 SYNTAX("itof %1%S1, %0");
1134 #line 855 "rx-decode.opc" 1133 #line 867 "rx-decode.opc"
1135 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_; 1134 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_;
1136 1135
1137 /*---------------------------------------------------- ------------------*/ 1136 /*---------------------------------------------------- ------------------*/
1138 /* BIT OPS */ 1137 /* BIT OPS */
1139 1138
1140 } 1139 }
1141 break; 1140 break;
1142 } 1141 }
1143 break; 1142 break;
1144 default: UNSUPPORTED(); break; 1143 default: UNSUPPORTED(); break;
(...skipping 1187 matching lines...) Expand 10 before | Expand all | Expand 10 after
2332 } 2331 }
2333 break; 2332 break;
2334 case 0x02: 2333 case 0x02:
2335 GETBYTE (); 2334 GETBYTE ();
2336 switch (op[3] & 0x00) 2335 switch (op[3] & 0x00)
2337 { 2336 {
2338 case 0x00: 2337 case 0x00:
2339 op_semantics_18: 2338 op_semantics_18:
2340 { 2339 {
2341 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */ 2340 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */
2342 #line 458 "rx-decode.opc" 2341 #line 470 "rx-decode.opc"
2343 int ss AU = op[1] & 0x03; 2342 int ss AU = op[1] & 0x03;
2344 #line 458 "rx-decode.opc" 2343 #line 470 "rx-decode.opc"
2345 int rsrc AU = (op[3] >> 4) & 0x0f; 2344 int rsrc AU = (op[3] >> 4) & 0x0f;
2346 #line 458 "rx-decode.opc" 2345 #line 470 "rx-decode.opc"
2347 int rdst AU = op[3] & 0x0f; 2346 int rdst AU = op[3] & 0x0f;
2348 if (trace) 2347 if (trace)
2349 { 2348 {
2350 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n", 2349 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\ n",
2351 "/** 0000 0110 1010 00ss 0000 0010 rsrc r dst adc %1%S1, %0 */", 2350 "/** 0000 0110 1010 00ss 0000 0010 rsrc r dst adc %1%S1, %0 */",
2352 op[0], op[1], op[2], op[3]); 2351 op[0], op[1], op[2], op[3]);
2353 printf (" ss = 0x%x,", ss); 2352 printf (" ss = 0x%x,", ss);
2354 printf (" rsrc = 0x%x,", rsrc); 2353 printf (" rsrc = 0x%x,", rsrc);
2355 printf (" rdst = 0x%x\n", rdst); 2354 printf (" rdst = 0x%x\n", rdst);
2356 } 2355 }
2357 SYNTAX("adc %1%S1, %0"); 2356 SYNTAX("adc %1%S1, %0");
2358 #line 458 "rx-decode.opc" 2357 #line 470 "rx-decode.opc"
2359 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC; 2358 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC;
2360 2359
2361 /*---------------------------------------------------- ------------------*/ 2360 /*---------------------------------------------------- ------------------*/
2362 /* ADD */ 2361 /* ADD */
2363 2362
2364 } 2363 }
2365 break; 2364 break;
2366 } 2365 }
2367 break; 2366 break;
2368 case 0x04: 2367 case 0x04:
(...skipping 1080 matching lines...) Expand 10 before | Expand all | Expand 10 after
3449 case 0x08: 3448 case 0x08:
3450 case 0x09: 3449 case 0x09:
3451 case 0x0a: 3450 case 0x0a:
3452 case 0x0b: 3451 case 0x0b:
3453 case 0x0c: 3452 case 0x0c:
3454 case 0x0d: 3453 case 0x0d:
3455 case 0x0e: 3454 case 0x0e:
3456 case 0x0f: 3455 case 0x0f:
3457 { 3456 {
3458 /** 0000 1dsp bra.s %a0 */ 3457 /** 0000 1dsp bra.s %a0 */
3459 #line 701 "rx-decode.opc" 3458 #line 713 "rx-decode.opc"
3460 int dsp AU = op[0] & 0x07; 3459 int dsp AU = op[0] & 0x07;
3461 if (trace) 3460 if (trace)
3462 { 3461 {
3463 printf ("\033[33m%s\033[0m %02x\n", 3462 printf ("\033[33m%s\033[0m %02x\n",
3464 "/** 0000 1dsp bra.s %a0 */", 3463 "/** 0000 1dsp bra.s %a0 */",
3465 op[0]); 3464 op[0]);
3466 printf (" dsp = 0x%x\n", dsp); 3465 printf (" dsp = 0x%x\n", dsp);
3467 } 3466 }
3468 SYNTAX("bra.s %a0"); 3467 SYNTAX("bra.s %a0");
3469 #line 701 "rx-decode.opc" 3468 #line 713 "rx-decode.opc"
3470 ID(branch); DC(pc + dsp3map[dsp]); 3469 ID(branch); DC(pc + dsp3map[dsp]);
3471 3470
3472 } 3471 }
3473 break; 3472 break;
3474 case 0x10: 3473 case 0x10:
3475 case 0x11: 3474 case 0x11:
3476 case 0x12: 3475 case 0x12:
3477 case 0x13: 3476 case 0x13:
3478 case 0x14: 3477 case 0x14:
3479 case 0x15: 3478 case 0x15:
3480 case 0x16: 3479 case 0x16:
3481 case 0x17: 3480 case 0x17:
3482 case 0x18: 3481 case 0x18:
3483 case 0x19: 3482 case 0x19:
3484 case 0x1a: 3483 case 0x1a:
3485 case 0x1b: 3484 case 0x1b:
3486 case 0x1c: 3485 case 0x1c:
3487 case 0x1d: 3486 case 0x1d:
3488 case 0x1e: 3487 case 0x1e:
3489 case 0x1f: 3488 case 0x1f:
3490 { 3489 {
3491 /** 0001 n dsp b%1.s %a0 */ 3490 /** 0001 n dsp b%1.s %a0 */
3492 #line 691 "rx-decode.opc" 3491 #line 703 "rx-decode.opc"
3493 int n AU = (op[0] >> 3) & 0x01; 3492 int n AU = (op[0] >> 3) & 0x01;
3494 #line 691 "rx-decode.opc" 3493 #line 703 "rx-decode.opc"
3495 int dsp AU = op[0] & 0x07; 3494 int dsp AU = op[0] & 0x07;
3496 if (trace) 3495 if (trace)
3497 { 3496 {
3498 printf ("\033[33m%s\033[0m %02x\n", 3497 printf ("\033[33m%s\033[0m %02x\n",
3499 "/** 0001 n dsp b%1.s %a0 */", 3498 "/** 0001 n dsp b%1.s %a0 */",
3500 op[0]); 3499 op[0]);
3501 printf (" n = 0x%x,", n); 3500 printf (" n = 0x%x,", n);
3502 printf (" dsp = 0x%x\n", dsp); 3501 printf (" dsp = 0x%x\n", dsp);
3503 } 3502 }
3504 SYNTAX("b%1.s %a0"); 3503 SYNTAX("b%1.s %a0");
3505 #line 691 "rx-decode.opc" 3504 #line 703 "rx-decode.opc"
3506 ID(branch); Scc(n); DC(pc + dsp3map[dsp]); 3505 ID(branch); Scc(n); DC(pc + dsp3map[dsp]);
3507 3506
3508 } 3507 }
3509 break; 3508 break;
3510 case 0x20: 3509 case 0x20:
3511 case 0x21: 3510 case 0x21:
3512 case 0x22: 3511 case 0x22:
3513 case 0x23: 3512 case 0x23:
3514 case 0x24: 3513 case 0x24:
3515 case 0x25: 3514 case 0x25:
3516 case 0x26: 3515 case 0x26:
3517 case 0x27: 3516 case 0x27:
3518 case 0x28: 3517 case 0x28:
3519 case 0x29: 3518 case 0x29:
3520 case 0x2a: 3519 case 0x2a:
3521 case 0x2b: 3520 case 0x2b:
3522 case 0x2c: 3521 case 0x2c:
3523 case 0x2d: 3522 case 0x2d:
3524 case 0x2f: 3523 case 0x2f:
3525 { 3524 {
3526 /** 0010 cond b%1.b %a0 */ 3525 /** 0010 cond b%1.b %a0 */
3527 #line 694 "rx-decode.opc" 3526 #line 706 "rx-decode.opc"
3528 int cond AU = op[0] & 0x0f; 3527 int cond AU = op[0] & 0x0f;
3529 if (trace) 3528 if (trace)
3530 { 3529 {
3531 printf ("\033[33m%s\033[0m %02x\n", 3530 printf ("\033[33m%s\033[0m %02x\n",
3532 "/** 0010 cond b%1.b %a0 */", 3531 "/** 0010 cond b%1.b %a0 */",
3533 op[0]); 3532 op[0]);
3534 printf (" cond = 0x%x\n", cond); 3533 printf (" cond = 0x%x\n", cond);
3535 } 3534 }
3536 SYNTAX("b%1.b %a0"); 3535 SYNTAX("b%1.b %a0");
3537 #line 694 "rx-decode.opc" 3536 #line 706 "rx-decode.opc"
3538 ID(branch); Scc(cond); DC(pc + IMMex (1)); 3537 ID(branch); Scc(cond); DC(pc + IMMex (1));
3539 3538
3540 } 3539 }
3541 break; 3540 break;
3542 case 0x2e: 3541 case 0x2e:
3543 { 3542 {
3544 /** 0010 1110 bra.b %a0 */ 3543 /** 0010 1110 bra.b %a0 */
3545 if (trace) 3544 if (trace)
3546 { 3545 {
3547 printf ("\033[33m%s\033[0m %02x\n", 3546 printf ("\033[33m%s\033[0m %02x\n",
3548 "/** 0010 1110 bra.b %a0 */", 3547 "/** 0010 1110 bra.b %a0 */",
3549 op[0]); 3548 op[0]);
3550 } 3549 }
3551 SYNTAX("bra.b %a0"); 3550 SYNTAX("bra.b %a0");
3552 #line 704 "rx-decode.opc" 3551 #line 716 "rx-decode.opc"
3553 ID(branch); DC(pc + IMMex(1)); 3552 ID(branch); DC(pc + IMMex(1));
3554 3553
3555 } 3554 }
3556 break; 3555 break;
3557 case 0x38: 3556 case 0x38:
3558 { 3557 {
3559 /** 0011 1000 bra.w %a0 */ 3558 /** 0011 1000 bra.w %a0 */
3560 if (trace) 3559 if (trace)
3561 { 3560 {
3562 printf ("\033[33m%s\033[0m %02x\n", 3561 printf ("\033[33m%s\033[0m %02x\n",
3563 "/** 0011 1000 bra.w %a0 */", 3562 "/** 0011 1000 bra.w %a0 */",
3564 op[0]); 3563 op[0]);
3565 } 3564 }
3566 SYNTAX("bra.w %a0"); 3565 SYNTAX("bra.w %a0");
3567 #line 707 "rx-decode.opc" 3566 #line 719 "rx-decode.opc"
3568 ID(branch); DC(pc + IMMex(2)); 3567 ID(branch); DC(pc + IMMex(2));
3569 3568
3570 } 3569 }
3571 break; 3570 break;
3572 case 0x39: 3571 case 0x39:
3573 { 3572 {
3574 /** 0011 1001 bsr.w %a0 */ 3573 /** 0011 1001 bsr.w %a0 */
3575 if (trace) 3574 if (trace)
3576 { 3575 {
3577 printf ("\033[33m%s\033[0m %02x\n", 3576 printf ("\033[33m%s\033[0m %02x\n",
3578 "/** 0011 1001 bsr.w %a0 */", 3577 "/** 0011 1001 bsr.w %a0 */",
3579 op[0]); 3578 op[0]);
3580 } 3579 }
3581 SYNTAX("bsr.w %a0"); 3580 SYNTAX("bsr.w %a0");
3582 #line 723 "rx-decode.opc" 3581 #line 735 "rx-decode.opc"
3583 ID(jsr); DC(pc + IMMex(2)); 3582 ID(jsr); DC(pc + IMMex(2));
3584 3583
3585 } 3584 }
3586 break; 3585 break;
3587 case 0x3a: 3586 case 0x3a:
3588 case 0x3b: 3587 case 0x3b:
3589 { 3588 {
3590 /** 0011 101c b%1.w %a0 */ 3589 /** 0011 101c b%1.w %a0 */
3591 #line 697 "rx-decode.opc" 3590 #line 709 "rx-decode.opc"
3592 int c AU = op[0] & 0x01; 3591 int c AU = op[0] & 0x01;
3593 if (trace) 3592 if (trace)
3594 { 3593 {
3595 printf ("\033[33m%s\033[0m %02x\n", 3594 printf ("\033[33m%s\033[0m %02x\n",
3596 "/** 0011 101c b%1.w %a0 */", 3595 "/** 0011 101c b%1.w %a0 */",
3597 op[0]); 3596 op[0]);
3598 printf (" c = 0x%x\n", c); 3597 printf (" c = 0x%x\n", c);
3599 } 3598 }
3600 SYNTAX("b%1.w %a0"); 3599 SYNTAX("b%1.w %a0");
3601 #line 697 "rx-decode.opc" 3600 #line 709 "rx-decode.opc"
3602 ID(branch); Scc(c); DC(pc + IMMex (2)); 3601 ID(branch); Scc(c); DC(pc + IMMex (2));
3603 3602
3604 3603
3605 } 3604 }
3606 break; 3605 break;
3607 case 0x3c: 3606 case 0x3c:
3608 GETBYTE (); 3607 GETBYTE ();
3609 switch (op[1] & 0x00) 3608 switch (op[1] & 0x00)
3610 { 3609 {
3611 case 0x00: 3610 case 0x00:
3612 op_semantics_19: 3611 op_semantics_19:
3613 { 3612 {
3614 /** 0011 11sz d dst sppp mov%s #%1, %0 */ 3613 /** 0011 11sz d dst sppp mov%s #%1, %0 */
3615 #line 271 "rx-decode.opc" 3614 #line 283 "rx-decode.opc"
3616 int sz AU = op[0] & 0x03; 3615 int sz AU = op[0] & 0x03;
3617 #line 271 "rx-decode.opc" 3616 #line 283 "rx-decode.opc"
3618 int d AU = (op[1] >> 7) & 0x01; 3617 int d AU = (op[1] >> 7) & 0x01;
3619 #line 271 "rx-decode.opc" 3618 #line 283 "rx-decode.opc"
3620 int dst AU = (op[1] >> 4) & 0x07; 3619 int dst AU = (op[1] >> 4) & 0x07;
3621 #line 271 "rx-decode.opc" 3620 #line 283 "rx-decode.opc"
3622 int sppp AU = op[1] & 0x0f; 3621 int sppp AU = op[1] & 0x0f;
3623 if (trace) 3622 if (trace)
3624 { 3623 {
3625 printf ("\033[33m%s\033[0m %02x %02x\n", 3624 printf ("\033[33m%s\033[0m %02x %02x\n",
3626 "/** 0011 11sz d dst sppp mov%s #%1, %0 */", 3625 "/** 0011 11sz d dst sppp mov%s #%1, %0 */",
3627 op[0], op[1]); 3626 op[0], op[1]);
3628 printf (" sz = 0x%x,", sz); 3627 printf (" sz = 0x%x,", sz);
3629 printf (" d = 0x%x,", d); 3628 printf (" d = 0x%x,", d);
3630 printf (" dst = 0x%x,", dst); 3629 printf (" dst = 0x%x,", dst);
3631 printf (" sppp = 0x%x\n", sppp); 3630 printf (" sppp = 0x%x\n", sppp);
3632 } 3631 }
3633 SYNTAX("mov%s #%1, %0"); 3632 SYNTAX("mov%s #%1, %0");
3634 #line 271 "rx-decode.opc" 3633 #line 283 "rx-decode.opc"
3635 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____; 3634 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____;
3636 3635
3637 } 3636 }
3638 break; 3637 break;
3639 } 3638 }
3640 break; 3639 break;
3641 case 0x3d: 3640 case 0x3d:
3642 GETBYTE (); 3641 GETBYTE ();
3643 switch (op[1] & 0x00) 3642 switch (op[1] & 0x00)
3644 { 3643 {
(...skipping 11 matching lines...) Expand all
3656 break; 3655 break;
3657 } 3656 }
3658 break; 3657 break;
3659 case 0x3f: 3658 case 0x3f:
3660 GETBYTE (); 3659 GETBYTE ();
3661 switch (op[1] & 0x00) 3660 switch (op[1] & 0x00)
3662 { 3661 {
3663 case 0x00: 3662 case 0x00:
3664 { 3663 {
3665 /** 0011 1111 rega regb rtsd #%1, %2-%0 */ 3664 /** 0011 1111 rega regb rtsd #%1, %2-%0 */
3666 #line 368 "rx-decode.opc" 3665 #line 380 "rx-decode.opc"
3667 int rega AU = (op[1] >> 4) & 0x0f; 3666 int rega AU = (op[1] >> 4) & 0x0f;
3668 #line 368 "rx-decode.opc" 3667 #line 380 "rx-decode.opc"
3669 int regb AU = op[1] & 0x0f; 3668 int regb AU = op[1] & 0x0f;
3670 if (trace) 3669 if (trace)
3671 { 3670 {
3672 printf ("\033[33m%s\033[0m %02x %02x\n", 3671 printf ("\033[33m%s\033[0m %02x %02x\n",
3673 "/** 0011 1111 rega regb rtsd #%1, %2- %0 */", 3672 "/** 0011 1111 rega regb rtsd #%1, %2- %0 */",
3674 op[0], op[1]); 3673 op[0], op[1]);
3675 printf (" rega = 0x%x,", rega); 3674 printf (" rega = 0x%x,", rega);
3676 printf (" regb = 0x%x\n", regb); 3675 printf (" regb = 0x%x\n", regb);
3677 } 3676 }
3678 SYNTAX("rtsd #%1, %2-%0"); 3677 SYNTAX("rtsd #%1, %2-%0");
3679 #line 368 "rx-decode.opc" 3678 #line 380 "rx-decode.opc"
3680 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb); 3679 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb);
3681 3680
3682 /*---------------------------------------------------------------- ------*/ 3681 /*---------------------------------------------------------------- ------*/
3683 /* AND */ 3682 /* AND */
3684 3683
3685 } 3684 }
3686 break; 3685 break;
3687 } 3686 }
3688 break; 3687 break;
3689 case 0x40: 3688 case 0x40:
3690 GETBYTE (); 3689 GETBYTE ();
3691 switch (op[1] & 0x00) 3690 switch (op[1] & 0x00)
3692 { 3691 {
3693 case 0x00: 3692 case 0x00:
3694 op_semantics_20: 3693 op_semantics_20:
3695 { 3694 {
3696 /** 0100 00ss rsrc rdst sub %2%S2, %1 */ 3695 /** 0100 00ss rsrc rdst sub %2%S2, %1 */
3697 #line 503 "rx-decode.opc" 3696 #line 515 "rx-decode.opc"
3698 int ss AU = op[0] & 0x03; 3697 int ss AU = op[0] & 0x03;
3699 #line 503 "rx-decode.opc" 3698 #line 515 "rx-decode.opc"
3700 int rsrc AU = (op[1] >> 4) & 0x0f; 3699 int rsrc AU = (op[1] >> 4) & 0x0f;
3701 #line 503 "rx-decode.opc" 3700 #line 515 "rx-decode.opc"
3702 int rdst AU = op[1] & 0x0f; 3701 int rdst AU = op[1] & 0x0f;
3703 if (trace) 3702 if (trace)
3704 { 3703 {
3705 printf ("\033[33m%s\033[0m %02x %02x\n", 3704 printf ("\033[33m%s\033[0m %02x %02x\n",
3706 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */", 3705 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */",
3707 op[0], op[1]); 3706 op[0], op[1]);
3708 printf (" ss = 0x%x,", ss); 3707 printf (" ss = 0x%x,", ss);
3709 printf (" rsrc = 0x%x,", rsrc); 3708 printf (" rsrc = 0x%x,", rsrc);
3710 printf (" rdst = 0x%x\n", rdst); 3709 printf (" rdst = 0x%x\n", rdst);
3711 } 3710 }
3712 SYNTAX("sub %2%S2, %1"); 3711 SYNTAX("sub %2%S2, %1");
3713 #line 503 "rx-decode.opc" 3712 #line 515 "rx-decode.opc"
3714 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC; 3713 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC;
3715 3714
3716 } 3715 }
3717 break; 3716 break;
3718 } 3717 }
3719 break; 3718 break;
3720 case 0x41: 3719 case 0x41:
3721 GETBYTE (); 3720 GETBYTE ();
3722 switch (op[1] & 0x00) 3721 switch (op[1] & 0x00)
3723 { 3722 {
(...skipping 21 matching lines...) Expand all
3745 } 3744 }
3746 break; 3745 break;
3747 case 0x44: 3746 case 0x44:
3748 GETBYTE (); 3747 GETBYTE ();
3749 switch (op[1] & 0x00) 3748 switch (op[1] & 0x00)
3750 { 3749 {
3751 case 0x00: 3750 case 0x00:
3752 op_semantics_21: 3751 op_semantics_21:
3753 { 3752 {
3754 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */ 3753 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */
3755 #line 491 "rx-decode.opc" 3754 #line 503 "rx-decode.opc"
3756 int ss AU = op[0] & 0x03; 3755 int ss AU = op[0] & 0x03;
3757 #line 491 "rx-decode.opc" 3756 #line 503 "rx-decode.opc"
3758 int rsrc AU = (op[1] >> 4) & 0x0f; 3757 int rsrc AU = (op[1] >> 4) & 0x0f;
3759 #line 491 "rx-decode.opc" 3758 #line 503 "rx-decode.opc"
3760 int rdst AU = op[1] & 0x0f; 3759 int rdst AU = op[1] & 0x0f;
3761 if (trace) 3760 if (trace)
3762 { 3761 {
3763 printf ("\033[33m%s\033[0m %02x %02x\n", 3762 printf ("\033[33m%s\033[0m %02x %02x\n",
3764 "/** 0100 01ss rsrc rdst cmp %2%S2, % 1 */", 3763 "/** 0100 01ss rsrc rdst cmp %2%S2, % 1 */",
3765 op[0], op[1]); 3764 op[0], op[1]);
3766 printf (" ss = 0x%x,", ss); 3765 printf (" ss = 0x%x,", ss);
3767 printf (" rsrc = 0x%x,", rsrc); 3766 printf (" rsrc = 0x%x,", rsrc);
3768 printf (" rdst = 0x%x\n", rdst); 3767 printf (" rdst = 0x%x\n", rdst);
3769 } 3768 }
3770 SYNTAX("cmp %2%S2, %1"); 3769 SYNTAX("cmp %2%S2, %1");
3771 #line 491 "rx-decode.opc" 3770 #line 503 "rx-decode.opc"
3772 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC; 3771 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC;
3773 3772
3774 } 3773 }
3775 break; 3774 break;
3776 } 3775 }
3777 break; 3776 break;
3778 case 0x45: 3777 case 0x45:
3779 GETBYTE (); 3778 GETBYTE ();
3780 switch (op[1] & 0x00) 3779 switch (op[1] & 0x00)
3781 { 3780 {
(...skipping 21 matching lines...) Expand all
3803 } 3802 }
3804 break; 3803 break;
3805 case 0x48: 3804 case 0x48:
3806 GETBYTE (); 3805 GETBYTE ();
3807 switch (op[1] & 0x00) 3806 switch (op[1] & 0x00)
3808 { 3807 {
3809 case 0x00: 3808 case 0x00:
3810 op_semantics_22: 3809 op_semantics_22:
3811 { 3810 {
3812 /** 0100 10ss rsrc rdst add %1%S1, %0 */ 3811 /** 0100 10ss rsrc rdst add %1%S1, %0 */
3813 #line 467 "rx-decode.opc" 3812 #line 479 "rx-decode.opc"
3814 int ss AU = op[0] & 0x03; 3813 int ss AU = op[0] & 0x03;
3815 #line 467 "rx-decode.opc" 3814 #line 479 "rx-decode.opc"
3816 int rsrc AU = (op[1] >> 4) & 0x0f; 3815 int rsrc AU = (op[1] >> 4) & 0x0f;
3817 #line 467 "rx-decode.opc" 3816 #line 479 "rx-decode.opc"
3818 int rdst AU = op[1] & 0x0f; 3817 int rdst AU = op[1] & 0x0f;
3819 if (trace) 3818 if (trace)
3820 { 3819 {
3821 printf ("\033[33m%s\033[0m %02x %02x\n", 3820 printf ("\033[33m%s\033[0m %02x %02x\n",
3822 "/** 0100 10ss rsrc rdst add %1%S1, %0 */", 3821 "/** 0100 10ss rsrc rdst add %1%S1, %0 */",
3823 op[0], op[1]); 3822 op[0], op[1]);
3824 printf (" ss = 0x%x,", ss); 3823 printf (" ss = 0x%x,", ss);
3825 printf (" rsrc = 0x%x,", rsrc); 3824 printf (" rsrc = 0x%x,", rsrc);
3826 printf (" rdst = 0x%x\n", rdst); 3825 printf (" rdst = 0x%x\n", rdst);
3827 } 3826 }
3828 SYNTAX("add %1%S1, %0"); 3827 SYNTAX("add %1%S1, %0");
3829 #line 467 "rx-decode.opc" 3828 #line 479 "rx-decode.opc"
3830 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC; 3829 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC;
3831 3830
3832 } 3831 }
3833 break; 3832 break;
3834 } 3833 }
3835 break; 3834 break;
3836 case 0x49: 3835 case 0x49:
3837 GETBYTE (); 3836 GETBYTE ();
3838 switch (op[1] & 0x00) 3837 switch (op[1] & 0x00)
3839 { 3838 {
(...skipping 21 matching lines...) Expand all
3861 } 3860 }
3862 break; 3861 break;
3863 case 0x4c: 3862 case 0x4c:
3864 GETBYTE (); 3863 GETBYTE ();
3865 switch (op[1] & 0x00) 3864 switch (op[1] & 0x00)
3866 { 3865 {
3867 case 0x00: 3866 case 0x00:
3868 op_semantics_23: 3867 op_semantics_23:
3869 { 3868 {
3870 /** 0100 11ss rsrc rdst mul %1%S1, %0 */ 3869 /** 0100 11ss rsrc rdst mul %1%S1, %0 */
3871 #line 572 "rx-decode.opc" 3870 #line 584 "rx-decode.opc"
3872 int ss AU = op[0] & 0x03; 3871 int ss AU = op[0] & 0x03;
3873 #line 572 "rx-decode.opc" 3872 #line 584 "rx-decode.opc"
3874 int rsrc AU = (op[1] >> 4) & 0x0f; 3873 int rsrc AU = (op[1] >> 4) & 0x0f;
3875 #line 572 "rx-decode.opc" 3874 #line 584 "rx-decode.opc"
3876 int rdst AU = op[1] & 0x0f; 3875 int rdst AU = op[1] & 0x0f;
3877 if (trace) 3876 if (trace)
3878 { 3877 {
3879 printf ("\033[33m%s\033[0m %02x %02x\n", 3878 printf ("\033[33m%s\033[0m %02x %02x\n",
3880 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */", 3879 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */",
3881 op[0], op[1]); 3880 op[0], op[1]);
3882 printf (" ss = 0x%x,", ss); 3881 printf (" ss = 0x%x,", ss);
3883 printf (" rsrc = 0x%x,", rsrc); 3882 printf (" rsrc = 0x%x,", rsrc);
3884 printf (" rdst = 0x%x\n", rdst); 3883 printf (" rdst = 0x%x\n", rdst);
3885 } 3884 }
3886 SYNTAX("mul %1%S1, %0"); 3885 SYNTAX("mul %1%S1, %0");
3887 #line 572 "rx-decode.opc" 3886 #line 584 "rx-decode.opc"
3888 ID(mul); SP(ss, rsrc); DR(rdst); F_____; 3887 ID(mul); SP(ss, rsrc); DR(rdst); F_____;
3889 3888
3890 } 3889 }
3891 break; 3890 break;
3892 } 3891 }
3893 break; 3892 break;
3894 case 0x4d: 3893 case 0x4d:
3895 GETBYTE (); 3894 GETBYTE ();
3896 switch (op[1] & 0x00) 3895 switch (op[1] & 0x00)
3897 { 3896 {
(...skipping 21 matching lines...) Expand all
3919 } 3918 }
3920 break; 3919 break;
3921 case 0x50: 3920 case 0x50:
3922 GETBYTE (); 3921 GETBYTE ();
3923 switch (op[1] & 0x00) 3922 switch (op[1] & 0x00)
3924 { 3923 {
3925 case 0x00: 3924 case 0x00:
3926 op_semantics_24: 3925 op_semantics_24:
3927 { 3926 {
3928 /** 0101 00ss rsrc rdst and %1%S1, %0 */ 3927 /** 0101 00ss rsrc rdst and %1%S1, %0 */
3929 #line 380 "rx-decode.opc" 3928 #line 392 "rx-decode.opc"
3930 int ss AU = op[0] & 0x03; 3929 int ss AU = op[0] & 0x03;
3931 #line 380 "rx-decode.opc" 3930 #line 392 "rx-decode.opc"
3932 int rsrc AU = (op[1] >> 4) & 0x0f; 3931 int rsrc AU = (op[1] >> 4) & 0x0f;
3933 #line 380 "rx-decode.opc" 3932 #line 392 "rx-decode.opc"
3934 int rdst AU = op[1] & 0x0f; 3933 int rdst AU = op[1] & 0x0f;
3935 if (trace) 3934 if (trace)
3936 { 3935 {
3937 printf ("\033[33m%s\033[0m %02x %02x\n", 3936 printf ("\033[33m%s\033[0m %02x %02x\n",
3938 "/** 0101 00ss rsrc rdst and %1%S1, %0 */", 3937 "/** 0101 00ss rsrc rdst and %1%S1, %0 */",
3939 op[0], op[1]); 3938 op[0], op[1]);
3940 printf (" ss = 0x%x,", ss); 3939 printf (" ss = 0x%x,", ss);
3941 printf (" rsrc = 0x%x,", rsrc); 3940 printf (" rsrc = 0x%x,", rsrc);
3942 printf (" rdst = 0x%x\n", rdst); 3941 printf (" rdst = 0x%x\n", rdst);
3943 } 3942 }
3944 SYNTAX("and %1%S1, %0"); 3943 SYNTAX("and %1%S1, %0");
3945 #line 380 "rx-decode.opc" 3944 #line 392 "rx-decode.opc"
3946 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_; 3945 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_;
3947 3946
3948 } 3947 }
3949 break; 3948 break;
3950 } 3949 }
3951 break; 3950 break;
3952 case 0x51: 3951 case 0x51:
3953 GETBYTE (); 3952 GETBYTE ();
3954 switch (op[1] & 0x00) 3953 switch (op[1] & 0x00)
3955 { 3954 {
(...skipping 21 matching lines...) Expand all
3977 } 3976 }
3978 break; 3977 break;
3979 case 0x54: 3978 case 0x54:
3980 GETBYTE (); 3979 GETBYTE ();
3981 switch (op[1] & 0x00) 3980 switch (op[1] & 0x00)
3982 { 3981 {
3983 case 0x00: 3982 case 0x00:
3984 op_semantics_25: 3983 op_semantics_25:
3985 { 3984 {
3986 /** 0101 01ss rsrc rdst or %1%S1, %0 */ 3985 /** 0101 01ss rsrc rdst or %1%S1, %0 */
3987 #line 398 "rx-decode.opc" 3986 #line 410 "rx-decode.opc"
3988 int ss AU = op[0] & 0x03; 3987 int ss AU = op[0] & 0x03;
3989 #line 398 "rx-decode.opc" 3988 #line 410 "rx-decode.opc"
3990 int rsrc AU = (op[1] >> 4) & 0x0f; 3989 int rsrc AU = (op[1] >> 4) & 0x0f;
3991 #line 398 "rx-decode.opc" 3990 #line 410 "rx-decode.opc"
3992 int rdst AU = op[1] & 0x0f; 3991 int rdst AU = op[1] & 0x0f;
3993 if (trace) 3992 if (trace)
3994 { 3993 {
3995 printf ("\033[33m%s\033[0m %02x %02x\n", 3994 printf ("\033[33m%s\033[0m %02x %02x\n",
3996 "/** 0101 01ss rsrc rdst or %1%S1, %0 */", 3995 "/** 0101 01ss rsrc rdst or %1%S1, %0 */",
3997 op[0], op[1]); 3996 op[0], op[1]);
3998 printf (" ss = 0x%x,", ss); 3997 printf (" ss = 0x%x,", ss);
3999 printf (" rsrc = 0x%x,", rsrc); 3998 printf (" rsrc = 0x%x,", rsrc);
4000 printf (" rdst = 0x%x\n", rdst); 3999 printf (" rdst = 0x%x\n", rdst);
4001 } 4000 }
4002 SYNTAX("or %1%S1, %0"); 4001 SYNTAX("or %1%S1, %0");
4003 #line 398 "rx-decode.opc" 4002 #line 410 "rx-decode.opc"
4004 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_; 4003 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_;
4005 4004
4006 } 4005 }
4007 break; 4006 break;
4008 } 4007 }
4009 break; 4008 break;
4010 case 0x55: 4009 case 0x55:
4011 GETBYTE (); 4010 GETBYTE ();
4012 switch (op[1] & 0x00) 4011 switch (op[1] & 0x00)
4013 { 4012 {
(...skipping 21 matching lines...) Expand all
4035 } 4034 }
4036 break; 4035 break;
4037 case 0x58: 4036 case 0x58:
4038 GETBYTE (); 4037 GETBYTE ();
4039 switch (op[1] & 0x00) 4038 switch (op[1] & 0x00)
4040 { 4039 {
4041 case 0x00: 4040 case 0x00:
4042 op_semantics_26: 4041 op_semantics_26:
4043 { 4042 {
4044 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */ 4043 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */
4045 #line 319 "rx-decode.opc" 4044 #line 331 "rx-decode.opc"
4046 int s AU = (op[0] >> 2) & 0x01; 4045 int s AU = (op[0] >> 2) & 0x01;
4047 #line 319 "rx-decode.opc" 4046 #line 331 "rx-decode.opc"
4048 int ss AU = op[0] & 0x03; 4047 int ss AU = op[0] & 0x03;
4049 #line 319 "rx-decode.opc" 4048 #line 331 "rx-decode.opc"
4050 int rsrc AU = (op[1] >> 4) & 0x0f; 4049 int rsrc AU = (op[1] >> 4) & 0x0f;
4051 #line 319 "rx-decode.opc" 4050 #line 331 "rx-decode.opc"
4052 int rdst AU = op[1] & 0x0f; 4051 int rdst AU = op[1] & 0x0f;
4053 if (trace) 4052 if (trace)
4054 { 4053 {
4055 printf ("\033[33m%s\033[0m %02x %02x\n", 4054 printf ("\033[33m%s\033[0m %02x %02x\n",
4056 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */", 4055 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */",
4057 op[0], op[1]); 4056 op[0], op[1]);
4058 printf (" s = 0x%x,", s); 4057 printf (" s = 0x%x,", s);
4059 printf (" ss = 0x%x,", ss); 4058 printf (" ss = 0x%x,", ss);
4060 printf (" rsrc = 0x%x,", rsrc); 4059 printf (" rsrc = 0x%x,", rsrc);
4061 printf (" rdst = 0x%x\n", rdst); 4060 printf (" rdst = 0x%x\n", rdst);
4062 } 4061 }
4063 SYNTAX("movu%s %1, %0"); 4062 SYNTAX("movu%s %1, %0");
4064 #line 319 "rx-decode.opc" 4063 #line 331 "rx-decode.opc"
4065 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F_____; 4064 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F_____;
4066 4065
4067 } 4066 }
4068 break; 4067 break;
4069 } 4068 }
4070 break; 4069 break;
4071 case 0x59: 4070 case 0x59:
4072 GETBYTE (); 4071 GETBYTE ();
4073 switch (op[1] & 0x00) 4072 switch (op[1] & 0x00)
4074 { 4073 {
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after
4131 break; 4130 break;
4132 } 4131 }
4133 break; 4132 break;
4134 case 0x60: 4133 case 0x60:
4135 GETBYTE (); 4134 GETBYTE ();
4136 switch (op[1] & 0x00) 4135 switch (op[1] & 0x00)
4137 { 4136 {
4138 case 0x00: 4137 case 0x00:
4139 { 4138 {
4140 /** 0110 0000 immm rdst sub #%2, %0 */ 4139 /** 0110 0000 immm rdst sub #%2, %0 */
4141 #line 500 "rx-decode.opc" 4140 #line 512 "rx-decode.opc"
4142 int immm AU = (op[1] >> 4) & 0x0f; 4141 int immm AU = (op[1] >> 4) & 0x0f;
4143 #line 500 "rx-decode.opc" 4142 #line 512 "rx-decode.opc"
4144 int rdst AU = op[1] & 0x0f; 4143 int rdst AU = op[1] & 0x0f;
4145 if (trace) 4144 if (trace)
4146 { 4145 {
4147 printf ("\033[33m%s\033[0m %02x %02x\n", 4146 printf ("\033[33m%s\033[0m %02x %02x\n",
4148 "/** 0110 0000 immm rdst sub #%2, %0 */", 4147 "/** 0110 0000 immm rdst sub #%2, %0 */",
4149 op[0], op[1]); 4148 op[0], op[1]);
4150 printf (" immm = 0x%x,", immm); 4149 printf (" immm = 0x%x,", immm);
4151 printf (" rdst = 0x%x\n", rdst); 4150 printf (" rdst = 0x%x\n", rdst);
4152 } 4151 }
4153 SYNTAX("sub #%2, %0"); 4152 SYNTAX("sub #%2, %0");
4154 #line 500 "rx-decode.opc" 4153 #line 512 "rx-decode.opc"
4155 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC; 4154 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC;
4156 4155
4157 } 4156 }
4158 break; 4157 break;
4159 } 4158 }
4160 break; 4159 break;
4161 case 0x61: 4160 case 0x61:
4162 GETBYTE (); 4161 GETBYTE ();
4163 switch (op[1] & 0x00) 4162 switch (op[1] & 0x00)
4164 { 4163 {
4165 case 0x00: 4164 case 0x00:
4166 { 4165 {
4167 /** 0110 0001 immm rdst cmp #%2, %1 */ 4166 /** 0110 0001 immm rdst cmp #%2, %1 */
4168 #line 482 "rx-decode.opc" 4167 #line 494 "rx-decode.opc"
4169 int immm AU = (op[1] >> 4) & 0x0f; 4168 int immm AU = (op[1] >> 4) & 0x0f;
4170 #line 482 "rx-decode.opc" 4169 #line 494 "rx-decode.opc"
4171 int rdst AU = op[1] & 0x0f; 4170 int rdst AU = op[1] & 0x0f;
4172 if (trace) 4171 if (trace)
4173 { 4172 {
4174 printf ("\033[33m%s\033[0m %02x %02x\n", 4173 printf ("\033[33m%s\033[0m %02x %02x\n",
4175 "/** 0110 0001 immm rdst cmp #%2, %1 */", 4174 "/** 0110 0001 immm rdst cmp #%2, %1 */",
4176 op[0], op[1]); 4175 op[0], op[1]);
4177 printf (" immm = 0x%x,", immm); 4176 printf (" immm = 0x%x,", immm);
4178 printf (" rdst = 0x%x\n", rdst); 4177 printf (" rdst = 0x%x\n", rdst);
4179 } 4178 }
4180 SYNTAX("cmp #%2, %1"); 4179 SYNTAX("cmp #%2, %1");
4181 #line 482 "rx-decode.opc" 4180 #line 494 "rx-decode.opc"
4182 ID(sub); S2C(immm); SR(rdst); F_OSZC; 4181 ID(sub); S2C(immm); SR(rdst); F_OSZC;
4183 4182
4184 } 4183 }
4185 break; 4184 break;
4186 } 4185 }
4187 break; 4186 break;
4188 case 0x62: 4187 case 0x62:
4189 GETBYTE (); 4188 GETBYTE ();
4190 switch (op[1] & 0x00) 4189 switch (op[1] & 0x00)
4191 { 4190 {
4192 case 0x00: 4191 case 0x00:
4193 { 4192 {
4194 /** 0110 0010 immm rdst add #%1, %0 */ 4193 /** 0110 0010 immm rdst add #%1, %0 */
4195 #line 464 "rx-decode.opc" 4194 #line 476 "rx-decode.opc"
4196 int immm AU = (op[1] >> 4) & 0x0f; 4195 int immm AU = (op[1] >> 4) & 0x0f;
4197 #line 464 "rx-decode.opc" 4196 #line 476 "rx-decode.opc"
4198 int rdst AU = op[1] & 0x0f; 4197 int rdst AU = op[1] & 0x0f;
4199 if (trace) 4198 if (trace)
4200 { 4199 {
4201 printf ("\033[33m%s\033[0m %02x %02x\n", 4200 printf ("\033[33m%s\033[0m %02x %02x\n",
4202 "/** 0110 0010 immm rdst add #%1, %0 */", 4201 "/** 0110 0010 immm rdst add #%1, %0 */",
4203 op[0], op[1]); 4202 op[0], op[1]);
4204 printf (" immm = 0x%x,", immm); 4203 printf (" immm = 0x%x,", immm);
4205 printf (" rdst = 0x%x\n", rdst); 4204 printf (" rdst = 0x%x\n", rdst);
4206 } 4205 }
4207 SYNTAX("add #%1, %0"); 4206 SYNTAX("add #%1, %0");
4208 #line 464 "rx-decode.opc" 4207 #line 476 "rx-decode.opc"
4209 ID(add); SC(immm); DR(rdst); F_OSZC; 4208 ID(add); SC(immm); DR(rdst); F_OSZC;
4210 4209
4211 } 4210 }
4212 break; 4211 break;
4213 } 4212 }
4214 break; 4213 break;
4215 case 0x63: 4214 case 0x63:
4216 GETBYTE (); 4215 GETBYTE ();
4217 switch (op[1] & 0x00) 4216 switch (op[1] & 0x00)
4218 { 4217 {
4219 case 0x00: 4218 case 0x00:
4220 { 4219 {
4221 /** 0110 0011 immm rdst mul #%1, %0 */ 4220 /** 0110 0011 immm rdst mul #%1, %0 */
4222 #line 566 "rx-decode.opc" 4221 #line 578 "rx-decode.opc"
4223 int immm AU = (op[1] >> 4) & 0x0f; 4222 int immm AU = (op[1] >> 4) & 0x0f;
4224 #line 566 "rx-decode.opc" 4223 #line 578 "rx-decode.opc"
4225 int rdst AU = op[1] & 0x0f; 4224 int rdst AU = op[1] & 0x0f;
4226 if (trace) 4225 if (trace)
4227 { 4226 {
4228 printf ("\033[33m%s\033[0m %02x %02x\n", 4227 printf ("\033[33m%s\033[0m %02x %02x\n",
4229 "/** 0110 0011 immm rdst mul #%1, %0 */", 4228 "/** 0110 0011 immm rdst mul #%1, %0 */",
4230 op[0], op[1]); 4229 op[0], op[1]);
4231 printf (" immm = 0x%x,", immm); 4230 printf (" immm = 0x%x,", immm);
4232 printf (" rdst = 0x%x\n", rdst); 4231 printf (" rdst = 0x%x\n", rdst);
4233 } 4232 }
4234 SYNTAX("mul #%1, %0"); 4233 SYNTAX("mul #%1, %0");
4235 #line 566 "rx-decode.opc" 4234 #line 578 "rx-decode.opc"
4236 ID(mul); DR(rdst); SC(immm); F_____; 4235 ID(mul); DR(rdst); SC(immm); F_____;
4237 4236
4238 } 4237 }
4239 break; 4238 break;
4240 } 4239 }
4241 break; 4240 break;
4242 case 0x64: 4241 case 0x64:
4243 GETBYTE (); 4242 GETBYTE ();
4244 switch (op[1] & 0x00) 4243 switch (op[1] & 0x00)
4245 { 4244 {
4246 case 0x00: 4245 case 0x00:
4247 { 4246 {
4248 /** 0110 0100 immm rdst and #%1, %0 */ 4247 /** 0110 0100 immm rdst and #%1, %0 */
4249 #line 374 "rx-decode.opc" 4248 #line 386 "rx-decode.opc"
4250 int immm AU = (op[1] >> 4) & 0x0f; 4249 int immm AU = (op[1] >> 4) & 0x0f;
4251 #line 374 "rx-decode.opc" 4250 #line 386 "rx-decode.opc"
4252 int rdst AU = op[1] & 0x0f; 4251 int rdst AU = op[1] & 0x0f;
4253 if (trace) 4252 if (trace)
4254 { 4253 {
4255 printf ("\033[33m%s\033[0m %02x %02x\n", 4254 printf ("\033[33m%s\033[0m %02x %02x\n",
4256 "/** 0110 0100 immm rdst and #%1, %0 */", 4255 "/** 0110 0100 immm rdst and #%1, %0 */",
4257 op[0], op[1]); 4256 op[0], op[1]);
4258 printf (" immm = 0x%x,", immm); 4257 printf (" immm = 0x%x,", immm);
4259 printf (" rdst = 0x%x\n", rdst); 4258 printf (" rdst = 0x%x\n", rdst);
4260 } 4259 }
4261 SYNTAX("and #%1, %0"); 4260 SYNTAX("and #%1, %0");
4262 #line 374 "rx-decode.opc" 4261 #line 386 "rx-decode.opc"
4263 ID(and); SC(immm); DR(rdst); F__SZ_; 4262 ID(and); SC(immm); DR(rdst); F__SZ_;
4264 4263
4265 } 4264 }
4266 break; 4265 break;
4267 } 4266 }
4268 break; 4267 break;
4269 case 0x65: 4268 case 0x65:
4270 GETBYTE (); 4269 GETBYTE ();
4271 switch (op[1] & 0x00) 4270 switch (op[1] & 0x00)
4272 { 4271 {
4273 case 0x00: 4272 case 0x00:
4274 { 4273 {
4275 /** 0110 0101 immm rdst or #%1, %0 */ 4274 /** 0110 0101 immm rdst or #%1, %0 */
4276 #line 392 "rx-decode.opc" 4275 #line 404 "rx-decode.opc"
4277 int immm AU = (op[1] >> 4) & 0x0f; 4276 int immm AU = (op[1] >> 4) & 0x0f;
4278 #line 392 "rx-decode.opc" 4277 #line 404 "rx-decode.opc"
4279 int rdst AU = op[1] & 0x0f; 4278 int rdst AU = op[1] & 0x0f;
4280 if (trace) 4279 if (trace)
4281 { 4280 {
4282 printf ("\033[33m%s\033[0m %02x %02x\n", 4281 printf ("\033[33m%s\033[0m %02x %02x\n",
4283 "/** 0110 0101 immm rdst or #%1, %0 */", 4282 "/** 0110 0101 immm rdst or #%1, %0 */",
4284 op[0], op[1]); 4283 op[0], op[1]);
4285 printf (" immm = 0x%x,", immm); 4284 printf (" immm = 0x%x,", immm);
4286 printf (" rdst = 0x%x\n", rdst); 4285 printf (" rdst = 0x%x\n", rdst);
4287 } 4286 }
4288 SYNTAX("or #%1, %0"); 4287 SYNTAX("or #%1, %0");
4289 #line 392 "rx-decode.opc" 4288 #line 404 "rx-decode.opc"
4290 ID(or); SC(immm); DR(rdst); F__SZ_; 4289 ID(or); SC(immm); DR(rdst); F__SZ_;
4291 4290
4292 } 4291 }
4293 break; 4292 break;
4294 } 4293 }
4295 break; 4294 break;
4296 case 0x66: 4295 case 0x66:
4297 GETBYTE (); 4296 GETBYTE ();
4298 switch (op[1] & 0x00) 4297 switch (op[1] & 0x00)
4299 { 4298 {
4300 case 0x00: 4299 case 0x00:
4301 { 4300 {
4302 /** 0110 0110 immm rdst mov%s #%1, %0 */ 4301 /** 0110 0110 immm rdst mov%s #%1, %0 */
4303 #line 268 "rx-decode.opc" 4302 #line 280 "rx-decode.opc"
4304 int immm AU = (op[1] >> 4) & 0x0f; 4303 int immm AU = (op[1] >> 4) & 0x0f;
4305 #line 268 "rx-decode.opc" 4304 #line 280 "rx-decode.opc"
4306 int rdst AU = op[1] & 0x0f; 4305 int rdst AU = op[1] & 0x0f;
4307 if (trace) 4306 if (trace)
4308 { 4307 {
4309 printf ("\033[33m%s\033[0m %02x %02x\n", 4308 printf ("\033[33m%s\033[0m %02x %02x\n",
4310 "/** 0110 0110 immm rdst mov%s #%1, %0 */", 4309 "/** 0110 0110 immm rdst mov%s #%1, %0 */",
4311 op[0], op[1]); 4310 op[0], op[1]);
4312 printf (" immm = 0x%x,", immm); 4311 printf (" immm = 0x%x,", immm);
4313 printf (" rdst = 0x%x\n", rdst); 4312 printf (" rdst = 0x%x\n", rdst);
4314 } 4313 }
4315 SYNTAX("mov%s #%1, %0"); 4314 SYNTAX("mov%s #%1, %0");
4316 #line 268 "rx-decode.opc" 4315 #line 280 "rx-decode.opc"
4317 ID(mov); DR(rdst); SC(immm); F_____; 4316 ID(mov); DR(rdst); SC(immm); F_____;
4318 4317
4319 } 4318 }
4320 break; 4319 break;
4321 } 4320 }
4322 break; 4321 break;
4323 case 0x67: 4322 case 0x67:
4324 { 4323 {
4325 /** 0110 0111 rtsd #%1 */ 4324 /** 0110 0111 rtsd #%1 */
4326 if (trace) 4325 if (trace)
4327 { 4326 {
4328 printf ("\033[33m%s\033[0m %02x\n", 4327 printf ("\033[33m%s\033[0m %02x\n",
4329 "/** 0110 0111 rtsd #%1 */", 4328 "/** 0110 0111 rtsd #%1 */",
4330 op[0]); 4329 op[0]);
4331 } 4330 }
4332 SYNTAX("rtsd #%1"); 4331 SYNTAX("rtsd #%1");
4333 #line 365 "rx-decode.opc" 4332 #line 377 "rx-decode.opc"
4334 ID(rtsd); SC(IMM(1) * 4); 4333 ID(rtsd); SC(IMM(1) * 4);
4335 4334
4336 } 4335 }
4337 break; 4336 break;
4338 case 0x68: 4337 case 0x68:
4339 GETBYTE (); 4338 GETBYTE ();
4340 switch (op[1] & 0x00) 4339 switch (op[1] & 0x00)
4341 { 4340 {
4342 case 0x00: 4341 case 0x00:
4343 op_semantics_27: 4342 op_semantics_27:
4344 { 4343 {
4345 /** 0110 100i mmmm rdst shlr #%2, %0 */ 4344 /** 0110 100i mmmm rdst shlr #%2, %0 */
4346 #line 652 "rx-decode.opc" 4345 #line 664 "rx-decode.opc"
4347 int i AU = op[0] & 0x01; 4346 int i AU = op[0] & 0x01;
4348 #line 652 "rx-decode.opc" 4347 #line 664 "rx-decode.opc"
4349 int mmmm AU = (op[1] >> 4) & 0x0f; 4348 int mmmm AU = (op[1] >> 4) & 0x0f;
4350 #line 652 "rx-decode.opc" 4349 #line 664 "rx-decode.opc"
4351 int rdst AU = op[1] & 0x0f; 4350 int rdst AU = op[1] & 0x0f;
4352 if (trace) 4351 if (trace)
4353 { 4352 {
4354 printf ("\033[33m%s\033[0m %02x %02x\n", 4353 printf ("\033[33m%s\033[0m %02x %02x\n",
4355 "/** 0110 100i mmmm rdst shlr #%2, %0 */", 4354 "/** 0110 100i mmmm rdst shlr #%2, %0 */",
4356 op[0], op[1]); 4355 op[0], op[1]);
4357 printf (" i = 0x%x,", i); 4356 printf (" i = 0x%x,", i);
4358 printf (" mmmm = 0x%x,", mmmm); 4357 printf (" mmmm = 0x%x,", mmmm);
4359 printf (" rdst = 0x%x\n", rdst); 4358 printf (" rdst = 0x%x\n", rdst);
4360 } 4359 }
4361 SYNTAX("shlr #%2, %0"); 4360 SYNTAX("shlr #%2, %0");
4362 #line 652 "rx-decode.opc" 4361 #line 664 "rx-decode.opc"
4363 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC; 4362 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC;
4364 4363
4365 } 4364 }
4366 break; 4365 break;
4367 } 4366 }
4368 break; 4367 break;
4369 case 0x69: 4368 case 0x69:
4370 GETBYTE (); 4369 GETBYTE ();
4371 switch (op[1] & 0x00) 4370 switch (op[1] & 0x00)
4372 { 4371 {
4373 case 0x00: 4372 case 0x00:
4374 goto op_semantics_27; 4373 goto op_semantics_27;
4375 break; 4374 break;
4376 } 4375 }
4377 break; 4376 break;
4378 case 0x6a: 4377 case 0x6a:
4379 GETBYTE (); 4378 GETBYTE ();
4380 switch (op[1] & 0x00) 4379 switch (op[1] & 0x00)
4381 { 4380 {
4382 case 0x00: 4381 case 0x00:
4383 op_semantics_28: 4382 op_semantics_28:
4384 { 4383 {
4385 /** 0110 101i mmmm rdst shar #%2, %0 */ 4384 /** 0110 101i mmmm rdst shar #%2, %0 */
4386 #line 642 "rx-decode.opc" 4385 #line 654 "rx-decode.opc"
4387 int i AU = op[0] & 0x01; 4386 int i AU = op[0] & 0x01;
4388 #line 642 "rx-decode.opc" 4387 #line 654 "rx-decode.opc"
4389 int mmmm AU = (op[1] >> 4) & 0x0f; 4388 int mmmm AU = (op[1] >> 4) & 0x0f;
4390 #line 642 "rx-decode.opc" 4389 #line 654 "rx-decode.opc"
4391 int rdst AU = op[1] & 0x0f; 4390 int rdst AU = op[1] & 0x0f;
4392 if (trace) 4391 if (trace)
4393 { 4392 {
4394 printf ("\033[33m%s\033[0m %02x %02x\n", 4393 printf ("\033[33m%s\033[0m %02x %02x\n",
4395 "/** 0110 101i mmmm rdst shar #%2, %0 */", 4394 "/** 0110 101i mmmm rdst shar #%2, %0 */",
4396 op[0], op[1]); 4395 op[0], op[1]);
4397 printf (" i = 0x%x,", i); 4396 printf (" i = 0x%x,", i);
4398 printf (" mmmm = 0x%x,", mmmm); 4397 printf (" mmmm = 0x%x,", mmmm);
4399 printf (" rdst = 0x%x\n", rdst); 4398 printf (" rdst = 0x%x\n", rdst);
4400 } 4399 }
4401 SYNTAX("shar #%2, %0"); 4400 SYNTAX("shar #%2, %0");
4402 #line 642 "rx-decode.opc" 4401 #line 654 "rx-decode.opc"
4403 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC; 4402 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC;
4404 4403
4405 } 4404 }
4406 break; 4405 break;
4407 } 4406 }
4408 break; 4407 break;
4409 case 0x6b: 4408 case 0x6b:
4410 GETBYTE (); 4409 GETBYTE ();
4411 switch (op[1] & 0x00) 4410 switch (op[1] & 0x00)
4412 { 4411 {
4413 case 0x00: 4412 case 0x00:
4414 goto op_semantics_28; 4413 goto op_semantics_28;
4415 break; 4414 break;
4416 } 4415 }
4417 break; 4416 break;
4418 case 0x6c: 4417 case 0x6c:
4419 GETBYTE (); 4418 GETBYTE ();
4420 switch (op[1] & 0x00) 4419 switch (op[1] & 0x00)
4421 { 4420 {
4422 case 0x00: 4421 case 0x00:
4423 op_semantics_29: 4422 op_semantics_29:
4424 { 4423 {
4425 /** 0110 110i mmmm rdst shll #%2, %0 */ 4424 /** 0110 110i mmmm rdst shll #%2, %0 */
4426 #line 632 "rx-decode.opc" 4425 #line 644 "rx-decode.opc"
4427 int i AU = op[0] & 0x01; 4426 int i AU = op[0] & 0x01;
4428 #line 632 "rx-decode.opc" 4427 #line 644 "rx-decode.opc"
4429 int mmmm AU = (op[1] >> 4) & 0x0f; 4428 int mmmm AU = (op[1] >> 4) & 0x0f;
4430 #line 632 "rx-decode.opc" 4429 #line 644 "rx-decode.opc"
4431 int rdst AU = op[1] & 0x0f; 4430 int rdst AU = op[1] & 0x0f;
4432 if (trace) 4431 if (trace)
4433 { 4432 {
4434 printf ("\033[33m%s\033[0m %02x %02x\n", 4433 printf ("\033[33m%s\033[0m %02x %02x\n",
4435 "/** 0110 110i mmmm rdst shll #%2, %0 */", 4434 "/** 0110 110i mmmm rdst shll #%2, %0 */",
4436 op[0], op[1]); 4435 op[0], op[1]);
4437 printf (" i = 0x%x,", i); 4436 printf (" i = 0x%x,", i);
4438 printf (" mmmm = 0x%x,", mmmm); 4437 printf (" mmmm = 0x%x,", mmmm);
4439 printf (" rdst = 0x%x\n", rdst); 4438 printf (" rdst = 0x%x\n", rdst);
4440 } 4439 }
4441 SYNTAX("shll #%2, %0"); 4440 SYNTAX("shll #%2, %0");
4442 #line 632 "rx-decode.opc" 4441 #line 644 "rx-decode.opc"
4443 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC; 4442 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC;
4444 4443
4445 } 4444 }
4446 break; 4445 break;
4447 } 4446 }
4448 break; 4447 break;
4449 case 0x6d: 4448 case 0x6d:
4450 GETBYTE (); 4449 GETBYTE ();
4451 switch (op[1] & 0x00) 4450 switch (op[1] & 0x00)
4452 { 4451 {
4453 case 0x00: 4452 case 0x00:
4454 goto op_semantics_29; 4453 goto op_semantics_29;
4455 break; 4454 break;
4456 } 4455 }
4457 break; 4456 break;
4458 case 0x6e: 4457 case 0x6e:
4459 GETBYTE (); 4458 GETBYTE ();
4460 switch (op[1] & 0x00) 4459 switch (op[1] & 0x00)
4461 { 4460 {
4462 case 0x00: 4461 case 0x00:
4463 { 4462 {
4464 /** 0110 1110 dsta dstb pushm %1-%2 */ 4463 /** 0110 1110 dsta dstb pushm %1-%2 */
4465 #line 332 "rx-decode.opc" 4464 #line 344 "rx-decode.opc"
4466 int dsta AU = (op[1] >> 4) & 0x0f; 4465 int dsta AU = (op[1] >> 4) & 0x0f;
4467 #line 332 "rx-decode.opc" 4466 #line 344 "rx-decode.opc"
4468 int dstb AU = op[1] & 0x0f; 4467 int dstb AU = op[1] & 0x0f;
4469 if (trace) 4468 if (trace)
4470 { 4469 {
4471 printf ("\033[33m%s\033[0m %02x %02x\n", 4470 printf ("\033[33m%s\033[0m %02x %02x\n",
4472 "/** 0110 1110 dsta dstb pushm %1-%2 */ ", 4471 "/** 0110 1110 dsta dstb pushm %1-%2 */ ",
4473 op[0], op[1]); 4472 op[0], op[1]);
4474 printf (" dsta = 0x%x,", dsta); 4473 printf (" dsta = 0x%x,", dsta);
4475 printf (" dstb = 0x%x\n", dstb); 4474 printf (" dstb = 0x%x\n", dstb);
4476 } 4475 }
4477 SYNTAX("pushm %1-%2"); 4476 SYNTAX("pushm %1-%2");
4478 #line 332 "rx-decode.opc" 4477 #line 344 "rx-decode.opc"
4479 ID(pushm); SR(dsta); S2R(dstb); F_____; 4478 ID(pushm); SR(dsta); S2R(dstb); F_____;
4480 4479
4481 } 4480 }
4482 break; 4481 break;
4483 } 4482 }
4484 break; 4483 break;
4485 case 0x6f: 4484 case 0x6f:
4486 GETBYTE (); 4485 GETBYTE ();
4487 switch (op[1] & 0x00) 4486 switch (op[1] & 0x00)
4488 { 4487 {
4489 case 0x00: 4488 case 0x00:
4490 { 4489 {
4491 /** 0110 1111 dsta dstb popm %1-%2 */ 4490 /** 0110 1111 dsta dstb popm %1-%2 */
4492 #line 329 "rx-decode.opc" 4491 #line 341 "rx-decode.opc"
4493 int dsta AU = (op[1] >> 4) & 0x0f; 4492 int dsta AU = (op[1] >> 4) & 0x0f;
4494 #line 329 "rx-decode.opc" 4493 #line 341 "rx-decode.opc"
4495 int dstb AU = op[1] & 0x0f; 4494 int dstb AU = op[1] & 0x0f;
4496 if (trace) 4495 if (trace)
4497 { 4496 {
4498 printf ("\033[33m%s\033[0m %02x %02x\n", 4497 printf ("\033[33m%s\033[0m %02x %02x\n",
4499 "/** 0110 1111 dsta dstb popm %1-%2 */ ", 4498 "/** 0110 1111 dsta dstb popm %1-%2 */ ",
4500 op[0], op[1]); 4499 op[0], op[1]);
4501 printf (" dsta = 0x%x,", dsta); 4500 printf (" dsta = 0x%x,", dsta);
4502 printf (" dstb = 0x%x\n", dstb); 4501 printf (" dstb = 0x%x\n", dstb);
4503 } 4502 }
4504 SYNTAX("popm %1-%2"); 4503 SYNTAX("popm %1-%2");
4505 #line 329 "rx-decode.opc" 4504 #line 341 "rx-decode.opc"
4506 ID(popm); SR(dsta); S2R(dstb); F_____; 4505 ID(popm); SR(dsta); S2R(dstb); F_____;
4507 4506
4508 } 4507 }
4509 break; 4508 break;
4510 } 4509 }
4511 break; 4510 break;
4512 case 0x70: 4511 case 0x70:
4513 GETBYTE (); 4512 GETBYTE ();
4514 switch (op[1] & 0x00) 4513 switch (op[1] & 0x00)
4515 { 4514 {
4516 case 0x00: 4515 case 0x00:
4517 op_semantics_30: 4516 op_semantics_30:
4518 { 4517 {
4519 /** 0111 00im rsrc rdst add #%1, %2, %0 */ 4518 /** 0111 00im rsrc rdst add #%1, %2, %0 */
4520 #line 473 "rx-decode.opc" 4519 #line 485 "rx-decode.opc"
4521 int im AU = op[0] & 0x03; 4520 int im AU = op[0] & 0x03;
4522 #line 473 "rx-decode.opc" 4521 #line 485 "rx-decode.opc"
4523 int rsrc AU = (op[1] >> 4) & 0x0f; 4522 int rsrc AU = (op[1] >> 4) & 0x0f;
4524 #line 473 "rx-decode.opc" 4523 #line 485 "rx-decode.opc"
4525 int rdst AU = op[1] & 0x0f; 4524 int rdst AU = op[1] & 0x0f;
4526 if (trace) 4525 if (trace)
4527 { 4526 {
4528 printf ("\033[33m%s\033[0m %02x %02x\n", 4527 printf ("\033[33m%s\033[0m %02x %02x\n",
4529 "/** 0111 00im rsrc rdst add #%1, %2, %0 */", 4528 "/** 0111 00im rsrc rdst add #%1, %2, %0 */",
4530 op[0], op[1]); 4529 op[0], op[1]);
4531 printf (" im = 0x%x,", im); 4530 printf (" im = 0x%x,", im);
4532 printf (" rsrc = 0x%x,", rsrc); 4531 printf (" rsrc = 0x%x,", rsrc);
4533 printf (" rdst = 0x%x\n", rdst); 4532 printf (" rdst = 0x%x\n", rdst);
4534 } 4533 }
4535 SYNTAX("add #%1, %2, %0"); 4534 SYNTAX("add #%1, %2, %0");
4536 #line 473 "rx-decode.opc" 4535 #line 485 "rx-decode.opc"
4537 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC; 4536 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC;
4538 4537
4539 } 4538 }
4540 break; 4539 break;
4541 } 4540 }
4542 break; 4541 break;
4543 case 0x71: 4542 case 0x71:
4544 GETBYTE (); 4543 GETBYTE ();
4545 switch (op[1] & 0x00) 4544 switch (op[1] & 0x00)
4546 { 4545 {
(...skipping 21 matching lines...) Expand all
4568 } 4567 }
4569 break; 4568 break;
4570 case 0x74: 4569 case 0x74:
4571 GETBYTE (); 4570 GETBYTE ();
4572 switch (op[1] & 0xf0) 4571 switch (op[1] & 0xf0)
4573 { 4572 {
4574 case 0x00: 4573 case 0x00:
4575 op_semantics_31: 4574 op_semantics_31:
4576 { 4575 {
4577 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */ 4576 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */
4578 #line 485 "rx-decode.opc" 4577 #line 497 "rx-decode.opc"
4579 int im AU = op[0] & 0x03; 4578 int im AU = op[0] & 0x03;
4580 #line 485 "rx-decode.opc" 4579 #line 497 "rx-decode.opc"
4581 int rsrc AU = op[1] & 0x0f; 4580 int rsrc AU = op[1] & 0x0f;
4582 if (trace) 4581 if (trace)
4583 { 4582 {
4584 printf ("\033[33m%s\033[0m %02x %02x\n", 4583 printf ("\033[33m%s\033[0m %02x %02x\n",
4585 "/** 0111 01im 0000 rsrc cmp #%2, %1% S1 */", 4584 "/** 0111 01im 0000 rsrc cmp #%2, %1% S1 */",
4586 op[0], op[1]); 4585 op[0], op[1]);
4587 printf (" im = 0x%x,", im); 4586 printf (" im = 0x%x,", im);
4588 printf (" rsrc = 0x%x\n", rsrc); 4587 printf (" rsrc = 0x%x\n", rsrc);
4589 } 4588 }
4590 SYNTAX("cmp #%2, %1%S1"); 4589 SYNTAX("cmp #%2, %1%S1");
4591 #line 485 "rx-decode.opc" 4590 #line 497 "rx-decode.opc"
4592 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC; 4591 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC;
4593 4592
4594 } 4593 }
4595 break; 4594 break;
4596 case 0x10: 4595 case 0x10:
4597 op_semantics_32: 4596 op_semantics_32:
4598 { 4597 {
4599 /** 0111 01im 0001rdst mul #%1, %0 */ 4598 /** 0111 01im 0001rdst mul #%1, %0 */
4600 #line 569 "rx-decode.opc" 4599 #line 581 "rx-decode.opc"
4601 int im AU = op[0] & 0x03; 4600 int im AU = op[0] & 0x03;
4602 #line 569 "rx-decode.opc" 4601 #line 581 "rx-decode.opc"
4603 int rdst AU = op[1] & 0x0f; 4602 int rdst AU = op[1] & 0x0f;
4604 if (trace) 4603 if (trace)
4605 { 4604 {
4606 printf ("\033[33m%s\033[0m %02x %02x\n", 4605 printf ("\033[33m%s\033[0m %02x %02x\n",
4607 "/** 0111 01im 0001rdst mul #%1, %0 */", 4606 "/** 0111 01im 0001rdst mul #%1, %0 */",
4608 op[0], op[1]); 4607 op[0], op[1]);
4609 printf (" im = 0x%x,", im); 4608 printf (" im = 0x%x,", im);
4610 printf (" rdst = 0x%x\n", rdst); 4609 printf (" rdst = 0x%x\n", rdst);
4611 } 4610 }
4612 SYNTAX("mul #%1, %0"); 4611 SYNTAX("mul #%1, %0");
4613 #line 569 "rx-decode.opc" 4612 #line 581 "rx-decode.opc"
4614 ID(mul); DR(rdst); SC(IMMex(im)); F_____; 4613 ID(mul); DR(rdst); SC(IMMex(im)); F_____;
4615 4614
4616 } 4615 }
4617 break; 4616 break;
4618 case 0x20: 4617 case 0x20:
4619 op_semantics_33: 4618 op_semantics_33:
4620 { 4619 {
4621 /** 0111 01im 0010 rdst and #%1, %0 */ 4620 /** 0111 01im 0010 rdst and #%1, %0 */
4622 #line 377 "rx-decode.opc" 4621 #line 389 "rx-decode.opc"
4623 int im AU = op[0] & 0x03; 4622 int im AU = op[0] & 0x03;
4624 #line 377 "rx-decode.opc" 4623 #line 389 "rx-decode.opc"
4625 int rdst AU = op[1] & 0x0f; 4624 int rdst AU = op[1] & 0x0f;
4626 if (trace) 4625 if (trace)
4627 { 4626 {
4628 printf ("\033[33m%s\033[0m %02x %02x\n", 4627 printf ("\033[33m%s\033[0m %02x %02x\n",
4629 "/** 0111 01im 0010 rdst and #%1, %0 */", 4628 "/** 0111 01im 0010 rdst and #%1, %0 */",
4630 op[0], op[1]); 4629 op[0], op[1]);
4631 printf (" im = 0x%x,", im); 4630 printf (" im = 0x%x,", im);
4632 printf (" rdst = 0x%x\n", rdst); 4631 printf (" rdst = 0x%x\n", rdst);
4633 } 4632 }
4634 SYNTAX("and #%1, %0"); 4633 SYNTAX("and #%1, %0");
4635 #line 377 "rx-decode.opc" 4634 #line 389 "rx-decode.opc"
4636 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_; 4635 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_;
4637 4636
4638 } 4637 }
4639 break; 4638 break;
4640 case 0x30: 4639 case 0x30:
4641 op_semantics_34: 4640 op_semantics_34:
4642 { 4641 {
4643 /** 0111 01im 0011 rdst or #%1, %0 */ 4642 /** 0111 01im 0011 rdst or #%1, %0 */
4644 #line 395 "rx-decode.opc" 4643 #line 407 "rx-decode.opc"
4645 int im AU = op[0] & 0x03; 4644 int im AU = op[0] & 0x03;
4646 #line 395 "rx-decode.opc" 4645 #line 407 "rx-decode.opc"
4647 int rdst AU = op[1] & 0x0f; 4646 int rdst AU = op[1] & 0x0f;
4648 if (trace) 4647 if (trace)
4649 { 4648 {
4650 printf ("\033[33m%s\033[0m %02x %02x\n", 4649 printf ("\033[33m%s\033[0m %02x %02x\n",
4651 "/** 0111 01im 0011 rdst or #%1, %0 */", 4650 "/** 0111 01im 0011 rdst or #%1, %0 */",
4652 op[0], op[1]); 4651 op[0], op[1]);
4653 printf (" im = 0x%x,", im); 4652 printf (" im = 0x%x,", im);
4654 printf (" rdst = 0x%x\n", rdst); 4653 printf (" rdst = 0x%x\n", rdst);
4655 } 4654 }
4656 SYNTAX("or #%1, %0"); 4655 SYNTAX("or #%1, %0");
4657 #line 395 "rx-decode.opc" 4656 #line 407 "rx-decode.opc"
4658 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_; 4657 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_;
4659 4658
4660 } 4659 }
4661 break; 4660 break;
4662 default: UNSUPPORTED(); break; 4661 default: UNSUPPORTED(); break;
4663 } 4662 }
4664 break; 4663 break;
4665 case 0x75: 4664 case 0x75:
4666 GETBYTE (); 4665 GETBYTE ();
4667 switch (op[1] & 0xff) 4666 switch (op[1] & 0xff)
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after
4749 case 0x48: 4748 case 0x48:
4750 case 0x49: 4749 case 0x49:
4751 case 0x4a: 4750 case 0x4a:
4752 case 0x4b: 4751 case 0x4b:
4753 case 0x4c: 4752 case 0x4c:
4754 case 0x4d: 4753 case 0x4d:
4755 case 0x4e: 4754 case 0x4e:
4756 case 0x4f: 4755 case 0x4f:
4757 { 4756 {
4758 /** 0111 0101 0100 rdst mov%s #%1, %0 */ 4757 /** 0111 0101 0100 rdst mov%s #%1, %0 */
4759 #line 262 "rx-decode.opc" 4758 #line 261 "rx-decode.opc"
4760 int rdst AU = op[1] & 0x0f; 4759 int rdst AU = op[1] & 0x0f;
4761 if (trace) 4760 if (trace)
4762 { 4761 {
4763 printf ("\033[33m%s\033[0m %02x %02x\n", 4762 printf ("\033[33m%s\033[0m %02x %02x\n",
4764 "/** 0111 0101 0100 rdst mov%s #%1, %0 */", 4763 "/** 0111 0101 0100 rdst mov%s #%1, %0 */",
4765 op[0], op[1]); 4764 op[0], op[1]);
4766 printf (" rdst = 0x%x\n", rdst); 4765 printf (" rdst = 0x%x\n", rdst);
4767 } 4766 }
4768 SYNTAX("mov%s #%1, %0"); 4767 SYNTAX("mov%s #%1, %0");
4769 #line 262 "rx-decode.opc" 4768 #line 261 "rx-decode.opc"
4770 ID(mov); DR(rdst); SC(IMM (1)); F_____; 4769 ID(mov); DR(rdst); SC(IMM (1)); F_____;
4771 4770
4772 } 4771 }
4773 break; 4772 break;
4774 case 0x50: 4773 case 0x50:
4775 case 0x51: 4774 case 0x51:
4776 case 0x52: 4775 case 0x52:
4777 case 0x53: 4776 case 0x53:
4778 case 0x54: 4777 case 0x54:
4779 case 0x55: 4778 case 0x55:
4780 case 0x56: 4779 case 0x56:
4781 case 0x57: 4780 case 0x57:
4782 case 0x58: 4781 case 0x58:
4783 case 0x59: 4782 case 0x59:
4784 case 0x5a: 4783 case 0x5a:
4785 case 0x5b: 4784 case 0x5b:
4786 case 0x5c: 4785 case 0x5c:
4787 case 0x5d: 4786 case 0x5d:
4788 case 0x5e: 4787 case 0x5e:
4789 case 0x5f: 4788 case 0x5f:
4790 { 4789 {
4791 /** 0111 0101 0101 rsrc cmp #%2, %1 */ 4790 /** 0111 0101 0101 rsrc cmp #%2, %1 */
4792 #line 488 "rx-decode.opc" 4791 #line 500 "rx-decode.opc"
4793 int rsrc AU = op[1] & 0x0f; 4792 int rsrc AU = op[1] & 0x0f;
4794 if (trace) 4793 if (trace)
4795 { 4794 {
4796 printf ("\033[33m%s\033[0m %02x %02x\n", 4795 printf ("\033[33m%s\033[0m %02x %02x\n",
4797 "/** 0111 0101 0101 rsrc cmp #%2, %1 */", 4796 "/** 0111 0101 0101 rsrc cmp #%2, %1 */",
4798 op[0], op[1]); 4797 op[0], op[1]);
4799 printf (" rsrc = 0x%x\n", rsrc); 4798 printf (" rsrc = 0x%x\n", rsrc);
4800 } 4799 }
4801 SYNTAX("cmp #%2, %1"); 4800 SYNTAX("cmp #%2, %1");
4802 #line 488 "rx-decode.opc" 4801 #line 500 "rx-decode.opc"
4803 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC; 4802 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC;
4804 4803
4805 } 4804 }
4806 break; 4805 break;
4807 case 0x60: 4806 case 0x60:
4808 { 4807 {
4809 /** 0111 0101 0110 0000 int #%1 */ 4808 /** 0111 0101 0110 0000 int #%1 */
4810 if (trace) 4809 if (trace)
4811 { 4810 {
4812 printf ("\033[33m%s\033[0m %02x %02x\n", 4811 printf ("\033[33m%s\033[0m %02x %02x\n",
4813 "/** 0111 0101 0110 0000 int #%1 */", 4812 "/** 0111 0101 0110 0000 int #%1 */",
4814 op[0], op[1]); 4813 op[0], op[1]);
4815 } 4814 }
4816 SYNTAX("int #%1"); 4815 SYNTAX("int #%1");
4817 #line 949 "rx-decode.opc" 4816 #line 961 "rx-decode.opc"
4818 ID(int); SC(IMM(1)); 4817 ID(int); SC(IMM(1));
4819 4818
4820 } 4819 }
4821 break; 4820 break;
4822 case 0x70: 4821 case 0x70:
4823 GETBYTE (); 4822 GETBYTE ();
4824 switch (op[2] & 0xf0) 4823 switch (op[2] & 0xf0)
4825 { 4824 {
4826 case 0x00: 4825 case 0x00:
4827 { 4826 {
4828 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */ 4827 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */
4829 #line 916 "rx-decode.opc" 4828 #line 928 "rx-decode.opc"
4830 int immm AU = op[2] & 0x0f; 4829 int immm AU = op[2] & 0x0f;
4831 if (trace) 4830 if (trace)
4832 { 4831 {
4833 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 4832 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
4834 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */", 4833 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */",
4835 op[0], op[1], op[2]); 4834 op[0], op[1], op[2]);
4836 printf (" immm = 0x%x\n", immm); 4835 printf (" immm = 0x%x\n", immm);
4837 } 4836 }
4838 SYNTAX("mvtipl #%1"); 4837 SYNTAX("mvtipl #%1");
4839 #line 916 "rx-decode.opc" 4838 #line 928 "rx-decode.opc"
4840 ID(mvtipl); SC(immm); 4839 ID(mvtipl); SC(immm);
4841 4840
4842 } 4841 }
4843 break; 4842 break;
4844 default: UNSUPPORTED(); break; 4843 default: UNSUPPORTED(); break;
4845 } 4844 }
4846 break; 4845 break;
4847 default: UNSUPPORTED(); break; 4846 default: UNSUPPORTED(); break;
4848 } 4847 }
4849 break; 4848 break;
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after
4886 } 4885 }
4887 break; 4886 break;
4888 case 0x78: 4887 case 0x78:
4889 GETBYTE (); 4888 GETBYTE ();
4890 switch (op[1] & 0x00) 4889 switch (op[1] & 0x00)
4891 { 4890 {
4892 case 0x00: 4891 case 0x00:
4893 op_semantics_35: 4892 op_semantics_35:
4894 { 4893 {
4895 /** 0111 100b ittt rdst bset #%1, %0 */ 4894 /** 0111 100b ittt rdst bset #%1, %0 */
4896 #line 867 "rx-decode.opc" 4895 #line 879 "rx-decode.opc"
4897 int b AU = op[0] & 0x01; 4896 int b AU = op[0] & 0x01;
4898 #line 867 "rx-decode.opc" 4897 #line 879 "rx-decode.opc"
4899 int ittt AU = (op[1] >> 4) & 0x0f; 4898 int ittt AU = (op[1] >> 4) & 0x0f;
4900 #line 867 "rx-decode.opc" 4899 #line 879 "rx-decode.opc"
4901 int rdst AU = op[1] & 0x0f; 4900 int rdst AU = op[1] & 0x0f;
4902 if (trace) 4901 if (trace)
4903 { 4902 {
4904 printf ("\033[33m%s\033[0m %02x %02x\n", 4903 printf ("\033[33m%s\033[0m %02x %02x\n",
4905 "/** 0111 100b ittt rdst bset #%1, %0 */", 4904 "/** 0111 100b ittt rdst bset #%1, %0 */",
4906 op[0], op[1]); 4905 op[0], op[1]);
4907 printf (" b = 0x%x,", b); 4906 printf (" b = 0x%x,", b);
4908 printf (" ittt = 0x%x,", ittt); 4907 printf (" ittt = 0x%x,", ittt);
4909 printf (" rdst = 0x%x\n", rdst); 4908 printf (" rdst = 0x%x\n", rdst);
4910 } 4909 }
4911 SYNTAX("bset #%1, %0"); 4910 SYNTAX("bset #%1, %0");
4912 #line 867 "rx-decode.opc" 4911 #line 879 "rx-decode.opc"
4913 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 4912 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4914 4913
4915 4914
4916 } 4915 }
4917 break; 4916 break;
4918 } 4917 }
4919 break; 4918 break;
4920 case 0x79: 4919 case 0x79:
4921 GETBYTE (); 4920 GETBYTE ();
4922 switch (op[1] & 0x00) 4921 switch (op[1] & 0x00)
4923 { 4922 {
4924 case 0x00: 4923 case 0x00:
4925 goto op_semantics_35; 4924 goto op_semantics_35;
4926 break; 4925 break;
4927 } 4926 }
4928 break; 4927 break;
4929 case 0x7a: 4928 case 0x7a:
4930 GETBYTE (); 4929 GETBYTE ();
4931 switch (op[1] & 0x00) 4930 switch (op[1] & 0x00)
4932 { 4931 {
4933 case 0x00: 4932 case 0x00:
4934 op_semantics_36: 4933 op_semantics_36:
4935 { 4934 {
4936 /** 0111 101b ittt rdst bclr #%1, %0 */ 4935 /** 0111 101b ittt rdst bclr #%1, %0 */
4937 #line 877 "rx-decode.opc" 4936 #line 889 "rx-decode.opc"
4938 int b AU = op[0] & 0x01; 4937 int b AU = op[0] & 0x01;
4939 #line 877 "rx-decode.opc" 4938 #line 889 "rx-decode.opc"
4940 int ittt AU = (op[1] >> 4) & 0x0f; 4939 int ittt AU = (op[1] >> 4) & 0x0f;
4941 #line 877 "rx-decode.opc" 4940 #line 889 "rx-decode.opc"
4942 int rdst AU = op[1] & 0x0f; 4941 int rdst AU = op[1] & 0x0f;
4943 if (trace) 4942 if (trace)
4944 { 4943 {
4945 printf ("\033[33m%s\033[0m %02x %02x\n", 4944 printf ("\033[33m%s\033[0m %02x %02x\n",
4946 "/** 0111 101b ittt rdst bclr #%1, %0 */", 4945 "/** 0111 101b ittt rdst bclr #%1, %0 */",
4947 op[0], op[1]); 4946 op[0], op[1]);
4948 printf (" b = 0x%x,", b); 4947 printf (" b = 0x%x,", b);
4949 printf (" ittt = 0x%x,", ittt); 4948 printf (" ittt = 0x%x,", ittt);
4950 printf (" rdst = 0x%x\n", rdst); 4949 printf (" rdst = 0x%x\n", rdst);
4951 } 4950 }
4952 SYNTAX("bclr #%1, %0"); 4951 SYNTAX("bclr #%1, %0");
4953 #line 877 "rx-decode.opc" 4952 #line 889 "rx-decode.opc"
4954 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 4953 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____;
4955 4954
4956 4955
4957 } 4956 }
4958 break; 4957 break;
4959 } 4958 }
4960 break; 4959 break;
4961 case 0x7b: 4960 case 0x7b:
4962 GETBYTE (); 4961 GETBYTE ();
4963 switch (op[1] & 0x00) 4962 switch (op[1] & 0x00)
4964 { 4963 {
4965 case 0x00: 4964 case 0x00:
4966 goto op_semantics_36; 4965 goto op_semantics_36;
4967 break; 4966 break;
4968 } 4967 }
4969 break; 4968 break;
4970 case 0x7c: 4969 case 0x7c:
4971 GETBYTE (); 4970 GETBYTE ();
4972 switch (op[1] & 0x00) 4971 switch (op[1] & 0x00)
4973 { 4972 {
4974 case 0x00: 4973 case 0x00:
4975 op_semantics_37: 4974 op_semantics_37:
4976 { 4975 {
4977 /** 0111 110b ittt rdst btst #%2, %1 */ 4976 /** 0111 110b ittt rdst btst #%2, %1 */
4978 #line 887 "rx-decode.opc" 4977 #line 899 "rx-decode.opc"
4979 int b AU = op[0] & 0x01; 4978 int b AU = op[0] & 0x01;
4980 #line 887 "rx-decode.opc" 4979 #line 899 "rx-decode.opc"
4981 int ittt AU = (op[1] >> 4) & 0x0f; 4980 int ittt AU = (op[1] >> 4) & 0x0f;
4982 #line 887 "rx-decode.opc" 4981 #line 899 "rx-decode.opc"
4983 int rdst AU = op[1] & 0x0f; 4982 int rdst AU = op[1] & 0x0f;
4984 if (trace) 4983 if (trace)
4985 { 4984 {
4986 printf ("\033[33m%s\033[0m %02x %02x\n", 4985 printf ("\033[33m%s\033[0m %02x %02x\n",
4987 "/** 0111 110b ittt rdst btst #%2, %1 */", 4986 "/** 0111 110b ittt rdst btst #%2, %1 */",
4988 op[0], op[1]); 4987 op[0], op[1]);
4989 printf (" b = 0x%x,", b); 4988 printf (" b = 0x%x,", b);
4990 printf (" ittt = 0x%x,", ittt); 4989 printf (" ittt = 0x%x,", ittt);
4991 printf (" rdst = 0x%x\n", rdst); 4990 printf (" rdst = 0x%x\n", rdst);
4992 } 4991 }
4993 SYNTAX("btst #%2, %1"); 4992 SYNTAX("btst #%2, %1");
4994 #line 887 "rx-decode.opc" 4993 #line 899 "rx-decode.opc"
4995 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC; 4994 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC;
4996 4995
4997 4996
4998 } 4997 }
4999 break; 4998 break;
5000 } 4999 }
5001 break; 5000 break;
5002 case 0x7d: 5001 case 0x7d:
5003 GETBYTE (); 5002 GETBYTE ();
5004 switch (op[1] & 0x00) 5003 switch (op[1] & 0x00)
5005 { 5004 {
5006 case 0x00: 5005 case 0x00:
5007 goto op_semantics_37; 5006 goto op_semantics_37;
5008 break; 5007 break;
5009 } 5008 }
5010 break; 5009 break;
5011 case 0x7e: 5010 case 0x7e:
5012 GETBYTE (); 5011 GETBYTE ();
5013 switch (op[1] & 0xf0) 5012 switch (op[1] & 0xf0)
5014 { 5013 {
5015 case 0x00: 5014 case 0x00:
5016 { 5015 {
5017 /** 0111 1110 0000 rdst not %0 */ 5016 /** 0111 1110 0000 rdst not %0 */
5018 #line 422 "rx-decode.opc" 5017 #line 434 "rx-decode.opc"
5019 int rdst AU = op[1] & 0x0f; 5018 int rdst AU = op[1] & 0x0f;
5020 if (trace) 5019 if (trace)
5021 { 5020 {
5022 printf ("\033[33m%s\033[0m %02x %02x\n", 5021 printf ("\033[33m%s\033[0m %02x %02x\n",
5023 "/** 0111 1110 0000 rdst not %0 */", 5022 "/** 0111 1110 0000 rdst not %0 */",
5024 op[0], op[1]); 5023 op[0], op[1]);
5025 printf (" rdst = 0x%x\n", rdst); 5024 printf (" rdst = 0x%x\n", rdst);
5026 } 5025 }
5027 SYNTAX("not %0"); 5026 SYNTAX("not %0");
5028 #line 422 "rx-decode.opc" 5027 #line 434 "rx-decode.opc"
5029 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_; 5028 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_;
5030 5029
5031 } 5030 }
5032 break; 5031 break;
5033 case 0x10: 5032 case 0x10:
5034 { 5033 {
5035 /** 0111 1110 0001 rdst neg %0 */ 5034 /** 0111 1110 0001 rdst neg %0 */
5036 #line 443 "rx-decode.opc" 5035 #line 455 "rx-decode.opc"
5037 int rdst AU = op[1] & 0x0f; 5036 int rdst AU = op[1] & 0x0f;
5038 if (trace) 5037 if (trace)
5039 { 5038 {
5040 printf ("\033[33m%s\033[0m %02x %02x\n", 5039 printf ("\033[33m%s\033[0m %02x %02x\n",
5041 "/** 0111 1110 0001 rdst neg %0 */", 5040 "/** 0111 1110 0001 rdst neg %0 */",
5042 op[0], op[1]); 5041 op[0], op[1]);
5043 printf (" rdst = 0x%x\n", rdst); 5042 printf (" rdst = 0x%x\n", rdst);
5044 } 5043 }
5045 SYNTAX("neg %0"); 5044 SYNTAX("neg %0");
5046 #line 443 "rx-decode.opc" 5045 #line 455 "rx-decode.opc"
5047 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC; 5046 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC;
5048 5047
5049 } 5048 }
5050 break; 5049 break;
5051 case 0x20: 5050 case 0x20:
5052 { 5051 {
5053 /** 0111 1110 0010 rdst abs %0 */ 5052 /** 0111 1110 0010 rdst abs %0 */
5054 #line 525 "rx-decode.opc" 5053 #line 537 "rx-decode.opc"
5055 int rdst AU = op[1] & 0x0f; 5054 int rdst AU = op[1] & 0x0f;
5056 if (trace) 5055 if (trace)
5057 { 5056 {
5058 printf ("\033[33m%s\033[0m %02x %02x\n", 5057 printf ("\033[33m%s\033[0m %02x %02x\n",
5059 "/** 0111 1110 0010 rdst abs %0 */", 5058 "/** 0111 1110 0010 rdst abs %0 */",
5060 op[0], op[1]); 5059 op[0], op[1]);
5061 printf (" rdst = 0x%x\n", rdst); 5060 printf (" rdst = 0x%x\n", rdst);
5062 } 5061 }
5063 SYNTAX("abs %0"); 5062 SYNTAX("abs %0");
5064 #line 525 "rx-decode.opc" 5063 #line 537 "rx-decode.opc"
5065 ID(abs); DR(rdst); SR(rdst); F_OSZ_; 5064 ID(abs); DR(rdst); SR(rdst); F_OSZ_;
5066 5065
5067 } 5066 }
5068 break; 5067 break;
5069 case 0x30: 5068 case 0x30:
5070 { 5069 {
5071 /** 0111 1110 0011 rdst sat %0 */ 5070 /** 0111 1110 0011 rdst sat %0 */
5072 #line 807 "rx-decode.opc" 5071 #line 819 "rx-decode.opc"
5073 int rdst AU = op[1] & 0x0f; 5072 int rdst AU = op[1] & 0x0f;
5074 if (trace) 5073 if (trace)
5075 { 5074 {
5076 printf ("\033[33m%s\033[0m %02x %02x\n", 5075 printf ("\033[33m%s\033[0m %02x %02x\n",
5077 "/** 0111 1110 0011 rdst sat %0 */", 5076 "/** 0111 1110 0011 rdst sat %0 */",
5078 op[0], op[1]); 5077 op[0], op[1]);
5079 printf (" rdst = 0x%x\n", rdst); 5078 printf (" rdst = 0x%x\n", rdst);
5080 } 5079 }
5081 SYNTAX("sat %0"); 5080 SYNTAX("sat %0");
5082 #line 807 "rx-decode.opc" 5081 #line 819 "rx-decode.opc"
5083 ID(sat); DR (rdst); 5082 ID(sat); DR (rdst);
5084 5083
5085 } 5084 }
5086 break; 5085 break;
5087 case 0x40: 5086 case 0x40:
5088 { 5087 {
5089 /** 0111 1110 0100 rdst rorc %0 */ 5088 /** 0111 1110 0100 rdst rorc %0 */
5090 #line 667 "rx-decode.opc" 5089 #line 679 "rx-decode.opc"
5091 int rdst AU = op[1] & 0x0f; 5090 int rdst AU = op[1] & 0x0f;
5092 if (trace) 5091 if (trace)
5093 { 5092 {
5094 printf ("\033[33m%s\033[0m %02x %02x\n", 5093 printf ("\033[33m%s\033[0m %02x %02x\n",
5095 "/** 0111 1110 0100 rdst rorc %0 */", 5094 "/** 0111 1110 0100 rdst rorc %0 */",
5096 op[0], op[1]); 5095 op[0], op[1]);
5097 printf (" rdst = 0x%x\n", rdst); 5096 printf (" rdst = 0x%x\n", rdst);
5098 } 5097 }
5099 SYNTAX("rorc %0"); 5098 SYNTAX("rorc %0");
5100 #line 667 "rx-decode.opc" 5099 #line 679 "rx-decode.opc"
5101 ID(rorc); DR(rdst); F__SZC; 5100 ID(rorc); DR(rdst); F__SZC;
5102 5101
5103 } 5102 }
5104 break; 5103 break;
5105 case 0x50: 5104 case 0x50:
5106 { 5105 {
5107 /** 0111 1110 0101 rdst rolc %0 */ 5106 /** 0111 1110 0101 rdst rolc %0 */
5108 #line 664 "rx-decode.opc" 5107 #line 676 "rx-decode.opc"
5109 int rdst AU = op[1] & 0x0f; 5108 int rdst AU = op[1] & 0x0f;
5110 if (trace) 5109 if (trace)
5111 { 5110 {
5112 printf ("\033[33m%s\033[0m %02x %02x\n", 5111 printf ("\033[33m%s\033[0m %02x %02x\n",
5113 "/** 0111 1110 0101 rdst rolc %0 */", 5112 "/** 0111 1110 0101 rdst rolc %0 */",
5114 op[0], op[1]); 5113 op[0], op[1]);
5115 printf (" rdst = 0x%x\n", rdst); 5114 printf (" rdst = 0x%x\n", rdst);
5116 } 5115 }
5117 SYNTAX("rolc %0"); 5116 SYNTAX("rolc %0");
5118 #line 664 "rx-decode.opc" 5117 #line 676 "rx-decode.opc"
5119 ID(rolc); DR(rdst); F__SZC; 5118 ID(rolc); DR(rdst); F__SZC;
5120 5119
5121 } 5120 }
5122 break; 5121 break;
5123 case 0x80: 5122 case 0x80:
5124 case 0x90: 5123 case 0x90:
5125 case 0xa0: 5124 case 0xa0:
5126 { 5125 {
5127 /** 0111 1110 10sz rsrc push%s %1 */ 5126 /** 0111 1110 10sz rsrc push%s %1 */
5128 #line 338 "rx-decode.opc" 5127 #line 350 "rx-decode.opc"
5129 int sz AU = (op[1] >> 4) & 0x03; 5128 int sz AU = (op[1] >> 4) & 0x03;
5130 #line 338 "rx-decode.opc" 5129 #line 350 "rx-decode.opc"
5131 int rsrc AU = op[1] & 0x0f; 5130 int rsrc AU = op[1] & 0x0f;
5132 if (trace) 5131 if (trace)
5133 { 5132 {
5134 printf ("\033[33m%s\033[0m %02x %02x\n", 5133 printf ("\033[33m%s\033[0m %02x %02x\n",
5135 "/** 0111 1110 10sz rsrc push%s %1 */", 5134 "/** 0111 1110 10sz rsrc push%s %1 */",
5136 op[0], op[1]); 5135 op[0], op[1]);
5137 printf (" sz = 0x%x,", sz); 5136 printf (" sz = 0x%x,", sz);
5138 printf (" rsrc = 0x%x\n", rsrc); 5137 printf (" rsrc = 0x%x\n", rsrc);
5139 } 5138 }
5140 SYNTAX("push%s %1"); 5139 SYNTAX("push%s %1");
5141 #line 338 "rx-decode.opc" 5140 #line 350 "rx-decode.opc"
5142 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F___ __; 5141 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F___ __;
5143 5142
5144 } 5143 }
5145 break; 5144 break;
5146 case 0xb0: 5145 case 0xb0:
5147 { 5146 {
5148 /** 0111 1110 1011 rdst pop %0 */ 5147 /** 0111 1110 1011 rdst pop %0 */
5149 #line 335 "rx-decode.opc" 5148 #line 347 "rx-decode.opc"
5150 int rdst AU = op[1] & 0x0f; 5149 int rdst AU = op[1] & 0x0f;
5151 if (trace) 5150 if (trace)
5152 { 5151 {
5153 printf ("\033[33m%s\033[0m %02x %02x\n", 5152 printf ("\033[33m%s\033[0m %02x %02x\n",
5154 "/** 0111 1110 1011 rdst pop %0 */", 5153 "/** 0111 1110 1011 rdst pop %0 */",
5155 op[0], op[1]); 5154 op[0], op[1]);
5156 printf (" rdst = 0x%x\n", rdst); 5155 printf (" rdst = 0x%x\n", rdst);
5157 } 5156 }
5158 SYNTAX("pop %0"); 5157 SYNTAX("pop %0");
5159 #line 335 "rx-decode.opc" 5158 #line 347 "rx-decode.opc"
5160 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____; 5159 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____;
5161 5160
5162 } 5161 }
5163 break; 5162 break;
5164 case 0xc0: 5163 case 0xc0:
5165 case 0xd0: 5164 case 0xd0:
5166 { 5165 {
5167 /** 0111 1110 110 crsrc pushc %1 */ 5166 /** 0111 1110 110 crsrc pushc %1 */
5168 #line 922 "rx-decode.opc" 5167 #line 934 "rx-decode.opc"
5169 int crsrc AU = op[1] & 0x1f; 5168 int crsrc AU = op[1] & 0x1f;
5170 if (trace) 5169 if (trace)
5171 { 5170 {
5172 printf ("\033[33m%s\033[0m %02x %02x\n", 5171 printf ("\033[33m%s\033[0m %02x %02x\n",
5173 "/** 0111 1110 110 crsrc pushc %1 */", 5172 "/** 0111 1110 110 crsrc pushc %1 */",
5174 op[0], op[1]); 5173 op[0], op[1]);
5175 printf (" crsrc = 0x%x\n", crsrc); 5174 printf (" crsrc = 0x%x\n", crsrc);
5176 } 5175 }
5177 SYNTAX("pushc %1"); 5176 SYNTAX("pushc %1");
5178 #line 922 "rx-decode.opc" 5177 #line 934 "rx-decode.opc"
5179 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16); 5178 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16);
5180 5179
5181 } 5180 }
5182 break; 5181 break;
5183 case 0xe0: 5182 case 0xe0:
5184 case 0xf0: 5183 case 0xf0:
5185 { 5184 {
5186 /** 0111 1110 111 crdst popc %0 */ 5185 /** 0111 1110 111 crdst popc %0 */
5187 #line 919 "rx-decode.opc" 5186 #line 931 "rx-decode.opc"
5188 int crdst AU = op[1] & 0x1f; 5187 int crdst AU = op[1] & 0x1f;
5189 if (trace) 5188 if (trace)
5190 { 5189 {
5191 printf ("\033[33m%s\033[0m %02x %02x\n", 5190 printf ("\033[33m%s\033[0m %02x %02x\n",
5192 "/** 0111 1110 111 crdst popc %0 */", 5191 "/** 0111 1110 111 crdst popc %0 */",
5193 op[0], op[1]); 5192 op[0], op[1]);
5194 printf (" crdst = 0x%x\n", crdst); 5193 printf (" crdst = 0x%x\n", crdst);
5195 } 5194 }
5196 SYNTAX("popc %0"); 5195 SYNTAX("popc %0");
5197 #line 919 "rx-decode.opc" 5196 #line 931 "rx-decode.opc"
5198 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16); 5197 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16);
5199 5198
5200 } 5199 }
5201 break; 5200 break;
5202 default: UNSUPPORTED(); break; 5201 default: UNSUPPORTED(); break;
5203 } 5202 }
5204 break; 5203 break;
5205 case 0x7f: 5204 case 0x7f:
5206 GETBYTE (); 5205 GETBYTE ();
5207 switch (op[1] & 0xff) 5206 switch (op[1] & 0xff)
5208 { 5207 {
5209 case 0x00: 5208 case 0x00:
5210 case 0x01: 5209 case 0x01:
5211 case 0x02: 5210 case 0x02:
5212 case 0x03: 5211 case 0x03:
5213 case 0x04: 5212 case 0x04:
5214 case 0x05: 5213 case 0x05:
5215 case 0x06: 5214 case 0x06:
5216 case 0x07: 5215 case 0x07:
5217 case 0x08: 5216 case 0x08:
5218 case 0x09: 5217 case 0x09:
5219 case 0x0a: 5218 case 0x0a:
5220 case 0x0b: 5219 case 0x0b:
5221 case 0x0c: 5220 case 0x0c:
5222 case 0x0d: 5221 case 0x0d:
5223 case 0x0e: 5222 case 0x0e:
5224 case 0x0f: 5223 case 0x0f:
5225 { 5224 {
5226 /** 0111 1111 0000 rsrc jmp %0 */ 5225 /** 0111 1111 0000 rsrc jmp %0 */
5227 #line 717 "rx-decode.opc" 5226 #line 729 "rx-decode.opc"
5228 int rsrc AU = op[1] & 0x0f; 5227 int rsrc AU = op[1] & 0x0f;
5229 if (trace) 5228 if (trace)
5230 { 5229 {
5231 printf ("\033[33m%s\033[0m %02x %02x\n", 5230 printf ("\033[33m%s\033[0m %02x %02x\n",
5232 "/** 0111 1111 0000 rsrc jmp %0 */", 5231 "/** 0111 1111 0000 rsrc jmp %0 */",
5233 op[0], op[1]); 5232 op[0], op[1]);
5234 printf (" rsrc = 0x%x\n", rsrc); 5233 printf (" rsrc = 0x%x\n", rsrc);
5235 } 5234 }
5236 SYNTAX("jmp %0"); 5235 SYNTAX("jmp %0");
5237 #line 717 "rx-decode.opc" 5236 #line 729 "rx-decode.opc"
5238 ID(branch); DR(rsrc); 5237 ID(branch); DR(rsrc);
5239 5238
5240 } 5239 }
5241 break; 5240 break;
5242 case 0x10: 5241 case 0x10:
5243 case 0x11: 5242 case 0x11:
5244 case 0x12: 5243 case 0x12:
5245 case 0x13: 5244 case 0x13:
5246 case 0x14: 5245 case 0x14:
5247 case 0x15: 5246 case 0x15:
5248 case 0x16: 5247 case 0x16:
5249 case 0x17: 5248 case 0x17:
5250 case 0x18: 5249 case 0x18:
5251 case 0x19: 5250 case 0x19:
5252 case 0x1a: 5251 case 0x1a:
5253 case 0x1b: 5252 case 0x1b:
5254 case 0x1c: 5253 case 0x1c:
5255 case 0x1d: 5254 case 0x1d:
5256 case 0x1e: 5255 case 0x1e:
5257 case 0x1f: 5256 case 0x1f:
5258 { 5257 {
5259 /** 0111 1111 0001 rsrc jsr %0 */ 5258 /** 0111 1111 0001 rsrc jsr %0 */
5260 #line 720 "rx-decode.opc" 5259 #line 732 "rx-decode.opc"
5261 int rsrc AU = op[1] & 0x0f; 5260 int rsrc AU = op[1] & 0x0f;
5262 if (trace) 5261 if (trace)
5263 { 5262 {
5264 printf ("\033[33m%s\033[0m %02x %02x\n", 5263 printf ("\033[33m%s\033[0m %02x %02x\n",
5265 "/** 0111 1111 0001 rsrc jsr %0 */", 5264 "/** 0111 1111 0001 rsrc jsr %0 */",
5266 op[0], op[1]); 5265 op[0], op[1]);
5267 printf (" rsrc = 0x%x\n", rsrc); 5266 printf (" rsrc = 0x%x\n", rsrc);
5268 } 5267 }
5269 SYNTAX("jsr %0"); 5268 SYNTAX("jsr %0");
5270 #line 720 "rx-decode.opc" 5269 #line 732 "rx-decode.opc"
5271 ID(jsr); DR(rsrc); 5270 ID(jsr); DR(rsrc);
5272 5271
5273 } 5272 }
5274 break; 5273 break;
5275 case 0x40: 5274 case 0x40:
5276 case 0x41: 5275 case 0x41:
5277 case 0x42: 5276 case 0x42:
5278 case 0x43: 5277 case 0x43:
5279 case 0x44: 5278 case 0x44:
5280 case 0x45: 5279 case 0x45:
5281 case 0x46: 5280 case 0x46:
5282 case 0x47: 5281 case 0x47:
5283 case 0x48: 5282 case 0x48:
5284 case 0x49: 5283 case 0x49:
5285 case 0x4a: 5284 case 0x4a:
5286 case 0x4b: 5285 case 0x4b:
5287 case 0x4c: 5286 case 0x4c:
5288 case 0x4d: 5287 case 0x4d:
5289 case 0x4e: 5288 case 0x4e:
5290 case 0x4f: 5289 case 0x4f:
5291 { 5290 {
5292 /** 0111 1111 0100 rsrc bra.l %0 */ 5291 /** 0111 1111 0100 rsrc bra.l %0 */
5293 #line 713 "rx-decode.opc" 5292 #line 725 "rx-decode.opc"
5294 int rsrc AU = op[1] & 0x0f; 5293 int rsrc AU = op[1] & 0x0f;
5295 if (trace) 5294 if (trace)
5296 { 5295 {
5297 printf ("\033[33m%s\033[0m %02x %02x\n", 5296 printf ("\033[33m%s\033[0m %02x %02x\n",
5298 "/** 0111 1111 0100 rsrc bra.l %0 */", 5297 "/** 0111 1111 0100 rsrc bra.l %0 */",
5299 op[0], op[1]); 5298 op[0], op[1]);
5300 printf (" rsrc = 0x%x\n", rsrc); 5299 printf (" rsrc = 0x%x\n", rsrc);
5301 } 5300 }
5302 SYNTAX("bra.l %0"); 5301 SYNTAX("bra.l %0");
5303 #line 713 "rx-decode.opc" 5302 #line 725 "rx-decode.opc"
5304 ID(branchrel); DR(rsrc); 5303 ID(branchrel); DR(rsrc);
5305 5304
5306 5305
5307 } 5306 }
5308 break; 5307 break;
5309 case 0x50: 5308 case 0x50:
5310 case 0x51: 5309 case 0x51:
5311 case 0x52: 5310 case 0x52:
5312 case 0x53: 5311 case 0x53:
5313 case 0x54: 5312 case 0x54:
5314 case 0x55: 5313 case 0x55:
5315 case 0x56: 5314 case 0x56:
5316 case 0x57: 5315 case 0x57:
5317 case 0x58: 5316 case 0x58:
5318 case 0x59: 5317 case 0x59:
5319 case 0x5a: 5318 case 0x5a:
5320 case 0x5b: 5319 case 0x5b:
5321 case 0x5c: 5320 case 0x5c:
5322 case 0x5d: 5321 case 0x5d:
5323 case 0x5e: 5322 case 0x5e:
5324 case 0x5f: 5323 case 0x5f:
5325 { 5324 {
5326 /** 0111 1111 0101 rsrc bsr.l %0 */ 5325 /** 0111 1111 0101 rsrc bsr.l %0 */
5327 #line 729 "rx-decode.opc" 5326 #line 741 "rx-decode.opc"
5328 int rsrc AU = op[1] & 0x0f; 5327 int rsrc AU = op[1] & 0x0f;
5329 if (trace) 5328 if (trace)
5330 { 5329 {
5331 printf ("\033[33m%s\033[0m %02x %02x\n", 5330 printf ("\033[33m%s\033[0m %02x %02x\n",
5332 "/** 0111 1111 0101 rsrc bsr.l %0 */", 5331 "/** 0111 1111 0101 rsrc bsr.l %0 */",
5333 op[0], op[1]); 5332 op[0], op[1]);
5334 printf (" rsrc = 0x%x\n", rsrc); 5333 printf (" rsrc = 0x%x\n", rsrc);
5335 } 5334 }
5336 SYNTAX("bsr.l %0"); 5335 SYNTAX("bsr.l %0");
5337 #line 729 "rx-decode.opc" 5336 #line 741 "rx-decode.opc"
5338 ID(jsrrel); DR(rsrc); 5337 ID(jsrrel); DR(rsrc);
5339 5338
5340 } 5339 }
5341 break; 5340 break;
5342 case 0x80: 5341 case 0x80:
5343 case 0x81: 5342 case 0x81:
5344 case 0x82: 5343 case 0x82:
5345 { 5344 {
5346 /** 0111 1111 1000 00sz suntil%s */ 5345 /** 0111 1111 1000 00sz suntil%s */
5347 #line 753 "rx-decode.opc" 5346 #line 765 "rx-decode.opc"
5348 int sz AU = op[1] & 0x03; 5347 int sz AU = op[1] & 0x03;
5349 if (trace) 5348 if (trace)
5350 { 5349 {
5351 printf ("\033[33m%s\033[0m %02x %02x\n", 5350 printf ("\033[33m%s\033[0m %02x %02x\n",
5352 "/** 0111 1111 1000 00sz suntil%s */", 5351 "/** 0111 1111 1000 00sz suntil%s */",
5353 op[0], op[1]); 5352 op[0], op[1]);
5354 printf (" sz = 0x%x\n", sz); 5353 printf (" sz = 0x%x\n", sz);
5355 } 5354 }
5356 SYNTAX("suntil%s"); 5355 SYNTAX("suntil%s");
5357 #line 753 "rx-decode.opc" 5356 #line 765 "rx-decode.opc"
5358 ID(suntil); BWL(sz); F___ZC; 5357 ID(suntil); BWL(sz); F___ZC;
5359 5358
5360 } 5359 }
5361 break; 5360 break;
5362 case 0x83: 5361 case 0x83:
5363 { 5362 {
5364 /** 0111 1111 1000 0011 scmpu */ 5363 /** 0111 1111 1000 0011 scmpu */
5365 if (trace) 5364 if (trace)
5366 { 5365 {
5367 printf ("\033[33m%s\033[0m %02x %02x\n", 5366 printf ("\033[33m%s\033[0m %02x %02x\n",
5368 "/** 0111 1111 1000 0011 scmpu */", 5367 "/** 0111 1111 1000 0011 scmpu */",
5369 op[0], op[1]); 5368 op[0], op[1]);
5370 } 5369 }
5371 SYNTAX("scmpu"); 5370 SYNTAX("scmpu");
5372 #line 744 "rx-decode.opc" 5371 #line 756 "rx-decode.opc"
5373 ID(scmpu); F___ZC; 5372 ID(scmpu); F___ZC;
5374 5373
5375 } 5374 }
5376 break; 5375 break;
5377 case 0x84: 5376 case 0x84:
5378 case 0x85: 5377 case 0x85:
5379 case 0x86: 5378 case 0x86:
5380 { 5379 {
5381 /** 0111 1111 1000 01sz swhile%s */ 5380 /** 0111 1111 1000 01sz swhile%s */
5382 #line 756 "rx-decode.opc" 5381 #line 768 "rx-decode.opc"
5383 int sz AU = op[1] & 0x03; 5382 int sz AU = op[1] & 0x03;
5384 if (trace) 5383 if (trace)
5385 { 5384 {
5386 printf ("\033[33m%s\033[0m %02x %02x\n", 5385 printf ("\033[33m%s\033[0m %02x %02x\n",
5387 "/** 0111 1111 1000 01sz swhile%s */", 5386 "/** 0111 1111 1000 01sz swhile%s */",
5388 op[0], op[1]); 5387 op[0], op[1]);
5389 printf (" sz = 0x%x\n", sz); 5388 printf (" sz = 0x%x\n", sz);
5390 } 5389 }
5391 SYNTAX("swhile%s"); 5390 SYNTAX("swhile%s");
5392 #line 756 "rx-decode.opc" 5391 #line 768 "rx-decode.opc"
5393 ID(swhile); BWL(sz); F___ZC; 5392 ID(swhile); BWL(sz); F___ZC;
5394 5393
5395 } 5394 }
5396 break; 5395 break;
5397 case 0x87: 5396 case 0x87:
5398 { 5397 {
5399 /** 0111 1111 1000 0111 smovu */ 5398 /** 0111 1111 1000 0111 smovu */
5400 if (trace) 5399 if (trace)
5401 { 5400 {
5402 printf ("\033[33m%s\033[0m %02x %02x\n", 5401 printf ("\033[33m%s\033[0m %02x %02x\n",
5403 "/** 0111 1111 1000 0111 smovu */", 5402 "/** 0111 1111 1000 0111 smovu */",
5404 op[0], op[1]); 5403 op[0], op[1]);
5405 } 5404 }
5406 SYNTAX("smovu"); 5405 SYNTAX("smovu");
5407 #line 747 "rx-decode.opc" 5406 #line 759 "rx-decode.opc"
5408 ID(smovu); 5407 ID(smovu);
5409 5408
5410 } 5409 }
5411 break; 5410 break;
5412 case 0x88: 5411 case 0x88:
5413 case 0x89: 5412 case 0x89:
5414 case 0x8a: 5413 case 0x8a:
5415 { 5414 {
5416 /** 0111 1111 1000 10sz sstr%s */ 5415 /** 0111 1111 1000 10sz sstr%s */
5417 #line 762 "rx-decode.opc" 5416 #line 774 "rx-decode.opc"
5418 int sz AU = op[1] & 0x03; 5417 int sz AU = op[1] & 0x03;
5419 if (trace) 5418 if (trace)
5420 { 5419 {
5421 printf ("\033[33m%s\033[0m %02x %02x\n", 5420 printf ("\033[33m%s\033[0m %02x %02x\n",
5422 "/** 0111 1111 1000 10sz sstr%s */", 5421 "/** 0111 1111 1000 10sz sstr%s */",
5423 op[0], op[1]); 5422 op[0], op[1]);
5424 printf (" sz = 0x%x\n", sz); 5423 printf (" sz = 0x%x\n", sz);
5425 } 5424 }
5426 SYNTAX("sstr%s"); 5425 SYNTAX("sstr%s");
5427 #line 762 "rx-decode.opc" 5426 #line 774 "rx-decode.opc"
5428 ID(sstr); BWL(sz); 5427 ID(sstr); BWL(sz);
5429 5428
5430 /*---------------------------------------------------------------- ------*/ 5429 /*---------------------------------------------------------------- ------*/
5431 /* RMPA */ 5430 /* RMPA */
5432 5431
5433 } 5432 }
5434 break; 5433 break;
5435 case 0x8b: 5434 case 0x8b:
5436 { 5435 {
5437 /** 0111 1111 1000 1011 smovb */ 5436 /** 0111 1111 1000 1011 smovb */
5438 if (trace) 5437 if (trace)
5439 { 5438 {
5440 printf ("\033[33m%s\033[0m %02x %02x\n", 5439 printf ("\033[33m%s\033[0m %02x %02x\n",
5441 "/** 0111 1111 1000 1011 smovb */", 5440 "/** 0111 1111 1000 1011 smovb */",
5442 op[0], op[1]); 5441 op[0], op[1]);
5443 } 5442 }
5444 SYNTAX("smovb"); 5443 SYNTAX("smovb");
5445 #line 750 "rx-decode.opc" 5444 #line 762 "rx-decode.opc"
5446 ID(smovb); 5445 ID(smovb);
5447 5446
5448 } 5447 }
5449 break; 5448 break;
5450 case 0x8c: 5449 case 0x8c:
5451 case 0x8d: 5450 case 0x8d:
5452 case 0x8e: 5451 case 0x8e:
5453 { 5452 {
5454 /** 0111 1111 1000 11sz rmpa%s */ 5453 /** 0111 1111 1000 11sz rmpa%s */
5455 #line 768 "rx-decode.opc" 5454 #line 780 "rx-decode.opc"
5456 int sz AU = op[1] & 0x03; 5455 int sz AU = op[1] & 0x03;
5457 if (trace) 5456 if (trace)
5458 { 5457 {
5459 printf ("\033[33m%s\033[0m %02x %02x\n", 5458 printf ("\033[33m%s\033[0m %02x %02x\n",
5460 "/** 0111 1111 1000 11sz rmpa%s */", 5459 "/** 0111 1111 1000 11sz rmpa%s */",
5461 op[0], op[1]); 5460 op[0], op[1]);
5462 printf (" sz = 0x%x\n", sz); 5461 printf (" sz = 0x%x\n", sz);
5463 } 5462 }
5464 SYNTAX("rmpa%s"); 5463 SYNTAX("rmpa%s");
5465 #line 768 "rx-decode.opc" 5464 #line 780 "rx-decode.opc"
5466 ID(rmpa); BWL(sz); F_OS__; 5465 ID(rmpa); BWL(sz); F_OS__;
5467 5466
5468 /*---------------------------------------------------------------- ------*/ 5467 /*---------------------------------------------------------------- ------*/
5469 /* HI/LO stuff */ 5468 /* HI/LO stuff */
5470 5469
5471 } 5470 }
5472 break; 5471 break;
5473 case 0x8f: 5472 case 0x8f:
5474 { 5473 {
5475 /** 0111 1111 1000 1111 smovf */ 5474 /** 0111 1111 1000 1111 smovf */
5476 if (trace) 5475 if (trace)
5477 { 5476 {
5478 printf ("\033[33m%s\033[0m %02x %02x\n", 5477 printf ("\033[33m%s\033[0m %02x %02x\n",
5479 "/** 0111 1111 1000 1111 smovf */", 5478 "/** 0111 1111 1000 1111 smovf */",
5480 op[0], op[1]); 5479 op[0], op[1]);
5481 } 5480 }
5482 SYNTAX("smovf"); 5481 SYNTAX("smovf");
5483 #line 759 "rx-decode.opc" 5482 #line 771 "rx-decode.opc"
5484 ID(smovf); 5483 ID(smovf);
5485 5484
5486 } 5485 }
5487 break; 5486 break;
5488 case 0x93: 5487 case 0x93:
5489 { 5488 {
5490 /** 0111 1111 1001 0011 satr */ 5489 /** 0111 1111 1001 0011 satr */
5491 if (trace) 5490 if (trace)
5492 { 5491 {
5493 printf ("\033[33m%s\033[0m %02x %02x\n", 5492 printf ("\033[33m%s\033[0m %02x %02x\n",
5494 "/** 0111 1111 1001 0011 satr */", 5493 "/** 0111 1111 1001 0011 satr */",
5495 op[0], op[1]); 5494 op[0], op[1]);
5496 } 5495 }
5497 SYNTAX("satr"); 5496 SYNTAX("satr");
5498 #line 810 "rx-decode.opc" 5497 #line 822 "rx-decode.opc"
5499 ID(satr); 5498 ID(satr);
5500 5499
5501 /*---------------------------------------------------------------- ------*/ 5500 /*---------------------------------------------------------------- ------*/
5502 /* FLOAT */ 5501 /* FLOAT */
5503 5502
5504 } 5503 }
5505 break; 5504 break;
5506 case 0x94: 5505 case 0x94:
5507 { 5506 {
5508 /** 0111 1111 1001 0100 rtfi */ 5507 /** 0111 1111 1001 0100 rtfi */
5509 if (trace) 5508 if (trace)
5510 { 5509 {
5511 printf ("\033[33m%s\033[0m %02x %02x\n", 5510 printf ("\033[33m%s\033[0m %02x %02x\n",
5512 "/** 0111 1111 1001 0100 rtfi */", 5511 "/** 0111 1111 1001 0100 rtfi */",
5513 op[0], op[1]); 5512 op[0], op[1]);
5514 } 5513 }
5515 SYNTAX("rtfi"); 5514 SYNTAX("rtfi");
5516 #line 937 "rx-decode.opc" 5515 #line 949 "rx-decode.opc"
5517 ID(rtfi); 5516 ID(rtfi);
5518 5517
5519 } 5518 }
5520 break; 5519 break;
5521 case 0x95: 5520 case 0x95:
5522 { 5521 {
5523 /** 0111 1111 1001 0101 rte */ 5522 /** 0111 1111 1001 0101 rte */
5524 if (trace) 5523 if (trace)
5525 { 5524 {
5526 printf ("\033[33m%s\033[0m %02x %02x\n", 5525 printf ("\033[33m%s\033[0m %02x %02x\n",
5527 "/** 0111 1111 1001 0101 rte */", 5526 "/** 0111 1111 1001 0101 rte */",
5528 op[0], op[1]); 5527 op[0], op[1]);
5529 } 5528 }
5530 SYNTAX("rte"); 5529 SYNTAX("rte");
5531 #line 940 "rx-decode.opc" 5530 #line 952 "rx-decode.opc"
5532 ID(rte); 5531 ID(rte);
5533 5532
5534 } 5533 }
5535 break; 5534 break;
5536 case 0x96: 5535 case 0x96:
5537 { 5536 {
5538 /** 0111 1111 1001 0110 wait */ 5537 /** 0111 1111 1001 0110 wait */
5539 if (trace) 5538 if (trace)
5540 { 5539 {
5541 printf ("\033[33m%s\033[0m %02x %02x\n", 5540 printf ("\033[33m%s\033[0m %02x %02x\n",
5542 "/** 0111 1111 1001 0110 wait */", 5541 "/** 0111 1111 1001 0110 wait */",
5543 op[0], op[1]); 5542 op[0], op[1]);
5544 } 5543 }
5545 SYNTAX("wait"); 5544 SYNTAX("wait");
5546 #line 952 "rx-decode.opc" 5545 #line 964 "rx-decode.opc"
5547 ID(wait); 5546 ID(wait);
5548 5547
5549 /*---------------------------------------------------------------- ------*/ 5548 /*---------------------------------------------------------------- ------*/
5550 /* SCcnd */ 5549 /* SCcnd */
5551 5550
5552 } 5551 }
5553 break; 5552 break;
5554 case 0xa0: 5553 case 0xa0:
5555 case 0xa1: 5554 case 0xa1:
5556 case 0xa2: 5555 case 0xa2:
5557 case 0xa3: 5556 case 0xa3:
5558 case 0xa4: 5557 case 0xa4:
5559 case 0xa5: 5558 case 0xa5:
5560 case 0xa6: 5559 case 0xa6:
5561 case 0xa7: 5560 case 0xa7:
5562 case 0xa8: 5561 case 0xa8:
5563 case 0xa9: 5562 case 0xa9:
5564 case 0xaa: 5563 case 0xaa:
5565 case 0xab: 5564 case 0xab:
5566 case 0xac: 5565 case 0xac:
5567 case 0xad: 5566 case 0xad:
5568 case 0xae: 5567 case 0xae:
5569 case 0xaf: 5568 case 0xaf:
5570 { 5569 {
5571 /** 0111 1111 1010 rdst setpsw %0 */ 5570 /** 0111 1111 1010 rdst setpsw %0 */
5572 #line 913 "rx-decode.opc" 5571 #line 925 "rx-decode.opc"
5573 int rdst AU = op[1] & 0x0f; 5572 int rdst AU = op[1] & 0x0f;
5574 if (trace) 5573 if (trace)
5575 { 5574 {
5576 printf ("\033[33m%s\033[0m %02x %02x\n", 5575 printf ("\033[33m%s\033[0m %02x %02x\n",
5577 "/** 0111 1111 1010 rdst setpsw %0 */", 5576 "/** 0111 1111 1010 rdst setpsw %0 */",
5578 op[0], op[1]); 5577 op[0], op[1]);
5579 printf (" rdst = 0x%x\n", rdst); 5578 printf (" rdst = 0x%x\n", rdst);
5580 } 5579 }
5581 SYNTAX("setpsw %0"); 5580 SYNTAX("setpsw %0");
5582 #line 913 "rx-decode.opc" 5581 #line 925 "rx-decode.opc"
5583 ID(setpsw); DF(rdst); 5582 ID(setpsw); DF(rdst);
5584 5583
5585 } 5584 }
5586 break; 5585 break;
5587 case 0xb0: 5586 case 0xb0:
5588 case 0xb1: 5587 case 0xb1:
5589 case 0xb2: 5588 case 0xb2:
5590 case 0xb3: 5589 case 0xb3:
5591 case 0xb4: 5590 case 0xb4:
5592 case 0xb5: 5591 case 0xb5:
5593 case 0xb6: 5592 case 0xb6:
5594 case 0xb7: 5593 case 0xb7:
5595 case 0xb8: 5594 case 0xb8:
5596 case 0xb9: 5595 case 0xb9:
5597 case 0xba: 5596 case 0xba:
5598 case 0xbb: 5597 case 0xbb:
5599 case 0xbc: 5598 case 0xbc:
5600 case 0xbd: 5599 case 0xbd:
5601 case 0xbe: 5600 case 0xbe:
5602 case 0xbf: 5601 case 0xbf:
5603 { 5602 {
5604 /** 0111 1111 1011 rdst clrpsw %0 */ 5603 /** 0111 1111 1011 rdst clrpsw %0 */
5605 #line 910 "rx-decode.opc" 5604 #line 922 "rx-decode.opc"
5606 int rdst AU = op[1] & 0x0f; 5605 int rdst AU = op[1] & 0x0f;
5607 if (trace) 5606 if (trace)
5608 { 5607 {
5609 printf ("\033[33m%s\033[0m %02x %02x\n", 5608 printf ("\033[33m%s\033[0m %02x %02x\n",
5610 "/** 0111 1111 1011 rdst clrpsw %0 */", 5609 "/** 0111 1111 1011 rdst clrpsw %0 */",
5611 op[0], op[1]); 5610 op[0], op[1]);
5612 printf (" rdst = 0x%x\n", rdst); 5611 printf (" rdst = 0x%x\n", rdst);
5613 } 5612 }
5614 SYNTAX("clrpsw %0"); 5613 SYNTAX("clrpsw %0");
5615 #line 910 "rx-decode.opc" 5614 #line 922 "rx-decode.opc"
5616 ID(clrpsw); DF(rdst); 5615 ID(clrpsw); DF(rdst);
5617 5616
5618 } 5617 }
5619 break; 5618 break;
5620 default: UNSUPPORTED(); break; 5619 default: UNSUPPORTED(); break;
5621 } 5620 }
5622 break; 5621 break;
5623 case 0x80: 5622 case 0x80:
5624 GETBYTE (); 5623 GETBYTE ();
5625 switch (op[1] & 0x00) 5624 switch (op[1] & 0x00)
5626 { 5625 {
5627 case 0x00: 5626 case 0x00:
5628 op_semantics_38: 5627 op_semantics_38:
5629 { 5628 {
5630 /** 10sz 0dsp a dst b src mov%s %1, %0 */ 5629 /** 10sz 0dsp a dst b src mov%s %1, %0 */
5631 #line 296 "rx-decode.opc" 5630 #line 308 "rx-decode.opc"
5632 int sz AU = (op[0] >> 4) & 0x03; 5631 int sz AU = (op[0] >> 4) & 0x03;
5633 #line 296 "rx-decode.opc" 5632 #line 308 "rx-decode.opc"
5634 int dsp AU = op[0] & 0x07; 5633 int dsp AU = op[0] & 0x07;
5635 #line 296 "rx-decode.opc" 5634 #line 308 "rx-decode.opc"
5636 int a AU = (op[1] >> 7) & 0x01; 5635 int a AU = (op[1] >> 7) & 0x01;
5637 #line 296 "rx-decode.opc" 5636 #line 308 "rx-decode.opc"
5638 int dst AU = (op[1] >> 4) & 0x07; 5637 int dst AU = (op[1] >> 4) & 0x07;
5639 #line 296 "rx-decode.opc" 5638 #line 308 "rx-decode.opc"
5640 int b AU = (op[1] >> 3) & 0x01; 5639 int b AU = (op[1] >> 3) & 0x01;
5641 #line 296 "rx-decode.opc" 5640 #line 308 "rx-decode.opc"
5642 int src AU = op[1] & 0x07; 5641 int src AU = op[1] & 0x07;
5643 if (trace) 5642 if (trace)
5644 { 5643 {
5645 printf ("\033[33m%s\033[0m %02x %02x\n", 5644 printf ("\033[33m%s\033[0m %02x %02x\n",
5646 "/** 10sz 0dsp a dst b src mov%s %1, %0 */", 5645 "/** 10sz 0dsp a dst b src mov%s %1, %0 */",
5647 op[0], op[1]); 5646 op[0], op[1]);
5648 printf (" sz = 0x%x,", sz); 5647 printf (" sz = 0x%x,", sz);
5649 printf (" dsp = 0x%x,", dsp); 5648 printf (" dsp = 0x%x,", dsp);
5650 printf (" a = 0x%x,", a); 5649 printf (" a = 0x%x,", a);
5651 printf (" dst = 0x%x,", dst); 5650 printf (" dst = 0x%x,", dst);
5652 printf (" b = 0x%x,", b); 5651 printf (" b = 0x%x,", b);
5653 printf (" src = 0x%x\n", src); 5652 printf (" src = 0x%x\n", src);
5654 } 5653 }
5655 SYNTAX("mov%s %1, %0"); 5654 SYNTAX("mov%s %1, %0");
5656 #line 296 "rx-decode.opc" 5655 #line 308 "rx-decode.opc"
5657 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____; 5656 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____;
5658 5657
5659 } 5658 }
5660 break; 5659 break;
5661 } 5660 }
5662 break; 5661 break;
5663 case 0x81: 5662 case 0x81:
5664 GETBYTE (); 5663 GETBYTE ();
5665 switch (op[1] & 0x00) 5664 switch (op[1] & 0x00)
5666 { 5665 {
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after
5724 } 5723 }
5725 break; 5724 break;
5726 case 0x88: 5725 case 0x88:
5727 GETBYTE (); 5726 GETBYTE ();
5728 switch (op[1] & 0x00) 5727 switch (op[1] & 0x00)
5729 { 5728 {
5730 case 0x00: 5729 case 0x00:
5731 op_semantics_39: 5730 op_semantics_39:
5732 { 5731 {
5733 /** 10sz 1dsp a src b dst mov%s %1, %0 */ 5732 /** 10sz 1dsp a src b dst mov%s %1, %0 */
5734 #line 293 "rx-decode.opc" 5733 #line 305 "rx-decode.opc"
5735 int sz AU = (op[0] >> 4) & 0x03; 5734 int sz AU = (op[0] >> 4) & 0x03;
5736 #line 293 "rx-decode.opc" 5735 #line 305 "rx-decode.opc"
5737 int dsp AU = op[0] & 0x07; 5736 int dsp AU = op[0] & 0x07;
5738 #line 293 "rx-decode.opc" 5737 #line 305 "rx-decode.opc"
5739 int a AU = (op[1] >> 7) & 0x01; 5738 int a AU = (op[1] >> 7) & 0x01;
5740 #line 293 "rx-decode.opc" 5739 #line 305 "rx-decode.opc"
5741 int src AU = (op[1] >> 4) & 0x07; 5740 int src AU = (op[1] >> 4) & 0x07;
5742 #line 293 "rx-decode.opc" 5741 #line 305 "rx-decode.opc"
5743 int b AU = (op[1] >> 3) & 0x01; 5742 int b AU = (op[1] >> 3) & 0x01;
5744 #line 293 "rx-decode.opc" 5743 #line 305 "rx-decode.opc"
5745 int dst AU = op[1] & 0x07; 5744 int dst AU = op[1] & 0x07;
5746 if (trace) 5745 if (trace)
5747 { 5746 {
5748 printf ("\033[33m%s\033[0m %02x %02x\n", 5747 printf ("\033[33m%s\033[0m %02x %02x\n",
5749 "/** 10sz 1dsp a src b dst mov%s %1, %0 */", 5748 "/** 10sz 1dsp a src b dst mov%s %1, %0 */",
5750 op[0], op[1]); 5749 op[0], op[1]);
5751 printf (" sz = 0x%x,", sz); 5750 printf (" sz = 0x%x,", sz);
5752 printf (" dsp = 0x%x,", dsp); 5751 printf (" dsp = 0x%x,", dsp);
5753 printf (" a = 0x%x,", a); 5752 printf (" a = 0x%x,", a);
5754 printf (" src = 0x%x,", src); 5753 printf (" src = 0x%x,", src);
5755 printf (" b = 0x%x,", b); 5754 printf (" b = 0x%x,", b);
5756 printf (" dst = 0x%x\n", dst); 5755 printf (" dst = 0x%x\n", dst);
5757 } 5756 }
5758 SYNTAX("mov%s %1, %0"); 5757 SYNTAX("mov%s %1, %0");
5759 #line 293 "rx-decode.opc" 5758 #line 305 "rx-decode.opc"
5760 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____; 5759 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____;
5761 5760
5762 } 5761 }
5763 break; 5762 break;
5764 } 5763 }
5765 break; 5764 break;
5766 case 0x89: 5765 case 0x89:
5767 GETBYTE (); 5766 GETBYTE ();
5768 switch (op[1] & 0x00) 5767 switch (op[1] & 0x00)
5769 { 5768 {
(...skipping 345 matching lines...) Expand 10 before | Expand all | Expand 10 after
6115 } 6114 }
6116 break; 6115 break;
6117 case 0xb0: 6116 case 0xb0:
6118 GETBYTE (); 6117 GETBYTE ();
6119 switch (op[1] & 0x00) 6118 switch (op[1] & 0x00)
6120 { 6119 {
6121 case 0x00: 6120 case 0x00:
6122 op_semantics_40: 6121 op_semantics_40:
6123 { 6122 {
6124 /** 1011 w dsp a src b dst movu%s %1, %0 */ 6123 /** 1011 w dsp a src b dst movu%s %1, %0 */
6125 #line 316 "rx-decode.opc" 6124 #line 328 "rx-decode.opc"
6126 int w AU = (op[0] >> 3) & 0x01; 6125 int w AU = (op[0] >> 3) & 0x01;
6127 #line 316 "rx-decode.opc" 6126 #line 328 "rx-decode.opc"
6128 int dsp AU = op[0] & 0x07; 6127 int dsp AU = op[0] & 0x07;
6129 #line 316 "rx-decode.opc" 6128 #line 328 "rx-decode.opc"
6130 int a AU = (op[1] >> 7) & 0x01; 6129 int a AU = (op[1] >> 7) & 0x01;
6131 #line 316 "rx-decode.opc" 6130 #line 328 "rx-decode.opc"
6132 int src AU = (op[1] >> 4) & 0x07; 6131 int src AU = (op[1] >> 4) & 0x07;
6133 #line 316 "rx-decode.opc" 6132 #line 328 "rx-decode.opc"
6134 int b AU = (op[1] >> 3) & 0x01; 6133 int b AU = (op[1] >> 3) & 0x01;
6135 #line 316 "rx-decode.opc" 6134 #line 328 "rx-decode.opc"
6136 int dst AU = op[1] & 0x07; 6135 int dst AU = op[1] & 0x07;
6137 if (trace) 6136 if (trace)
6138 { 6137 {
6139 printf ("\033[33m%s\033[0m %02x %02x\n", 6138 printf ("\033[33m%s\033[0m %02x %02x\n",
6140 "/** 1011 w dsp a src b dst movu%s %1, %0 */", 6139 "/** 1011 w dsp a src b dst movu%s %1, %0 */",
6141 op[0], op[1]); 6140 op[0], op[1]);
6142 printf (" w = 0x%x,", w); 6141 printf (" w = 0x%x,", w);
6143 printf (" dsp = 0x%x,", dsp); 6142 printf (" dsp = 0x%x,", dsp);
6144 printf (" a = 0x%x,", a); 6143 printf (" a = 0x%x,", a);
6145 printf (" src = 0x%x,", src); 6144 printf (" src = 0x%x,", src);
6146 printf (" b = 0x%x,", b); 6145 printf (" b = 0x%x,", b);
6147 printf (" dst = 0x%x\n", dst); 6146 printf (" dst = 0x%x\n", dst);
6148 } 6147 }
6149 SYNTAX("movu%s %1, %0"); 6148 SYNTAX("movu%s %1, %0");
6150 #line 316 "rx-decode.opc" 6149 #line 328 "rx-decode.opc"
6151 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____; 6150 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____;
6152 6151
6153 } 6152 }
6154 break; 6153 break;
6155 } 6154 }
6156 break; 6155 break;
6157 case 0xb1: 6156 case 0xb1:
6158 GETBYTE (); 6157 GETBYTE ();
6159 switch (op[1] & 0x00) 6158 switch (op[1] & 0x00)
6160 { 6159 {
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after
6290 } 6289 }
6291 break; 6290 break;
6292 case 0xc0: 6291 case 0xc0:
6293 GETBYTE (); 6292 GETBYTE ();
6294 switch (op[1] & 0x00) 6293 switch (op[1] & 0x00)
6295 { 6294 {
6296 case 0x00: 6295 case 0x00:
6297 op_semantics_41: 6296 op_semantics_41:
6298 { 6297 {
6299 /** 11sz sd ss rsrc rdst mov%s %1, %0 */ 6298 /** 11sz sd ss rsrc rdst mov%s %1, %0 */
6300 #line 274 "rx-decode.opc" 6299 #line 286 "rx-decode.opc"
6301 int sz AU = (op[0] >> 4) & 0x03; 6300 int sz AU = (op[0] >> 4) & 0x03;
6302 #line 274 "rx-decode.opc" 6301 #line 286 "rx-decode.opc"
6303 int sd AU = (op[0] >> 2) & 0x03; 6302 int sd AU = (op[0] >> 2) & 0x03;
6304 #line 274 "rx-decode.opc" 6303 #line 286 "rx-decode.opc"
6305 int ss AU = op[0] & 0x03; 6304 int ss AU = op[0] & 0x03;
6306 #line 274 "rx-decode.opc" 6305 #line 286 "rx-decode.opc"
6307 int rsrc AU = (op[1] >> 4) & 0x0f; 6306 int rsrc AU = (op[1] >> 4) & 0x0f;
6308 #line 274 "rx-decode.opc" 6307 #line 286 "rx-decode.opc"
6309 int rdst AU = op[1] & 0x0f; 6308 int rdst AU = op[1] & 0x0f;
6310 if (trace) 6309 if (trace)
6311 { 6310 {
6312 printf ("\033[33m%s\033[0m %02x %02x\n", 6311 printf ("\033[33m%s\033[0m %02x %02x\n",
6313 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */", 6312 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */",
6314 op[0], op[1]); 6313 op[0], op[1]);
6315 printf (" sz = 0x%x,", sz); 6314 printf (" sz = 0x%x,", sz);
6316 printf (" sd = 0x%x,", sd); 6315 printf (" sd = 0x%x,", sd);
6317 printf (" ss = 0x%x,", ss); 6316 printf (" ss = 0x%x,", ss);
6318 printf (" rsrc = 0x%x,", rsrc); 6317 printf (" rsrc = 0x%x,", rsrc);
6319 printf (" rdst = 0x%x\n", rdst); 6318 printf (" rdst = 0x%x\n", rdst);
6320 } 6319 }
6321 SYNTAX("mov%s %1, %0"); 6320 SYNTAX("mov%s %1, %0");
6322 #line 274 "rx-decode.opc" 6321 #line 286 "rx-decode.opc"
6323 if (ss == 3 && sz == 2 && rsrc == 0 && rdst == 0) 6322 if (ss == 3 && sz == 2 && rsrc == 0 && rdst == 0)
6324 { 6323 {
6325 ID(nop2); 6324 ID(nop2);
6326 rx->syntax = "nop"; 6325 rx->syntax = "nop";
6327 } 6326 }
6328 else 6327 else
6329 { 6328 {
6330 ID(mov); sBWL(sz); F_____; 6329 ID(mov); sBWL(sz); F_____;
6331 if ((ss == 3) && (sd != 3)) 6330 if ((ss == 3) && (sd != 3))
6332 { 6331 {
(...skipping 433 matching lines...) Expand 10 before | Expand all | Expand 10 after
6766 } 6765 }
6767 break; 6766 break;
6768 case 0xf0: 6767 case 0xf0:
6769 GETBYTE (); 6768 GETBYTE ();
6770 switch (op[1] & 0x08) 6769 switch (op[1] & 0x08)
6771 { 6770 {
6772 case 0x00: 6771 case 0x00:
6773 op_semantics_42: 6772 op_semantics_42:
6774 { 6773 {
6775 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */ 6774 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */
6776 #line 861 "rx-decode.opc" 6775 #line 873 "rx-decode.opc"
6777 int sd AU = op[0] & 0x03; 6776 int sd AU = op[0] & 0x03;
6778 #line 861 "rx-decode.opc" 6777 #line 873 "rx-decode.opc"
6779 int rdst AU = (op[1] >> 4) & 0x0f; 6778 int rdst AU = (op[1] >> 4) & 0x0f;
6780 #line 861 "rx-decode.opc" 6779 #line 873 "rx-decode.opc"
6781 int bit AU = op[1] & 0x07; 6780 int bit AU = op[1] & 0x07;
6782 if (trace) 6781 if (trace)
6783 { 6782 {
6784 printf ("\033[33m%s\033[0m %02x %02x\n", 6783 printf ("\033[33m%s\033[0m %02x %02x\n",
6785 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */", 6784 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */",
6786 op[0], op[1]); 6785 op[0], op[1]);
6787 printf (" sd = 0x%x,", sd); 6786 printf (" sd = 0x%x,", sd);
6788 printf (" rdst = 0x%x,", rdst); 6787 printf (" rdst = 0x%x,", rdst);
6789 printf (" bit = 0x%x\n", bit); 6788 printf (" bit = 0x%x\n", bit);
6790 } 6789 }
6791 SYNTAX("bset #%1, %0%S0"); 6790 SYNTAX("bset #%1, %0%S0");
6792 #line 861 "rx-decode.opc" 6791 #line 873 "rx-decode.opc"
6793 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 6792 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6794 6793
6795 } 6794 }
6796 break; 6795 break;
6797 case 0x08: 6796 case 0x08:
6798 op_semantics_43: 6797 op_semantics_43:
6799 { 6798 {
6800 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */ 6799 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */
6801 #line 871 "rx-decode.opc" 6800 #line 883 "rx-decode.opc"
6802 int sd AU = op[0] & 0x03; 6801 int sd AU = op[0] & 0x03;
6803 #line 871 "rx-decode.opc" 6802 #line 883 "rx-decode.opc"
6804 int rdst AU = (op[1] >> 4) & 0x0f; 6803 int rdst AU = (op[1] >> 4) & 0x0f;
6805 #line 871 "rx-decode.opc" 6804 #line 883 "rx-decode.opc"
6806 int bit AU = op[1] & 0x07; 6805 int bit AU = op[1] & 0x07;
6807 if (trace) 6806 if (trace)
6808 { 6807 {
6809 printf ("\033[33m%s\033[0m %02x %02x\n", 6808 printf ("\033[33m%s\033[0m %02x %02x\n",
6810 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */", 6809 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */",
6811 op[0], op[1]); 6810 op[0], op[1]);
6812 printf (" sd = 0x%x,", sd); 6811 printf (" sd = 0x%x,", sd);
6813 printf (" rdst = 0x%x,", rdst); 6812 printf (" rdst = 0x%x,", rdst);
6814 printf (" bit = 0x%x\n", bit); 6813 printf (" bit = 0x%x\n", bit);
6815 } 6814 }
6816 SYNTAX("bclr #%1, %0%S0"); 6815 SYNTAX("bclr #%1, %0%S0");
6817 #line 871 "rx-decode.opc" 6816 #line 883 "rx-decode.opc"
6818 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 6817 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____;
6819 6818
6820 } 6819 }
6821 break; 6820 break;
6822 } 6821 }
6823 break; 6822 break;
6824 case 0xf1: 6823 case 0xf1:
6825 GETBYTE (); 6824 GETBYTE ();
6826 switch (op[1] & 0x08) 6825 switch (op[1] & 0x08)
6827 { 6826 {
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
6859 break; 6858 break;
6860 case 0xf4: 6859 case 0xf4:
6861 GETBYTE (); 6860 GETBYTE ();
6862 switch (op[1] & 0x0c) 6861 switch (op[1] & 0x0c)
6863 { 6862 {
6864 case 0x00: 6863 case 0x00:
6865 case 0x04: 6864 case 0x04:
6866 op_semantics_44: 6865 op_semantics_44:
6867 { 6866 {
6868 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */ 6867 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */
6869 #line 881 "rx-decode.opc" 6868 #line 893 "rx-decode.opc"
6870 int sd AU = op[0] & 0x03; 6869 int sd AU = op[0] & 0x03;
6871 #line 881 "rx-decode.opc" 6870 #line 893 "rx-decode.opc"
6872 int rdst AU = (op[1] >> 4) & 0x0f; 6871 int rdst AU = (op[1] >> 4) & 0x0f;
6873 #line 881 "rx-decode.opc" 6872 #line 893 "rx-decode.opc"
6874 int bit AU = op[1] & 0x07; 6873 int bit AU = op[1] & 0x07;
6875 if (trace) 6874 if (trace)
6876 { 6875 {
6877 printf ("\033[33m%s\033[0m %02x %02x\n", 6876 printf ("\033[33m%s\033[0m %02x %02x\n",
6878 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */", 6877 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */",
6879 op[0], op[1]); 6878 op[0], op[1]);
6880 printf (" sd = 0x%x,", sd); 6879 printf (" sd = 0x%x,", sd);
6881 printf (" rdst = 0x%x,", rdst); 6880 printf (" rdst = 0x%x,", rdst);
6882 printf (" bit = 0x%x\n", bit); 6881 printf (" bit = 0x%x\n", bit);
6883 } 6882 }
6884 SYNTAX("btst #%2, %1%S1"); 6883 SYNTAX("btst #%2, %1%S1");
6885 #line 881 "rx-decode.opc" 6884 #line 893 "rx-decode.opc"
6886 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC; 6885 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC;
6887 6886
6888 } 6887 }
6889 break; 6888 break;
6890 case 0x08: 6889 case 0x08:
6891 op_semantics_45: 6890 op_semantics_45:
6892 { 6891 {
6893 /** 1111 01ss rsrc 10sz push%s %1 */ 6892 /** 1111 01ss rsrc 10sz push%s %1 */
6894 #line 341 "rx-decode.opc" 6893 #line 353 "rx-decode.opc"
6895 int ss AU = op[0] & 0x03; 6894 int ss AU = op[0] & 0x03;
6896 #line 341 "rx-decode.opc" 6895 #line 353 "rx-decode.opc"
6897 int rsrc AU = (op[1] >> 4) & 0x0f; 6896 int rsrc AU = (op[1] >> 4) & 0x0f;
6898 #line 341 "rx-decode.opc" 6897 #line 353 "rx-decode.opc"
6899 int sz AU = op[1] & 0x03; 6898 int sz AU = op[1] & 0x03;
6900 if (trace) 6899 if (trace)
6901 { 6900 {
6902 printf ("\033[33m%s\033[0m %02x %02x\n", 6901 printf ("\033[33m%s\033[0m %02x %02x\n",
6903 "/** 1111 01ss rsrc 10sz push%s %1 */", 6902 "/** 1111 01ss rsrc 10sz push%s %1 */",
6904 op[0], op[1]); 6903 op[0], op[1]);
6905 printf (" ss = 0x%x,", ss); 6904 printf (" ss = 0x%x,", ss);
6906 printf (" rsrc = 0x%x,", rsrc); 6905 printf (" rsrc = 0x%x,", rsrc);
6907 printf (" sz = 0x%x\n", sz); 6906 printf (" sz = 0x%x\n", sz);
6908 } 6907 }
6909 SYNTAX("push%s %1"); 6908 SYNTAX("push%s %1");
6910 #line 341 "rx-decode.opc" 6909 #line 353 "rx-decode.opc"
6911 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, s z); F_____; 6910 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, s z); F_____;
6912 6911
6913 /*---------------------------------------------------------------- ------*/ 6912 /*---------------------------------------------------------------- ------*/
6914 /* XCHG */ 6913 /* XCHG */
6915 6914
6916 } 6915 }
6917 break; 6916 break;
6918 default: UNSUPPORTED(); break; 6917 default: UNSUPPORTED(); break;
6919 } 6918 }
6920 break; 6919 break;
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
6961 } 6960 }
6962 break; 6961 break;
6963 case 0xf8: 6962 case 0xf8:
6964 GETBYTE (); 6963 GETBYTE ();
6965 switch (op[1] & 0x00) 6964 switch (op[1] & 0x00)
6966 { 6965 {
6967 case 0x00: 6966 case 0x00:
6968 op_semantics_46: 6967 op_semantics_46:
6969 { 6968 {
6970 /** 1111 10sd rdst im sz mov%s #%1, %0 */ 6969 /** 1111 10sd rdst im sz mov%s #%1, %0 */
6971 #line 265 "rx-decode.opc" 6970 #line 264 "rx-decode.opc"
6972 int sd AU = op[0] & 0x03; 6971 int sd AU = op[0] & 0x03;
6973 #line 265 "rx-decode.opc" 6972 #line 264 "rx-decode.opc"
6974 int rdst AU = (op[1] >> 4) & 0x0f; 6973 int rdst AU = (op[1] >> 4) & 0x0f;
6975 #line 265 "rx-decode.opc" 6974 #line 264 "rx-decode.opc"
6976 int im AU = (op[1] >> 2) & 0x03; 6975 int im AU = (op[1] >> 2) & 0x03;
6977 #line 265 "rx-decode.opc" 6976 #line 264 "rx-decode.opc"
6978 int sz AU = op[1] & 0x03; 6977 int sz AU = op[1] & 0x03;
6979 if (trace) 6978 if (trace)
6980 { 6979 {
6981 printf ("\033[33m%s\033[0m %02x %02x\n", 6980 printf ("\033[33m%s\033[0m %02x %02x\n",
6982 "/** 1111 10sd rdst im sz mov%s #%1, %0 */", 6981 "/** 1111 10sd rdst im sz mov%s #%1, %0 */",
6983 op[0], op[1]); 6982 op[0], op[1]);
6984 printf (" sd = 0x%x,", sd); 6983 printf (" sd = 0x%x,", sd);
6985 printf (" rdst = 0x%x,", rdst); 6984 printf (" rdst = 0x%x,", rdst);
6986 printf (" im = 0x%x,", im); 6985 printf (" im = 0x%x,", im);
6987 printf (" sz = 0x%x\n", sz); 6986 printf (" sz = 0x%x\n", sz);
6988 } 6987 }
6989 SYNTAX("mov%s #%1, %0"); 6988 SYNTAX("mov%s #%1, %0");
6990 #line 265 "rx-decode.opc" 6989 #line 264 "rx-decode.opc"
6991 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F_____; 6990 ID(mov); DD(sd, rdst, sz);
6991 if ((im == 1 && sz == 0)
6992 || (im == 2 && sz == 1)
6993 || (im == 0 && sz == 2))
6994 {
6995 BWL (sz);
6996 SC(IMM(im));
6997 }
6998 else
6999 {
7000 sBWL (sz);
7001 SC(IMMex(im));
7002 }
7003 F_____;
6992 7004
6993 } 7005 }
6994 break; 7006 break;
6995 } 7007 }
6996 break; 7008 break;
6997 case 0xf9: 7009 case 0xf9:
6998 GETBYTE (); 7010 GETBYTE ();
6999 switch (op[1] & 0x00) 7011 switch (op[1] & 0x00)
7000 { 7012 {
7001 case 0x00: 7013 case 0x00:
(...skipping 23 matching lines...) Expand all
7025 GETBYTE (); 7037 GETBYTE ();
7026 switch (op[1] & 0xff) 7038 switch (op[1] & 0xff)
7027 { 7039 {
7028 case 0x03: 7040 case 0x03:
7029 GETBYTE (); 7041 GETBYTE ();
7030 switch (op[2] & 0x00) 7042 switch (op[2] & 0x00)
7031 { 7043 {
7032 case 0x00: 7044 case 0x00:
7033 { 7045 {
7034 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */ 7046 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */
7035 #line 515 "rx-decode.opc" 7047 #line 527 "rx-decode.opc"
7036 int rsrc AU = (op[2] >> 4) & 0x0f; 7048 int rsrc AU = (op[2] >> 4) & 0x0f;
7037 #line 515 "rx-decode.opc" 7049 #line 527 "rx-decode.opc"
7038 int rdst AU = op[2] & 0x0f; 7050 int rdst AU = op[2] & 0x0f;
7039 if (trace) 7051 if (trace)
7040 { 7052 {
7041 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7053 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7042 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */", 7054 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */",
7043 op[0], op[1], op[2]); 7055 op[0], op[1], op[2]);
7044 printf (" rsrc = 0x%x,", rsrc); 7056 printf (" rsrc = 0x%x,", rsrc);
7045 printf (" rdst = 0x%x\n", rdst); 7057 printf (" rdst = 0x%x\n", rdst);
7046 } 7058 }
7047 SYNTAX("sbb %1, %0"); 7059 SYNTAX("sbb %1, %0");
7048 #line 515 "rx-decode.opc" 7060 #line 527 "rx-decode.opc"
7049 ID(sbb); SR (rsrc); DR(rdst); F_OSZC; 7061 ID(sbb); SR (rsrc); DR(rdst); F_OSZC;
7050 7062
7051 /* FIXME: only supports .L */ 7063 /* FIXME: only supports .L */
7052 } 7064 }
7053 break; 7065 break;
7054 } 7066 }
7055 break; 7067 break;
7056 case 0x07: 7068 case 0x07:
7057 GETBYTE (); 7069 GETBYTE ();
7058 switch (op[2] & 0x00) 7070 switch (op[2] & 0x00)
7059 { 7071 {
7060 case 0x00: 7072 case 0x00:
7061 { 7073 {
7062 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */ 7074 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */
7063 #line 446 "rx-decode.opc" 7075 #line 458 "rx-decode.opc"
7064 int rsrc AU = (op[2] >> 4) & 0x0f; 7076 int rsrc AU = (op[2] >> 4) & 0x0f;
7065 #line 446 "rx-decode.opc" 7077 #line 458 "rx-decode.opc"
7066 int rdst AU = op[2] & 0x0f; 7078 int rdst AU = op[2] & 0x0f;
7067 if (trace) 7079 if (trace)
7068 { 7080 {
7069 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7081 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7070 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */", 7082 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */",
7071 op[0], op[1], op[2]); 7083 op[0], op[1], op[2]);
7072 printf (" rsrc = 0x%x,", rsrc); 7084 printf (" rsrc = 0x%x,", rsrc);
7073 printf (" rdst = 0x%x\n", rdst); 7085 printf (" rdst = 0x%x\n", rdst);
7074 } 7086 }
7075 SYNTAX("neg %2, %0"); 7087 SYNTAX("neg %2, %0");
7076 #line 446 "rx-decode.opc" 7088 #line 458 "rx-decode.opc"
7077 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC; 7089 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC;
7078 7090
7079 /*---------------------------------------------------------- ------------*/ 7091 /*---------------------------------------------------------- ------------*/
7080 /* ADC */ 7092 /* ADC */
7081 7093
7082 } 7094 }
7083 break; 7095 break;
7084 } 7096 }
7085 break; 7097 break;
7086 case 0x0b: 7098 case 0x0b:
7087 GETBYTE (); 7099 GETBYTE ();
7088 switch (op[2] & 0x00) 7100 switch (op[2] & 0x00)
7089 { 7101 {
7090 case 0x00: 7102 case 0x00:
7091 { 7103 {
7092 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */ 7104 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */
7093 #line 455 "rx-decode.opc" 7105 #line 467 "rx-decode.opc"
7094 int rsrc AU = (op[2] >> 4) & 0x0f; 7106 int rsrc AU = (op[2] >> 4) & 0x0f;
7095 #line 455 "rx-decode.opc" 7107 #line 467 "rx-decode.opc"
7096 int rdst AU = op[2] & 0x0f; 7108 int rdst AU = op[2] & 0x0f;
7097 if (trace) 7109 if (trace)
7098 { 7110 {
7099 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7111 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7100 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */", 7112 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */",
7101 op[0], op[1], op[2]); 7113 op[0], op[1], op[2]);
7102 printf (" rsrc = 0x%x,", rsrc); 7114 printf (" rsrc = 0x%x,", rsrc);
7103 printf (" rdst = 0x%x\n", rdst); 7115 printf (" rdst = 0x%x\n", rdst);
7104 } 7116 }
7105 SYNTAX("adc %1, %0"); 7117 SYNTAX("adc %1, %0");
7106 #line 455 "rx-decode.opc" 7118 #line 467 "rx-decode.opc"
7107 ID(adc); SR(rsrc); DR(rdst); F_OSZC; 7119 ID(adc); SR(rsrc); DR(rdst); F_OSZC;
7108 7120
7109 } 7121 }
7110 break; 7122 break;
7111 } 7123 }
7112 break; 7124 break;
7113 case 0x0f: 7125 case 0x0f:
7114 GETBYTE (); 7126 GETBYTE ();
7115 switch (op[2] & 0x00) 7127 switch (op[2] & 0x00)
7116 { 7128 {
7117 case 0x00: 7129 case 0x00:
7118 { 7130 {
7119 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */ 7131 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */
7120 #line 528 "rx-decode.opc" 7132 #line 540 "rx-decode.opc"
7121 int rsrc AU = (op[2] >> 4) & 0x0f; 7133 int rsrc AU = (op[2] >> 4) & 0x0f;
7122 #line 528 "rx-decode.opc" 7134 #line 540 "rx-decode.opc"
7123 int rdst AU = op[2] & 0x0f; 7135 int rdst AU = op[2] & 0x0f;
7124 if (trace) 7136 if (trace)
7125 { 7137 {
7126 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7138 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7127 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */", 7139 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */",
7128 op[0], op[1], op[2]); 7140 op[0], op[1], op[2]);
7129 printf (" rsrc = 0x%x,", rsrc); 7141 printf (" rsrc = 0x%x,", rsrc);
7130 printf (" rdst = 0x%x\n", rdst); 7142 printf (" rdst = 0x%x\n", rdst);
7131 } 7143 }
7132 SYNTAX("abs %1, %0"); 7144 SYNTAX("abs %1, %0");
7133 #line 528 "rx-decode.opc" 7145 #line 540 "rx-decode.opc"
7134 ID(abs); DR(rdst); SR(rsrc); F_OSZ_; 7146 ID(abs); DR(rdst); SR(rsrc); F_OSZ_;
7135 7147
7136 /*---------------------------------------------------------- ------------*/ 7148 /*---------------------------------------------------------- ------------*/
7137 /* MAX */ 7149 /* MAX */
7138 7150
7139 } 7151 }
7140 break; 7152 break;
7141 } 7153 }
7142 break; 7154 break;
7143 case 0x10: 7155 case 0x10:
7144 GETBYTE (); 7156 GETBYTE ();
7145 switch (op[2] & 0x00) 7157 switch (op[2] & 0x00)
7146 { 7158 {
7147 case 0x00: 7159 case 0x00:
7148 op_semantics_47: 7160 op_semantics_47:
7149 { 7161 {
7150 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */ 7162 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */
7151 #line 537 "rx-decode.opc" 7163 #line 549 "rx-decode.opc"
7152 int ss AU = op[1] & 0x03; 7164 int ss AU = op[1] & 0x03;
7153 #line 537 "rx-decode.opc" 7165 #line 549 "rx-decode.opc"
7154 int rsrc AU = (op[2] >> 4) & 0x0f; 7166 int rsrc AU = (op[2] >> 4) & 0x0f;
7155 #line 537 "rx-decode.opc" 7167 #line 549 "rx-decode.opc"
7156 int rdst AU = op[2] & 0x0f; 7168 int rdst AU = op[2] & 0x0f;
7157 if (trace) 7169 if (trace)
7158 { 7170 {
7159 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7171 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7160 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */", 7172 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */",
7161 op[0], op[1], op[2]); 7173 op[0], op[1], op[2]);
7162 printf (" ss = 0x%x,", ss); 7174 printf (" ss = 0x%x,", ss);
7163 printf (" rsrc = 0x%x,", rsrc); 7175 printf (" rsrc = 0x%x,", rsrc);
7164 printf (" rdst = 0x%x\n", rdst); 7176 printf (" rdst = 0x%x\n", rdst);
7165 } 7177 }
7166 SYNTAX("max %1%S1, %0"); 7178 SYNTAX("max %1%S1, %0");
7167 #line 537 "rx-decode.opc" 7179 #line 549 "rx-decode.opc"
7168 if (ss == 3 && rsrc == 0 && rdst == 0) 7180 if (ss == 3 && rsrc == 0 && rdst == 0)
7169 { 7181 {
7170 ID(nop3); 7182 ID(nop3);
7171 rx->syntax = "nop"; 7183 rx->syntax = "nop";
7172 } 7184 }
7173 else 7185 else
7174 { 7186 {
7175 ID(max); SP(ss, rsrc); DR(rdst); 7187 ID(max); SP(ss, rsrc); DR(rdst);
7176 } 7188 }
7177 7189
(...skipping 29 matching lines...) Expand all
7207 } 7219 }
7208 break; 7220 break;
7209 case 0x14: 7221 case 0x14:
7210 GETBYTE (); 7222 GETBYTE ();
7211 switch (op[2] & 0x00) 7223 switch (op[2] & 0x00)
7212 { 7224 {
7213 case 0x00: 7225 case 0x00:
7214 op_semantics_48: 7226 op_semantics_48:
7215 { 7227 {
7216 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */ 7228 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */
7217 #line 557 "rx-decode.opc" 7229 #line 569 "rx-decode.opc"
7218 int ss AU = op[1] & 0x03; 7230 int ss AU = op[1] & 0x03;
7219 #line 557 "rx-decode.opc" 7231 #line 569 "rx-decode.opc"
7220 int rsrc AU = (op[2] >> 4) & 0x0f; 7232 int rsrc AU = (op[2] >> 4) & 0x0f;
7221 #line 557 "rx-decode.opc" 7233 #line 569 "rx-decode.opc"
7222 int rdst AU = op[2] & 0x0f; 7234 int rdst AU = op[2] & 0x0f;
7223 if (trace) 7235 if (trace)
7224 { 7236 {
7225 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7237 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7226 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */", 7238 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */",
7227 op[0], op[1], op[2]); 7239 op[0], op[1], op[2]);
7228 printf (" ss = 0x%x,", ss); 7240 printf (" ss = 0x%x,", ss);
7229 printf (" rsrc = 0x%x,", rsrc); 7241 printf (" rsrc = 0x%x,", rsrc);
7230 printf (" rdst = 0x%x\n", rdst); 7242 printf (" rdst = 0x%x\n", rdst);
7231 } 7243 }
7232 SYNTAX("min %1%S1, %0"); 7244 SYNTAX("min %1%S1, %0");
7233 #line 557 "rx-decode.opc" 7245 #line 569 "rx-decode.opc"
7234 ID(min); SP(ss, rsrc); DR(rdst); 7246 ID(min); SP(ss, rsrc); DR(rdst);
7235 7247
7236 } 7248 }
7237 break; 7249 break;
7238 } 7250 }
7239 break; 7251 break;
7240 case 0x15: 7252 case 0x15:
7241 GETBYTE (); 7253 GETBYTE ();
7242 switch (op[2] & 0x00) 7254 switch (op[2] & 0x00)
7243 { 7255 {
(...skipping 21 matching lines...) Expand all
7265 } 7277 }
7266 break; 7278 break;
7267 case 0x18: 7279 case 0x18:
7268 GETBYTE (); 7280 GETBYTE ();
7269 switch (op[2] & 0x00) 7281 switch (op[2] & 0x00)
7270 { 7282 {
7271 case 0x00: 7283 case 0x00:
7272 op_semantics_49: 7284 op_semantics_49:
7273 { 7285 {
7274 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */ 7286 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */
7275 #line 587 "rx-decode.opc" 7287 #line 599 "rx-decode.opc"
7276 int ss AU = op[1] & 0x03; 7288 int ss AU = op[1] & 0x03;
7277 #line 587 "rx-decode.opc" 7289 #line 599 "rx-decode.opc"
7278 int rsrc AU = (op[2] >> 4) & 0x0f; 7290 int rsrc AU = (op[2] >> 4) & 0x0f;
7279 #line 587 "rx-decode.opc" 7291 #line 599 "rx-decode.opc"
7280 int rdst AU = op[2] & 0x0f; 7292 int rdst AU = op[2] & 0x0f;
7281 if (trace) 7293 if (trace)
7282 { 7294 {
7283 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7295 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7284 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */", 7296 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */",
7285 op[0], op[1], op[2]); 7297 op[0], op[1], op[2]);
7286 printf (" ss = 0x%x,", ss); 7298 printf (" ss = 0x%x,", ss);
7287 printf (" rsrc = 0x%x,", rsrc); 7299 printf (" rsrc = 0x%x,", rsrc);
7288 printf (" rdst = 0x%x\n", rdst); 7300 printf (" rdst = 0x%x\n", rdst);
7289 } 7301 }
7290 SYNTAX("emul %1%S1, %0"); 7302 SYNTAX("emul %1%S1, %0");
7291 #line 587 "rx-decode.opc" 7303 #line 599 "rx-decode.opc"
7292 ID(emul); SP(ss, rsrc); DR(rdst); 7304 ID(emul); SP(ss, rsrc); DR(rdst);
7293 7305
7294 } 7306 }
7295 break; 7307 break;
7296 } 7308 }
7297 break; 7309 break;
7298 case 0x19: 7310 case 0x19:
7299 GETBYTE (); 7311 GETBYTE ();
7300 switch (op[2] & 0x00) 7312 switch (op[2] & 0x00)
7301 { 7313 {
(...skipping 21 matching lines...) Expand all
7323 } 7335 }
7324 break; 7336 break;
7325 case 0x1c: 7337 case 0x1c:
7326 GETBYTE (); 7338 GETBYTE ();
7327 switch (op[2] & 0x00) 7339 switch (op[2] & 0x00)
7328 { 7340 {
7329 case 0x00: 7341 case 0x00:
7330 op_semantics_50: 7342 op_semantics_50:
7331 { 7343 {
7332 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */ 7344 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */
7333 #line 599 "rx-decode.opc" 7345 #line 611 "rx-decode.opc"
7334 int ss AU = op[1] & 0x03; 7346 int ss AU = op[1] & 0x03;
7335 #line 599 "rx-decode.opc" 7347 #line 611 "rx-decode.opc"
7336 int rsrc AU = (op[2] >> 4) & 0x0f; 7348 int rsrc AU = (op[2] >> 4) & 0x0f;
7337 #line 599 "rx-decode.opc" 7349 #line 611 "rx-decode.opc"
7338 int rdst AU = op[2] & 0x0f; 7350 int rdst AU = op[2] & 0x0f;
7339 if (trace) 7351 if (trace)
7340 { 7352 {
7341 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7353 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7342 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */", 7354 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */",
7343 op[0], op[1], op[2]); 7355 op[0], op[1], op[2]);
7344 printf (" ss = 0x%x,", ss); 7356 printf (" ss = 0x%x,", ss);
7345 printf (" rsrc = 0x%x,", rsrc); 7357 printf (" rsrc = 0x%x,", rsrc);
7346 printf (" rdst = 0x%x\n", rdst); 7358 printf (" rdst = 0x%x\n", rdst);
7347 } 7359 }
7348 SYNTAX("emulu %1%S1, %0"); 7360 SYNTAX("emulu %1%S1, %0");
7349 #line 599 "rx-decode.opc" 7361 #line 611 "rx-decode.opc"
7350 ID(emulu); SP(ss, rsrc); DR(rdst); 7362 ID(emulu); SP(ss, rsrc); DR(rdst);
7351 7363
7352 } 7364 }
7353 break; 7365 break;
7354 } 7366 }
7355 break; 7367 break;
7356 case 0x1d: 7368 case 0x1d:
7357 GETBYTE (); 7369 GETBYTE ();
7358 switch (op[2] & 0x00) 7370 switch (op[2] & 0x00)
7359 { 7371 {
(...skipping 21 matching lines...) Expand all
7381 } 7393 }
7382 break; 7394 break;
7383 case 0x20: 7395 case 0x20:
7384 GETBYTE (); 7396 GETBYTE ();
7385 switch (op[2] & 0x00) 7397 switch (op[2] & 0x00)
7386 { 7398 {
7387 case 0x00: 7399 case 0x00:
7388 op_semantics_51: 7400 op_semantics_51:
7389 { 7401 {
7390 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */ 7402 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */
7391 #line 611 "rx-decode.opc" 7403 #line 623 "rx-decode.opc"
7392 int ss AU = op[1] & 0x03; 7404 int ss AU = op[1] & 0x03;
7393 #line 611 "rx-decode.opc" 7405 #line 623 "rx-decode.opc"
7394 int rsrc AU = (op[2] >> 4) & 0x0f; 7406 int rsrc AU = (op[2] >> 4) & 0x0f;
7395 #line 611 "rx-decode.opc" 7407 #line 623 "rx-decode.opc"
7396 int rdst AU = op[2] & 0x0f; 7408 int rdst AU = op[2] & 0x0f;
7397 if (trace) 7409 if (trace)
7398 { 7410 {
7399 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7411 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7400 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */", 7412 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */",
7401 op[0], op[1], op[2]); 7413 op[0], op[1], op[2]);
7402 printf (" ss = 0x%x,", ss); 7414 printf (" ss = 0x%x,", ss);
7403 printf (" rsrc = 0x%x,", rsrc); 7415 printf (" rsrc = 0x%x,", rsrc);
7404 printf (" rdst = 0x%x\n", rdst); 7416 printf (" rdst = 0x%x\n", rdst);
7405 } 7417 }
7406 SYNTAX("div %1%S1, %0"); 7418 SYNTAX("div %1%S1, %0");
7407 #line 611 "rx-decode.opc" 7419 #line 623 "rx-decode.opc"
7408 ID(div); SP(ss, rsrc); DR(rdst); F_O___; 7420 ID(div); SP(ss, rsrc); DR(rdst); F_O___;
7409 7421
7410 } 7422 }
7411 break; 7423 break;
7412 } 7424 }
7413 break; 7425 break;
7414 case 0x21: 7426 case 0x21:
7415 GETBYTE (); 7427 GETBYTE ();
7416 switch (op[2] & 0x00) 7428 switch (op[2] & 0x00)
7417 { 7429 {
(...skipping 21 matching lines...) Expand all
7439 } 7451 }
7440 break; 7452 break;
7441 case 0x24: 7453 case 0x24:
7442 GETBYTE (); 7454 GETBYTE ();
7443 switch (op[2] & 0x00) 7455 switch (op[2] & 0x00)
7444 { 7456 {
7445 case 0x00: 7457 case 0x00:
7446 op_semantics_52: 7458 op_semantics_52:
7447 { 7459 {
7448 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */ 7460 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */
7449 #line 623 "rx-decode.opc" 7461 #line 635 "rx-decode.opc"
7450 int ss AU = op[1] & 0x03; 7462 int ss AU = op[1] & 0x03;
7451 #line 623 "rx-decode.opc" 7463 #line 635 "rx-decode.opc"
7452 int rsrc AU = (op[2] >> 4) & 0x0f; 7464 int rsrc AU = (op[2] >> 4) & 0x0f;
7453 #line 623 "rx-decode.opc" 7465 #line 635 "rx-decode.opc"
7454 int rdst AU = op[2] & 0x0f; 7466 int rdst AU = op[2] & 0x0f;
7455 if (trace) 7467 if (trace)
7456 { 7468 {
7457 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7469 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7458 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */", 7470 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */",
7459 op[0], op[1], op[2]); 7471 op[0], op[1], op[2]);
7460 printf (" ss = 0x%x,", ss); 7472 printf (" ss = 0x%x,", ss);
7461 printf (" rsrc = 0x%x,", rsrc); 7473 printf (" rsrc = 0x%x,", rsrc);
7462 printf (" rdst = 0x%x\n", rdst); 7474 printf (" rdst = 0x%x\n", rdst);
7463 } 7475 }
7464 SYNTAX("divu %1%S1, %0"); 7476 SYNTAX("divu %1%S1, %0");
7465 #line 623 "rx-decode.opc" 7477 #line 635 "rx-decode.opc"
7466 ID(divu); SP(ss, rsrc); DR(rdst); F_O___; 7478 ID(divu); SP(ss, rsrc); DR(rdst); F_O___;
7467 7479
7468 } 7480 }
7469 break; 7481 break;
7470 } 7482 }
7471 break; 7483 break;
7472 case 0x25: 7484 case 0x25:
7473 GETBYTE (); 7485 GETBYTE ();
7474 switch (op[2] & 0x00) 7486 switch (op[2] & 0x00)
7475 { 7487 {
(...skipping 21 matching lines...) Expand all
7497 } 7509 }
7498 break; 7510 break;
7499 case 0x30: 7511 case 0x30:
7500 GETBYTE (); 7512 GETBYTE ();
7501 switch (op[2] & 0x00) 7513 switch (op[2] & 0x00)
7502 { 7514 {
7503 case 0x00: 7515 case 0x00:
7504 op_semantics_53: 7516 op_semantics_53:
7505 { 7517 {
7506 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */ 7518 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */
7507 #line 434 "rx-decode.opc" 7519 #line 446 "rx-decode.opc"
7508 int ss AU = op[1] & 0x03; 7520 int ss AU = op[1] & 0x03;
7509 #line 434 "rx-decode.opc" 7521 #line 446 "rx-decode.opc"
7510 int rsrc AU = (op[2] >> 4) & 0x0f; 7522 int rsrc AU = (op[2] >> 4) & 0x0f;
7511 #line 434 "rx-decode.opc" 7523 #line 446 "rx-decode.opc"
7512 int rdst AU = op[2] & 0x0f; 7524 int rdst AU = op[2] & 0x0f;
7513 if (trace) 7525 if (trace)
7514 { 7526 {
7515 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7527 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7516 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */", 7528 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */",
7517 op[0], op[1], op[2]); 7529 op[0], op[1], op[2]);
7518 printf (" ss = 0x%x,", ss); 7530 printf (" ss = 0x%x,", ss);
7519 printf (" rsrc = 0x%x,", rsrc); 7531 printf (" rsrc = 0x%x,", rsrc);
7520 printf (" rdst = 0x%x\n", rdst); 7532 printf (" rdst = 0x%x\n", rdst);
7521 } 7533 }
7522 SYNTAX("tst %1%S1, %2"); 7534 SYNTAX("tst %1%S1, %2");
7523 #line 434 "rx-decode.opc" 7535 #line 446 "rx-decode.opc"
7524 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_; 7536 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_;
7525 7537
7526 } 7538 }
7527 break; 7539 break;
7528 } 7540 }
7529 break; 7541 break;
7530 case 0x31: 7542 case 0x31:
7531 GETBYTE (); 7543 GETBYTE ();
7532 switch (op[2] & 0x00) 7544 switch (op[2] & 0x00)
7533 { 7545 {
(...skipping 21 matching lines...) Expand all
7555 } 7567 }
7556 break; 7568 break;
7557 case 0x34: 7569 case 0x34:
7558 GETBYTE (); 7570 GETBYTE ();
7559 switch (op[2] & 0x00) 7571 switch (op[2] & 0x00)
7560 { 7572 {
7561 case 0x00: 7573 case 0x00:
7562 op_semantics_54: 7574 op_semantics_54:
7563 { 7575 {
7564 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */ 7576 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */
7565 #line 413 "rx-decode.opc" 7577 #line 425 "rx-decode.opc"
7566 int ss AU = op[1] & 0x03; 7578 int ss AU = op[1] & 0x03;
7567 #line 413 "rx-decode.opc" 7579 #line 425 "rx-decode.opc"
7568 int rsrc AU = (op[2] >> 4) & 0x0f; 7580 int rsrc AU = (op[2] >> 4) & 0x0f;
7569 #line 413 "rx-decode.opc" 7581 #line 425 "rx-decode.opc"
7570 int rdst AU = op[2] & 0x0f; 7582 int rdst AU = op[2] & 0x0f;
7571 if (trace) 7583 if (trace)
7572 { 7584 {
7573 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7574 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */", 7586 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */",
7575 op[0], op[1], op[2]); 7587 op[0], op[1], op[2]);
7576 printf (" ss = 0x%x,", ss); 7588 printf (" ss = 0x%x,", ss);
7577 printf (" rsrc = 0x%x,", rsrc); 7589 printf (" rsrc = 0x%x,", rsrc);
7578 printf (" rdst = 0x%x\n", rdst); 7590 printf (" rdst = 0x%x\n", rdst);
7579 } 7591 }
7580 SYNTAX("xor %1%S1, %0"); 7592 SYNTAX("xor %1%S1, %0");
7581 #line 413 "rx-decode.opc" 7593 #line 425 "rx-decode.opc"
7582 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_; 7594 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_;
7583 7595
7584 } 7596 }
7585 break; 7597 break;
7586 } 7598 }
7587 break; 7599 break;
7588 case 0x35: 7600 case 0x35:
7589 GETBYTE (); 7601 GETBYTE ();
7590 switch (op[2] & 0x00) 7602 switch (op[2] & 0x00)
7591 { 7603 {
(...skipping 20 matching lines...) Expand all
7612 break; 7624 break;
7613 } 7625 }
7614 break; 7626 break;
7615 case 0x3b: 7627 case 0x3b:
7616 GETBYTE (); 7628 GETBYTE ();
7617 switch (op[2] & 0x00) 7629 switch (op[2] & 0x00)
7618 { 7630 {
7619 case 0x00: 7631 case 0x00:
7620 { 7632 {
7621 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */ 7633 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */
7622 #line 425 "rx-decode.opc" 7634 #line 437 "rx-decode.opc"
7623 int rsrc AU = (op[2] >> 4) & 0x0f; 7635 int rsrc AU = (op[2] >> 4) & 0x0f;
7624 #line 425 "rx-decode.opc" 7636 #line 437 "rx-decode.opc"
7625 int rdst AU = op[2] & 0x0f; 7637 int rdst AU = op[2] & 0x0f;
7626 if (trace) 7638 if (trace)
7627 { 7639 {
7628 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7640 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7629 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */", 7641 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */",
7630 op[0], op[1], op[2]); 7642 op[0], op[1], op[2]);
7631 printf (" rsrc = 0x%x,", rsrc); 7643 printf (" rsrc = 0x%x,", rsrc);
7632 printf (" rdst = 0x%x\n", rdst); 7644 printf (" rdst = 0x%x\n", rdst);
7633 } 7645 }
7634 SYNTAX("not %1, %0"); 7646 SYNTAX("not %1, %0");
7635 #line 425 "rx-decode.opc" 7647 #line 437 "rx-decode.opc"
7636 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_; 7648 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_;
7637 7649
7638 /*---------------------------------------------------------- ------------*/ 7650 /*---------------------------------------------------------- ------------*/
7639 /* TST */ 7651 /* TST */
7640 7652
7641 } 7653 }
7642 break; 7654 break;
7643 } 7655 }
7644 break; 7656 break;
7645 case 0x40: 7657 case 0x40:
7646 GETBYTE (); 7658 GETBYTE ();
7647 switch (op[2] & 0x00) 7659 switch (op[2] & 0x00)
7648 { 7660 {
7649 case 0x00: 7661 case 0x00:
7650 op_semantics_55: 7662 op_semantics_55:
7651 { 7663 {
7652 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */ 7664 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */
7653 #line 347 "rx-decode.opc" 7665 #line 359 "rx-decode.opc"
7654 int ss AU = op[1] & 0x03; 7666 int ss AU = op[1] & 0x03;
7655 #line 347 "rx-decode.opc" 7667 #line 359 "rx-decode.opc"
7656 int rsrc AU = (op[2] >> 4) & 0x0f; 7668 int rsrc AU = (op[2] >> 4) & 0x0f;
7657 #line 347 "rx-decode.opc" 7669 #line 359 "rx-decode.opc"
7658 int rdst AU = op[2] & 0x0f; 7670 int rdst AU = op[2] & 0x0f;
7659 if (trace) 7671 if (trace)
7660 { 7672 {
7661 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7673 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7662 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */", 7674 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */",
7663 op[0], op[1], op[2]); 7675 op[0], op[1], op[2]);
7664 printf (" ss = 0x%x,", ss); 7676 printf (" ss = 0x%x,", ss);
7665 printf (" rsrc = 0x%x,", rsrc); 7677 printf (" rsrc = 0x%x,", rsrc);
7666 printf (" rdst = 0x%x\n", rdst); 7678 printf (" rdst = 0x%x\n", rdst);
7667 } 7679 }
7668 SYNTAX("xchg %1%S1, %0"); 7680 SYNTAX("xchg %1%S1, %0");
7669 #line 347 "rx-decode.opc" 7681 #line 359 "rx-decode.opc"
7670 ID(xchg); DR(rdst); SP(ss, rsrc); 7682 ID(xchg); DR(rdst); SP(ss, rsrc);
7671 7683
7672 } 7684 }
7673 break; 7685 break;
7674 } 7686 }
7675 break; 7687 break;
7676 case 0x41: 7688 case 0x41:
7677 GETBYTE (); 7689 GETBYTE ();
7678 switch (op[2] & 0x00) 7690 switch (op[2] & 0x00)
7679 { 7691 {
(...skipping 21 matching lines...) Expand all
7701 } 7713 }
7702 break; 7714 break;
7703 case 0x44: 7715 case 0x44:
7704 GETBYTE (); 7716 GETBYTE ();
7705 switch (op[2] & 0x00) 7717 switch (op[2] & 0x00)
7706 { 7718 {
7707 case 0x00: 7719 case 0x00:
7708 op_semantics_56: 7720 op_semantics_56:
7709 { 7721 {
7710 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */ 7722 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */
7711 #line 852 "rx-decode.opc" 7723 #line 864 "rx-decode.opc"
7712 int sd AU = op[1] & 0x03; 7724 int sd AU = op[1] & 0x03;
7713 #line 852 "rx-decode.opc" 7725 #line 864 "rx-decode.opc"
7714 int rsrc AU = (op[2] >> 4) & 0x0f; 7726 int rsrc AU = (op[2] >> 4) & 0x0f;
7715 #line 852 "rx-decode.opc" 7727 #line 864 "rx-decode.opc"
7716 int rdst AU = op[2] & 0x0f; 7728 int rdst AU = op[2] & 0x0f;
7717 if (trace) 7729 if (trace)
7718 { 7730 {
7719 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7731 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7720 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */", 7732 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */",
7721 op[0], op[1], op[2]); 7733 op[0], op[1], op[2]);
7722 printf (" sd = 0x%x,", sd); 7734 printf (" sd = 0x%x,", sd);
7723 printf (" rsrc = 0x%x,", rsrc); 7735 printf (" rsrc = 0x%x,", rsrc);
7724 printf (" rdst = 0x%x\n", rdst); 7736 printf (" rdst = 0x%x\n", rdst);
7725 } 7737 }
7726 SYNTAX("itof %1%S1, %0"); 7738 SYNTAX("itof %1%S1, %0");
7727 #line 852 "rx-decode.opc" 7739 #line 864 "rx-decode.opc"
7728 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_; 7740 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_;
7729 7741
7730 } 7742 }
7731 break; 7743 break;
7732 } 7744 }
7733 break; 7745 break;
7734 case 0x45: 7746 case 0x45:
7735 GETBYTE (); 7747 GETBYTE ();
7736 switch (op[2] & 0x00) 7748 switch (op[2] & 0x00)
7737 { 7749 {
(...skipping 21 matching lines...) Expand all
7759 } 7771 }
7760 break; 7772 break;
7761 case 0x60: 7773 case 0x60:
7762 GETBYTE (); 7774 GETBYTE ();
7763 switch (op[2] & 0x00) 7775 switch (op[2] & 0x00)
7764 { 7776 {
7765 case 0x00: 7777 case 0x00:
7766 op_semantics_57: 7778 op_semantics_57:
7767 { 7779 {
7768 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */ 7780 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */
7769 #line 864 "rx-decode.opc" 7781 #line 876 "rx-decode.opc"
7770 int sd AU = op[1] & 0x03; 7782 int sd AU = op[1] & 0x03;
7771 #line 864 "rx-decode.opc" 7783 #line 876 "rx-decode.opc"
7772 int rdst AU = (op[2] >> 4) & 0x0f; 7784 int rdst AU = (op[2] >> 4) & 0x0f;
7773 #line 864 "rx-decode.opc" 7785 #line 876 "rx-decode.opc"
7774 int rsrc AU = op[2] & 0x0f; 7786 int rsrc AU = op[2] & 0x0f;
7775 if (trace) 7787 if (trace)
7776 { 7788 {
7777 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7789 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7778 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */", 7790 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */",
7779 op[0], op[1], op[2]); 7791 op[0], op[1], op[2]);
7780 printf (" sd = 0x%x,", sd); 7792 printf (" sd = 0x%x,", sd);
7781 printf (" rdst = 0x%x,", rdst); 7793 printf (" rdst = 0x%x,", rdst);
7782 printf (" rsrc = 0x%x\n", rsrc); 7794 printf (" rsrc = 0x%x\n", rsrc);
7783 } 7795 }
7784 SYNTAX("bset %1, %0%S0"); 7796 SYNTAX("bset %1, %0%S0");
7785 #line 864 "rx-decode.opc" 7797 #line 876 "rx-decode.opc"
7786 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F____ _; 7798 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F____ _;
7787 7799
7788 } 7800 }
7789 break; 7801 break;
7790 } 7802 }
7791 break; 7803 break;
7792 case 0x61: 7804 case 0x61:
7793 GETBYTE (); 7805 GETBYTE ();
7794 switch (op[2] & 0x00) 7806 switch (op[2] & 0x00)
7795 { 7807 {
(...skipping 21 matching lines...) Expand all
7817 } 7829 }
7818 break; 7830 break;
7819 case 0x64: 7831 case 0x64:
7820 GETBYTE (); 7832 GETBYTE ();
7821 switch (op[2] & 0x00) 7833 switch (op[2] & 0x00)
7822 { 7834 {
7823 case 0x00: 7835 case 0x00:
7824 op_semantics_58: 7836 op_semantics_58:
7825 { 7837 {
7826 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */ 7838 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */
7827 #line 874 "rx-decode.opc" 7839 #line 886 "rx-decode.opc"
7828 int sd AU = op[1] & 0x03; 7840 int sd AU = op[1] & 0x03;
7829 #line 874 "rx-decode.opc" 7841 #line 886 "rx-decode.opc"
7830 int rdst AU = (op[2] >> 4) & 0x0f; 7842 int rdst AU = (op[2] >> 4) & 0x0f;
7831 #line 874 "rx-decode.opc" 7843 #line 886 "rx-decode.opc"
7832 int rsrc AU = op[2] & 0x0f; 7844 int rsrc AU = op[2] & 0x0f;
7833 if (trace) 7845 if (trace)
7834 { 7846 {
7835 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7847 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7836 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */", 7848 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */",
7837 op[0], op[1], op[2]); 7849 op[0], op[1], op[2]);
7838 printf (" sd = 0x%x,", sd); 7850 printf (" sd = 0x%x,", sd);
7839 printf (" rdst = 0x%x,", rdst); 7851 printf (" rdst = 0x%x,", rdst);
7840 printf (" rsrc = 0x%x\n", rsrc); 7852 printf (" rsrc = 0x%x\n", rsrc);
7841 } 7853 }
7842 SYNTAX("bclr %1, %0%S0"); 7854 SYNTAX("bclr %1, %0%S0");
7843 #line 874 "rx-decode.opc" 7855 #line 886 "rx-decode.opc"
7844 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F____ _; 7856 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F____ _;
7845 7857
7846 } 7858 }
7847 break; 7859 break;
7848 } 7860 }
7849 break; 7861 break;
7850 case 0x65: 7862 case 0x65:
7851 GETBYTE (); 7863 GETBYTE ();
7852 switch (op[2] & 0x00) 7864 switch (op[2] & 0x00)
7853 { 7865 {
(...skipping 21 matching lines...) Expand all
7875 } 7887 }
7876 break; 7888 break;
7877 case 0x68: 7889 case 0x68:
7878 GETBYTE (); 7890 GETBYTE ();
7879 switch (op[2] & 0x00) 7891 switch (op[2] & 0x00)
7880 { 7892 {
7881 case 0x00: 7893 case 0x00:
7882 op_semantics_59: 7894 op_semantics_59:
7883 { 7895 {
7884 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */ 7896 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */
7885 #line 884 "rx-decode.opc" 7897 #line 896 "rx-decode.opc"
7886 int sd AU = op[1] & 0x03; 7898 int sd AU = op[1] & 0x03;
7887 #line 884 "rx-decode.opc" 7899 #line 896 "rx-decode.opc"
7888 int rdst AU = (op[2] >> 4) & 0x0f; 7900 int rdst AU = (op[2] >> 4) & 0x0f;
7889 #line 884 "rx-decode.opc" 7901 #line 896 "rx-decode.opc"
7890 int rsrc AU = op[2] & 0x0f; 7902 int rsrc AU = op[2] & 0x0f;
7891 if (trace) 7903 if (trace)
7892 { 7904 {
7893 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7905 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7894 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */", 7906 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */",
7895 op[0], op[1], op[2]); 7907 op[0], op[1], op[2]);
7896 printf (" sd = 0x%x,", sd); 7908 printf (" sd = 0x%x,", sd);
7897 printf (" rdst = 0x%x,", rdst); 7909 printf (" rdst = 0x%x,", rdst);
7898 printf (" rsrc = 0x%x\n", rsrc); 7910 printf (" rsrc = 0x%x\n", rsrc);
7899 } 7911 }
7900 SYNTAX("btst %2, %1%S1"); 7912 SYNTAX("btst %2, %1%S1");
7901 #line 884 "rx-decode.opc" 7913 #line 896 "rx-decode.opc"
7902 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ ZC; 7914 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ ZC;
7903 7915
7904 } 7916 }
7905 break; 7917 break;
7906 } 7918 }
7907 break; 7919 break;
7908 case 0x69: 7920 case 0x69:
7909 GETBYTE (); 7921 GETBYTE ();
7910 switch (op[2] & 0x00) 7922 switch (op[2] & 0x00)
7911 { 7923 {
(...skipping 21 matching lines...) Expand all
7933 } 7945 }
7934 break; 7946 break;
7935 case 0x6c: 7947 case 0x6c:
7936 GETBYTE (); 7948 GETBYTE ();
7937 switch (op[2] & 0x00) 7949 switch (op[2] & 0x00)
7938 { 7950 {
7939 case 0x00: 7951 case 0x00:
7940 op_semantics_60: 7952 op_semantics_60:
7941 { 7953 {
7942 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */ 7954 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */
7943 #line 894 "rx-decode.opc" 7955 #line 906 "rx-decode.opc"
7944 int sd AU = op[1] & 0x03; 7956 int sd AU = op[1] & 0x03;
7945 #line 894 "rx-decode.opc" 7957 #line 906 "rx-decode.opc"
7946 int rdst AU = (op[2] >> 4) & 0x0f; 7958 int rdst AU = (op[2] >> 4) & 0x0f;
7947 #line 894 "rx-decode.opc" 7959 #line 906 "rx-decode.opc"
7948 int rsrc AU = op[2] & 0x0f; 7960 int rsrc AU = op[2] & 0x0f;
7949 if (trace) 7961 if (trace)
7950 { 7962 {
7951 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7963 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
7952 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */", 7964 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */",
7953 op[0], op[1], op[2]); 7965 op[0], op[1], op[2]);
7954 printf (" sd = 0x%x,", sd); 7966 printf (" sd = 0x%x,", sd);
7955 printf (" rdst = 0x%x,", rdst); 7967 printf (" rdst = 0x%x,", rdst);
7956 printf (" rsrc = 0x%x\n", rsrc); 7968 printf (" rsrc = 0x%x\n", rsrc);
7957 } 7969 }
7958 SYNTAX("bnot %1, %0%S0"); 7970 SYNTAX("bnot %1, %0%S0");
7959 #line 894 "rx-decode.opc" 7971 #line 906 "rx-decode.opc"
7960 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); 7972 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE);
7961 7973
7962 } 7974 }
7963 break; 7975 break;
7964 } 7976 }
7965 break; 7977 break;
7966 case 0x6d: 7978 case 0x6d:
7967 GETBYTE (); 7979 GETBYTE ();
7968 switch (op[2] & 0x00) 7980 switch (op[2] & 0x00)
7969 { 7981 {
(...skipping 21 matching lines...) Expand all
7991 } 8003 }
7992 break; 8004 break;
7993 case 0x80: 8005 case 0x80:
7994 GETBYTE (); 8006 GETBYTE ();
7995 switch (op[2] & 0x00) 8007 switch (op[2] & 0x00)
7996 { 8008 {
7997 case 0x00: 8009 case 0x00:
7998 op_semantics_61: 8010 op_semantics_61:
7999 { 8011 {
8000 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */ 8012 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */
8001 #line 831 "rx-decode.opc" 8013 #line 843 "rx-decode.opc"
8002 int sd AU = op[1] & 0x03; 8014 int sd AU = op[1] & 0x03;
8003 #line 831 "rx-decode.opc" 8015 #line 843 "rx-decode.opc"
8004 int rsrc AU = (op[2] >> 4) & 0x0f; 8016 int rsrc AU = (op[2] >> 4) & 0x0f;
8005 #line 831 "rx-decode.opc" 8017 #line 843 "rx-decode.opc"
8006 int rdst AU = op[2] & 0x0f; 8018 int rdst AU = op[2] & 0x0f;
8007 if (trace) 8019 if (trace)
8008 { 8020 {
8009 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8021 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8010 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */", 8022 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */",
8011 op[0], op[1], op[2]); 8023 op[0], op[1], op[2]);
8012 printf (" sd = 0x%x,", sd); 8024 printf (" sd = 0x%x,", sd);
8013 printf (" rsrc = 0x%x,", rsrc); 8025 printf (" rsrc = 0x%x,", rsrc);
8014 printf (" rdst = 0x%x\n", rdst); 8026 printf (" rdst = 0x%x\n", rdst);
8015 } 8027 }
8016 SYNTAX("fsub %1%S1, %0"); 8028 SYNTAX("fsub %1%S1, %0");
8017 #line 831 "rx-decode.opc" 8029 #line 843 "rx-decode.opc"
8018 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8030 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8019 8031
8020 } 8032 }
8021 break; 8033 break;
8022 } 8034 }
8023 break; 8035 break;
8024 case 0x81: 8036 case 0x81:
8025 GETBYTE (); 8037 GETBYTE ();
8026 switch (op[2] & 0x00) 8038 switch (op[2] & 0x00)
8027 { 8039 {
(...skipping 21 matching lines...) Expand all
8049 } 8061 }
8050 break; 8062 break;
8051 case 0x84: 8063 case 0x84:
8052 GETBYTE (); 8064 GETBYTE ();
8053 switch (op[2] & 0x00) 8065 switch (op[2] & 0x00)
8054 { 8066 {
8055 case 0x00: 8067 case 0x00:
8056 op_semantics_62: 8068 op_semantics_62:
8057 { 8069 {
8058 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */ 8070 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */
8059 #line 825 "rx-decode.opc" 8071 #line 837 "rx-decode.opc"
8060 int sd AU = op[1] & 0x03; 8072 int sd AU = op[1] & 0x03;
8061 #line 825 "rx-decode.opc" 8073 #line 837 "rx-decode.opc"
8062 int rsrc AU = (op[2] >> 4) & 0x0f; 8074 int rsrc AU = (op[2] >> 4) & 0x0f;
8063 #line 825 "rx-decode.opc" 8075 #line 837 "rx-decode.opc"
8064 int rdst AU = op[2] & 0x0f; 8076 int rdst AU = op[2] & 0x0f;
8065 if (trace) 8077 if (trace)
8066 { 8078 {
8067 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8079 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8068 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */", 8080 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */",
8069 op[0], op[1], op[2]); 8081 op[0], op[1], op[2]);
8070 printf (" sd = 0x%x,", sd); 8082 printf (" sd = 0x%x,", sd);
8071 printf (" rsrc = 0x%x,", rsrc); 8083 printf (" rsrc = 0x%x,", rsrc);
8072 printf (" rdst = 0x%x\n", rdst); 8084 printf (" rdst = 0x%x\n", rdst);
8073 } 8085 }
8074 SYNTAX("fcmp %1%S1, %0"); 8086 SYNTAX("fcmp %1%S1, %0");
8075 #line 825 "rx-decode.opc" 8087 #line 837 "rx-decode.opc"
8076 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_; 8088 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_;
8077 8089
8078 } 8090 }
8079 break; 8091 break;
8080 } 8092 }
8081 break; 8093 break;
8082 case 0x85: 8094 case 0x85:
8083 GETBYTE (); 8095 GETBYTE ();
8084 switch (op[2] & 0x00) 8096 switch (op[2] & 0x00)
8085 { 8097 {
(...skipping 21 matching lines...) Expand all
8107 } 8119 }
8108 break; 8120 break;
8109 case 0x88: 8121 case 0x88:
8110 GETBYTE (); 8122 GETBYTE ();
8111 switch (op[2] & 0x00) 8123 switch (op[2] & 0x00)
8112 { 8124 {
8113 case 0x00: 8125 case 0x00:
8114 op_semantics_63: 8126 op_semantics_63:
8115 { 8127 {
8116 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */ 8128 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */
8117 #line 819 "rx-decode.opc" 8129 #line 831 "rx-decode.opc"
8118 int sd AU = op[1] & 0x03; 8130 int sd AU = op[1] & 0x03;
8119 #line 819 "rx-decode.opc" 8131 #line 831 "rx-decode.opc"
8120 int rsrc AU = (op[2] >> 4) & 0x0f; 8132 int rsrc AU = (op[2] >> 4) & 0x0f;
8121 #line 819 "rx-decode.opc" 8133 #line 831 "rx-decode.opc"
8122 int rdst AU = op[2] & 0x0f; 8134 int rdst AU = op[2] & 0x0f;
8123 if (trace) 8135 if (trace)
8124 { 8136 {
8125 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8137 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8126 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */", 8138 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */",
8127 op[0], op[1], op[2]); 8139 op[0], op[1], op[2]);
8128 printf (" sd = 0x%x,", sd); 8140 printf (" sd = 0x%x,", sd);
8129 printf (" rsrc = 0x%x,", rsrc); 8141 printf (" rsrc = 0x%x,", rsrc);
8130 printf (" rdst = 0x%x\n", rdst); 8142 printf (" rdst = 0x%x\n", rdst);
8131 } 8143 }
8132 SYNTAX("fadd %1%S1, %0"); 8144 SYNTAX("fadd %1%S1, %0");
8133 #line 819 "rx-decode.opc" 8145 #line 831 "rx-decode.opc"
8134 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8146 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8135 8147
8136 } 8148 }
8137 break; 8149 break;
8138 } 8150 }
8139 break; 8151 break;
8140 case 0x89: 8152 case 0x89:
8141 GETBYTE (); 8153 GETBYTE ();
8142 switch (op[2] & 0x00) 8154 switch (op[2] & 0x00)
8143 { 8155 {
(...skipping 21 matching lines...) Expand all
8165 } 8177 }
8166 break; 8178 break;
8167 case 0x8c: 8179 case 0x8c:
8168 GETBYTE (); 8180 GETBYTE ();
8169 switch (op[2] & 0x00) 8181 switch (op[2] & 0x00)
8170 { 8182 {
8171 case 0x00: 8183 case 0x00:
8172 op_semantics_64: 8184 op_semantics_64:
8173 { 8185 {
8174 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */ 8186 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */
8175 #line 840 "rx-decode.opc" 8187 #line 852 "rx-decode.opc"
8176 int sd AU = op[1] & 0x03; 8188 int sd AU = op[1] & 0x03;
8177 #line 840 "rx-decode.opc" 8189 #line 852 "rx-decode.opc"
8178 int rsrc AU = (op[2] >> 4) & 0x0f; 8190 int rsrc AU = (op[2] >> 4) & 0x0f;
8179 #line 840 "rx-decode.opc" 8191 #line 852 "rx-decode.opc"
8180 int rdst AU = op[2] & 0x0f; 8192 int rdst AU = op[2] & 0x0f;
8181 if (trace) 8193 if (trace)
8182 { 8194 {
8183 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8195 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8184 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */", 8196 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */",
8185 op[0], op[1], op[2]); 8197 op[0], op[1], op[2]);
8186 printf (" sd = 0x%x,", sd); 8198 printf (" sd = 0x%x,", sd);
8187 printf (" rsrc = 0x%x,", rsrc); 8199 printf (" rsrc = 0x%x,", rsrc);
8188 printf (" rdst = 0x%x\n", rdst); 8200 printf (" rdst = 0x%x\n", rdst);
8189 } 8201 }
8190 SYNTAX("fmul %1%S1, %0"); 8202 SYNTAX("fmul %1%S1, %0");
8191 #line 840 "rx-decode.opc" 8203 #line 852 "rx-decode.opc"
8192 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8204 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8193 8205
8194 } 8206 }
8195 break; 8207 break;
8196 } 8208 }
8197 break; 8209 break;
8198 case 0x8d: 8210 case 0x8d:
8199 GETBYTE (); 8211 GETBYTE ();
8200 switch (op[2] & 0x00) 8212 switch (op[2] & 0x00)
8201 { 8213 {
(...skipping 21 matching lines...) Expand all
8223 } 8235 }
8224 break; 8236 break;
8225 case 0x90: 8237 case 0x90:
8226 GETBYTE (); 8238 GETBYTE ();
8227 switch (op[2] & 0x00) 8239 switch (op[2] & 0x00)
8228 { 8240 {
8229 case 0x00: 8241 case 0x00:
8230 op_semantics_65: 8242 op_semantics_65:
8231 { 8243 {
8232 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */ 8244 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */
8233 #line 846 "rx-decode.opc" 8245 #line 858 "rx-decode.opc"
8234 int sd AU = op[1] & 0x03; 8246 int sd AU = op[1] & 0x03;
8235 #line 846 "rx-decode.opc" 8247 #line 858 "rx-decode.opc"
8236 int rsrc AU = (op[2] >> 4) & 0x0f; 8248 int rsrc AU = (op[2] >> 4) & 0x0f;
8237 #line 846 "rx-decode.opc" 8249 #line 858 "rx-decode.opc"
8238 int rdst AU = op[2] & 0x0f; 8250 int rdst AU = op[2] & 0x0f;
8239 if (trace) 8251 if (trace)
8240 { 8252 {
8241 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8253 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8242 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */", 8254 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */",
8243 op[0], op[1], op[2]); 8255 op[0], op[1], op[2]);
8244 printf (" sd = 0x%x,", sd); 8256 printf (" sd = 0x%x,", sd);
8245 printf (" rsrc = 0x%x,", rsrc); 8257 printf (" rsrc = 0x%x,", rsrc);
8246 printf (" rdst = 0x%x\n", rdst); 8258 printf (" rdst = 0x%x\n", rdst);
8247 } 8259 }
8248 SYNTAX("fdiv %1%S1, %0"); 8260 SYNTAX("fdiv %1%S1, %0");
8249 #line 846 "rx-decode.opc" 8261 #line 858 "rx-decode.opc"
8250 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8262 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8251 8263
8252 } 8264 }
8253 break; 8265 break;
8254 } 8266 }
8255 break; 8267 break;
8256 case 0x91: 8268 case 0x91:
8257 GETBYTE (); 8269 GETBYTE ();
8258 switch (op[2] & 0x00) 8270 switch (op[2] & 0x00)
8259 { 8271 {
(...skipping 21 matching lines...) Expand all
8281 } 8293 }
8282 break; 8294 break;
8283 case 0x94: 8295 case 0x94:
8284 GETBYTE (); 8296 GETBYTE ();
8285 switch (op[2] & 0x00) 8297 switch (op[2] & 0x00)
8286 { 8298 {
8287 case 0x00: 8299 case 0x00:
8288 op_semantics_66: 8300 op_semantics_66:
8289 { 8301 {
8290 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */ 8302 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */
8291 #line 834 "rx-decode.opc" 8303 #line 846 "rx-decode.opc"
8292 int sd AU = op[1] & 0x03; 8304 int sd AU = op[1] & 0x03;
8293 #line 834 "rx-decode.opc" 8305 #line 846 "rx-decode.opc"
8294 int rsrc AU = (op[2] >> 4) & 0x0f; 8306 int rsrc AU = (op[2] >> 4) & 0x0f;
8295 #line 834 "rx-decode.opc" 8307 #line 846 "rx-decode.opc"
8296 int rdst AU = op[2] & 0x0f; 8308 int rdst AU = op[2] & 0x0f;
8297 if (trace) 8309 if (trace)
8298 { 8310 {
8299 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8311 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8300 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */", 8312 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */",
8301 op[0], op[1], op[2]); 8313 op[0], op[1], op[2]);
8302 printf (" sd = 0x%x,", sd); 8314 printf (" sd = 0x%x,", sd);
8303 printf (" rsrc = 0x%x,", rsrc); 8315 printf (" rsrc = 0x%x,", rsrc);
8304 printf (" rdst = 0x%x\n", rdst); 8316 printf (" rdst = 0x%x\n", rdst);
8305 } 8317 }
8306 SYNTAX("ftoi %1%S1, %0"); 8318 SYNTAX("ftoi %1%S1, %0");
8307 #line 834 "rx-decode.opc" 8319 #line 846 "rx-decode.opc"
8308 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8320 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8309 8321
8310 } 8322 }
8311 break; 8323 break;
8312 } 8324 }
8313 break; 8325 break;
8314 case 0x95: 8326 case 0x95:
8315 GETBYTE (); 8327 GETBYTE ();
8316 switch (op[2] & 0x00) 8328 switch (op[2] & 0x00)
8317 { 8329 {
(...skipping 21 matching lines...) Expand all
8339 } 8351 }
8340 break; 8352 break;
8341 case 0x98: 8353 case 0x98:
8342 GETBYTE (); 8354 GETBYTE ();
8343 switch (op[2] & 0x00) 8355 switch (op[2] & 0x00)
8344 { 8356 {
8345 case 0x00: 8357 case 0x00:
8346 op_semantics_67: 8358 op_semantics_67:
8347 { 8359 {
8348 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */ 8360 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */
8349 #line 849 "rx-decode.opc" 8361 #line 861 "rx-decode.opc"
8350 int sd AU = op[1] & 0x03; 8362 int sd AU = op[1] & 0x03;
8351 #line 849 "rx-decode.opc" 8363 #line 861 "rx-decode.opc"
8352 int rsrc AU = (op[2] >> 4) & 0x0f; 8364 int rsrc AU = (op[2] >> 4) & 0x0f;
8353 #line 849 "rx-decode.opc" 8365 #line 861 "rx-decode.opc"
8354 int rdst AU = op[2] & 0x0f; 8366 int rdst AU = op[2] & 0x0f;
8355 if (trace) 8367 if (trace)
8356 { 8368 {
8357 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8369 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8358 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */", 8370 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */",
8359 op[0], op[1], op[2]); 8371 op[0], op[1], op[2]);
8360 printf (" sd = 0x%x,", sd); 8372 printf (" sd = 0x%x,", sd);
8361 printf (" rsrc = 0x%x,", rsrc); 8373 printf (" rsrc = 0x%x,", rsrc);
8362 printf (" rdst = 0x%x\n", rdst); 8374 printf (" rdst = 0x%x\n", rdst);
8363 } 8375 }
8364 SYNTAX("round %1%S1, %0"); 8376 SYNTAX("round %1%S1, %0");
8365 #line 849 "rx-decode.opc" 8377 #line 861 "rx-decode.opc"
8366 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8378 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_;
8367 8379
8368 } 8380 }
8369 break; 8381 break;
8370 } 8382 }
8371 break; 8383 break;
8372 case 0x99: 8384 case 0x99:
8373 GETBYTE (); 8385 GETBYTE ();
8374 switch (op[2] & 0x00) 8386 switch (op[2] & 0x00)
8375 { 8387 {
(...skipping 21 matching lines...) Expand all
8397 } 8409 }
8398 break; 8410 break;
8399 case 0xd0: 8411 case 0xd0:
8400 GETBYTE (); 8412 GETBYTE ();
8401 switch (op[2] & 0x00) 8413 switch (op[2] & 0x00)
8402 { 8414 {
8403 case 0x00: 8415 case 0x00:
8404 op_semantics_68: 8416 op_semantics_68:
8405 { 8417 {
8406 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */ 8418 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */
8407 #line 958 "rx-decode.opc" 8419 #line 970 "rx-decode.opc"
8408 int sz AU = (op[1] >> 2) & 0x03; 8420 int sz AU = (op[1] >> 2) & 0x03;
8409 #line 958 "rx-decode.opc" 8421 #line 970 "rx-decode.opc"
8410 int sd AU = op[1] & 0x03; 8422 int sd AU = op[1] & 0x03;
8411 #line 958 "rx-decode.opc" 8423 #line 970 "rx-decode.opc"
8412 int rdst AU = (op[2] >> 4) & 0x0f; 8424 int rdst AU = (op[2] >> 4) & 0x0f;
8413 #line 958 "rx-decode.opc" 8425 #line 970 "rx-decode.opc"
8414 int cond AU = op[2] & 0x0f; 8426 int cond AU = op[2] & 0x0f;
8415 if (trace) 8427 if (trace)
8416 { 8428 {
8417 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8429 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8418 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */", 8430 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */",
8419 op[0], op[1], op[2]); 8431 op[0], op[1], op[2]);
8420 printf (" sz = 0x%x,", sz); 8432 printf (" sz = 0x%x,", sz);
8421 printf (" sd = 0x%x,", sd); 8433 printf (" sd = 0x%x,", sd);
8422 printf (" rdst = 0x%x,", rdst); 8434 printf (" rdst = 0x%x,", rdst);
8423 printf (" cond = 0x%x\n", cond); 8435 printf (" cond = 0x%x\n", cond);
8424 } 8436 }
8425 SYNTAX("sc%1%s %0"); 8437 SYNTAX("sc%1%s %0");
8426 #line 958 "rx-decode.opc" 8438 #line 970 "rx-decode.opc"
8427 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond); 8439 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond);
8428 8440
8429 } 8441 }
8430 break; 8442 break;
8431 } 8443 }
8432 break; 8444 break;
8433 case 0xd1: 8445 case 0xd1:
8434 GETBYTE (); 8446 GETBYTE ();
8435 switch (op[2] & 0x00) 8447 switch (op[2] & 0x00)
8436 { 8448 {
(...skipping 107 matching lines...) Expand 10 before | Expand all | Expand 10 after
8544 case 0x08: 8556 case 0x08:
8545 case 0x09: 8557 case 0x09:
8546 case 0x0a: 8558 case 0x0a:
8547 case 0x0b: 8559 case 0x0b:
8548 case 0x0c: 8560 case 0x0c:
8549 case 0x0d: 8561 case 0x0d:
8550 case 0x0e: 8562 case 0x0e:
8551 op_semantics_69: 8563 op_semantics_69:
8552 { 8564 {
8553 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */ 8565 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */
8554 #line 901 "rx-decode.opc" 8566 #line 913 "rx-decode.opc"
8555 int bit AU = (op[1] >> 2) & 0x07; 8567 int bit AU = (op[1] >> 2) & 0x07;
8556 #line 901 "rx-decode.opc" 8568 #line 913 "rx-decode.opc"
8557 int sd AU = op[1] & 0x03; 8569 int sd AU = op[1] & 0x03;
8558 #line 901 "rx-decode.opc" 8570 #line 913 "rx-decode.opc"
8559 int rdst AU = (op[2] >> 4) & 0x0f; 8571 int rdst AU = (op[2] >> 4) & 0x0f;
8560 #line 901 "rx-decode.opc" 8572 #line 913 "rx-decode.opc"
8561 int cond AU = op[2] & 0x0f; 8573 int cond AU = op[2] & 0x0f;
8562 if (trace) 8574 if (trace)
8563 { 8575 {
8564 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8576 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8565 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */", 8577 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */",
8566 op[0], op[1], op[2]); 8578 op[0], op[1], op[2]);
8567 printf (" bit = 0x%x,", bit); 8579 printf (" bit = 0x%x,", bit);
8568 printf (" sd = 0x%x,", sd); 8580 printf (" sd = 0x%x,", sd);
8569 printf (" rdst = 0x%x,", rdst); 8581 printf (" rdst = 0x%x,", rdst);
8570 printf (" cond = 0x%x\n", cond); 8582 printf (" cond = 0x%x\n", cond);
8571 } 8583 }
8572 SYNTAX("bm%2 #%1, %0%S0"); 8584 SYNTAX("bm%2 #%1, %0%S0");
8573 #line 901 "rx-decode.opc" 8585 #line 913 "rx-decode.opc"
8574 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BS IZE); 8586 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BS IZE);
8575 8587
8576 } 8588 }
8577 break; 8589 break;
8578 case 0x0f: 8590 case 0x0f:
8579 op_semantics_70: 8591 op_semantics_70:
8580 { 8592 {
8581 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */ 8593 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */
8582 #line 891 "rx-decode.opc" 8594 #line 903 "rx-decode.opc"
8583 int bit AU = (op[1] >> 2) & 0x07; 8595 int bit AU = (op[1] >> 2) & 0x07;
8584 #line 891 "rx-decode.opc" 8596 #line 903 "rx-decode.opc"
8585 int sd AU = op[1] & 0x03; 8597 int sd AU = op[1] & 0x03;
8586 #line 891 "rx-decode.opc" 8598 #line 903 "rx-decode.opc"
8587 int rdst AU = (op[2] >> 4) & 0x0f; 8599 int rdst AU = (op[2] >> 4) & 0x0f;
8588 if (trace) 8600 if (trace)
8589 { 8601 {
8590 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8602 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
8591 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */", 8603 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */",
8592 op[0], op[1], op[2]); 8604 op[0], op[1], op[2]);
8593 printf (" bit = 0x%x,", bit); 8605 printf (" bit = 0x%x,", bit);
8594 printf (" sd = 0x%x,", sd); 8606 printf (" sd = 0x%x,", sd);
8595 printf (" rdst = 0x%x\n", rdst); 8607 printf (" rdst = 0x%x\n", rdst);
8596 } 8608 }
8597 SYNTAX("bnot #%1, %0%S0"); 8609 SYNTAX("bnot #%1, %0%S0");
8598 #line 891 "rx-decode.opc" 8610 #line 903 "rx-decode.opc"
8599 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); 8611 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE);
8600 8612
8601 } 8613 }
8602 break; 8614 break;
8603 } 8615 }
8604 break; 8616 break;
8605 case 0xe1: 8617 case 0xe1:
8606 GETBYTE (); 8618 GETBYTE ();
8607 switch (op[2] & 0x0f) 8619 switch (op[2] & 0x0f)
8608 { 8620 {
(...skipping 806 matching lines...) Expand 10 before | Expand all | Expand 10 after
9415 GETBYTE (); 9427 GETBYTE ();
9416 switch (op[1] & 0xff) 9428 switch (op[1] & 0xff)
9417 { 9429 {
9418 case 0x00: 9430 case 0x00:
9419 GETBYTE (); 9431 GETBYTE ();
9420 switch (op[2] & 0x00) 9432 switch (op[2] & 0x00)
9421 { 9433 {
9422 case 0x00: 9434 case 0x00:
9423 { 9435 {
9424 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */ 9436 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */
9425 #line 774 "rx-decode.opc" 9437 #line 786 "rx-decode.opc"
9426 int srca AU = (op[2] >> 4) & 0x0f; 9438 int srca AU = (op[2] >> 4) & 0x0f;
9427 #line 774 "rx-decode.opc" 9439 #line 786 "rx-decode.opc"
9428 int srcb AU = op[2] & 0x0f; 9440 int srcb AU = op[2] & 0x0f;
9429 if (trace) 9441 if (trace)
9430 { 9442 {
9431 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9443 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9432 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */", 9444 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */",
9433 op[0], op[1], op[2]); 9445 op[0], op[1], op[2]);
9434 printf (" srca = 0x%x,", srca); 9446 printf (" srca = 0x%x,", srca);
9435 printf (" srcb = 0x%x\n", srcb); 9447 printf (" srcb = 0x%x\n", srcb);
9436 } 9448 }
9437 SYNTAX("mulhi %1, %2"); 9449 SYNTAX("mulhi %1, %2");
9438 #line 774 "rx-decode.opc" 9450 #line 786 "rx-decode.opc"
9439 ID(mulhi); SR(srca); S2R(srcb); F_____; 9451 ID(mulhi); SR(srca); S2R(srcb); F_____;
9440 9452
9441 } 9453 }
9442 break; 9454 break;
9443 } 9455 }
9444 break; 9456 break;
9445 case 0x01: 9457 case 0x01:
9446 GETBYTE (); 9458 GETBYTE ();
9447 switch (op[2] & 0x00) 9459 switch (op[2] & 0x00)
9448 { 9460 {
9449 case 0x00: 9461 case 0x00:
9450 { 9462 {
9451 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */ 9463 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */
9452 #line 777 "rx-decode.opc" 9464 #line 789 "rx-decode.opc"
9453 int srca AU = (op[2] >> 4) & 0x0f; 9465 int srca AU = (op[2] >> 4) & 0x0f;
9454 #line 777 "rx-decode.opc" 9466 #line 789 "rx-decode.opc"
9455 int srcb AU = op[2] & 0x0f; 9467 int srcb AU = op[2] & 0x0f;
9456 if (trace) 9468 if (trace)
9457 { 9469 {
9458 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9470 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9459 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */", 9471 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */",
9460 op[0], op[1], op[2]); 9472 op[0], op[1], op[2]);
9461 printf (" srca = 0x%x,", srca); 9473 printf (" srca = 0x%x,", srca);
9462 printf (" srcb = 0x%x\n", srcb); 9474 printf (" srcb = 0x%x\n", srcb);
9463 } 9475 }
9464 SYNTAX("mullo %1, %2"); 9476 SYNTAX("mullo %1, %2");
9465 #line 777 "rx-decode.opc" 9477 #line 789 "rx-decode.opc"
9466 ID(mullo); SR(srca); S2R(srcb); F_____; 9478 ID(mullo); SR(srca); S2R(srcb); F_____;
9467 9479
9468 } 9480 }
9469 break; 9481 break;
9470 } 9482 }
9471 break; 9483 break;
9472 case 0x04: 9484 case 0x04:
9473 GETBYTE (); 9485 GETBYTE ();
9474 switch (op[2] & 0x00) 9486 switch (op[2] & 0x00)
9475 { 9487 {
9476 case 0x00: 9488 case 0x00:
9477 { 9489 {
9478 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */ 9490 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */
9479 #line 780 "rx-decode.opc" 9491 #line 792 "rx-decode.opc"
9480 int srca AU = (op[2] >> 4) & 0x0f; 9492 int srca AU = (op[2] >> 4) & 0x0f;
9481 #line 780 "rx-decode.opc" 9493 #line 792 "rx-decode.opc"
9482 int srcb AU = op[2] & 0x0f; 9494 int srcb AU = op[2] & 0x0f;
9483 if (trace) 9495 if (trace)
9484 { 9496 {
9485 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9497 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9486 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */", 9498 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */",
9487 op[0], op[1], op[2]); 9499 op[0], op[1], op[2]);
9488 printf (" srca = 0x%x,", srca); 9500 printf (" srca = 0x%x,", srca);
9489 printf (" srcb = 0x%x\n", srcb); 9501 printf (" srcb = 0x%x\n", srcb);
9490 } 9502 }
9491 SYNTAX("machi %1, %2"); 9503 SYNTAX("machi %1, %2");
9492 #line 780 "rx-decode.opc" 9504 #line 792 "rx-decode.opc"
9493 ID(machi); SR(srca); S2R(srcb); F_____; 9505 ID(machi); SR(srca); S2R(srcb); F_____;
9494 9506
9495 } 9507 }
9496 break; 9508 break;
9497 } 9509 }
9498 break; 9510 break;
9499 case 0x05: 9511 case 0x05:
9500 GETBYTE (); 9512 GETBYTE ();
9501 switch (op[2] & 0x00) 9513 switch (op[2] & 0x00)
9502 { 9514 {
9503 case 0x00: 9515 case 0x00:
9504 { 9516 {
9505 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */ 9517 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */
9506 #line 783 "rx-decode.opc" 9518 #line 795 "rx-decode.opc"
9507 int srca AU = (op[2] >> 4) & 0x0f; 9519 int srca AU = (op[2] >> 4) & 0x0f;
9508 #line 783 "rx-decode.opc" 9520 #line 795 "rx-decode.opc"
9509 int srcb AU = op[2] & 0x0f; 9521 int srcb AU = op[2] & 0x0f;
9510 if (trace) 9522 if (trace)
9511 { 9523 {
9512 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9524 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9513 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */", 9525 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */",
9514 op[0], op[1], op[2]); 9526 op[0], op[1], op[2]);
9515 printf (" srca = 0x%x,", srca); 9527 printf (" srca = 0x%x,", srca);
9516 printf (" srcb = 0x%x\n", srcb); 9528 printf (" srcb = 0x%x\n", srcb);
9517 } 9529 }
9518 SYNTAX("maclo %1, %2"); 9530 SYNTAX("maclo %1, %2");
9519 #line 783 "rx-decode.opc" 9531 #line 795 "rx-decode.opc"
9520 ID(maclo); SR(srca); S2R(srcb); F_____; 9532 ID(maclo); SR(srca); S2R(srcb); F_____;
9521 9533
9522 } 9534 }
9523 break; 9535 break;
9524 } 9536 }
9525 break; 9537 break;
9526 case 0x17: 9538 case 0x17:
9527 GETBYTE (); 9539 GETBYTE ();
9528 switch (op[2] & 0xf0) 9540 switch (op[2] & 0xf0)
9529 { 9541 {
9530 case 0x00: 9542 case 0x00:
9531 { 9543 {
9532 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */ 9544 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */
9533 #line 786 "rx-decode.opc" 9545 #line 798 "rx-decode.opc"
9534 int rsrc AU = op[2] & 0x0f; 9546 int rsrc AU = op[2] & 0x0f;
9535 if (trace) 9547 if (trace)
9536 { 9548 {
9537 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9549 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9538 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */", 9550 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */",
9539 op[0], op[1], op[2]); 9551 op[0], op[1], op[2]);
9540 printf (" rsrc = 0x%x\n", rsrc); 9552 printf (" rsrc = 0x%x\n", rsrc);
9541 } 9553 }
9542 SYNTAX("mvtachi %1"); 9554 SYNTAX("mvtachi %1");
9543 #line 786 "rx-decode.opc" 9555 #line 798 "rx-decode.opc"
9544 ID(mvtachi); SR(rsrc); F_____; 9556 ID(mvtachi); SR(rsrc); F_____;
9545 9557
9546 } 9558 }
9547 break; 9559 break;
9548 case 0x10: 9560 case 0x10:
9549 { 9561 {
9550 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */ 9562 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */
9551 #line 789 "rx-decode.opc" 9563 #line 801 "rx-decode.opc"
9552 int rsrc AU = op[2] & 0x0f; 9564 int rsrc AU = op[2] & 0x0f;
9553 if (trace) 9565 if (trace)
9554 { 9566 {
9555 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9567 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9556 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */", 9568 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */",
9557 op[0], op[1], op[2]); 9569 op[0], op[1], op[2]);
9558 printf (" rsrc = 0x%x\n", rsrc); 9570 printf (" rsrc = 0x%x\n", rsrc);
9559 } 9571 }
9560 SYNTAX("mvtaclo %1"); 9572 SYNTAX("mvtaclo %1");
9561 #line 789 "rx-decode.opc" 9573 #line 801 "rx-decode.opc"
9562 ID(mvtaclo); SR(rsrc); F_____; 9574 ID(mvtaclo); SR(rsrc); F_____;
9563 9575
9564 } 9576 }
9565 break; 9577 break;
9566 default: UNSUPPORTED(); break; 9578 default: UNSUPPORTED(); break;
9567 } 9579 }
9568 break; 9580 break;
9569 case 0x18: 9581 case 0x18:
9570 GETBYTE (); 9582 GETBYTE ();
9571 switch (op[2] & 0xef) 9583 switch (op[2] & 0xef)
9572 { 9584 {
9573 case 0x00: 9585 case 0x00:
9574 { 9586 {
9575 /** 1111 1101 0001 1000 000i 0000 racw #%1 */ 9587 /** 1111 1101 0001 1000 000i 0000 racw #%1 */
9576 #line 801 "rx-decode.opc" 9588 #line 813 "rx-decode.opc"
9577 int i AU = (op[2] >> 4) & 0x01; 9589 int i AU = (op[2] >> 4) & 0x01;
9578 if (trace) 9590 if (trace)
9579 { 9591 {
9580 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9592 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9581 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */", 9593 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */",
9582 op[0], op[1], op[2]); 9594 op[0], op[1], op[2]);
9583 printf (" i = 0x%x\n", i); 9595 printf (" i = 0x%x\n", i);
9584 } 9596 }
9585 SYNTAX("racw #%1"); 9597 SYNTAX("racw #%1");
9586 #line 801 "rx-decode.opc" 9598 #line 813 "rx-decode.opc"
9587 ID(racw); SC(i+1); F_____; 9599 ID(racw); SC(i+1); F_____;
9588 9600
9589 /*---------------------------------------------------------- ------------*/ 9601 /*---------------------------------------------------------- ------------*/
9590 /* SAT */ 9602 /* SAT */
9591 9603
9592 } 9604 }
9593 break; 9605 break;
9594 default: UNSUPPORTED(); break; 9606 default: UNSUPPORTED(); break;
9595 } 9607 }
9596 break; 9608 break;
9597 case 0x1f: 9609 case 0x1f:
9598 GETBYTE (); 9610 GETBYTE ();
9599 switch (op[2] & 0xf0) 9611 switch (op[2] & 0xf0)
9600 { 9612 {
9601 case 0x00: 9613 case 0x00:
9602 { 9614 {
9603 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */ 9615 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */
9604 #line 792 "rx-decode.opc" 9616 #line 804 "rx-decode.opc"
9605 int rdst AU = op[2] & 0x0f; 9617 int rdst AU = op[2] & 0x0f;
9606 if (trace) 9618 if (trace)
9607 { 9619 {
9608 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9620 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9609 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */", 9621 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */",
9610 op[0], op[1], op[2]); 9622 op[0], op[1], op[2]);
9611 printf (" rdst = 0x%x\n", rdst); 9623 printf (" rdst = 0x%x\n", rdst);
9612 } 9624 }
9613 SYNTAX("mvfachi %0"); 9625 SYNTAX("mvfachi %0");
9614 #line 792 "rx-decode.opc" 9626 #line 804 "rx-decode.opc"
9615 ID(mvfachi); DR(rdst); F_____; 9627 ID(mvfachi); DR(rdst); F_____;
9616 9628
9617 } 9629 }
9618 break; 9630 break;
9619 case 0x10: 9631 case 0x10:
9620 { 9632 {
9621 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */ 9633 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */
9622 #line 798 "rx-decode.opc" 9634 #line 810 "rx-decode.opc"
9623 int rdst AU = op[2] & 0x0f; 9635 int rdst AU = op[2] & 0x0f;
9624 if (trace) 9636 if (trace)
9625 { 9637 {
9626 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9638 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9627 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */", 9639 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */",
9628 op[0], op[1], op[2]); 9640 op[0], op[1], op[2]);
9629 printf (" rdst = 0x%x\n", rdst); 9641 printf (" rdst = 0x%x\n", rdst);
9630 } 9642 }
9631 SYNTAX("mvfaclo %0"); 9643 SYNTAX("mvfaclo %0");
9632 #line 798 "rx-decode.opc" 9644 #line 810 "rx-decode.opc"
9633 ID(mvfaclo); DR(rdst); F_____; 9645 ID(mvfaclo); DR(rdst); F_____;
9634 9646
9635 } 9647 }
9636 break; 9648 break;
9637 case 0x20: 9649 case 0x20:
9638 { 9650 {
9639 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */ 9651 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */
9640 #line 795 "rx-decode.opc" 9652 #line 807 "rx-decode.opc"
9641 int rdst AU = op[2] & 0x0f; 9653 int rdst AU = op[2] & 0x0f;
9642 if (trace) 9654 if (trace)
9643 { 9655 {
9644 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9656 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9645 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */", 9657 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */",
9646 op[0], op[1], op[2]); 9658 op[0], op[1], op[2]);
9647 printf (" rdst = 0x%x\n", rdst); 9659 printf (" rdst = 0x%x\n", rdst);
9648 } 9660 }
9649 SYNTAX("mvfacmi %0"); 9661 SYNTAX("mvfacmi %0");
9650 #line 795 "rx-decode.opc" 9662 #line 807 "rx-decode.opc"
9651 ID(mvfacmi); DR(rdst); F_____; 9663 ID(mvfacmi); DR(rdst); F_____;
9652 9664
9653 } 9665 }
9654 break; 9666 break;
9655 default: UNSUPPORTED(); break; 9667 default: UNSUPPORTED(); break;
9656 } 9668 }
9657 break; 9669 break;
9658 case 0x20: 9670 case 0x20:
9659 GETBYTE (); 9671 GETBYTE ();
9660 switch (op[2] & 0x00) 9672 switch (op[2] & 0x00)
9661 { 9673 {
9662 case 0x00: 9674 case 0x00:
9663 op_semantics_71: 9675 op_semantics_71:
9664 { 9676 {
9665 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 * / 9677 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 * /
9666 #line 308 "rx-decode.opc" 9678 #line 320 "rx-decode.opc"
9667 int p AU = (op[1] >> 2) & 0x01; 9679 int p AU = (op[1] >> 2) & 0x01;
9668 #line 308 "rx-decode.opc" 9680 #line 320 "rx-decode.opc"
9669 int sz AU = op[1] & 0x03; 9681 int sz AU = op[1] & 0x03;
9670 #line 308 "rx-decode.opc" 9682 #line 320 "rx-decode.opc"
9671 int rdst AU = (op[2] >> 4) & 0x0f; 9683 int rdst AU = (op[2] >> 4) & 0x0f;
9672 #line 308 "rx-decode.opc" 9684 #line 320 "rx-decode.opc"
9673 int rsrc AU = op[2] & 0x0f; 9685 int rsrc AU = op[2] & 0x0f;
9674 if (trace) 9686 if (trace)
9675 { 9687 {
9676 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9688 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9677 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */", 9689 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */",
9678 op[0], op[1], op[2]); 9690 op[0], op[1], op[2]);
9679 printf (" p = 0x%x,", p); 9691 printf (" p = 0x%x,", p);
9680 printf (" sz = 0x%x,", sz); 9692 printf (" sz = 0x%x,", sz);
9681 printf (" rdst = 0x%x,", rdst); 9693 printf (" rdst = 0x%x,", rdst);
9682 printf (" rsrc = 0x%x\n", rsrc); 9694 printf (" rsrc = 0x%x\n", rsrc);
9683 } 9695 }
9684 SYNTAX("mov%s %1, %0"); 9696 SYNTAX("mov%s %1, %0");
9685 #line 308 "rx-decode.opc" 9697 #line 320 "rx-decode.opc"
9686 ID(mov); sBWL (sz); SR(rsrc); F_____; 9698 ID(mov); sBWL (sz); SR(rsrc); F_____;
9687 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0) ; 9699 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0) ;
9688 9700
9689 } 9701 }
9690 break; 9702 break;
9691 } 9703 }
9692 break; 9704 break;
9693 case 0x21: 9705 case 0x21:
9694 GETBYTE (); 9706 GETBYTE ();
9695 switch (op[2] & 0x00) 9707 switch (op[2] & 0x00)
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
9736 } 9748 }
9737 break; 9749 break;
9738 case 0x28: 9750 case 0x28:
9739 GETBYTE (); 9751 GETBYTE ();
9740 switch (op[2] & 0x00) 9752 switch (op[2] & 0x00)
9741 { 9753 {
9742 case 0x00: 9754 case 0x00:
9743 op_semantics_72: 9755 op_semantics_72:
9744 { 9756 {
9745 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 * / 9757 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 * /
9746 #line 312 "rx-decode.opc" 9758 #line 324 "rx-decode.opc"
9747 int p AU = (op[1] >> 2) & 0x01; 9759 int p AU = (op[1] >> 2) & 0x01;
9748 #line 312 "rx-decode.opc" 9760 #line 324 "rx-decode.opc"
9749 int sz AU = op[1] & 0x03; 9761 int sz AU = op[1] & 0x03;
9750 #line 312 "rx-decode.opc" 9762 #line 324 "rx-decode.opc"
9751 int rsrc AU = (op[2] >> 4) & 0x0f; 9763 int rsrc AU = (op[2] >> 4) & 0x0f;
9752 #line 312 "rx-decode.opc" 9764 #line 324 "rx-decode.opc"
9753 int rdst AU = op[2] & 0x0f; 9765 int rdst AU = op[2] & 0x0f;
9754 if (trace) 9766 if (trace)
9755 { 9767 {
9756 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9768 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9757 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */", 9769 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */",
9758 op[0], op[1], op[2]); 9770 op[0], op[1], op[2]);
9759 printf (" p = 0x%x,", p); 9771 printf (" p = 0x%x,", p);
9760 printf (" sz = 0x%x,", sz); 9772 printf (" sz = 0x%x,", sz);
9761 printf (" rsrc = 0x%x,", rsrc); 9773 printf (" rsrc = 0x%x,", rsrc);
9762 printf (" rdst = 0x%x\n", rdst); 9774 printf (" rdst = 0x%x\n", rdst);
9763 } 9775 }
9764 SYNTAX("mov%s %1, %0"); 9776 SYNTAX("mov%s %1, %0");
9765 #line 312 "rx-decode.opc" 9777 #line 324 "rx-decode.opc"
9766 ID(mov); sBWL (sz); DR(rdst); F_____; 9778 ID(mov); sBWL (sz); DR(rdst); F_____;
9767 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0) ; 9779 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0) ;
9768 9780
9769 } 9781 }
9770 break; 9782 break;
9771 } 9783 }
9772 break; 9784 break;
9773 case 0x29: 9785 case 0x29:
9774 GETBYTE (); 9786 GETBYTE ();
9775 switch (op[2] & 0x00) 9787 switch (op[2] & 0x00)
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after
9816 } 9828 }
9817 break; 9829 break;
9818 case 0x38: 9830 case 0x38:
9819 GETBYTE (); 9831 GETBYTE ();
9820 switch (op[2] & 0x00) 9832 switch (op[2] & 0x00)
9821 { 9833 {
9822 case 0x00: 9834 case 0x00:
9823 op_semantics_73: 9835 op_semantics_73:
9824 { 9836 {
9825 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 * / 9837 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 * /
9826 #line 322 "rx-decode.opc" 9838 #line 334 "rx-decode.opc"
9827 int p AU = (op[1] >> 2) & 0x01; 9839 int p AU = (op[1] >> 2) & 0x01;
9828 #line 322 "rx-decode.opc" 9840 #line 334 "rx-decode.opc"
9829 int sz AU = op[1] & 0x03; 9841 int sz AU = op[1] & 0x03;
9830 #line 322 "rx-decode.opc" 9842 #line 334 "rx-decode.opc"
9831 int rsrc AU = (op[2] >> 4) & 0x0f; 9843 int rsrc AU = (op[2] >> 4) & 0x0f;
9832 #line 322 "rx-decode.opc" 9844 #line 334 "rx-decode.opc"
9833 int rdst AU = op[2] & 0x0f; 9845 int rdst AU = op[2] & 0x0f;
9834 if (trace) 9846 if (trace)
9835 { 9847 {
9836 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9848 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9837 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */", 9849 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */",
9838 op[0], op[1], op[2]); 9850 op[0], op[1], op[2]);
9839 printf (" p = 0x%x,", p); 9851 printf (" p = 0x%x,", p);
9840 printf (" sz = 0x%x,", sz); 9852 printf (" sz = 0x%x,", sz);
9841 printf (" rsrc = 0x%x,", rsrc); 9853 printf (" rsrc = 0x%x,", rsrc);
9842 printf (" rdst = 0x%x\n", rdst); 9854 printf (" rdst = 0x%x\n", rdst);
9843 } 9855 }
9844 SYNTAX("movu%s %1, %0"); 9856 SYNTAX("movu%s %1, %0");
9845 #line 322 "rx-decode.opc" 9857 #line 334 "rx-decode.opc"
9846 ID(mov); uBWL (sz); DR(rdst); F_____; 9858 ID(mov); uBWL (sz); DR(rdst); F_____;
9847 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0 ); 9859 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0 );
9848 9860
9849 /*---------------------------------------------------------- ------------*/ 9861 /*---------------------------------------------------------- ------------*/
9850 /* PUSH/POP */ 9862 /* PUSH/POP */
9851 9863
9852 } 9864 }
9853 break; 9865 break;
9854 } 9866 }
9855 break; 9867 break;
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after
9898 break; 9910 break;
9899 } 9911 }
9900 break; 9912 break;
9901 case 0x60: 9913 case 0x60:
9902 GETBYTE (); 9914 GETBYTE ();
9903 switch (op[2] & 0x00) 9915 switch (op[2] & 0x00)
9904 { 9916 {
9905 case 0x00: 9917 case 0x00:
9906 { 9918 {
9907 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */ 9919 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */
9908 #line 655 "rx-decode.opc" 9920 #line 667 "rx-decode.opc"
9909 int rsrc AU = (op[2] >> 4) & 0x0f; 9921 int rsrc AU = (op[2] >> 4) & 0x0f;
9910 #line 655 "rx-decode.opc" 9922 #line 667 "rx-decode.opc"
9911 int rdst AU = op[2] & 0x0f; 9923 int rdst AU = op[2] & 0x0f;
9912 if (trace) 9924 if (trace)
9913 { 9925 {
9914 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9926 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9915 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */", 9927 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */",
9916 op[0], op[1], op[2]); 9928 op[0], op[1], op[2]);
9917 printf (" rsrc = 0x%x,", rsrc); 9929 printf (" rsrc = 0x%x,", rsrc);
9918 printf (" rdst = 0x%x\n", rdst); 9930 printf (" rdst = 0x%x\n", rdst);
9919 } 9931 }
9920 SYNTAX("shlr %2, %0"); 9932 SYNTAX("shlr %2, %0");
9921 #line 655 "rx-decode.opc" 9933 #line 667 "rx-decode.opc"
9922 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC; 9934 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC;
9923 9935
9924 } 9936 }
9925 break; 9937 break;
9926 } 9938 }
9927 break; 9939 break;
9928 case 0x61: 9940 case 0x61:
9929 GETBYTE (); 9941 GETBYTE ();
9930 switch (op[2] & 0x00) 9942 switch (op[2] & 0x00)
9931 { 9943 {
9932 case 0x00: 9944 case 0x00:
9933 { 9945 {
9934 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */ 9946 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */
9935 #line 645 "rx-decode.opc" 9947 #line 657 "rx-decode.opc"
9936 int rsrc AU = (op[2] >> 4) & 0x0f; 9948 int rsrc AU = (op[2] >> 4) & 0x0f;
9937 #line 645 "rx-decode.opc" 9949 #line 657 "rx-decode.opc"
9938 int rdst AU = op[2] & 0x0f; 9950 int rdst AU = op[2] & 0x0f;
9939 if (trace) 9951 if (trace)
9940 { 9952 {
9941 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9953 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9942 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */", 9954 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */",
9943 op[0], op[1], op[2]); 9955 op[0], op[1], op[2]);
9944 printf (" rsrc = 0x%x,", rsrc); 9956 printf (" rsrc = 0x%x,", rsrc);
9945 printf (" rdst = 0x%x\n", rdst); 9957 printf (" rdst = 0x%x\n", rdst);
9946 } 9958 }
9947 SYNTAX("shar %2, %0"); 9959 SYNTAX("shar %2, %0");
9948 #line 645 "rx-decode.opc" 9960 #line 657 "rx-decode.opc"
9949 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC; 9961 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC;
9950 9962
9951 } 9963 }
9952 break; 9964 break;
9953 } 9965 }
9954 break; 9966 break;
9955 case 0x62: 9967 case 0x62:
9956 GETBYTE (); 9968 GETBYTE ();
9957 switch (op[2] & 0x00) 9969 switch (op[2] & 0x00)
9958 { 9970 {
9959 case 0x00: 9971 case 0x00:
9960 { 9972 {
9961 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */ 9973 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */
9962 #line 635 "rx-decode.opc" 9974 #line 647 "rx-decode.opc"
9963 int rsrc AU = (op[2] >> 4) & 0x0f; 9975 int rsrc AU = (op[2] >> 4) & 0x0f;
9964 #line 635 "rx-decode.opc" 9976 #line 647 "rx-decode.opc"
9965 int rdst AU = op[2] & 0x0f; 9977 int rdst AU = op[2] & 0x0f;
9966 if (trace) 9978 if (trace)
9967 { 9979 {
9968 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9980 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9969 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */", 9981 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */",
9970 op[0], op[1], op[2]); 9982 op[0], op[1], op[2]);
9971 printf (" rsrc = 0x%x,", rsrc); 9983 printf (" rsrc = 0x%x,", rsrc);
9972 printf (" rdst = 0x%x\n", rdst); 9984 printf (" rdst = 0x%x\n", rdst);
9973 } 9985 }
9974 SYNTAX("shll %2, %0"); 9986 SYNTAX("shll %2, %0");
9975 #line 635 "rx-decode.opc" 9987 #line 647 "rx-decode.opc"
9976 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC; 9988 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC;
9977 9989
9978 } 9990 }
9979 break; 9991 break;
9980 } 9992 }
9981 break; 9993 break;
9982 case 0x64: 9994 case 0x64:
9983 GETBYTE (); 9995 GETBYTE ();
9984 switch (op[2] & 0x00) 9996 switch (op[2] & 0x00)
9985 { 9997 {
9986 case 0x00: 9998 case 0x00:
9987 { 9999 {
9988 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */ 10000 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */
9989 #line 679 "rx-decode.opc" 10001 #line 691 "rx-decode.opc"
9990 int rsrc AU = (op[2] >> 4) & 0x0f; 10002 int rsrc AU = (op[2] >> 4) & 0x0f;
9991 #line 679 "rx-decode.opc" 10003 #line 691 "rx-decode.opc"
9992 int rdst AU = op[2] & 0x0f; 10004 int rdst AU = op[2] & 0x0f;
9993 if (trace) 10005 if (trace)
9994 { 10006 {
9995 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10007 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
9996 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */", 10008 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */",
9997 op[0], op[1], op[2]); 10009 op[0], op[1], op[2]);
9998 printf (" rsrc = 0x%x,", rsrc); 10010 printf (" rsrc = 0x%x,", rsrc);
9999 printf (" rdst = 0x%x\n", rdst); 10011 printf (" rdst = 0x%x\n", rdst);
10000 } 10012 }
10001 SYNTAX("rotr %1, %0"); 10013 SYNTAX("rotr %1, %0");
10002 #line 679 "rx-decode.opc" 10014 #line 691 "rx-decode.opc"
10003 ID(rotr); SR(rsrc); DR(rdst); F__SZC; 10015 ID(rotr); SR(rsrc); DR(rdst); F__SZC;
10004 10016
10005 } 10017 }
10006 break; 10018 break;
10007 } 10019 }
10008 break; 10020 break;
10009 case 0x65: 10021 case 0x65:
10010 GETBYTE (); 10022 GETBYTE ();
10011 switch (op[2] & 0x00) 10023 switch (op[2] & 0x00)
10012 { 10024 {
10013 case 0x00: 10025 case 0x00:
10014 { 10026 {
10015 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */ 10027 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */
10016 #line 682 "rx-decode.opc" 10028 #line 694 "rx-decode.opc"
10017 int rsrc AU = (op[2] >> 4) & 0x0f; 10029 int rsrc AU = (op[2] >> 4) & 0x0f;
10018 #line 682 "rx-decode.opc" 10030 #line 694 "rx-decode.opc"
10019 int rdst AU = op[2] & 0x0f; 10031 int rdst AU = op[2] & 0x0f;
10020 if (trace) 10032 if (trace)
10021 { 10033 {
10022 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10034 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10023 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */", 10035 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */",
10024 op[0], op[1], op[2]); 10036 op[0], op[1], op[2]);
10025 printf (" rsrc = 0x%x,", rsrc); 10037 printf (" rsrc = 0x%x,", rsrc);
10026 printf (" rdst = 0x%x\n", rdst); 10038 printf (" rdst = 0x%x\n", rdst);
10027 } 10039 }
10028 SYNTAX("revw %1, %0"); 10040 SYNTAX("revw %1, %0");
10029 #line 682 "rx-decode.opc" 10041 #line 694 "rx-decode.opc"
10030 ID(revw); SR(rsrc); DR(rdst); 10042 ID(revw); SR(rsrc); DR(rdst);
10031 10043
10032 } 10044 }
10033 break; 10045 break;
10034 } 10046 }
10035 break; 10047 break;
10036 case 0x66: 10048 case 0x66:
10037 GETBYTE (); 10049 GETBYTE ();
10038 switch (op[2] & 0x00) 10050 switch (op[2] & 0x00)
10039 { 10051 {
10040 case 0x00: 10052 case 0x00:
10041 { 10053 {
10042 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */ 10054 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */
10043 #line 673 "rx-decode.opc" 10055 #line 685 "rx-decode.opc"
10044 int rsrc AU = (op[2] >> 4) & 0x0f; 10056 int rsrc AU = (op[2] >> 4) & 0x0f;
10045 #line 673 "rx-decode.opc" 10057 #line 685 "rx-decode.opc"
10046 int rdst AU = op[2] & 0x0f; 10058 int rdst AU = op[2] & 0x0f;
10047 if (trace) 10059 if (trace)
10048 { 10060 {
10049 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10061 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10050 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */", 10062 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */",
10051 op[0], op[1], op[2]); 10063 op[0], op[1], op[2]);
10052 printf (" rsrc = 0x%x,", rsrc); 10064 printf (" rsrc = 0x%x,", rsrc);
10053 printf (" rdst = 0x%x\n", rdst); 10065 printf (" rdst = 0x%x\n", rdst);
10054 } 10066 }
10055 SYNTAX("rotl %1, %0"); 10067 SYNTAX("rotl %1, %0");
10056 #line 673 "rx-decode.opc" 10068 #line 685 "rx-decode.opc"
10057 ID(rotl); SR(rsrc); DR(rdst); F__SZC; 10069 ID(rotl); SR(rsrc); DR(rdst); F__SZC;
10058 10070
10059 } 10071 }
10060 break; 10072 break;
10061 } 10073 }
10062 break; 10074 break;
10063 case 0x67: 10075 case 0x67:
10064 GETBYTE (); 10076 GETBYTE ();
10065 switch (op[2] & 0x00) 10077 switch (op[2] & 0x00)
10066 { 10078 {
10067 case 0x00: 10079 case 0x00:
10068 { 10080 {
10069 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */ 10081 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */
10070 #line 685 "rx-decode.opc" 10082 #line 697 "rx-decode.opc"
10071 int rsrc AU = (op[2] >> 4) & 0x0f; 10083 int rsrc AU = (op[2] >> 4) & 0x0f;
10072 #line 685 "rx-decode.opc" 10084 #line 697 "rx-decode.opc"
10073 int rdst AU = op[2] & 0x0f; 10085 int rdst AU = op[2] & 0x0f;
10074 if (trace) 10086 if (trace)
10075 { 10087 {
10076 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10088 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10077 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */", 10089 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */",
10078 op[0], op[1], op[2]); 10090 op[0], op[1], op[2]);
10079 printf (" rsrc = 0x%x,", rsrc); 10091 printf (" rsrc = 0x%x,", rsrc);
10080 printf (" rdst = 0x%x\n", rdst); 10092 printf (" rdst = 0x%x\n", rdst);
10081 } 10093 }
10082 SYNTAX("revl %1, %0"); 10094 SYNTAX("revl %1, %0");
10083 #line 685 "rx-decode.opc" 10095 #line 697 "rx-decode.opc"
10084 ID(revl); SR(rsrc); DR(rdst); 10096 ID(revl); SR(rsrc); DR(rdst);
10085 10097
10086 /*---------------------------------------------------------- ------------*/ 10098 /*---------------------------------------------------------- ------------*/
10087 /* BRANCH */ 10099 /* BRANCH */
10088 10100
10089 } 10101 }
10090 break; 10102 break;
10091 } 10103 }
10092 break; 10104 break;
10093 case 0x68: 10105 case 0x68:
10094 GETBYTE (); 10106 GETBYTE ();
10095 switch (op[2] & 0x00) 10107 switch (op[2] & 0x00)
10096 { 10108 {
10097 case 0x00: 10109 case 0x00:
10098 op_semantics_74: 10110 op_semantics_74:
10099 { 10111 {
10100 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */ 10112 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */
10101 #line 928 "rx-decode.opc" 10113 #line 940 "rx-decode.opc"
10102 int c AU = op[1] & 0x01; 10114 int c AU = op[1] & 0x01;
10103 #line 928 "rx-decode.opc" 10115 #line 940 "rx-decode.opc"
10104 int rsrc AU = (op[2] >> 4) & 0x0f; 10116 int rsrc AU = (op[2] >> 4) & 0x0f;
10105 #line 928 "rx-decode.opc" 10117 #line 940 "rx-decode.opc"
10106 int rdst AU = op[2] & 0x0f; 10118 int rdst AU = op[2] & 0x0f;
10107 if (trace) 10119 if (trace)
10108 { 10120 {
10109 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10121 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10110 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */", 10122 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */",
10111 op[0], op[1], op[2]); 10123 op[0], op[1], op[2]);
10112 printf (" c = 0x%x,", c); 10124 printf (" c = 0x%x,", c);
10113 printf (" rsrc = 0x%x,", rsrc); 10125 printf (" rsrc = 0x%x,", rsrc);
10114 printf (" rdst = 0x%x\n", rdst); 10126 printf (" rdst = 0x%x\n", rdst);
10115 } 10127 }
10116 SYNTAX("mvtc %1, %0"); 10128 SYNTAX("mvtc %1, %0");
10117 #line 928 "rx-decode.opc" 10129 #line 940 "rx-decode.opc"
10118 ID(mov); SR(rsrc); DR(c*16+rdst + 16); 10130 ID(mov); SR(rsrc); DR(c*16+rdst + 16);
10119 10131
10120 } 10132 }
10121 break; 10133 break;
10122 } 10134 }
10123 break; 10135 break;
10124 case 0x69: 10136 case 0x69:
10125 GETBYTE (); 10137 GETBYTE ();
10126 switch (op[2] & 0x00) 10138 switch (op[2] & 0x00)
10127 { 10139 {
10128 case 0x00: 10140 case 0x00:
10129 goto op_semantics_74; 10141 goto op_semantics_74;
10130 break; 10142 break;
10131 } 10143 }
10132 break; 10144 break;
10133 case 0x6a: 10145 case 0x6a:
10134 GETBYTE (); 10146 GETBYTE ();
10135 switch (op[2] & 0x00) 10147 switch (op[2] & 0x00)
10136 { 10148 {
10137 case 0x00: 10149 case 0x00:
10138 op_semantics_75: 10150 op_semantics_75:
10139 { 10151 {
10140 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */ 10152 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */
10141 #line 931 "rx-decode.opc" 10153 #line 943 "rx-decode.opc"
10142 int s AU = op[1] & 0x01; 10154 int s AU = op[1] & 0x01;
10143 #line 931 "rx-decode.opc" 10155 #line 943 "rx-decode.opc"
10144 int rsrc AU = (op[2] >> 4) & 0x0f; 10156 int rsrc AU = (op[2] >> 4) & 0x0f;
10145 #line 931 "rx-decode.opc" 10157 #line 943 "rx-decode.opc"
10146 int rdst AU = op[2] & 0x0f; 10158 int rdst AU = op[2] & 0x0f;
10147 if (trace) 10159 if (trace)
10148 { 10160 {
10149 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10161 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10150 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */", 10162 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */",
10151 op[0], op[1], op[2]); 10163 op[0], op[1], op[2]);
10152 printf (" s = 0x%x,", s); 10164 printf (" s = 0x%x,", s);
10153 printf (" rsrc = 0x%x,", rsrc); 10165 printf (" rsrc = 0x%x,", rsrc);
10154 printf (" rdst = 0x%x\n", rdst); 10166 printf (" rdst = 0x%x\n", rdst);
10155 } 10167 }
10156 SYNTAX("mvfc %1, %0"); 10168 SYNTAX("mvfc %1, %0");
10157 #line 931 "rx-decode.opc" 10169 #line 943 "rx-decode.opc"
10158 ID(mov); SR((s*16+rsrc) + 16); DR(rdst); 10170 ID(mov); SR((s*16+rsrc) + 16); DR(rdst);
10159 10171
10160 /*---------------------------------------------------------- ------------*/ 10172 /*---------------------------------------------------------- ------------*/
10161 /* INTERRUPTS */ 10173 /* INTERRUPTS */
10162 10174
10163 } 10175 }
10164 break; 10176 break;
10165 } 10177 }
10166 break; 10178 break;
10167 case 0x6b: 10179 case 0x6b:
10168 GETBYTE (); 10180 GETBYTE ();
10169 switch (op[2] & 0x00) 10181 switch (op[2] & 0x00)
10170 { 10182 {
10171 case 0x00: 10183 case 0x00:
10172 goto op_semantics_75; 10184 goto op_semantics_75;
10173 break; 10185 break;
10174 } 10186 }
10175 break; 10187 break;
10176 case 0x6c: 10188 case 0x6c:
10177 GETBYTE (); 10189 GETBYTE ();
10178 switch (op[2] & 0x00) 10190 switch (op[2] & 0x00)
10179 { 10191 {
10180 case 0x00: 10192 case 0x00:
10181 op_semantics_76: 10193 op_semantics_76:
10182 { 10194 {
10183 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */ 10195 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */
10184 #line 676 "rx-decode.opc" 10196 #line 688 "rx-decode.opc"
10185 int i AU = op[1] & 0x01; 10197 int i AU = op[1] & 0x01;
10186 #line 676 "rx-decode.opc" 10198 #line 688 "rx-decode.opc"
10187 int mmmm AU = (op[2] >> 4) & 0x0f; 10199 int mmmm AU = (op[2] >> 4) & 0x0f;
10188 #line 676 "rx-decode.opc" 10200 #line 688 "rx-decode.opc"
10189 int rdst AU = op[2] & 0x0f; 10201 int rdst AU = op[2] & 0x0f;
10190 if (trace) 10202 if (trace)
10191 { 10203 {
10192 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10204 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10193 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */", 10205 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */",
10194 op[0], op[1], op[2]); 10206 op[0], op[1], op[2]);
10195 printf (" i = 0x%x,", i); 10207 printf (" i = 0x%x,", i);
10196 printf (" mmmm = 0x%x,", mmmm); 10208 printf (" mmmm = 0x%x,", mmmm);
10197 printf (" rdst = 0x%x\n", rdst); 10209 printf (" rdst = 0x%x\n", rdst);
10198 } 10210 }
10199 SYNTAX("rotr #%1, %0"); 10211 SYNTAX("rotr #%1, %0");
10200 #line 676 "rx-decode.opc" 10212 #line 688 "rx-decode.opc"
10201 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC; 10213 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC;
10202 10214
10203 } 10215 }
10204 break; 10216 break;
10205 } 10217 }
10206 break; 10218 break;
10207 case 0x6d: 10219 case 0x6d:
10208 GETBYTE (); 10220 GETBYTE ();
10209 switch (op[2] & 0x00) 10221 switch (op[2] & 0x00)
10210 { 10222 {
10211 case 0x00: 10223 case 0x00:
10212 goto op_semantics_76; 10224 goto op_semantics_76;
10213 break; 10225 break;
10214 } 10226 }
10215 break; 10227 break;
10216 case 0x6e: 10228 case 0x6e:
10217 GETBYTE (); 10229 GETBYTE ();
10218 switch (op[2] & 0x00) 10230 switch (op[2] & 0x00)
10219 { 10231 {
10220 case 0x00: 10232 case 0x00:
10221 op_semantics_77: 10233 op_semantics_77:
10222 { 10234 {
10223 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */ 10235 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */
10224 #line 670 "rx-decode.opc" 10236 #line 682 "rx-decode.opc"
10225 int i AU = op[1] & 0x01; 10237 int i AU = op[1] & 0x01;
10226 #line 670 "rx-decode.opc" 10238 #line 682 "rx-decode.opc"
10227 int mmmm AU = (op[2] >> 4) & 0x0f; 10239 int mmmm AU = (op[2] >> 4) & 0x0f;
10228 #line 670 "rx-decode.opc" 10240 #line 682 "rx-decode.opc"
10229 int rdst AU = op[2] & 0x0f; 10241 int rdst AU = op[2] & 0x0f;
10230 if (trace) 10242 if (trace)
10231 { 10243 {
10232 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10244 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10233 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */", 10245 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */",
10234 op[0], op[1], op[2]); 10246 op[0], op[1], op[2]);
10235 printf (" i = 0x%x,", i); 10247 printf (" i = 0x%x,", i);
10236 printf (" mmmm = 0x%x,", mmmm); 10248 printf (" mmmm = 0x%x,", mmmm);
10237 printf (" rdst = 0x%x\n", rdst); 10249 printf (" rdst = 0x%x\n", rdst);
10238 } 10250 }
10239 SYNTAX("rotl #%1, %0"); 10251 SYNTAX("rotl #%1, %0");
10240 #line 670 "rx-decode.opc" 10252 #line 682 "rx-decode.opc"
10241 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC; 10253 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC;
10242 10254
10243 } 10255 }
10244 break; 10256 break;
10245 } 10257 }
10246 break; 10258 break;
10247 case 0x6f: 10259 case 0x6f:
10248 GETBYTE (); 10260 GETBYTE ();
10249 switch (op[2] & 0x00) 10261 switch (op[2] & 0x00)
10250 { 10262 {
10251 case 0x00: 10263 case 0x00:
10252 goto op_semantics_77; 10264 goto op_semantics_77;
10253 break; 10265 break;
10254 } 10266 }
10255 break; 10267 break;
10256 case 0x70: 10268 case 0x70:
10257 GETBYTE (); 10269 GETBYTE ();
10258 switch (op[2] & 0xf0) 10270 switch (op[2] & 0xf0)
10259 { 10271 {
10260 case 0x20: 10272 case 0x20:
10261 op_semantics_78: 10273 op_semantics_78:
10262 { 10274 {
10263 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */ 10275 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */
10264 #line 452 "rx-decode.opc" 10276 #line 464 "rx-decode.opc"
10265 int im AU = (op[1] >> 2) & 0x03; 10277 int im AU = (op[1] >> 2) & 0x03;
10266 #line 452 "rx-decode.opc" 10278 #line 464 "rx-decode.opc"
10267 int rdst AU = op[2] & 0x0f; 10279 int rdst AU = op[2] & 0x0f;
10268 if (trace) 10280 if (trace)
10269 { 10281 {
10270 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10282 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10271 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */", 10283 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */",
10272 op[0], op[1], op[2]); 10284 op[0], op[1], op[2]);
10273 printf (" im = 0x%x,", im); 10285 printf (" im = 0x%x,", im);
10274 printf (" rdst = 0x%x\n", rdst); 10286 printf (" rdst = 0x%x\n", rdst);
10275 } 10287 }
10276 SYNTAX("adc #%1, %0"); 10288 SYNTAX("adc #%1, %0");
10277 #line 452 "rx-decode.opc" 10289 #line 464 "rx-decode.opc"
10278 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC; 10290 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC;
10279 10291
10280 } 10292 }
10281 break; 10293 break;
10282 case 0x40: 10294 case 0x40:
10283 op_semantics_79: 10295 op_semantics_79:
10284 { 10296 {
10285 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */ 10297 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */
10286 #line 534 "rx-decode.opc" 10298 #line 546 "rx-decode.opc"
10287 int im AU = (op[1] >> 2) & 0x03; 10299 int im AU = (op[1] >> 2) & 0x03;
10288 #line 534 "rx-decode.opc" 10300 #line 546 "rx-decode.opc"
10289 int rdst AU = op[2] & 0x0f; 10301 int rdst AU = op[2] & 0x0f;
10290 if (trace) 10302 if (trace)
10291 { 10303 {
10292 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10304 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10293 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */", 10305 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */",
10294 op[0], op[1], op[2]); 10306 op[0], op[1], op[2]);
10295 printf (" im = 0x%x,", im); 10307 printf (" im = 0x%x,", im);
10296 printf (" rdst = 0x%x\n", rdst); 10308 printf (" rdst = 0x%x\n", rdst);
10297 } 10309 }
10298 SYNTAX("max #%1, %0"); 10310 SYNTAX("max #%1, %0");
10299 #line 534 "rx-decode.opc" 10311 #line 546 "rx-decode.opc"
10300 ID(max); DR(rdst); SC(IMMex(im)); 10312 ID(max); DR(rdst); SC(IMMex(im));
10301 10313
10302 } 10314 }
10303 break; 10315 break;
10304 case 0x50: 10316 case 0x50:
10305 op_semantics_80: 10317 op_semantics_80:
10306 { 10318 {
10307 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */ 10319 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */
10308 #line 554 "rx-decode.opc" 10320 #line 566 "rx-decode.opc"
10309 int im AU = (op[1] >> 2) & 0x03; 10321 int im AU = (op[1] >> 2) & 0x03;
10310 #line 554 "rx-decode.opc" 10322 #line 566 "rx-decode.opc"
10311 int rdst AU = op[2] & 0x0f; 10323 int rdst AU = op[2] & 0x0f;
10312 if (trace) 10324 if (trace)
10313 { 10325 {
10314 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10326 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10315 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */", 10327 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */",
10316 op[0], op[1], op[2]); 10328 op[0], op[1], op[2]);
10317 printf (" im = 0x%x,", im); 10329 printf (" im = 0x%x,", im);
10318 printf (" rdst = 0x%x\n", rdst); 10330 printf (" rdst = 0x%x\n", rdst);
10319 } 10331 }
10320 SYNTAX("min #%1, %0"); 10332 SYNTAX("min #%1, %0");
10321 #line 554 "rx-decode.opc" 10333 #line 566 "rx-decode.opc"
10322 ID(min); DR(rdst); SC(IMMex(im)); 10334 ID(min); DR(rdst); SC(IMMex(im));
10323 10335
10324 } 10336 }
10325 break; 10337 break;
10326 case 0x60: 10338 case 0x60:
10327 op_semantics_81: 10339 op_semantics_81:
10328 { 10340 {
10329 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */ 10341 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */
10330 #line 584 "rx-decode.opc" 10342 #line 596 "rx-decode.opc"
10331 int im AU = (op[1] >> 2) & 0x03; 10343 int im AU = (op[1] >> 2) & 0x03;
10332 #line 584 "rx-decode.opc" 10344 #line 596 "rx-decode.opc"
10333 int rdst AU = op[2] & 0x0f; 10345 int rdst AU = op[2] & 0x0f;
10334 if (trace) 10346 if (trace)
10335 { 10347 {
10336 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10348 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10337 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */", 10349 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */",
10338 op[0], op[1], op[2]); 10350 op[0], op[1], op[2]);
10339 printf (" im = 0x%x,", im); 10351 printf (" im = 0x%x,", im);
10340 printf (" rdst = 0x%x\n", rdst); 10352 printf (" rdst = 0x%x\n", rdst);
10341 } 10353 }
10342 SYNTAX("emul #%1, %0"); 10354 SYNTAX("emul #%1, %0");
10343 #line 584 "rx-decode.opc" 10355 #line 596 "rx-decode.opc"
10344 ID(emul); DR(rdst); SC(IMMex(im)); 10356 ID(emul); DR(rdst); SC(IMMex(im));
10345 10357
10346 } 10358 }
10347 break; 10359 break;
10348 case 0x70: 10360 case 0x70:
10349 op_semantics_82: 10361 op_semantics_82:
10350 { 10362 {
10351 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */ 10363 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */
10352 #line 596 "rx-decode.opc" 10364 #line 608 "rx-decode.opc"
10353 int im AU = (op[1] >> 2) & 0x03; 10365 int im AU = (op[1] >> 2) & 0x03;
10354 #line 596 "rx-decode.opc" 10366 #line 608 "rx-decode.opc"
10355 int rdst AU = op[2] & 0x0f; 10367 int rdst AU = op[2] & 0x0f;
10356 if (trace) 10368 if (trace)
10357 { 10369 {
10358 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10370 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10359 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */", 10371 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */",
10360 op[0], op[1], op[2]); 10372 op[0], op[1], op[2]);
10361 printf (" im = 0x%x,", im); 10373 printf (" im = 0x%x,", im);
10362 printf (" rdst = 0x%x\n", rdst); 10374 printf (" rdst = 0x%x\n", rdst);
10363 } 10375 }
10364 SYNTAX("emulu #%1, %0"); 10376 SYNTAX("emulu #%1, %0");
10365 #line 596 "rx-decode.opc" 10377 #line 608 "rx-decode.opc"
10366 ID(emulu); DR(rdst); SC(IMMex(im)); 10378 ID(emulu); DR(rdst); SC(IMMex(im));
10367 10379
10368 } 10380 }
10369 break; 10381 break;
10370 case 0x80: 10382 case 0x80:
10371 op_semantics_83: 10383 op_semantics_83:
10372 { 10384 {
10373 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */ 10385 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */
10374 #line 608 "rx-decode.opc" 10386 #line 620 "rx-decode.opc"
10375 int im AU = (op[1] >> 2) & 0x03; 10387 int im AU = (op[1] >> 2) & 0x03;
10376 #line 608 "rx-decode.opc" 10388 #line 620 "rx-decode.opc"
10377 int rdst AU = op[2] & 0x0f; 10389 int rdst AU = op[2] & 0x0f;
10378 if (trace) 10390 if (trace)
10379 { 10391 {
10380 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10392 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10381 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */", 10393 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */",
10382 op[0], op[1], op[2]); 10394 op[0], op[1], op[2]);
10383 printf (" im = 0x%x,", im); 10395 printf (" im = 0x%x,", im);
10384 printf (" rdst = 0x%x\n", rdst); 10396 printf (" rdst = 0x%x\n", rdst);
10385 } 10397 }
10386 SYNTAX("div #%1, %0"); 10398 SYNTAX("div #%1, %0");
10387 #line 608 "rx-decode.opc" 10399 #line 620 "rx-decode.opc"
10388 ID(div); DR(rdst); SC(IMMex(im)); F_O___; 10400 ID(div); DR(rdst); SC(IMMex(im)); F_O___;
10389 10401
10390 } 10402 }
10391 break; 10403 break;
10392 case 0x90: 10404 case 0x90:
10393 op_semantics_84: 10405 op_semantics_84:
10394 { 10406 {
10395 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */ 10407 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */
10396 #line 620 "rx-decode.opc" 10408 #line 632 "rx-decode.opc"
10397 int im AU = (op[1] >> 2) & 0x03; 10409 int im AU = (op[1] >> 2) & 0x03;
10398 #line 620 "rx-decode.opc" 10410 #line 632 "rx-decode.opc"
10399 int rdst AU = op[2] & 0x0f; 10411 int rdst AU = op[2] & 0x0f;
10400 if (trace) 10412 if (trace)
10401 { 10413 {
10402 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10414 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10403 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */", 10415 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */",
10404 op[0], op[1], op[2]); 10416 op[0], op[1], op[2]);
10405 printf (" im = 0x%x,", im); 10417 printf (" im = 0x%x,", im);
10406 printf (" rdst = 0x%x\n", rdst); 10418 printf (" rdst = 0x%x\n", rdst);
10407 } 10419 }
10408 SYNTAX("divu #%1, %0"); 10420 SYNTAX("divu #%1, %0");
10409 #line 620 "rx-decode.opc" 10421 #line 632 "rx-decode.opc"
10410 ID(divu); DR(rdst); SC(IMMex(im)); F_O___; 10422 ID(divu); DR(rdst); SC(IMMex(im)); F_O___;
10411 10423
10412 } 10424 }
10413 break; 10425 break;
10414 case 0xc0: 10426 case 0xc0:
10415 op_semantics_85: 10427 op_semantics_85:
10416 { 10428 {
10417 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */ 10429 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */
10418 #line 431 "rx-decode.opc" 10430 #line 443 "rx-decode.opc"
10419 int im AU = (op[1] >> 2) & 0x03; 10431 int im AU = (op[1] >> 2) & 0x03;
10420 #line 431 "rx-decode.opc" 10432 #line 443 "rx-decode.opc"
10421 int rdst AU = op[2] & 0x0f; 10433 int rdst AU = op[2] & 0x0f;
10422 if (trace) 10434 if (trace)
10423 { 10435 {
10424 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10436 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10425 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */", 10437 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */",
10426 op[0], op[1], op[2]); 10438 op[0], op[1], op[2]);
10427 printf (" im = 0x%x,", im); 10439 printf (" im = 0x%x,", im);
10428 printf (" rdst = 0x%x\n", rdst); 10440 printf (" rdst = 0x%x\n", rdst);
10429 } 10441 }
10430 SYNTAX("tst #%1, %2"); 10442 SYNTAX("tst #%1, %2");
10431 #line 431 "rx-decode.opc" 10443 #line 443 "rx-decode.opc"
10432 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_; 10444 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_;
10433 10445
10434 } 10446 }
10435 break; 10447 break;
10436 case 0xd0: 10448 case 0xd0:
10437 op_semantics_86: 10449 op_semantics_86:
10438 { 10450 {
10439 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */ 10451 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */
10440 #line 410 "rx-decode.opc" 10452 #line 422 "rx-decode.opc"
10441 int im AU = (op[1] >> 2) & 0x03; 10453 int im AU = (op[1] >> 2) & 0x03;
10442 #line 410 "rx-decode.opc" 10454 #line 422 "rx-decode.opc"
10443 int rdst AU = op[2] & 0x0f; 10455 int rdst AU = op[2] & 0x0f;
10444 if (trace) 10456 if (trace)
10445 { 10457 {
10446 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10458 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10447 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */", 10459 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */",
10448 op[0], op[1], op[2]); 10460 op[0], op[1], op[2]);
10449 printf (" im = 0x%x,", im); 10461 printf (" im = 0x%x,", im);
10450 printf (" rdst = 0x%x\n", rdst); 10462 printf (" rdst = 0x%x\n", rdst);
10451 } 10463 }
10452 SYNTAX("xor #%1, %0"); 10464 SYNTAX("xor #%1, %0");
10453 #line 410 "rx-decode.opc" 10465 #line 422 "rx-decode.opc"
10454 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_; 10466 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_;
10455 10467
10456 } 10468 }
10457 break; 10469 break;
10458 case 0xe0: 10470 case 0xe0:
10459 op_semantics_87: 10471 op_semantics_87:
10460 { 10472 {
10461 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */ 10473 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */
10462 #line 356 "rx-decode.opc" 10474 #line 368 "rx-decode.opc"
10463 int im AU = (op[1] >> 2) & 0x03; 10475 int im AU = (op[1] >> 2) & 0x03;
10464 #line 356 "rx-decode.opc" 10476 #line 368 "rx-decode.opc"
10465 int rdst AU = op[2] & 0x0f; 10477 int rdst AU = op[2] & 0x0f;
10466 if (trace) 10478 if (trace)
10467 { 10479 {
10468 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10480 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10469 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */", 10481 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */",
10470 op[0], op[1], op[2]); 10482 op[0], op[1], op[2]);
10471 printf (" im = 0x%x,", im); 10483 printf (" im = 0x%x,", im);
10472 printf (" rdst = 0x%x\n", rdst); 10484 printf (" rdst = 0x%x\n", rdst);
10473 } 10485 }
10474 SYNTAX("stz #%1, %0"); 10486 SYNTAX("stz #%1, %0");
10475 #line 356 "rx-decode.opc" 10487 #line 368 "rx-decode.opc"
10476 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z); 10488 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z);
10477 10489
10478 } 10490 }
10479 break; 10491 break;
10480 case 0xf0: 10492 case 0xf0:
10481 op_semantics_88: 10493 op_semantics_88:
10482 { 10494 {
10483 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */ 10495 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */
10484 #line 359 "rx-decode.opc" 10496 #line 371 "rx-decode.opc"
10485 int im AU = (op[1] >> 2) & 0x03; 10497 int im AU = (op[1] >> 2) & 0x03;
10486 #line 359 "rx-decode.opc" 10498 #line 371 "rx-decode.opc"
10487 int rdst AU = op[2] & 0x0f; 10499 int rdst AU = op[2] & 0x0f;
10488 if (trace) 10500 if (trace)
10489 { 10501 {
10490 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10502 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10491 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */", 10503 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */",
10492 op[0], op[1], op[2]); 10504 op[0], op[1], op[2]);
10493 printf (" im = 0x%x,", im); 10505 printf (" im = 0x%x,", im);
10494 printf (" rdst = 0x%x\n", rdst); 10506 printf (" rdst = 0x%x\n", rdst);
10495 } 10507 }
10496 SYNTAX("stnz #%1, %0"); 10508 SYNTAX("stnz #%1, %0");
10497 #line 359 "rx-decode.opc" 10509 #line 371 "rx-decode.opc"
10498 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz); 10510 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz);
10499 10511
10500 /*---------------------------------------------------------- ------------*/ 10512 /*---------------------------------------------------------- ------------*/
10501 /* RTSD */ 10513 /* RTSD */
10502 10514
10503 } 10515 }
10504 break; 10516 break;
10505 default: UNSUPPORTED(); break; 10517 default: UNSUPPORTED(); break;
10506 } 10518 }
10507 break; 10519 break;
10508 case 0x72: 10520 case 0x72:
10509 GETBYTE (); 10521 GETBYTE ();
10510 switch (op[2] & 0xf0) 10522 switch (op[2] & 0xf0)
10511 { 10523 {
10512 case 0x00: 10524 case 0x00:
10513 { 10525 {
10514 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */ 10526 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */
10515 #line 828 "rx-decode.opc" 10527 #line 840 "rx-decode.opc"
10516 int rdst AU = op[2] & 0x0f; 10528 int rdst AU = op[2] & 0x0f;
10517 if (trace) 10529 if (trace)
10518 { 10530 {
10519 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10531 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10520 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */", 10532 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */",
10521 op[0], op[1], op[2]); 10533 op[0], op[1], op[2]);
10522 printf (" rdst = 0x%x\n", rdst); 10534 printf (" rdst = 0x%x\n", rdst);
10523 } 10535 }
10524 SYNTAX("fsub #%1, %0"); 10536 SYNTAX("fsub #%1, %0");
10525 #line 828 "rx-decode.opc" 10537 #line 840 "rx-decode.opc"
10526 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_; 10538 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_;
10527 10539
10528 } 10540 }
10529 break; 10541 break;
10530 case 0x10: 10542 case 0x10:
10531 { 10543 {
10532 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */ 10544 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */
10533 #line 822 "rx-decode.opc" 10545 #line 834 "rx-decode.opc"
10534 int rdst AU = op[2] & 0x0f; 10546 int rdst AU = op[2] & 0x0f;
10535 if (trace) 10547 if (trace)
10536 { 10548 {
10537 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10549 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10538 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */", 10550 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */",
10539 op[0], op[1], op[2]); 10551 op[0], op[1], op[2]);
10540 printf (" rdst = 0x%x\n", rdst); 10552 printf (" rdst = 0x%x\n", rdst);
10541 } 10553 }
10542 SYNTAX("fcmp #%1, %0"); 10554 SYNTAX("fcmp #%1, %0");
10543 #line 822 "rx-decode.opc" 10555 #line 834 "rx-decode.opc"
10544 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_; 10556 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_;
10545 10557
10546 } 10558 }
10547 break; 10559 break;
10548 case 0x20: 10560 case 0x20:
10549 { 10561 {
10550 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */ 10562 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */
10551 #line 816 "rx-decode.opc" 10563 #line 828 "rx-decode.opc"
10552 int rdst AU = op[2] & 0x0f; 10564 int rdst AU = op[2] & 0x0f;
10553 if (trace) 10565 if (trace)
10554 { 10566 {
10555 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10567 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10556 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */", 10568 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */",
10557 op[0], op[1], op[2]); 10569 op[0], op[1], op[2]);
10558 printf (" rdst = 0x%x\n", rdst); 10570 printf (" rdst = 0x%x\n", rdst);
10559 } 10571 }
10560 SYNTAX("fadd #%1, %0"); 10572 SYNTAX("fadd #%1, %0");
10561 #line 816 "rx-decode.opc" 10573 #line 828 "rx-decode.opc"
10562 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_; 10574 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_;
10563 10575
10564 } 10576 }
10565 break; 10577 break;
10566 case 0x30: 10578 case 0x30:
10567 { 10579 {
10568 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */ 10580 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */
10569 #line 837 "rx-decode.opc" 10581 #line 849 "rx-decode.opc"
10570 int rdst AU = op[2] & 0x0f; 10582 int rdst AU = op[2] & 0x0f;
10571 if (trace) 10583 if (trace)
10572 { 10584 {
10573 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10585 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10574 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */", 10586 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */",
10575 op[0], op[1], op[2]); 10587 op[0], op[1], op[2]);
10576 printf (" rdst = 0x%x\n", rdst); 10588 printf (" rdst = 0x%x\n", rdst);
10577 } 10589 }
10578 SYNTAX("fmul #%1, %0"); 10590 SYNTAX("fmul #%1, %0");
10579 #line 837 "rx-decode.opc" 10591 #line 849 "rx-decode.opc"
10580 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_; 10592 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_;
10581 10593
10582 } 10594 }
10583 break; 10595 break;
10584 case 0x40: 10596 case 0x40:
10585 { 10597 {
10586 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */ 10598 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */
10587 #line 843 "rx-decode.opc" 10599 #line 855 "rx-decode.opc"
10588 int rdst AU = op[2] & 0x0f; 10600 int rdst AU = op[2] & 0x0f;
10589 if (trace) 10601 if (trace)
10590 { 10602 {
10591 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10603 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10592 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */", 10604 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */",
10593 op[0], op[1], op[2]); 10605 op[0], op[1], op[2]);
10594 printf (" rdst = 0x%x\n", rdst); 10606 printf (" rdst = 0x%x\n", rdst);
10595 } 10607 }
10596 SYNTAX("fdiv #%1, %0"); 10608 SYNTAX("fdiv #%1, %0");
10597 #line 843 "rx-decode.opc" 10609 #line 855 "rx-decode.opc"
10598 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_; 10610 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_;
10599 10611
10600 } 10612 }
10601 break; 10613 break;
10602 default: UNSUPPORTED(); break; 10614 default: UNSUPPORTED(); break;
10603 } 10615 }
10604 break; 10616 break;
10605 case 0x73: 10617 case 0x73:
10606 GETBYTE (); 10618 GETBYTE ();
10607 switch (op[2] & 0xe0) 10619 switch (op[2] & 0xe0)
10608 { 10620 {
10609 case 0x00: 10621 case 0x00:
10610 op_semantics_89: 10622 op_semantics_89:
10611 { 10623 {
10612 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */ 10624 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */
10613 #line 925 "rx-decode.opc" 10625 #line 937 "rx-decode.opc"
10614 int im AU = (op[1] >> 2) & 0x03; 10626 int im AU = (op[1] >> 2) & 0x03;
10615 #line 925 "rx-decode.opc" 10627 #line 937 "rx-decode.opc"
10616 int crdst AU = op[2] & 0x1f; 10628 int crdst AU = op[2] & 0x1f;
10617 if (trace) 10629 if (trace)
10618 { 10630 {
10619 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10631 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10620 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */", 10632 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */",
10621 op[0], op[1], op[2]); 10633 op[0], op[1], op[2]);
10622 printf (" im = 0x%x,", im); 10634 printf (" im = 0x%x,", im);
10623 printf (" crdst = 0x%x\n", crdst); 10635 printf (" crdst = 0x%x\n", crdst);
10624 } 10636 }
10625 SYNTAX("mvtc #%1, %0"); 10637 SYNTAX("mvtc #%1, %0");
10626 #line 925 "rx-decode.opc" 10638 #line 937 "rx-decode.opc"
10627 ID(mov); SC(IMMex(im)); DR(crdst + 16); 10639 ID(mov); SC(IMMex(im)); DR(crdst + 16);
10628 10640
10629 } 10641 }
10630 break; 10642 break;
10631 default: UNSUPPORTED(); break; 10643 default: UNSUPPORTED(); break;
10632 } 10644 }
10633 break; 10645 break;
10634 case 0x74: 10646 case 0x74:
10635 GETBYTE (); 10647 GETBYTE ();
10636 switch (op[2] & 0xf0) 10648 switch (op[2] & 0xf0)
(...skipping 145 matching lines...) Expand 10 before | Expand all | Expand 10 after
10782 } 10794 }
10783 break; 10795 break;
10784 case 0x80: 10796 case 0x80:
10785 GETBYTE (); 10797 GETBYTE ();
10786 switch (op[2] & 0x00) 10798 switch (op[2] & 0x00)
10787 { 10799 {
10788 case 0x00: 10800 case 0x00:
10789 op_semantics_90: 10801 op_semantics_90:
10790 { 10802 {
10791 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */ 10803 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */
10792 #line 658 "rx-decode.opc" 10804 #line 670 "rx-decode.opc"
10793 int immmm AU = op[1] & 0x1f; 10805 int immmm AU = op[1] & 0x1f;
10794 #line 658 "rx-decode.opc" 10806 #line 670 "rx-decode.opc"
10795 int rsrc AU = (op[2] >> 4) & 0x0f; 10807 int rsrc AU = (op[2] >> 4) & 0x0f;
10796 #line 658 "rx-decode.opc" 10808 #line 670 "rx-decode.opc"
10797 int rdst AU = op[2] & 0x0f; 10809 int rdst AU = op[2] & 0x0f;
10798 if (trace) 10810 if (trace)
10799 { 10811 {
10800 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10812 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
10801 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */", 10813 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */",
10802 op[0], op[1], op[2]); 10814 op[0], op[1], op[2]);
10803 printf (" immmm = 0x%x,", immmm); 10815 printf (" immmm = 0x%x,", immmm);
10804 printf (" rsrc = 0x%x,", rsrc); 10816 printf (" rsrc = 0x%x,", rsrc);
10805 printf (" rdst = 0x%x\n", rdst); 10817 printf (" rdst = 0x%x\n", rdst);
10806 } 10818 }
10807 SYNTAX("shlr #%2, %1, %0"); 10819 SYNTAX("shlr #%2, %1, %0");
10808 #line 658 "rx-decode.opc" 10820 #line 670 "rx-decode.opc"
10809 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC; 10821 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC;
10810 10822
10811 /*---------------------------------------------------------- ------------*/ 10823 /*---------------------------------------------------------- ------------*/
10812 /* ROTATE */ 10824 /* ROTATE */
10813 10825
10814 } 10826 }
10815 break; 10827 break;
10816 } 10828 }
10817 break; 10829 break;
10818 case 0x81: 10830 case 0x81:
(...skipping 276 matching lines...) Expand 10 before | Expand all | Expand 10 after
11095 } 11107 }
11096 break; 11108 break;
11097 case 0xa0: 11109 case 0xa0:
11098 GETBYTE (); 11110 GETBYTE ();
11099 switch (op[2] & 0x00) 11111 switch (op[2] & 0x00)
11100 { 11112 {
11101 case 0x00: 11113 case 0x00:
11102 op_semantics_91: 11114 op_semantics_91:
11103 { 11115 {
11104 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */ 11116 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */
11105 #line 648 "rx-decode.opc" 11117 #line 660 "rx-decode.opc"
11106 int immmm AU = op[1] & 0x1f; 11118 int immmm AU = op[1] & 0x1f;
11107 #line 648 "rx-decode.opc" 11119 #line 660 "rx-decode.opc"
11108 int rsrc AU = (op[2] >> 4) & 0x0f; 11120 int rsrc AU = (op[2] >> 4) & 0x0f;
11109 #line 648 "rx-decode.opc" 11121 #line 660 "rx-decode.opc"
11110 int rdst AU = op[2] & 0x0f; 11122 int rdst AU = op[2] & 0x0f;
11111 if (trace) 11123 if (trace)
11112 { 11124 {
11113 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11125 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11114 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */", 11126 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */",
11115 op[0], op[1], op[2]); 11127 op[0], op[1], op[2]);
11116 printf (" immmm = 0x%x,", immmm); 11128 printf (" immmm = 0x%x,", immmm);
11117 printf (" rsrc = 0x%x,", rsrc); 11129 printf (" rsrc = 0x%x,", rsrc);
11118 printf (" rdst = 0x%x\n", rdst); 11130 printf (" rdst = 0x%x\n", rdst);
11119 } 11131 }
11120 SYNTAX("shar #%2, %1, %0"); 11132 SYNTAX("shar #%2, %1, %0");
11121 #line 648 "rx-decode.opc" 11133 #line 660 "rx-decode.opc"
11122 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC; 11134 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC;
11123 11135
11124 11136
11125 } 11137 }
11126 break; 11138 break;
11127 } 11139 }
11128 break; 11140 break;
11129 case 0xa1: 11141 case 0xa1:
11130 GETBYTE (); 11142 GETBYTE ();
11131 switch (op[2] & 0x00) 11143 switch (op[2] & 0x00)
(...skipping 274 matching lines...) Expand 10 before | Expand all | Expand 10 after
11406 } 11418 }
11407 break; 11419 break;
11408 case 0xc0: 11420 case 0xc0:
11409 GETBYTE (); 11421 GETBYTE ();
11410 switch (op[2] & 0x00) 11422 switch (op[2] & 0x00)
11411 { 11423 {
11412 case 0x00: 11424 case 0x00:
11413 op_semantics_92: 11425 op_semantics_92:
11414 { 11426 {
11415 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */ 11427 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */
11416 #line 638 "rx-decode.opc" 11428 #line 650 "rx-decode.opc"
11417 int immmm AU = op[1] & 0x1f; 11429 int immmm AU = op[1] & 0x1f;
11418 #line 638 "rx-decode.opc" 11430 #line 650 "rx-decode.opc"
11419 int rsrc AU = (op[2] >> 4) & 0x0f; 11431 int rsrc AU = (op[2] >> 4) & 0x0f;
11420 #line 638 "rx-decode.opc" 11432 #line 650 "rx-decode.opc"
11421 int rdst AU = op[2] & 0x0f; 11433 int rdst AU = op[2] & 0x0f;
11422 if (trace) 11434 if (trace)
11423 { 11435 {
11424 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11436 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11425 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */", 11437 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */",
11426 op[0], op[1], op[2]); 11438 op[0], op[1], op[2]);
11427 printf (" immmm = 0x%x,", immmm); 11439 printf (" immmm = 0x%x,", immmm);
11428 printf (" rsrc = 0x%x,", rsrc); 11440 printf (" rsrc = 0x%x,", rsrc);
11429 printf (" rdst = 0x%x\n", rdst); 11441 printf (" rdst = 0x%x\n", rdst);
11430 } 11442 }
11431 SYNTAX("shll #%2, %1, %0"); 11443 SYNTAX("shll #%2, %1, %0");
11432 #line 638 "rx-decode.opc" 11444 #line 650 "rx-decode.opc"
11433 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC; 11445 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC;
11434 11446
11435 11447
11436 } 11448 }
11437 break; 11449 break;
11438 } 11450 }
11439 break; 11451 break;
11440 case 0xc1: 11452 case 0xc1:
11441 GETBYTE (); 11453 GETBYTE ();
11442 switch (op[2] & 0x00) 11454 switch (op[2] & 0x00)
(...skipping 288 matching lines...) Expand 10 before | Expand all | Expand 10 after
11731 case 0x80: 11743 case 0x80:
11732 case 0x90: 11744 case 0x90:
11733 case 0xa0: 11745 case 0xa0:
11734 case 0xb0: 11746 case 0xb0:
11735 case 0xc0: 11747 case 0xc0:
11736 case 0xd0: 11748 case 0xd0:
11737 case 0xe0: 11749 case 0xe0:
11738 op_semantics_93: 11750 op_semantics_93:
11739 { 11751 {
11740 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */ 11752 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */
11741 #line 904 "rx-decode.opc" 11753 #line 916 "rx-decode.opc"
11742 int bittt AU = op[1] & 0x1f; 11754 int bittt AU = op[1] & 0x1f;
11743 #line 904 "rx-decode.opc" 11755 #line 916 "rx-decode.opc"
11744 int cond AU = (op[2] >> 4) & 0x0f; 11756 int cond AU = (op[2] >> 4) & 0x0f;
11745 #line 904 "rx-decode.opc" 11757 #line 916 "rx-decode.opc"
11746 int rdst AU = op[2] & 0x0f; 11758 int rdst AU = op[2] & 0x0f;
11747 if (trace) 11759 if (trace)
11748 { 11760 {
11749 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11761 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11750 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */", 11762 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */",
11751 op[0], op[1], op[2]); 11763 op[0], op[1], op[2]);
11752 printf (" bittt = 0x%x,", bittt); 11764 printf (" bittt = 0x%x,", bittt);
11753 printf (" cond = 0x%x,", cond); 11765 printf (" cond = 0x%x,", cond);
11754 printf (" rdst = 0x%x\n", rdst); 11766 printf (" rdst = 0x%x\n", rdst);
11755 } 11767 }
11756 SYNTAX("bm%2 #%1, %0%S0"); 11768 SYNTAX("bm%2 #%1, %0%S0");
11757 #line 904 "rx-decode.opc" 11769 #line 916 "rx-decode.opc"
11758 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst); 11770 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst);
11759 11771
11760 /*---------------------------------------------------------- ------------*/ 11772 /*---------------------------------------------------------- ------------*/
11761 /* CONTROL REGISTERS */ 11773 /* CONTROL REGISTERS */
11762 11774
11763 } 11775 }
11764 break; 11776 break;
11765 case 0xf0: 11777 case 0xf0:
11766 op_semantics_94: 11778 op_semantics_94:
11767 { 11779 {
11768 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */ 11780 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */
11769 #line 897 "rx-decode.opc" 11781 #line 909 "rx-decode.opc"
11770 int bittt AU = op[1] & 0x1f; 11782 int bittt AU = op[1] & 0x1f;
11771 #line 897 "rx-decode.opc" 11783 #line 909 "rx-decode.opc"
11772 int rdst AU = op[2] & 0x0f; 11784 int rdst AU = op[2] & 0x0f;
11773 if (trace) 11785 if (trace)
11774 { 11786 {
11775 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11787 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
11776 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */", 11788 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */",
11777 op[0], op[1], op[2]); 11789 op[0], op[1], op[2]);
11778 printf (" bittt = 0x%x,", bittt); 11790 printf (" bittt = 0x%x,", bittt);
11779 printf (" rdst = 0x%x\n", rdst); 11791 printf (" rdst = 0x%x\n", rdst);
11780 } 11792 }
11781 SYNTAX("bnot #%1, %0"); 11793 SYNTAX("bnot #%1, %0");
11782 #line 897 "rx-decode.opc" 11794 #line 909 "rx-decode.opc"
11783 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst); 11795 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst);
11784 11796
11785 11797
11786 } 11798 }
11787 break; 11799 break;
11788 } 11800 }
11789 break; 11801 break;
11790 case 0xe1: 11802 case 0xe1:
11791 GETBYTE (); 11803 GETBYTE ();
11792 switch (op[2] & 0xf0) 11804 switch (op[2] & 0xf0)
(...skipping 808 matching lines...) Expand 10 before | Expand all | Expand 10 after
12601 switch (op[1] & 0xff) 12613 switch (op[1] & 0xff)
12602 { 12614 {
12603 case 0x00: 12615 case 0x00:
12604 GETBYTE (); 12616 GETBYTE ();
12605 switch (op[2] & 0x00) 12617 switch (op[2] & 0x00)
12606 { 12618 {
12607 case 0x00: 12619 case 0x00:
12608 op_semantics_95: 12620 op_semantics_95:
12609 { 12621 {
12610 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */ 12622 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */
12611 #line 302 "rx-decode.opc" 12623 #line 314 "rx-decode.opc"
12612 int sz AU = (op[1] >> 4) & 0x03; 12624 int sz AU = (op[1] >> 4) & 0x03;
12613 #line 302 "rx-decode.opc" 12625 #line 314 "rx-decode.opc"
12614 int isrc AU = op[1] & 0x0f; 12626 int isrc AU = op[1] & 0x0f;
12615 #line 302 "rx-decode.opc" 12627 #line 314 "rx-decode.opc"
12616 int bsrc AU = (op[2] >> 4) & 0x0f; 12628 int bsrc AU = (op[2] >> 4) & 0x0f;
12617 #line 302 "rx-decode.opc" 12629 #line 314 "rx-decode.opc"
12618 int rdst AU = op[2] & 0x0f; 12630 int rdst AU = op[2] & 0x0f;
12619 if (trace) 12631 if (trace)
12620 { 12632 {
12621 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12633 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
12622 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */", 12634 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */",
12623 op[0], op[1], op[2]); 12635 op[0], op[1], op[2]);
12624 printf (" sz = 0x%x,", sz); 12636 printf (" sz = 0x%x,", sz);
12625 printf (" isrc = 0x%x,", isrc); 12637 printf (" isrc = 0x%x,", isrc);
12626 printf (" bsrc = 0x%x,", bsrc); 12638 printf (" bsrc = 0x%x,", bsrc);
12627 printf (" rdst = 0x%x\n", rdst); 12639 printf (" rdst = 0x%x\n", rdst);
12628 } 12640 }
12629 SYNTAX("mov%s %0, [%1, %2]"); 12641 SYNTAX("mov%s %0, [%1, %2]");
12630 #line 302 "rx-decode.opc" 12642 #line 314 "rx-decode.opc"
12631 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F___ __; 12643 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F___ __;
12632 12644
12633 } 12645 }
12634 break; 12646 break;
12635 } 12647 }
12636 break; 12648 break;
12637 case 0x01: 12649 case 0x01:
12638 GETBYTE (); 12650 GETBYTE ();
12639 switch (op[2] & 0x00) 12651 switch (op[2] & 0x00)
12640 { 12652 {
(...skipping 417 matching lines...) Expand 10 before | Expand all | Expand 10 after
13058 } 13070 }
13059 break; 13071 break;
13060 case 0x40: 13072 case 0x40:
13061 GETBYTE (); 13073 GETBYTE ();
13062 switch (op[2] & 0x00) 13074 switch (op[2] & 0x00)
13063 { 13075 {
13064 case 0x00: 13076 case 0x00:
13065 op_semantics_96: 13077 op_semantics_96:
13066 { 13078 {
13067 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */ 13079 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */
13068 #line 299 "rx-decode.opc" 13080 #line 311 "rx-decode.opc"
13069 int sz AU = (op[1] >> 4) & 0x03; 13081 int sz AU = (op[1] >> 4) & 0x03;
13070 #line 299 "rx-decode.opc" 13082 #line 311 "rx-decode.opc"
13071 int isrc AU = op[1] & 0x0f; 13083 int isrc AU = op[1] & 0x0f;
13072 #line 299 "rx-decode.opc" 13084 #line 311 "rx-decode.opc"
13073 int bsrc AU = (op[2] >> 4) & 0x0f; 13085 int bsrc AU = (op[2] >> 4) & 0x0f;
13074 #line 299 "rx-decode.opc" 13086 #line 311 "rx-decode.opc"
13075 int rdst AU = op[2] & 0x0f; 13087 int rdst AU = op[2] & 0x0f;
13076 if (trace) 13088 if (trace)
13077 { 13089 {
13078 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13090 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13079 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */", 13091 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */",
13080 op[0], op[1], op[2]); 13092 op[0], op[1], op[2]);
13081 printf (" sz = 0x%x,", sz); 13093 printf (" sz = 0x%x,", sz);
13082 printf (" isrc = 0x%x,", isrc); 13094 printf (" isrc = 0x%x,", isrc);
13083 printf (" bsrc = 0x%x,", bsrc); 13095 printf (" bsrc = 0x%x,", bsrc);
13084 printf (" rdst = 0x%x\n", rdst); 13096 printf (" rdst = 0x%x\n", rdst);
13085 } 13097 }
13086 SYNTAX("mov%s [%1, %2], %0"); 13098 SYNTAX("mov%s [%1, %2], %0");
13087 #line 299 "rx-decode.opc" 13099 #line 311 "rx-decode.opc"
13088 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F____ _; 13100 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F____ _;
13089 13101
13090 } 13102 }
13091 break; 13103 break;
13092 } 13104 }
13093 break; 13105 break;
13094 case 0x41: 13106 case 0x41:
13095 GETBYTE (); 13107 GETBYTE ();
13096 switch (op[2] & 0x00) 13108 switch (op[2] & 0x00)
13097 { 13109 {
(...skipping 417 matching lines...) Expand 10 before | Expand all | Expand 10 after
13515 } 13527 }
13516 break; 13528 break;
13517 case 0xc0: 13529 case 0xc0:
13518 GETBYTE (); 13530 GETBYTE ();
13519 switch (op[2] & 0x00) 13531 switch (op[2] & 0x00)
13520 { 13532 {
13521 case 0x00: 13533 case 0x00:
13522 op_semantics_97: 13534 op_semantics_97:
13523 { 13535 {
13524 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */ 13536 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */
13525 #line 305 "rx-decode.opc" 13537 #line 317 "rx-decode.opc"
13526 int sz AU = (op[1] >> 4) & 0x03; 13538 int sz AU = (op[1] >> 4) & 0x03;
13527 #line 305 "rx-decode.opc" 13539 #line 317 "rx-decode.opc"
13528 int isrc AU = op[1] & 0x0f; 13540 int isrc AU = op[1] & 0x0f;
13529 #line 305 "rx-decode.opc" 13541 #line 317 "rx-decode.opc"
13530 int bsrc AU = (op[2] >> 4) & 0x0f; 13542 int bsrc AU = (op[2] >> 4) & 0x0f;
13531 #line 305 "rx-decode.opc" 13543 #line 317 "rx-decode.opc"
13532 int rdst AU = op[2] & 0x0f; 13544 int rdst AU = op[2] & 0x0f;
13533 if (trace) 13545 if (trace)
13534 { 13546 {
13535 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13547 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13536 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */", 13548 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */",
13537 op[0], op[1], op[2]); 13549 op[0], op[1], op[2]);
13538 printf (" sz = 0x%x,", sz); 13550 printf (" sz = 0x%x,", sz);
13539 printf (" isrc = 0x%x,", isrc); 13551 printf (" isrc = 0x%x,", isrc);
13540 printf (" bsrc = 0x%x,", bsrc); 13552 printf (" bsrc = 0x%x,", bsrc);
13541 printf (" rdst = 0x%x\n", rdst); 13553 printf (" rdst = 0x%x\n", rdst);
13542 } 13554 }
13543 SYNTAX("movu%s [%1, %2], %0"); 13555 SYNTAX("movu%s [%1, %2], %0");
13544 #line 305 "rx-decode.opc" 13556 #line 317 "rx-decode.opc"
13545 ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F____ _; 13557 ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F____ _;
13546 13558
13547 } 13559 }
13548 break; 13560 break;
13549 } 13561 }
13550 break; 13562 break;
13551 case 0xc1: 13563 case 0xc1:
13552 GETBYTE (); 13564 GETBYTE ();
13553 switch (op[2] & 0x00) 13565 switch (op[2] & 0x00)
13554 { 13566 {
(...skipping 424 matching lines...) Expand 10 before | Expand all | Expand 10 after
13979 switch (op[1] & 0xff) 13991 switch (op[1] & 0xff)
13980 { 13992 {
13981 case 0x00: 13993 case 0x00:
13982 GETBYTE (); 13994 GETBYTE ();
13983 switch (op[2] & 0x00) 13995 switch (op[2] & 0x00)
13984 { 13996 {
13985 case 0x00: 13997 case 0x00:
13986 op_semantics_98: 13998 op_semantics_98:
13987 { 13999 {
13988 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */ 14000 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */
13989 #line 509 "rx-decode.opc" 14001 #line 521 "rx-decode.opc"
13990 int rdst AU = op[1] & 0x0f; 14002 int rdst AU = op[1] & 0x0f;
13991 #line 509 "rx-decode.opc" 14003 #line 521 "rx-decode.opc"
13992 int srca AU = (op[2] >> 4) & 0x0f; 14004 int srca AU = (op[2] >> 4) & 0x0f;
13993 #line 509 "rx-decode.opc" 14005 #line 521 "rx-decode.opc"
13994 int srcb AU = op[2] & 0x0f; 14006 int srcb AU = op[2] & 0x0f;
13995 if (trace) 14007 if (trace)
13996 { 14008 {
13997 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14009 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
13998 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */", 14010 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */",
13999 op[0], op[1], op[2]); 14011 op[0], op[1], op[2]);
14000 printf (" rdst = 0x%x,", rdst); 14012 printf (" rdst = 0x%x,", rdst);
14001 printf (" srca = 0x%x,", srca); 14013 printf (" srca = 0x%x,", srca);
14002 printf (" srcb = 0x%x\n", srcb); 14014 printf (" srcb = 0x%x\n", srcb);
14003 } 14015 }
14004 SYNTAX("sub %2, %1, %0"); 14016 SYNTAX("sub %2, %1, %0");
14005 #line 509 "rx-decode.opc" 14017 #line 521 "rx-decode.opc"
14006 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 14018 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14007 14019
14008 /*---------------------------------------------------------- ------------*/ 14020 /*---------------------------------------------------------- ------------*/
14009 /* SBB */ 14021 /* SBB */
14010 14022
14011 } 14023 }
14012 break; 14024 break;
14013 } 14025 }
14014 break; 14026 break;
14015 case 0x01: 14027 case 0x01:
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after
14148 } 14160 }
14149 break; 14161 break;
14150 case 0x20: 14162 case 0x20:
14151 GETBYTE (); 14163 GETBYTE ();
14152 switch (op[2] & 0x00) 14164 switch (op[2] & 0x00)
14153 { 14165 {
14154 case 0x00: 14166 case 0x00:
14155 op_semantics_99: 14167 op_semantics_99:
14156 { 14168 {
14157 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */ 14169 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */
14158 #line 476 "rx-decode.opc" 14170 #line 488 "rx-decode.opc"
14159 int rdst AU = op[1] & 0x0f; 14171 int rdst AU = op[1] & 0x0f;
14160 #line 476 "rx-decode.opc" 14172 #line 488 "rx-decode.opc"
14161 int srca AU = (op[2] >> 4) & 0x0f; 14173 int srca AU = (op[2] >> 4) & 0x0f;
14162 #line 476 "rx-decode.opc" 14174 #line 488 "rx-decode.opc"
14163 int srcb AU = op[2] & 0x0f; 14175 int srcb AU = op[2] & 0x0f;
14164 if (trace) 14176 if (trace)
14165 { 14177 {
14166 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14178 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14167 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */", 14179 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */",
14168 op[0], op[1], op[2]); 14180 op[0], op[1], op[2]);
14169 printf (" rdst = 0x%x,", rdst); 14181 printf (" rdst = 0x%x,", rdst);
14170 printf (" srca = 0x%x,", srca); 14182 printf (" srca = 0x%x,", srca);
14171 printf (" srcb = 0x%x\n", srcb); 14183 printf (" srcb = 0x%x\n", srcb);
14172 } 14184 }
14173 SYNTAX("add %2, %1, %0"); 14185 SYNTAX("add %2, %1, %0");
14174 #line 476 "rx-decode.opc" 14186 #line 488 "rx-decode.opc"
14175 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 14187 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC;
14176 14188
14177 /*---------------------------------------------------------- ------------*/ 14189 /*---------------------------------------------------------- ------------*/
14178 /* CMP */ 14190 /* CMP */
14179 14191
14180 } 14192 }
14181 break; 14193 break;
14182 } 14194 }
14183 break; 14195 break;
14184 case 0x21: 14196 case 0x21:
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after
14317 } 14329 }
14318 break; 14330 break;
14319 case 0x30: 14331 case 0x30:
14320 GETBYTE (); 14332 GETBYTE ();
14321 switch (op[2] & 0x00) 14333 switch (op[2] & 0x00)
14322 { 14334 {
14323 case 0x00: 14335 case 0x00:
14324 op_semantics_100: 14336 op_semantics_100:
14325 { 14337 {
14326 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */ 14338 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */
14327 #line 578 "rx-decode.opc" 14339 #line 590 "rx-decode.opc"
14328 int rdst AU = op[1] & 0x0f; 14340 int rdst AU = op[1] & 0x0f;
14329 #line 578 "rx-decode.opc" 14341 #line 590 "rx-decode.opc"
14330 int srca AU = (op[2] >> 4) & 0x0f; 14342 int srca AU = (op[2] >> 4) & 0x0f;
14331 #line 578 "rx-decode.opc" 14343 #line 590 "rx-decode.opc"
14332 int srcb AU = op[2] & 0x0f; 14344 int srcb AU = op[2] & 0x0f;
14333 if (trace) 14345 if (trace)
14334 { 14346 {
14335 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14347 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14336 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */", 14348 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */",
14337 op[0], op[1], op[2]); 14349 op[0], op[1], op[2]);
14338 printf (" rdst = 0x%x,", rdst); 14350 printf (" rdst = 0x%x,", rdst);
14339 printf (" srca = 0x%x,", srca); 14351 printf (" srca = 0x%x,", srca);
14340 printf (" srcb = 0x%x\n", srcb); 14352 printf (" srcb = 0x%x\n", srcb);
14341 } 14353 }
14342 SYNTAX("mul %2, %1, %0"); 14354 SYNTAX("mul %2, %1, %0");
14343 #line 578 "rx-decode.opc" 14355 #line 590 "rx-decode.opc"
14344 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____; 14356 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____;
14345 14357
14346 /*---------------------------------------------------------- ------------*/ 14358 /*---------------------------------------------------------- ------------*/
14347 /* EMUL */ 14359 /* EMUL */
14348 14360
14349 } 14361 }
14350 break; 14362 break;
14351 } 14363 }
14352 break; 14364 break;
14353 case 0x31: 14365 case 0x31:
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after
14486 } 14498 }
14487 break; 14499 break;
14488 case 0x40: 14500 case 0x40:
14489 GETBYTE (); 14501 GETBYTE ();
14490 switch (op[2] & 0x00) 14502 switch (op[2] & 0x00)
14491 { 14503 {
14492 case 0x00: 14504 case 0x00:
14493 op_semantics_101: 14505 op_semantics_101:
14494 { 14506 {
14495 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */ 14507 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */
14496 #line 386 "rx-decode.opc" 14508 #line 398 "rx-decode.opc"
14497 int rdst AU = op[1] & 0x0f; 14509 int rdst AU = op[1] & 0x0f;
14498 #line 386 "rx-decode.opc" 14510 #line 398 "rx-decode.opc"
14499 int srca AU = (op[2] >> 4) & 0x0f; 14511 int srca AU = (op[2] >> 4) & 0x0f;
14500 #line 386 "rx-decode.opc" 14512 #line 398 "rx-decode.opc"
14501 int srcb AU = op[2] & 0x0f; 14513 int srcb AU = op[2] & 0x0f;
14502 if (trace) 14514 if (trace)
14503 { 14515 {
14504 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14516 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14505 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */", 14517 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */",
14506 op[0], op[1], op[2]); 14518 op[0], op[1], op[2]);
14507 printf (" rdst = 0x%x,", rdst); 14519 printf (" rdst = 0x%x,", rdst);
14508 printf (" srca = 0x%x,", srca); 14520 printf (" srca = 0x%x,", srca);
14509 printf (" srcb = 0x%x\n", srcb); 14521 printf (" srcb = 0x%x\n", srcb);
14510 } 14522 }
14511 SYNTAX("and %2, %1, %0"); 14523 SYNTAX("and %2, %1, %0");
14512 #line 386 "rx-decode.opc" 14524 #line 398 "rx-decode.opc"
14513 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 14525 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14514 14526
14515 /*---------------------------------------------------------- ------------*/ 14527 /*---------------------------------------------------------- ------------*/
14516 /* OR */ 14528 /* OR */
14517 14529
14518 } 14530 }
14519 break; 14531 break;
14520 } 14532 }
14521 break; 14533 break;
14522 case 0x41: 14534 case 0x41:
(...skipping 132 matching lines...) Expand 10 before | Expand all | Expand 10 after
14655 } 14667 }
14656 break; 14668 break;
14657 case 0x50: 14669 case 0x50:
14658 GETBYTE (); 14670 GETBYTE ();
14659 switch (op[2] & 0x00) 14671 switch (op[2] & 0x00)
14660 { 14672 {
14661 case 0x00: 14673 case 0x00:
14662 op_semantics_102: 14674 op_semantics_102:
14663 { 14675 {
14664 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */ 14676 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */
14665 #line 404 "rx-decode.opc" 14677 #line 416 "rx-decode.opc"
14666 int rdst AU = op[1] & 0x0f; 14678 int rdst AU = op[1] & 0x0f;
14667 #line 404 "rx-decode.opc" 14679 #line 416 "rx-decode.opc"
14668 int srca AU = (op[2] >> 4) & 0x0f; 14680 int srca AU = (op[2] >> 4) & 0x0f;
14669 #line 404 "rx-decode.opc" 14681 #line 416 "rx-decode.opc"
14670 int srcb AU = op[2] & 0x0f; 14682 int srcb AU = op[2] & 0x0f;
14671 if (trace) 14683 if (trace)
14672 { 14684 {
14673 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14685 printf ("\033[33m%s\033[0m %02x %02x %02x\n",
14674 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */", 14686 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */",
14675 op[0], op[1], op[2]); 14687 op[0], op[1], op[2]);
14676 printf (" rdst = 0x%x,", rdst); 14688 printf (" rdst = 0x%x,", rdst);
14677 printf (" srca = 0x%x,", srca); 14689 printf (" srca = 0x%x,", srca);
14678 printf (" srcb = 0x%x\n", srcb); 14690 printf (" srcb = 0x%x\n", srcb);
14679 } 14691 }
14680 SYNTAX("or %2, %1, %0"); 14692 SYNTAX("or %2, %1, %0");
14681 #line 404 "rx-decode.opc" 14693 #line 416 "rx-decode.opc"
14682 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 14694 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_;
14683 14695
14684 /*---------------------------------------------------------- ------------*/ 14696 /*---------------------------------------------------------- ------------*/
14685 /* XOR */ 14697 /* XOR */
14686 14698
14687 } 14699 }
14688 break; 14700 break;
14689 } 14701 }
14690 break; 14702 break;
14691 case 0x51: 14703 case 0x51:
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after
14821 case 0x00: 14833 case 0x00:
14822 goto op_semantics_102; 14834 goto op_semantics_102;
14823 break; 14835 break;
14824 } 14836 }
14825 break; 14837 break;
14826 default: UNSUPPORTED(); break; 14838 default: UNSUPPORTED(); break;
14827 } 14839 }
14828 break; 14840 break;
14829 default: UNSUPPORTED(); break; 14841 default: UNSUPPORTED(); break;
14830 } 14842 }
14831 #line 961 "rx-decode.opc" 14843 #line 973 "rx-decode.opc"
14832 14844
14833 return rx->n_bytes; 14845 return rx->n_bytes;
14834 } 14846 }
OLDNEW
« no previous file with comments | « opcodes/rl78-dis.c ('k') | opcodes/rx-decode.opc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698