1 #line 1 "rx-decode.opc" 2 /* -*- c -*- */ 3 #include <stdio.h> 4 #include <stdlib.h> 5 #include <string.h> 6 7 #include "config.h" 8 #include "ansidecl.h" 9 #include "opcode/rx.h" 10 11 #define RX_OPCODE_BIG_ENDIAN 0 12 13 typedef struct 14 { 15 RX_Opcode_Decoded * rx; 16 int (* getbyte)(void *); 17 void * ptr; 18 unsigned char * op; 19 } LocalData; 20 21 static int trace = 0; 22 23 #define BSIZE 0 24 #define WSIZE 1 25 #define LSIZE 2 26 27 /* These are for when the upper bits are "don't care" or "undefined". */ 28 static int bwl[] = 29 { 30 RX_Byte, 31 RX_Word, 32 RX_Long 33 }; 34 35 static int sbwl[] = 36 { 37 RX_SByte, 38 RX_SWord, 39 RX_Long 40 }; 41 42 static int ubwl[] = 43 { 44 RX_UByte, 45 RX_UWord, 46 RX_Long 47 }; 48 49 static int memex[] = 50 { 51 RX_SByte, 52 RX_SWord, 53 RX_Long, 54 RX_UWord 55 }; 56 57 #define ID(x) rx->id = RXO_##x 58 #define OP(n,t,r,a) (rx->op[n].type = t, \ 59 rx->op[n].reg = r, \ 60 rx->op[n].addend = a ) 61 #define OPs(n,t,r,a,s) (OP (n,t,r,a), \ 62 rx->op[n].size = s ) 63 64 /* This is for the BWL and BW bitfields. */ 65 static int SCALE[] = { 1, 2, 4 }; 66 /* This is for the prefix size enum. */ 67 static int PSCALE[] = { 4, 1, 1, 1, 2, 2, 2, 3, 4 }; 68 69 static int flagmap[] = {0, 1, 2, 3, 0, 0, 0, 0, 70 16, 17, 0, 0, 0, 0, 0, 0 }; 71 72 static int dsp3map[] = { 8, 9, 10, 3, 4, 5, 6, 7 }; 73 74 /* 75 *C a constant (immediate) c 76 *R A register 77 *I Register indirect, no offset 78 *Is Register indirect, with offset 79 *D standard displacement: type (r,[r],dsp8,dsp16 code), register, BWL code 80 *P standard displacement: type (r,[r]), reg, assumes UByte 81 *Pm memex displacement: type (r,[r]), reg, memex code 82 *cc condition code. */ 83 84 #define DC(c) OP (0, RX_Operand_Immediate, 0, c) 85 #define DR(r) OP (0, RX_Operand_Register, r, 0) 86 #define DI(r,a) OP (0, RX_Operand_Indirect, r, a) 87 #define DIs(r,a,s) OP (0, RX_Operand_Indirect, r, (a) * SCALE[s]) 88 #define DD(t,r,s) rx_disp (0, t, r, bwl[s], ld); 89 #define DF(r) OP (0, RX_Operand_Flag, flagmap[r], 0) 90 91 #define SC(i) OP (1, RX_Operand_Immediate, 0, i) 92 #define SR(r) OP (1, RX_Operand_Register, r, 0) 93 #define SRR(r) OP (1, RX_Operand_TwoReg, r, 0) 94 #define SI(r,a) OP (1, RX_Operand_Indirect, r, a) 95 #define SIs(r,a,s) OP (1, RX_Operand_Indirect, r, (a) * SCALE[s]) 96 #define SD(t,r,s) rx_disp (1, t, r, bwl[s], ld); 97 #define SP(t,r) rx_disp (1, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 1); 98 #define SPm(t,r,m) rx_disp (1, t, r, memex[m], ld); rx->op[1].size = memex[m]; 99 #define Scc(cc) OP (1, RX_Operand_Condition, cc, 0) 100 101 #define S2C(i) OP (2, RX_Operand_Immediate, 0, i) 102 #define S2R(r) OP (2, RX_Operand_Register, r, 0) 103 #define S2I(r,a) OP (2, RX_Operand_Indirect, r, a) 104 #define S2Is(r,a,s) OP (2, RX_Operand_Indirect, r, (a) * SCALE[s]) 105 #define S2D(t,r,s) rx_disp (2, t, r, bwl[s], ld); 106 #define S2P(t,r) rx_disp (2, t, r, (t!=3) ? RX_UByte : RX_Long, ld); P(t, 2); 107 #define S2Pm(t,r,m) rx_disp (2, t, r, memex[m], ld); rx->op[2].size = memex[m]; 108 #define S2cc(cc) OP (2, RX_Operand_Condition, cc, 0) 109 110 #define BWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = bwl[sz] 111 #define sBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = sbwl[sz] 112 #define uBWL(sz) rx->op[0].size = rx->op[1].size = rx->op[2].size = rx->size = ubwl[sz] 113 #define P(t, n) rx->op[n].size = (t!=3) ? RX_UByte : RX_Long; 114 115 #define F(f) store_flags(rx, f) 116 117 #define AU ATTRIBUTE_UNUSED 118 #define GETBYTE() (ld->op [ld->rx->n_bytes++] = ld->getbyte (ld->ptr)) 119 120 #define SYNTAX(x) rx->syntax = x 121 122 #define UNSUPPORTED() \ 123 rx->syntax = "*unknown*" 124 125 #define IMM(sf) immediate (sf, 0, ld) 126 #define IMMex(sf) immediate (sf, 1, ld) 127 128 static int 129 immediate (int sfield, int ex, LocalData * ld) 130 { 131 unsigned long i = 0, j; 132 133 switch (sfield) 134 { 135 #define B ((unsigned long) GETBYTE()) 136 case 0: 137 #if RX_OPCODE_BIG_ENDIAN 138 i = B; 139 if (ex && (i & 0x80)) 140 i -= 0x100; 141 i <<= 24; 142 i |= B << 16; 143 i |= B << 8; 144 i |= B; 145 #else 146 i = B; 147 i |= B << 8; 148 i |= B << 16; 149 j = B; 150 if (ex && (j & 0x80)) 151 j -= 0x100; 152 i |= j << 24; 153 #endif 154 break; 155 case 3: 156 #if RX_OPCODE_BIG_ENDIAN 157 i = B << 16; 158 i |= B << 8; 159 i |= B; 160 #else 161 i = B; 162 i |= B << 8; 163 i |= B << 16; 164 #endif 165 if (ex && (i & 0x800000)) 166 i -= 0x1000000; 167 break; 168 case 2: 169 #if RX_OPCODE_BIG_ENDIAN 170 i |= B << 8; 171 i |= B; 172 #else 173 i |= B; 174 i |= B << 8; 175 #endif 176 if (ex && (i & 0x8000)) 177 i -= 0x10000; 178 break; 179 case 1: 180 i |= B; 181 if (ex && (i & 0x80)) 182 i -= 0x100; 183 break; 184 default: 185 abort(); 186 } 187 return i; 188 } 189 190 static void 191 rx_disp (int n, int type, int reg, int size, LocalData * ld) 192 { 193 int disp; 194 195 ld->rx->op[n].reg = reg; 196 switch (type) 197 { 198 case 3: 199 ld->rx->op[n].type = RX_Operand_Register; 200 break; 201 case 0: 202 ld->rx->op[n].type = RX_Operand_Indirect; 203 ld->rx->op[n].addend = 0; 204 break; 205 case 1: 206 ld->rx->op[n].type = RX_Operand_Indirect; 207 disp = GETBYTE (); 208 ld->rx->op[n].addend = disp * PSCALE[size]; 209 break; 210 case 2: 211 ld->rx->op[n].type = RX_Operand_Indirect; 212 disp = GETBYTE (); 213 #if RX_OPCODE_BIG_ENDIAN 214 disp = disp * 256 + GETBYTE (); 215 #else 216 disp = disp + GETBYTE () * 256; 217 #endif 218 ld->rx->op[n].addend = disp * PSCALE[size]; 219 break; 220 default: 221 abort (); 222 } 223 } 224 225 #define xO 8 226 #define xS 4 227 #define xZ 2 228 #define xC 1 229 230 #define F_____ 231 #define F___ZC rx->flags_0 = rx->flags_s = xZ|xC; 232 #define F__SZ_ rx->flags_0 = rx->flags_s = xS|xZ; 233 #define F__SZC rx->flags_0 = rx->flags_s = xS|xZ|xC; 234 #define F_0SZC rx->flags_0 = xO|xS|xZ|xC; rx->flags_s = xS|xZ|xC; 235 #define F_O___ rx->flags_0 = rx->flags_s = xO; 236 #define F_OS__ rx->flags_0 = rx->flags_s = xO|xS; 237 #define F_OSZ_ rx->flags_0 = rx->flags_s = xO|xS|xZ; 238 #define F_OSZC rx->flags_0 = rx->flags_s = xO|xS|xZ|xC; 239 240 int 241 rx_decode_opcode (unsigned long pc AU, 242 RX_Opcode_Decoded * rx, 243 int (* getbyte)(void *), 244 void * ptr) 245 { 246 LocalData lds, * ld = &lds; 247 unsigned char op[20] = {0}; 248 249 lds.rx = rx; 250 lds.getbyte = getbyte; 251 lds.ptr = ptr; 252 lds.op = op; 253 254 memset (rx, 0, sizeof (*rx)); 255 BWL(LSIZE); 256 257 258 /*----------------------------------------------------------------------*/ 259 /* MOV */ 260 261 GETBYTE (); 262 switch (op[0] & 0xff) 263 { 264 case 0x00: 265 { 266 /** 0000 0000 brk */ 267 if (trace) 268 { 269 printf ("\033[33m%s\033[0m %02x\n", 270 "/** 0000 0000 brk */", 271 op[0]); 272 } 273 SYNTAX("brk"); 274 #line 941 "rx-decode.opc" 275 ID(brk); 276 277 } 278 break; 279 case 0x01: 280 { 281 /** 0000 0001 dbt */ 282 if (trace) 283 { 284 printf ("\033[33m%s\033[0m %02x\n", 285 "/** 0000 0001 dbt */", 286 op[0]); 287 } 288 SYNTAX("dbt"); 289 #line 944 "rx-decode.opc" 290 ID(dbt); 291 292 } 293 break; 294 case 0x02: 295 { 296 /** 0000 0010 rts */ 297 if (trace) 298 { 299 printf ("\033[33m%s\033[0m %02x\n", 300 "/** 0000 0010 rts */", 301 op[0]); 302 } 303 SYNTAX("rts"); 304 #line 730 "rx-decode.opc" 305 ID(rts); 306 307 /*----------------------------------------------------------------------*/ 308 /* NOP */ 309 310 } 311 break; 312 case 0x03: 313 { 314 /** 0000 0011 nop */ 315 if (trace) 316 { 317 printf ("\033[33m%s\033[0m %02x\n", 318 "/** 0000 0011 nop */", 319 op[0]); 320 } 321 SYNTAX("nop"); 322 #line 736 "rx-decode.opc" 323 ID(nop); 324 325 /*----------------------------------------------------------------------*/ 326 /* STRING FUNCTIONS */ 327 328 } 329 break; 330 case 0x04: 331 { 332 /** 0000 0100 bra.a %a0 */ 333 if (trace) 334 { 335 printf ("\033[33m%s\033[0m %02x\n", 336 "/** 0000 0100 bra.a %a0 */", 337 op[0]); 338 } 339 SYNTAX("bra.a %a0"); 340 #line 708 "rx-decode.opc" 341 ID(branch); DC(pc + IMMex(3)); 342 343 } 344 break; 345 case 0x05: 346 { 347 /** 0000 0101 bsr.a %a0 */ 348 if (trace) 349 { 350 printf ("\033[33m%s\033[0m %02x\n", 351 "/** 0000 0101 bsr.a %a0 */", 352 op[0]); 353 } 354 SYNTAX("bsr.a %a0"); 355 #line 724 "rx-decode.opc" 356 ID(jsr); DC(pc + IMMex(3)); 357 358 } 359 break; 360 case 0x06: 361 GETBYTE (); 362 switch (op[1] & 0xff) 363 { 364 case 0x00: 365 GETBYTE (); 366 switch (op[2] & 0x00) 367 { 368 case 0x00: 369 op_semantics_1: 370 { 371 /** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */ 372 #line 505 "rx-decode.opc" 373 int mx AU = (op[1] >> 6) & 0x03; 374 #line 505 "rx-decode.opc" 375 int ss AU = op[1] & 0x03; 376 #line 505 "rx-decode.opc" 377 int rsrc AU = (op[2] >> 4) & 0x0f; 378 #line 505 "rx-decode.opc" 379 int rdst AU = op[2] & 0x0f; 380 if (trace) 381 { 382 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 383 "/** 0000 0110 mx00 00ss rsrc rdst sub %2%S2, %1 */", 384 op[0], op[1], op[2]); 385 printf (" mx = 0x%x,", mx); 386 printf (" ss = 0x%x,", ss); 387 printf (" rsrc = 0x%x,", rsrc); 388 printf (" rdst = 0x%x\n", rdst); 389 } 390 SYNTAX("sub %2%S2, %1"); 391 #line 505 "rx-decode.opc" 392 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); DR(rdst); F_OSZC; 393 394 } 395 break; 396 } 397 break; 398 case 0x01: 399 GETBYTE (); 400 switch (op[2] & 0x00) 401 { 402 case 0x00: 403 goto op_semantics_1; 404 break; 405 } 406 break; 407 case 0x02: 408 GETBYTE (); 409 switch (op[2] & 0x00) 410 { 411 case 0x00: 412 goto op_semantics_1; 413 break; 414 } 415 break; 416 case 0x03: 417 GETBYTE (); 418 switch (op[2] & 0x00) 419 { 420 case 0x00: 421 goto op_semantics_1; 422 break; 423 } 424 break; 425 case 0x04: 426 GETBYTE (); 427 switch (op[2] & 0x00) 428 { 429 case 0x00: 430 op_semantics_2: 431 { 432 /** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */ 433 #line 493 "rx-decode.opc" 434 int mx AU = (op[1] >> 6) & 0x03; 435 #line 493 "rx-decode.opc" 436 int ss AU = op[1] & 0x03; 437 #line 493 "rx-decode.opc" 438 int rsrc AU = (op[2] >> 4) & 0x0f; 439 #line 493 "rx-decode.opc" 440 int rdst AU = op[2] & 0x0f; 441 if (trace) 442 { 443 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 444 "/** 0000 0110 mx00 01ss rsrc rdst cmp %2%S2, %1 */", 445 op[0], op[1], op[2]); 446 printf (" mx = 0x%x,", mx); 447 printf (" ss = 0x%x,", ss); 448 printf (" rsrc = 0x%x,", rsrc); 449 printf (" rdst = 0x%x\n", rdst); 450 } 451 SYNTAX("cmp %2%S2, %1"); 452 #line 493 "rx-decode.opc" 453 ID(sub); S2Pm(ss, rsrc, mx); SR(rdst); F_OSZC; 454 455 /*----------------------------------------------------------------------*/ 456 /* SUB */ 457 458 } 459 break; 460 } 461 break; 462 case 0x05: 463 GETBYTE (); 464 switch (op[2] & 0x00) 465 { 466 case 0x00: 467 goto op_semantics_2; 468 break; 469 } 470 break; 471 case 0x06: 472 GETBYTE (); 473 switch (op[2] & 0x00) 474 { 475 case 0x00: 476 goto op_semantics_2; 477 break; 478 } 479 break; 480 case 0x07: 481 GETBYTE (); 482 switch (op[2] & 0x00) 483 { 484 case 0x00: 485 goto op_semantics_2; 486 break; 487 } 488 break; 489 case 0x08: 490 GETBYTE (); 491 switch (op[2] & 0x00) 492 { 493 case 0x00: 494 op_semantics_3: 495 { 496 /** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */ 497 #line 469 "rx-decode.opc" 498 int mx AU = (op[1] >> 6) & 0x03; 499 #line 469 "rx-decode.opc" 500 int ss AU = op[1] & 0x03; 501 #line 469 "rx-decode.opc" 502 int rsrc AU = (op[2] >> 4) & 0x0f; 503 #line 469 "rx-decode.opc" 504 int rdst AU = op[2] & 0x0f; 505 if (trace) 506 { 507 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 508 "/** 0000 0110 mx00 10ss rsrc rdst add %1%S1, %0 */", 509 op[0], op[1], op[2]); 510 printf (" mx = 0x%x,", mx); 511 printf (" ss = 0x%x,", ss); 512 printf (" rsrc = 0x%x,", rsrc); 513 printf (" rdst = 0x%x\n", rdst); 514 } 515 SYNTAX("add %1%S1, %0"); 516 #line 469 "rx-decode.opc" 517 ID(add); SPm(ss, rsrc, mx); DR(rdst); F_OSZC; 518 519 } 520 break; 521 } 522 break; 523 case 0x09: 524 GETBYTE (); 525 switch (op[2] & 0x00) 526 { 527 case 0x00: 528 goto op_semantics_3; 529 break; 530 } 531 break; 532 case 0x0a: 533 GETBYTE (); 534 switch (op[2] & 0x00) 535 { 536 case 0x00: 537 goto op_semantics_3; 538 break; 539 } 540 break; 541 case 0x0b: 542 GETBYTE (); 543 switch (op[2] & 0x00) 544 { 545 case 0x00: 546 goto op_semantics_3; 547 break; 548 } 549 break; 550 case 0x0c: 551 GETBYTE (); 552 switch (op[2] & 0x00) 553 { 554 case 0x00: 555 op_semantics_4: 556 { 557 /** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */ 558 #line 573 "rx-decode.opc" 559 int mx AU = (op[1] >> 6) & 0x03; 560 #line 573 "rx-decode.opc" 561 int ss AU = op[1] & 0x03; 562 #line 573 "rx-decode.opc" 563 int rsrc AU = (op[2] >> 4) & 0x0f; 564 #line 573 "rx-decode.opc" 565 int rdst AU = op[2] & 0x0f; 566 if (trace) 567 { 568 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 569 "/** 0000 0110 mx00 11ss rsrc rdst mul %1%S1, %0 */", 570 op[0], op[1], op[2]); 571 printf (" mx = 0x%x,", mx); 572 printf (" ss = 0x%x,", ss); 573 printf (" rsrc = 0x%x,", rsrc); 574 printf (" rdst = 0x%x\n", rdst); 575 } 576 SYNTAX("mul %1%S1, %0"); 577 #line 573 "rx-decode.opc" 578 ID(mul); SPm(ss, rsrc, mx); DR(rdst); F_____; 579 580 } 581 break; 582 } 583 break; 584 case 0x0d: 585 GETBYTE (); 586 switch (op[2] & 0x00) 587 { 588 case 0x00: 589 goto op_semantics_4; 590 break; 591 } 592 break; 593 case 0x0e: 594 GETBYTE (); 595 switch (op[2] & 0x00) 596 { 597 case 0x00: 598 goto op_semantics_4; 599 break; 600 } 601 break; 602 case 0x0f: 603 GETBYTE (); 604 switch (op[2] & 0x00) 605 { 606 case 0x00: 607 goto op_semantics_4; 608 break; 609 } 610 break; 611 case 0x10: 612 GETBYTE (); 613 switch (op[2] & 0x00) 614 { 615 case 0x00: 616 op_semantics_5: 617 { 618 /** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */ 619 #line 382 "rx-decode.opc" 620 int mx AU = (op[1] >> 6) & 0x03; 621 #line 382 "rx-decode.opc" 622 int ss AU = op[1] & 0x03; 623 #line 382 "rx-decode.opc" 624 int rsrc AU = (op[2] >> 4) & 0x0f; 625 #line 382 "rx-decode.opc" 626 int rdst AU = op[2] & 0x0f; 627 if (trace) 628 { 629 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 630 "/** 0000 0110 mx01 00ss rsrc rdst and %1%S1, %0 */", 631 op[0], op[1], op[2]); 632 printf (" mx = 0x%x,", mx); 633 printf (" ss = 0x%x,", ss); 634 printf (" rsrc = 0x%x,", rsrc); 635 printf (" rdst = 0x%x\n", rdst); 636 } 637 SYNTAX("and %1%S1, %0"); 638 #line 382 "rx-decode.opc" 639 ID(and); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 640 641 } 642 break; 643 } 644 break; 645 case 0x11: 646 GETBYTE (); 647 switch (op[2] & 0x00) 648 { 649 case 0x00: 650 goto op_semantics_5; 651 break; 652 } 653 break; 654 case 0x12: 655 GETBYTE (); 656 switch (op[2] & 0x00) 657 { 658 case 0x00: 659 goto op_semantics_5; 660 break; 661 } 662 break; 663 case 0x13: 664 GETBYTE (); 665 switch (op[2] & 0x00) 666 { 667 case 0x00: 668 goto op_semantics_5; 669 break; 670 } 671 break; 672 case 0x14: 673 GETBYTE (); 674 switch (op[2] & 0x00) 675 { 676 case 0x00: 677 op_semantics_6: 678 { 679 /** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */ 680 #line 400 "rx-decode.opc" 681 int mx AU = (op[1] >> 6) & 0x03; 682 #line 400 "rx-decode.opc" 683 int ss AU = op[1] & 0x03; 684 #line 400 "rx-decode.opc" 685 int rsrc AU = (op[2] >> 4) & 0x0f; 686 #line 400 "rx-decode.opc" 687 int rdst AU = op[2] & 0x0f; 688 if (trace) 689 { 690 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 691 "/** 0000 0110 mx01 01ss rsrc rdst or %1%S1, %0 */", 692 op[0], op[1], op[2]); 693 printf (" mx = 0x%x,", mx); 694 printf (" ss = 0x%x,", ss); 695 printf (" rsrc = 0x%x,", rsrc); 696 printf (" rdst = 0x%x\n", rdst); 697 } 698 SYNTAX("or %1%S1, %0"); 699 #line 400 "rx-decode.opc" 700 ID(or); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 701 702 } 703 break; 704 } 705 break; 706 case 0x15: 707 GETBYTE (); 708 switch (op[2] & 0x00) 709 { 710 case 0x00: 711 goto op_semantics_6; 712 break; 713 } 714 break; 715 case 0x16: 716 GETBYTE (); 717 switch (op[2] & 0x00) 718 { 719 case 0x00: 720 goto op_semantics_6; 721 break; 722 } 723 break; 724 case 0x17: 725 GETBYTE (); 726 switch (op[2] & 0x00) 727 { 728 case 0x00: 729 goto op_semantics_6; 730 break; 731 } 732 break; 733 case 0x20: 734 GETBYTE (); 735 switch (op[2] & 0xff) 736 { 737 case 0x00: 738 GETBYTE (); 739 switch (op[3] & 0x00) 740 { 741 case 0x00: 742 op_semantics_7: 743 { 744 /** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */ 745 #line 518 "rx-decode.opc" 746 int mx AU = (op[1] >> 6) & 0x03; 747 #line 518 "rx-decode.opc" 748 int sp AU = op[1] & 0x03; 749 #line 518 "rx-decode.opc" 750 int rsrc AU = (op[3] >> 4) & 0x0f; 751 #line 518 "rx-decode.opc" 752 int rdst AU = op[3] & 0x0f; 753 if (trace) 754 { 755 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 756 "/** 0000 0110 mx10 00sp 0000 0000 rsrc rdst sbb %1%S1, %0 */", 757 op[0], op[1], op[2], op[3]); 758 printf (" mx = 0x%x,", mx); 759 printf (" sp = 0x%x,", sp); 760 printf (" rsrc = 0x%x,", rsrc); 761 printf (" rdst = 0x%x\n", rdst); 762 } 763 SYNTAX("sbb %1%S1, %0"); 764 #line 518 "rx-decode.opc" 765 ID(sbb); SPm(sp, rsrc, mx); DR(rdst); F_OSZC; 766 767 /*----------------------------------------------------------------------*/ 768 /* ABS */ 769 770 } 771 break; 772 } 773 break; 774 case 0x04: 775 GETBYTE (); 776 switch (op[3] & 0x00) 777 { 778 case 0x00: 779 op_semantics_8: 780 { 781 /** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */ 782 #line 546 "rx-decode.opc" 783 int mx AU = (op[1] >> 6) & 0x03; 784 #line 546 "rx-decode.opc" 785 int ss AU = op[1] & 0x03; 786 #line 546 "rx-decode.opc" 787 int rsrc AU = (op[3] >> 4) & 0x0f; 788 #line 546 "rx-decode.opc" 789 int rdst AU = op[3] & 0x0f; 790 if (trace) 791 { 792 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 793 "/** 0000 0110 mx10 00ss 0000 0100 rsrc rdst max %1%S1, %0 */", 794 op[0], op[1], op[2], op[3]); 795 printf (" mx = 0x%x,", mx); 796 printf (" ss = 0x%x,", ss); 797 printf (" rsrc = 0x%x,", rsrc); 798 printf (" rdst = 0x%x\n", rdst); 799 } 800 SYNTAX("max %1%S1, %0"); 801 #line 546 "rx-decode.opc" 802 ID(max); SPm(ss, rsrc, mx); DR(rdst); 803 804 /*----------------------------------------------------------------------*/ 805 /* MIN */ 806 807 } 808 break; 809 } 810 break; 811 case 0x05: 812 GETBYTE (); 813 switch (op[3] & 0x00) 814 { 815 case 0x00: 816 op_semantics_9: 817 { 818 /** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */ 819 #line 558 "rx-decode.opc" 820 int mx AU = (op[1] >> 6) & 0x03; 821 #line 558 "rx-decode.opc" 822 int ss AU = op[1] & 0x03; 823 #line 558 "rx-decode.opc" 824 int rsrc AU = (op[3] >> 4) & 0x0f; 825 #line 558 "rx-decode.opc" 826 int rdst AU = op[3] & 0x0f; 827 if (trace) 828 { 829 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 830 "/** 0000 0110 mx10 00ss 0000 0101 rsrc rdst min %1%S1, %0 */", 831 op[0], op[1], op[2], op[3]); 832 printf (" mx = 0x%x,", mx); 833 printf (" ss = 0x%x,", ss); 834 printf (" rsrc = 0x%x,", rsrc); 835 printf (" rdst = 0x%x\n", rdst); 836 } 837 SYNTAX("min %1%S1, %0"); 838 #line 558 "rx-decode.opc" 839 ID(min); SPm(ss, rsrc, mx); DR(rdst); 840 841 /*----------------------------------------------------------------------*/ 842 /* MUL */ 843 844 } 845 break; 846 } 847 break; 848 case 0x06: 849 GETBYTE (); 850 switch (op[3] & 0x00) 851 { 852 case 0x00: 853 op_semantics_10: 854 { 855 /** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */ 856 #line 588 "rx-decode.opc" 857 int mx AU = (op[1] >> 6) & 0x03; 858 #line 588 "rx-decode.opc" 859 int ss AU = op[1] & 0x03; 860 #line 588 "rx-decode.opc" 861 int rsrc AU = (op[3] >> 4) & 0x0f; 862 #line 588 "rx-decode.opc" 863 int rdst AU = op[3] & 0x0f; 864 if (trace) 865 { 866 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 867 "/** 0000 0110 mx10 00ss 0000 0110 rsrc rdst emul %1%S1, %0 */", 868 op[0], op[1], op[2], op[3]); 869 printf (" mx = 0x%x,", mx); 870 printf (" ss = 0x%x,", ss); 871 printf (" rsrc = 0x%x,", rsrc); 872 printf (" rdst = 0x%x\n", rdst); 873 } 874 SYNTAX("emul %1%S1, %0"); 875 #line 588 "rx-decode.opc" 876 ID(emul); SPm(ss, rsrc, mx); DR(rdst); 877 878 /*----------------------------------------------------------------------*/ 879 /* EMULU */ 880 881 } 882 break; 883 } 884 break; 885 case 0x07: 886 GETBYTE (); 887 switch (op[3] & 0x00) 888 { 889 case 0x00: 890 op_semantics_11: 891 { 892 /** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */ 893 #line 600 "rx-decode.opc" 894 int mx AU = (op[1] >> 6) & 0x03; 895 #line 600 "rx-decode.opc" 896 int ss AU = op[1] & 0x03; 897 #line 600 "rx-decode.opc" 898 int rsrc AU = (op[3] >> 4) & 0x0f; 899 #line 600 "rx-decode.opc" 900 int rdst AU = op[3] & 0x0f; 901 if (trace) 902 { 903 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 904 "/** 0000 0110 mx10 00ss 0000 0111 rsrc rdst emulu %1%S1, %0 */", 905 op[0], op[1], op[2], op[3]); 906 printf (" mx = 0x%x,", mx); 907 printf (" ss = 0x%x,", ss); 908 printf (" rsrc = 0x%x,", rsrc); 909 printf (" rdst = 0x%x\n", rdst); 910 } 911 SYNTAX("emulu %1%S1, %0"); 912 #line 600 "rx-decode.opc" 913 ID(emulu); SPm(ss, rsrc, mx); DR(rdst); 914 915 /*----------------------------------------------------------------------*/ 916 /* DIV */ 917 918 } 919 break; 920 } 921 break; 922 case 0x08: 923 GETBYTE (); 924 switch (op[3] & 0x00) 925 { 926 case 0x00: 927 op_semantics_12: 928 { 929 /** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */ 930 #line 612 "rx-decode.opc" 931 int mx AU = (op[1] >> 6) & 0x03; 932 #line 612 "rx-decode.opc" 933 int ss AU = op[1] & 0x03; 934 #line 612 "rx-decode.opc" 935 int rsrc AU = (op[3] >> 4) & 0x0f; 936 #line 612 "rx-decode.opc" 937 int rdst AU = op[3] & 0x0f; 938 if (trace) 939 { 940 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 941 "/** 0000 0110 mx10 00ss 0000 1000 rsrc rdst div %1%S1, %0 */", 942 op[0], op[1], op[2], op[3]); 943 printf (" mx = 0x%x,", mx); 944 printf (" ss = 0x%x,", ss); 945 printf (" rsrc = 0x%x,", rsrc); 946 printf (" rdst = 0x%x\n", rdst); 947 } 948 SYNTAX("div %1%S1, %0"); 949 #line 612 "rx-decode.opc" 950 ID(div); SPm(ss, rsrc, mx); DR(rdst); F_O___; 951 952 /*----------------------------------------------------------------------*/ 953 /* DIVU */ 954 955 } 956 break; 957 } 958 break; 959 case 0x09: 960 GETBYTE (); 961 switch (op[3] & 0x00) 962 { 963 case 0x00: 964 op_semantics_13: 965 { 966 /** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */ 967 #line 624 "rx-decode.opc" 968 int mx AU = (op[1] >> 6) & 0x03; 969 #line 624 "rx-decode.opc" 970 int ss AU = op[1] & 0x03; 971 #line 624 "rx-decode.opc" 972 int rsrc AU = (op[3] >> 4) & 0x0f; 973 #line 624 "rx-decode.opc" 974 int rdst AU = op[3] & 0x0f; 975 if (trace) 976 { 977 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 978 "/** 0000 0110 mx10 00ss 0000 1001 rsrc rdst divu %1%S1, %0 */", 979 op[0], op[1], op[2], op[3]); 980 printf (" mx = 0x%x,", mx); 981 printf (" ss = 0x%x,", ss); 982 printf (" rsrc = 0x%x,", rsrc); 983 printf (" rdst = 0x%x\n", rdst); 984 } 985 SYNTAX("divu %1%S1, %0"); 986 #line 624 "rx-decode.opc" 987 ID(divu); SPm(ss, rsrc, mx); DR(rdst); F_O___; 988 989 /*----------------------------------------------------------------------*/ 990 /* SHIFT */ 991 992 } 993 break; 994 } 995 break; 996 case 0x0c: 997 GETBYTE (); 998 switch (op[3] & 0x00) 999 { 1000 case 0x00: 1001 op_semantics_14: 1002 { 1003 /** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */ 1004 #line 436 "rx-decode.opc" 1005 int mx AU = (op[1] >> 6) & 0x03; 1006 #line 436 "rx-decode.opc" 1007 int ss AU = op[1] & 0x03; 1008 #line 436 "rx-decode.opc" 1009 int rsrc AU = (op[3] >> 4) & 0x0f; 1010 #line 436 "rx-decode.opc" 1011 int rdst AU = op[3] & 0x0f; 1012 if (trace) 1013 { 1014 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1015 "/** 0000 0110 mx10 00ss 0000 1100 rsrc rdst tst %1%S1, %2 */", 1016 op[0], op[1], op[2], op[3]); 1017 printf (" mx = 0x%x,", mx); 1018 printf (" ss = 0x%x,", ss); 1019 printf (" rsrc = 0x%x,", rsrc); 1020 printf (" rdst = 0x%x\n", rdst); 1021 } 1022 SYNTAX("tst %1%S1, %2"); 1023 #line 436 "rx-decode.opc" 1024 ID(and); SPm(ss, rsrc, mx); S2R(rdst); F__SZ_; 1025 1026 /*----------------------------------------------------------------------*/ 1027 /* NEG */ 1028 1029 } 1030 break; 1031 } 1032 break; 1033 case 0x0d: 1034 GETBYTE (); 1035 switch (op[3] & 0x00) 1036 { 1037 case 0x00: 1038 op_semantics_15: 1039 { 1040 /** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */ 1041 #line 415 "rx-decode.opc" 1042 int mx AU = (op[1] >> 6) & 0x03; 1043 #line 415 "rx-decode.opc" 1044 int ss AU = op[1] & 0x03; 1045 #line 415 "rx-decode.opc" 1046 int rsrc AU = (op[3] >> 4) & 0x0f; 1047 #line 415 "rx-decode.opc" 1048 int rdst AU = op[3] & 0x0f; 1049 if (trace) 1050 { 1051 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1052 "/** 0000 0110 mx10 00ss 0000 1101 rsrc rdst xor %1%S1, %0 */", 1053 op[0], op[1], op[2], op[3]); 1054 printf (" mx = 0x%x,", mx); 1055 printf (" ss = 0x%x,", ss); 1056 printf (" rsrc = 0x%x,", rsrc); 1057 printf (" rdst = 0x%x\n", rdst); 1058 } 1059 SYNTAX("xor %1%S1, %0"); 1060 #line 415 "rx-decode.opc" 1061 ID(xor); SPm(ss, rsrc, mx); DR(rdst); F__SZ_; 1062 1063 /*----------------------------------------------------------------------*/ 1064 /* NOT */ 1065 1066 } 1067 break; 1068 } 1069 break; 1070 case 0x10: 1071 GETBYTE (); 1072 switch (op[3] & 0x00) 1073 { 1074 case 0x00: 1075 op_semantics_16: 1076 { 1077 /** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */ 1078 #line 349 "rx-decode.opc" 1079 int mx AU = (op[1] >> 6) & 0x03; 1080 #line 349 "rx-decode.opc" 1081 int ss AU = op[1] & 0x03; 1082 #line 349 "rx-decode.opc" 1083 int rsrc AU = (op[3] >> 4) & 0x0f; 1084 #line 349 "rx-decode.opc" 1085 int rdst AU = op[3] & 0x0f; 1086 if (trace) 1087 { 1088 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1089 "/** 0000 0110 mx10 00ss 0001 0000 rsrc rdst xchg %1%S1, %0 */", 1090 op[0], op[1], op[2], op[3]); 1091 printf (" mx = 0x%x,", mx); 1092 printf (" ss = 0x%x,", ss); 1093 printf (" rsrc = 0x%x,", rsrc); 1094 printf (" rdst = 0x%x\n", rdst); 1095 } 1096 SYNTAX("xchg %1%S1, %0"); 1097 #line 349 "rx-decode.opc" 1098 ID(xchg); DR(rdst); SPm(ss, rsrc, mx); 1099 1100 /*----------------------------------------------------------------------*/ 1101 /* STZ/STNZ */ 1102 1103 } 1104 break; 1105 } 1106 break; 1107 case 0x11: 1108 GETBYTE (); 1109 switch (op[3] & 0x00) 1110 { 1111 case 0x00: 1112 op_semantics_17: 1113 { 1114 /** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */ 1115 #line 853 "rx-decode.opc" 1116 int mx AU = (op[1] >> 6) & 0x03; 1117 #line 853 "rx-decode.opc" 1118 int sd AU = op[1] & 0x03; 1119 #line 853 "rx-decode.opc" 1120 int rsrc AU = (op[3] >> 4) & 0x0f; 1121 #line 853 "rx-decode.opc" 1122 int rdst AU = op[3] & 0x0f; 1123 if (trace) 1124 { 1125 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 1126 "/** 0000 0110 mx10 00sd 0001 0001 rsrc rdst itof %1%S1, %0 */", 1127 op[0], op[1], op[2], op[3]); 1128 printf (" mx = 0x%x,", mx); 1129 printf (" sd = 0x%x,", sd); 1130 printf (" rsrc = 0x%x,", rsrc); 1131 printf (" rdst = 0x%x\n", rdst); 1132 } 1133 SYNTAX("itof %1%S1, %0"); 1134 #line 853 "rx-decode.opc" 1135 ID(itof); DR (rdst); SPm(sd, rsrc, mx); F__SZ_; 1136 1137 /*----------------------------------------------------------------------*/ 1138 /* BIT OPS */ 1139 1140 } 1141 break; 1142 } 1143 break; 1144 default: UNSUPPORTED(); break; 1145 } 1146 break; 1147 case 0x21: 1148 GETBYTE (); 1149 switch (op[2] & 0xff) 1150 { 1151 case 0x00: 1152 GETBYTE (); 1153 switch (op[3] & 0x00) 1154 { 1155 case 0x00: 1156 goto op_semantics_7; 1157 break; 1158 } 1159 break; 1160 case 0x04: 1161 GETBYTE (); 1162 switch (op[3] & 0x00) 1163 { 1164 case 0x00: 1165 goto op_semantics_8; 1166 break; 1167 } 1168 break; 1169 case 0x05: 1170 GETBYTE (); 1171 switch (op[3] & 0x00) 1172 { 1173 case 0x00: 1174 goto op_semantics_9; 1175 break; 1176 } 1177 break; 1178 case 0x06: 1179 GETBYTE (); 1180 switch (op[3] & 0x00) 1181 { 1182 case 0x00: 1183 goto op_semantics_10; 1184 break; 1185 } 1186 break; 1187 case 0x07: 1188 GETBYTE (); 1189 switch (op[3] & 0x00) 1190 { 1191 case 0x00: 1192 goto op_semantics_11; 1193 break; 1194 } 1195 break; 1196 case 0x08: 1197 GETBYTE (); 1198 switch (op[3] & 0x00) 1199 { 1200 case 0x00: 1201 goto op_semantics_12; 1202 break; 1203 } 1204 break; 1205 case 0x09: 1206 GETBYTE (); 1207 switch (op[3] & 0x00) 1208 { 1209 case 0x00: 1210 goto op_semantics_13; 1211 break; 1212 } 1213 break; 1214 case 0x0c: 1215 GETBYTE (); 1216 switch (op[3] & 0x00) 1217 { 1218 case 0x00: 1219 goto op_semantics_14; 1220 break; 1221 } 1222 break; 1223 case 0x0d: 1224 GETBYTE (); 1225 switch (op[3] & 0x00) 1226 { 1227 case 0x00: 1228 goto op_semantics_15; 1229 break; 1230 } 1231 break; 1232 case 0x10: 1233 GETBYTE (); 1234 switch (op[3] & 0x00) 1235 { 1236 case 0x00: 1237 goto op_semantics_16; 1238 break; 1239 } 1240 break; 1241 case 0x11: 1242 GETBYTE (); 1243 switch (op[3] & 0x00) 1244 { 1245 case 0x00: 1246 goto op_semantics_17; 1247 break; 1248 } 1249 break; 1250 default: UNSUPPORTED(); break; 1251 } 1252 break; 1253 case 0x22: 1254 GETBYTE (); 1255 switch (op[2] & 0xff) 1256 { 1257 case 0x00: 1258 GETBYTE (); 1259 switch (op[3] & 0x00) 1260 { 1261 case 0x00: 1262 goto op_semantics_7; 1263 break; 1264 } 1265 break; 1266 case 0x04: 1267 GETBYTE (); 1268 switch (op[3] & 0x00) 1269 { 1270 case 0x00: 1271 goto op_semantics_8; 1272 break; 1273 } 1274 break; 1275 case 0x05: 1276 GETBYTE (); 1277 switch (op[3] & 0x00) 1278 { 1279 case 0x00: 1280 goto op_semantics_9; 1281 break; 1282 } 1283 break; 1284 case 0x06: 1285 GETBYTE (); 1286 switch (op[3] & 0x00) 1287 { 1288 case 0x00: 1289 goto op_semantics_10; 1290 break; 1291 } 1292 break; 1293 case 0x07: 1294 GETBYTE (); 1295 switch (op[3] & 0x00) 1296 { 1297 case 0x00: 1298 goto op_semantics_11; 1299 break; 1300 } 1301 break; 1302 case 0x08: 1303 GETBYTE (); 1304 switch (op[3] & 0x00) 1305 { 1306 case 0x00: 1307 goto op_semantics_12; 1308 break; 1309 } 1310 break; 1311 case 0x09: 1312 GETBYTE (); 1313 switch (op[3] & 0x00) 1314 { 1315 case 0x00: 1316 goto op_semantics_13; 1317 break; 1318 } 1319 break; 1320 case 0x0c: 1321 GETBYTE (); 1322 switch (op[3] & 0x00) 1323 { 1324 case 0x00: 1325 goto op_semantics_14; 1326 break; 1327 } 1328 break; 1329 case 0x0d: 1330 GETBYTE (); 1331 switch (op[3] & 0x00) 1332 { 1333 case 0x00: 1334 goto op_semantics_15; 1335 break; 1336 } 1337 break; 1338 case 0x10: 1339 GETBYTE (); 1340 switch (op[3] & 0x00) 1341 { 1342 case 0x00: 1343 goto op_semantics_16; 1344 break; 1345 } 1346 break; 1347 case 0x11: 1348 GETBYTE (); 1349 switch (op[3] & 0x00) 1350 { 1351 case 0x00: 1352 goto op_semantics_17; 1353 break; 1354 } 1355 break; 1356 default: UNSUPPORTED(); break; 1357 } 1358 break; 1359 case 0x23: 1360 GETBYTE (); 1361 switch (op[2] & 0xff) 1362 { 1363 case 0x00: 1364 GETBYTE (); 1365 switch (op[3] & 0x00) 1366 { 1367 case 0x00: 1368 goto op_semantics_7; 1369 break; 1370 } 1371 break; 1372 case 0x04: 1373 GETBYTE (); 1374 switch (op[3] & 0x00) 1375 { 1376 case 0x00: 1377 goto op_semantics_8; 1378 break; 1379 } 1380 break; 1381 case 0x05: 1382 GETBYTE (); 1383 switch (op[3] & 0x00) 1384 { 1385 case 0x00: 1386 goto op_semantics_9; 1387 break; 1388 } 1389 break; 1390 case 0x06: 1391 GETBYTE (); 1392 switch (op[3] & 0x00) 1393 { 1394 case 0x00: 1395 goto op_semantics_10; 1396 break; 1397 } 1398 break; 1399 case 0x07: 1400 GETBYTE (); 1401 switch (op[3] & 0x00) 1402 { 1403 case 0x00: 1404 goto op_semantics_11; 1405 break; 1406 } 1407 break; 1408 case 0x08: 1409 GETBYTE (); 1410 switch (op[3] & 0x00) 1411 { 1412 case 0x00: 1413 goto op_semantics_12; 1414 break; 1415 } 1416 break; 1417 case 0x09: 1418 GETBYTE (); 1419 switch (op[3] & 0x00) 1420 { 1421 case 0x00: 1422 goto op_semantics_13; 1423 break; 1424 } 1425 break; 1426 case 0x0c: 1427 GETBYTE (); 1428 switch (op[3] & 0x00) 1429 { 1430 case 0x00: 1431 goto op_semantics_14; 1432 break; 1433 } 1434 break; 1435 case 0x0d: 1436 GETBYTE (); 1437 switch (op[3] & 0x00) 1438 { 1439 case 0x00: 1440 goto op_semantics_15; 1441 break; 1442 } 1443 break; 1444 case 0x10: 1445 GETBYTE (); 1446 switch (op[3] & 0x00) 1447 { 1448 case 0x00: 1449 goto op_semantics_16; 1450 break; 1451 } 1452 break; 1453 case 0x11: 1454 GETBYTE (); 1455 switch (op[3] & 0x00) 1456 { 1457 case 0x00: 1458 goto op_semantics_17; 1459 break; 1460 } 1461 break; 1462 default: UNSUPPORTED(); break; 1463 } 1464 break; 1465 case 0x40: 1466 GETBYTE (); 1467 switch (op[2] & 0x00) 1468 { 1469 case 0x00: 1470 goto op_semantics_1; 1471 break; 1472 } 1473 break; 1474 case 0x41: 1475 GETBYTE (); 1476 switch (op[2] & 0x00) 1477 { 1478 case 0x00: 1479 goto op_semantics_1; 1480 break; 1481 } 1482 break; 1483 case 0x42: 1484 GETBYTE (); 1485 switch (op[2] & 0x00) 1486 { 1487 case 0x00: 1488 goto op_semantics_1; 1489 break; 1490 } 1491 break; 1492 case 0x43: 1493 GETBYTE (); 1494 switch (op[2] & 0x00) 1495 { 1496 case 0x00: 1497 goto op_semantics_1; 1498 break; 1499 } 1500 break; 1501 case 0x44: 1502 GETBYTE (); 1503 switch (op[2] & 0x00) 1504 { 1505 case 0x00: 1506 goto op_semantics_2; 1507 break; 1508 } 1509 break; 1510 case 0x45: 1511 GETBYTE (); 1512 switch (op[2] & 0x00) 1513 { 1514 case 0x00: 1515 goto op_semantics_2; 1516 break; 1517 } 1518 break; 1519 case 0x46: 1520 GETBYTE (); 1521 switch (op[2] & 0x00) 1522 { 1523 case 0x00: 1524 goto op_semantics_2; 1525 break; 1526 } 1527 break; 1528 case 0x47: 1529 GETBYTE (); 1530 switch (op[2] & 0x00) 1531 { 1532 case 0x00: 1533 goto op_semantics_2; 1534 break; 1535 } 1536 break; 1537 case 0x48: 1538 GETBYTE (); 1539 switch (op[2] & 0x00) 1540 { 1541 case 0x00: 1542 goto op_semantics_3; 1543 break; 1544 } 1545 break; 1546 case 0x49: 1547 GETBYTE (); 1548 switch (op[2] & 0x00) 1549 { 1550 case 0x00: 1551 goto op_semantics_3; 1552 break; 1553 } 1554 break; 1555 case 0x4a: 1556 GETBYTE (); 1557 switch (op[2] & 0x00) 1558 { 1559 case 0x00: 1560 goto op_semantics_3; 1561 break; 1562 } 1563 break; 1564 case 0x4b: 1565 GETBYTE (); 1566 switch (op[2] & 0x00) 1567 { 1568 case 0x00: 1569 goto op_semantics_3; 1570 break; 1571 } 1572 break; 1573 case 0x4c: 1574 GETBYTE (); 1575 switch (op[2] & 0x00) 1576 { 1577 case 0x00: 1578 goto op_semantics_4; 1579 break; 1580 } 1581 break; 1582 case 0x4d: 1583 GETBYTE (); 1584 switch (op[2] & 0x00) 1585 { 1586 case 0x00: 1587 goto op_semantics_4; 1588 break; 1589 } 1590 break; 1591 case 0x4e: 1592 GETBYTE (); 1593 switch (op[2] & 0x00) 1594 { 1595 case 0x00: 1596 goto op_semantics_4; 1597 break; 1598 } 1599 break; 1600 case 0x4f: 1601 GETBYTE (); 1602 switch (op[2] & 0x00) 1603 { 1604 case 0x00: 1605 goto op_semantics_4; 1606 break; 1607 } 1608 break; 1609 case 0x50: 1610 GETBYTE (); 1611 switch (op[2] & 0x00) 1612 { 1613 case 0x00: 1614 goto op_semantics_5; 1615 break; 1616 } 1617 break; 1618 case 0x51: 1619 GETBYTE (); 1620 switch (op[2] & 0x00) 1621 { 1622 case 0x00: 1623 goto op_semantics_5; 1624 break; 1625 } 1626 break; 1627 case 0x52: 1628 GETBYTE (); 1629 switch (op[2] & 0x00) 1630 { 1631 case 0x00: 1632 goto op_semantics_5; 1633 break; 1634 } 1635 break; 1636 case 0x53: 1637 GETBYTE (); 1638 switch (op[2] & 0x00) 1639 { 1640 case 0x00: 1641 goto op_semantics_5; 1642 break; 1643 } 1644 break; 1645 case 0x54: 1646 GETBYTE (); 1647 switch (op[2] & 0x00) 1648 { 1649 case 0x00: 1650 goto op_semantics_6; 1651 break; 1652 } 1653 break; 1654 case 0x55: 1655 GETBYTE (); 1656 switch (op[2] & 0x00) 1657 { 1658 case 0x00: 1659 goto op_semantics_6; 1660 break; 1661 } 1662 break; 1663 case 0x56: 1664 GETBYTE (); 1665 switch (op[2] & 0x00) 1666 { 1667 case 0x00: 1668 goto op_semantics_6; 1669 break; 1670 } 1671 break; 1672 case 0x57: 1673 GETBYTE (); 1674 switch (op[2] & 0x00) 1675 { 1676 case 0x00: 1677 goto op_semantics_6; 1678 break; 1679 } 1680 break; 1681 case 0x60: 1682 GETBYTE (); 1683 switch (op[2] & 0xff) 1684 { 1685 case 0x00: 1686 GETBYTE (); 1687 switch (op[3] & 0x00) 1688 { 1689 case 0x00: 1690 goto op_semantics_7; 1691 break; 1692 } 1693 break; 1694 case 0x04: 1695 GETBYTE (); 1696 switch (op[3] & 0x00) 1697 { 1698 case 0x00: 1699 goto op_semantics_8; 1700 break; 1701 } 1702 break; 1703 case 0x05: 1704 GETBYTE (); 1705 switch (op[3] & 0x00) 1706 { 1707 case 0x00: 1708 goto op_semantics_9; 1709 break; 1710 } 1711 break; 1712 case 0x06: 1713 GETBYTE (); 1714 switch (op[3] & 0x00) 1715 { 1716 case 0x00: 1717 goto op_semantics_10; 1718 break; 1719 } 1720 break; 1721 case 0x07: 1722 GETBYTE (); 1723 switch (op[3] & 0x00) 1724 { 1725 case 0x00: 1726 goto op_semantics_11; 1727 break; 1728 } 1729 break; 1730 case 0x08: 1731 GETBYTE (); 1732 switch (op[3] & 0x00) 1733 { 1734 case 0x00: 1735 goto op_semantics_12; 1736 break; 1737 } 1738 break; 1739 case 0x09: 1740 GETBYTE (); 1741 switch (op[3] & 0x00) 1742 { 1743 case 0x00: 1744 goto op_semantics_13; 1745 break; 1746 } 1747 break; 1748 case 0x0c: 1749 GETBYTE (); 1750 switch (op[3] & 0x00) 1751 { 1752 case 0x00: 1753 goto op_semantics_14; 1754 break; 1755 } 1756 break; 1757 case 0x0d: 1758 GETBYTE (); 1759 switch (op[3] & 0x00) 1760 { 1761 case 0x00: 1762 goto op_semantics_15; 1763 break; 1764 } 1765 break; 1766 case 0x10: 1767 GETBYTE (); 1768 switch (op[3] & 0x00) 1769 { 1770 case 0x00: 1771 goto op_semantics_16; 1772 break; 1773 } 1774 break; 1775 case 0x11: 1776 GETBYTE (); 1777 switch (op[3] & 0x00) 1778 { 1779 case 0x00: 1780 goto op_semantics_17; 1781 break; 1782 } 1783 break; 1784 default: UNSUPPORTED(); break; 1785 } 1786 break; 1787 case 0x61: 1788 GETBYTE (); 1789 switch (op[2] & 0xff) 1790 { 1791 case 0x00: 1792 GETBYTE (); 1793 switch (op[3] & 0x00) 1794 { 1795 case 0x00: 1796 goto op_semantics_7; 1797 break; 1798 } 1799 break; 1800 case 0x04: 1801 GETBYTE (); 1802 switch (op[3] & 0x00) 1803 { 1804 case 0x00: 1805 goto op_semantics_8; 1806 break; 1807 } 1808 break; 1809 case 0x05: 1810 GETBYTE (); 1811 switch (op[3] & 0x00) 1812 { 1813 case 0x00: 1814 goto op_semantics_9; 1815 break; 1816 } 1817 break; 1818 case 0x06: 1819 GETBYTE (); 1820 switch (op[3] & 0x00) 1821 { 1822 case 0x00: 1823 goto op_semantics_10; 1824 break; 1825 } 1826 break; 1827 case 0x07: 1828 GETBYTE (); 1829 switch (op[3] & 0x00) 1830 { 1831 case 0x00: 1832 goto op_semantics_11; 1833 break; 1834 } 1835 break; 1836 case 0x08: 1837 GETBYTE (); 1838 switch (op[3] & 0x00) 1839 { 1840 case 0x00: 1841 goto op_semantics_12; 1842 break; 1843 } 1844 break; 1845 case 0x09: 1846 GETBYTE (); 1847 switch (op[3] & 0x00) 1848 { 1849 case 0x00: 1850 goto op_semantics_13; 1851 break; 1852 } 1853 break; 1854 case 0x0c: 1855 GETBYTE (); 1856 switch (op[3] & 0x00) 1857 { 1858 case 0x00: 1859 goto op_semantics_14; 1860 break; 1861 } 1862 break; 1863 case 0x0d: 1864 GETBYTE (); 1865 switch (op[3] & 0x00) 1866 { 1867 case 0x00: 1868 goto op_semantics_15; 1869 break; 1870 } 1871 break; 1872 case 0x10: 1873 GETBYTE (); 1874 switch (op[3] & 0x00) 1875 { 1876 case 0x00: 1877 goto op_semantics_16; 1878 break; 1879 } 1880 break; 1881 case 0x11: 1882 GETBYTE (); 1883 switch (op[3] & 0x00) 1884 { 1885 case 0x00: 1886 goto op_semantics_17; 1887 break; 1888 } 1889 break; 1890 default: UNSUPPORTED(); break; 1891 } 1892 break; 1893 case 0x62: 1894 GETBYTE (); 1895 switch (op[2] & 0xff) 1896 { 1897 case 0x00: 1898 GETBYTE (); 1899 switch (op[3] & 0x00) 1900 { 1901 case 0x00: 1902 goto op_semantics_7; 1903 break; 1904 } 1905 break; 1906 case 0x04: 1907 GETBYTE (); 1908 switch (op[3] & 0x00) 1909 { 1910 case 0x00: 1911 goto op_semantics_8; 1912 break; 1913 } 1914 break; 1915 case 0x05: 1916 GETBYTE (); 1917 switch (op[3] & 0x00) 1918 { 1919 case 0x00: 1920 goto op_semantics_9; 1921 break; 1922 } 1923 break; 1924 case 0x06: 1925 GETBYTE (); 1926 switch (op[3] & 0x00) 1927 { 1928 case 0x00: 1929 goto op_semantics_10; 1930 break; 1931 } 1932 break; 1933 case 0x07: 1934 GETBYTE (); 1935 switch (op[3] & 0x00) 1936 { 1937 case 0x00: 1938 goto op_semantics_11; 1939 break; 1940 } 1941 break; 1942 case 0x08: 1943 GETBYTE (); 1944 switch (op[3] & 0x00) 1945 { 1946 case 0x00: 1947 goto op_semantics_12; 1948 break; 1949 } 1950 break; 1951 case 0x09: 1952 GETBYTE (); 1953 switch (op[3] & 0x00) 1954 { 1955 case 0x00: 1956 goto op_semantics_13; 1957 break; 1958 } 1959 break; 1960 case 0x0c: 1961 GETBYTE (); 1962 switch (op[3] & 0x00) 1963 { 1964 case 0x00: 1965 goto op_semantics_14; 1966 break; 1967 } 1968 break; 1969 case 0x0d: 1970 GETBYTE (); 1971 switch (op[3] & 0x00) 1972 { 1973 case 0x00: 1974 goto op_semantics_15; 1975 break; 1976 } 1977 break; 1978 case 0x10: 1979 GETBYTE (); 1980 switch (op[3] & 0x00) 1981 { 1982 case 0x00: 1983 goto op_semantics_16; 1984 break; 1985 } 1986 break; 1987 case 0x11: 1988 GETBYTE (); 1989 switch (op[3] & 0x00) 1990 { 1991 case 0x00: 1992 goto op_semantics_17; 1993 break; 1994 } 1995 break; 1996 default: UNSUPPORTED(); break; 1997 } 1998 break; 1999 case 0x63: 2000 GETBYTE (); 2001 switch (op[2] & 0xff) 2002 { 2003 case 0x00: 2004 GETBYTE (); 2005 switch (op[3] & 0x00) 2006 { 2007 case 0x00: 2008 goto op_semantics_7; 2009 break; 2010 } 2011 break; 2012 case 0x04: 2013 GETBYTE (); 2014 switch (op[3] & 0x00) 2015 { 2016 case 0x00: 2017 goto op_semantics_8; 2018 break; 2019 } 2020 break; 2021 case 0x05: 2022 GETBYTE (); 2023 switch (op[3] & 0x00) 2024 { 2025 case 0x00: 2026 goto op_semantics_9; 2027 break; 2028 } 2029 break; 2030 case 0x06: 2031 GETBYTE (); 2032 switch (op[3] & 0x00) 2033 { 2034 case 0x00: 2035 goto op_semantics_10; 2036 break; 2037 } 2038 break; 2039 case 0x07: 2040 GETBYTE (); 2041 switch (op[3] & 0x00) 2042 { 2043 case 0x00: 2044 goto op_semantics_11; 2045 break; 2046 } 2047 break; 2048 case 0x08: 2049 GETBYTE (); 2050 switch (op[3] & 0x00) 2051 { 2052 case 0x00: 2053 goto op_semantics_12; 2054 break; 2055 } 2056 break; 2057 case 0x09: 2058 GETBYTE (); 2059 switch (op[3] & 0x00) 2060 { 2061 case 0x00: 2062 goto op_semantics_13; 2063 break; 2064 } 2065 break; 2066 case 0x0c: 2067 GETBYTE (); 2068 switch (op[3] & 0x00) 2069 { 2070 case 0x00: 2071 goto op_semantics_14; 2072 break; 2073 } 2074 break; 2075 case 0x0d: 2076 GETBYTE (); 2077 switch (op[3] & 0x00) 2078 { 2079 case 0x00: 2080 goto op_semantics_15; 2081 break; 2082 } 2083 break; 2084 case 0x10: 2085 GETBYTE (); 2086 switch (op[3] & 0x00) 2087 { 2088 case 0x00: 2089 goto op_semantics_16; 2090 break; 2091 } 2092 break; 2093 case 0x11: 2094 GETBYTE (); 2095 switch (op[3] & 0x00) 2096 { 2097 case 0x00: 2098 goto op_semantics_17; 2099 break; 2100 } 2101 break; 2102 default: UNSUPPORTED(); break; 2103 } 2104 break; 2105 case 0x80: 2106 GETBYTE (); 2107 switch (op[2] & 0x00) 2108 { 2109 case 0x00: 2110 goto op_semantics_1; 2111 break; 2112 } 2113 break; 2114 case 0x81: 2115 GETBYTE (); 2116 switch (op[2] & 0x00) 2117 { 2118 case 0x00: 2119 goto op_semantics_1; 2120 break; 2121 } 2122 break; 2123 case 0x82: 2124 GETBYTE (); 2125 switch (op[2] & 0x00) 2126 { 2127 case 0x00: 2128 goto op_semantics_1; 2129 break; 2130 } 2131 break; 2132 case 0x83: 2133 GETBYTE (); 2134 switch (op[2] & 0x00) 2135 { 2136 case 0x00: 2137 goto op_semantics_1; 2138 break; 2139 } 2140 break; 2141 case 0x84: 2142 GETBYTE (); 2143 switch (op[2] & 0x00) 2144 { 2145 case 0x00: 2146 goto op_semantics_2; 2147 break; 2148 } 2149 break; 2150 case 0x85: 2151 GETBYTE (); 2152 switch (op[2] & 0x00) 2153 { 2154 case 0x00: 2155 goto op_semantics_2; 2156 break; 2157 } 2158 break; 2159 case 0x86: 2160 GETBYTE (); 2161 switch (op[2] & 0x00) 2162 { 2163 case 0x00: 2164 goto op_semantics_2; 2165 break; 2166 } 2167 break; 2168 case 0x87: 2169 GETBYTE (); 2170 switch (op[2] & 0x00) 2171 { 2172 case 0x00: 2173 goto op_semantics_2; 2174 break; 2175 } 2176 break; 2177 case 0x88: 2178 GETBYTE (); 2179 switch (op[2] & 0x00) 2180 { 2181 case 0x00: 2182 goto op_semantics_3; 2183 break; 2184 } 2185 break; 2186 case 0x89: 2187 GETBYTE (); 2188 switch (op[2] & 0x00) 2189 { 2190 case 0x00: 2191 goto op_semantics_3; 2192 break; 2193 } 2194 break; 2195 case 0x8a: 2196 GETBYTE (); 2197 switch (op[2] & 0x00) 2198 { 2199 case 0x00: 2200 goto op_semantics_3; 2201 break; 2202 } 2203 break; 2204 case 0x8b: 2205 GETBYTE (); 2206 switch (op[2] & 0x00) 2207 { 2208 case 0x00: 2209 goto op_semantics_3; 2210 break; 2211 } 2212 break; 2213 case 0x8c: 2214 GETBYTE (); 2215 switch (op[2] & 0x00) 2216 { 2217 case 0x00: 2218 goto op_semantics_4; 2219 break; 2220 } 2221 break; 2222 case 0x8d: 2223 GETBYTE (); 2224 switch (op[2] & 0x00) 2225 { 2226 case 0x00: 2227 goto op_semantics_4; 2228 break; 2229 } 2230 break; 2231 case 0x8e: 2232 GETBYTE (); 2233 switch (op[2] & 0x00) 2234 { 2235 case 0x00: 2236 goto op_semantics_4; 2237 break; 2238 } 2239 break; 2240 case 0x8f: 2241 GETBYTE (); 2242 switch (op[2] & 0x00) 2243 { 2244 case 0x00: 2245 goto op_semantics_4; 2246 break; 2247 } 2248 break; 2249 case 0x90: 2250 GETBYTE (); 2251 switch (op[2] & 0x00) 2252 { 2253 case 0x00: 2254 goto op_semantics_5; 2255 break; 2256 } 2257 break; 2258 case 0x91: 2259 GETBYTE (); 2260 switch (op[2] & 0x00) 2261 { 2262 case 0x00: 2263 goto op_semantics_5; 2264 break; 2265 } 2266 break; 2267 case 0x92: 2268 GETBYTE (); 2269 switch (op[2] & 0x00) 2270 { 2271 case 0x00: 2272 goto op_semantics_5; 2273 break; 2274 } 2275 break; 2276 case 0x93: 2277 GETBYTE (); 2278 switch (op[2] & 0x00) 2279 { 2280 case 0x00: 2281 goto op_semantics_5; 2282 break; 2283 } 2284 break; 2285 case 0x94: 2286 GETBYTE (); 2287 switch (op[2] & 0x00) 2288 { 2289 case 0x00: 2290 goto op_semantics_6; 2291 break; 2292 } 2293 break; 2294 case 0x95: 2295 GETBYTE (); 2296 switch (op[2] & 0x00) 2297 { 2298 case 0x00: 2299 goto op_semantics_6; 2300 break; 2301 } 2302 break; 2303 case 0x96: 2304 GETBYTE (); 2305 switch (op[2] & 0x00) 2306 { 2307 case 0x00: 2308 goto op_semantics_6; 2309 break; 2310 } 2311 break; 2312 case 0x97: 2313 GETBYTE (); 2314 switch (op[2] & 0x00) 2315 { 2316 case 0x00: 2317 goto op_semantics_6; 2318 break; 2319 } 2320 break; 2321 case 0xa0: 2322 GETBYTE (); 2323 switch (op[2] & 0xff) 2324 { 2325 case 0x00: 2326 GETBYTE (); 2327 switch (op[3] & 0x00) 2328 { 2329 case 0x00: 2330 goto op_semantics_7; 2331 break; 2332 } 2333 break; 2334 case 0x02: 2335 GETBYTE (); 2336 switch (op[3] & 0x00) 2337 { 2338 case 0x00: 2339 op_semantics_18: 2340 { 2341 /** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */ 2342 #line 457 "rx-decode.opc" 2343 int ss AU = op[1] & 0x03; 2344 #line 457 "rx-decode.opc" 2345 int rsrc AU = (op[3] >> 4) & 0x0f; 2346 #line 457 "rx-decode.opc" 2347 int rdst AU = op[3] & 0x0f; 2348 if (trace) 2349 { 2350 printf ("\033[33m%s\033[0m %02x %02x %02x %02x\n", 2351 "/** 0000 0110 1010 00ss 0000 0010 rsrc rdst adc %1%S1, %0 */", 2352 op[0], op[1], op[2], op[3]); 2353 printf (" ss = 0x%x,", ss); 2354 printf (" rsrc = 0x%x,", rsrc); 2355 printf (" rdst = 0x%x\n", rdst); 2356 } 2357 SYNTAX("adc %1%S1, %0"); 2358 #line 457 "rx-decode.opc" 2359 ID(adc); SPm(ss, rsrc, 2); DR(rdst); F_OSZC; 2360 2361 /*----------------------------------------------------------------------*/ 2362 /* ADD */ 2363 2364 } 2365 break; 2366 } 2367 break; 2368 case 0x04: 2369 GETBYTE (); 2370 switch (op[3] & 0x00) 2371 { 2372 case 0x00: 2373 goto op_semantics_8; 2374 break; 2375 } 2376 break; 2377 case 0x05: 2378 GETBYTE (); 2379 switch (op[3] & 0x00) 2380 { 2381 case 0x00: 2382 goto op_semantics_9; 2383 break; 2384 } 2385 break; 2386 case 0x06: 2387 GETBYTE (); 2388 switch (op[3] & 0x00) 2389 { 2390 case 0x00: 2391 goto op_semantics_10; 2392 break; 2393 } 2394 break; 2395 case 0x07: 2396 GETBYTE (); 2397 switch (op[3] & 0x00) 2398 { 2399 case 0x00: 2400 goto op_semantics_11; 2401 break; 2402 } 2403 break; 2404 case 0x08: 2405 GETBYTE (); 2406 switch (op[3] & 0x00) 2407 { 2408 case 0x00: 2409 goto op_semantics_12; 2410 break; 2411 } 2412 break; 2413 case 0x09: 2414 GETBYTE (); 2415 switch (op[3] & 0x00) 2416 { 2417 case 0x00: 2418 goto op_semantics_13; 2419 break; 2420 } 2421 break; 2422 case 0x0c: 2423 GETBYTE (); 2424 switch (op[3] & 0x00) 2425 { 2426 case 0x00: 2427 goto op_semantics_14; 2428 break; 2429 } 2430 break; 2431 case 0x0d: 2432 GETBYTE (); 2433 switch (op[3] & 0x00) 2434 { 2435 case 0x00: 2436 goto op_semantics_15; 2437 break; 2438 } 2439 break; 2440 case 0x10: 2441 GETBYTE (); 2442 switch (op[3] & 0x00) 2443 { 2444 case 0x00: 2445 goto op_semantics_16; 2446 break; 2447 } 2448 break; 2449 case 0x11: 2450 GETBYTE (); 2451 switch (op[3] & 0x00) 2452 { 2453 case 0x00: 2454 goto op_semantics_17; 2455 break; 2456 } 2457 break; 2458 default: UNSUPPORTED(); break; 2459 } 2460 break; 2461 case 0xa1: 2462 GETBYTE (); 2463 switch (op[2] & 0xff) 2464 { 2465 case 0x00: 2466 GETBYTE (); 2467 switch (op[3] & 0x00) 2468 { 2469 case 0x00: 2470 goto op_semantics_7; 2471 break; 2472 } 2473 break; 2474 case 0x02: 2475 GETBYTE (); 2476 switch (op[3] & 0x00) 2477 { 2478 case 0x00: 2479 goto op_semantics_18; 2480 break; 2481 } 2482 break; 2483 case 0x04: 2484 GETBYTE (); 2485 switch (op[3] & 0x00) 2486 { 2487 case 0x00: 2488 goto op_semantics_8; 2489 break; 2490 } 2491 break; 2492 case 0x05: 2493 GETBYTE (); 2494 switch (op[3] & 0x00) 2495 { 2496 case 0x00: 2497 goto op_semantics_9; 2498 break; 2499 } 2500 break; 2501 case 0x06: 2502 GETBYTE (); 2503 switch (op[3] & 0x00) 2504 { 2505 case 0x00: 2506 goto op_semantics_10; 2507 break; 2508 } 2509 break; 2510 case 0x07: 2511 GETBYTE (); 2512 switch (op[3] & 0x00) 2513 { 2514 case 0x00: 2515 goto op_semantics_11; 2516 break; 2517 } 2518 break; 2519 case 0x08: 2520 GETBYTE (); 2521 switch (op[3] & 0x00) 2522 { 2523 case 0x00: 2524 goto op_semantics_12; 2525 break; 2526 } 2527 break; 2528 case 0x09: 2529 GETBYTE (); 2530 switch (op[3] & 0x00) 2531 { 2532 case 0x00: 2533 goto op_semantics_13; 2534 break; 2535 } 2536 break; 2537 case 0x0c: 2538 GETBYTE (); 2539 switch (op[3] & 0x00) 2540 { 2541 case 0x00: 2542 goto op_semantics_14; 2543 break; 2544 } 2545 break; 2546 case 0x0d: 2547 GETBYTE (); 2548 switch (op[3] & 0x00) 2549 { 2550 case 0x00: 2551 goto op_semantics_15; 2552 break; 2553 } 2554 break; 2555 case 0x10: 2556 GETBYTE (); 2557 switch (op[3] & 0x00) 2558 { 2559 case 0x00: 2560 goto op_semantics_16; 2561 break; 2562 } 2563 break; 2564 case 0x11: 2565 GETBYTE (); 2566 switch (op[3] & 0x00) 2567 { 2568 case 0x00: 2569 goto op_semantics_17; 2570 break; 2571 } 2572 break; 2573 default: UNSUPPORTED(); break; 2574 } 2575 break; 2576 case 0xa2: 2577 GETBYTE (); 2578 switch (op[2] & 0xff) 2579 { 2580 case 0x00: 2581 GETBYTE (); 2582 switch (op[3] & 0x00) 2583 { 2584 case 0x00: 2585 goto op_semantics_7; 2586 break; 2587 } 2588 break; 2589 case 0x02: 2590 GETBYTE (); 2591 switch (op[3] & 0x00) 2592 { 2593 case 0x00: 2594 goto op_semantics_18; 2595 break; 2596 } 2597 break; 2598 case 0x04: 2599 GETBYTE (); 2600 switch (op[3] & 0x00) 2601 { 2602 case 0x00: 2603 goto op_semantics_8; 2604 break; 2605 } 2606 break; 2607 case 0x05: 2608 GETBYTE (); 2609 switch (op[3] & 0x00) 2610 { 2611 case 0x00: 2612 goto op_semantics_9; 2613 break; 2614 } 2615 break; 2616 case 0x06: 2617 GETBYTE (); 2618 switch (op[3] & 0x00) 2619 { 2620 case 0x00: 2621 goto op_semantics_10; 2622 break; 2623 } 2624 break; 2625 case 0x07: 2626 GETBYTE (); 2627 switch (op[3] & 0x00) 2628 { 2629 case 0x00: 2630 goto op_semantics_11; 2631 break; 2632 } 2633 break; 2634 case 0x08: 2635 GETBYTE (); 2636 switch (op[3] & 0x00) 2637 { 2638 case 0x00: 2639 goto op_semantics_12; 2640 break; 2641 } 2642 break; 2643 case 0x09: 2644 GETBYTE (); 2645 switch (op[3] & 0x00) 2646 { 2647 case 0x00: 2648 goto op_semantics_13; 2649 break; 2650 } 2651 break; 2652 case 0x0c: 2653 GETBYTE (); 2654 switch (op[3] & 0x00) 2655 { 2656 case 0x00: 2657 goto op_semantics_14; 2658 break; 2659 } 2660 break; 2661 case 0x0d: 2662 GETBYTE (); 2663 switch (op[3] & 0x00) 2664 { 2665 case 0x00: 2666 goto op_semantics_15; 2667 break; 2668 } 2669 break; 2670 case 0x10: 2671 GETBYTE (); 2672 switch (op[3] & 0x00) 2673 { 2674 case 0x00: 2675 goto op_semantics_16; 2676 break; 2677 } 2678 break; 2679 case 0x11: 2680 GETBYTE (); 2681 switch (op[3] & 0x00) 2682 { 2683 case 0x00: 2684 goto op_semantics_17; 2685 break; 2686 } 2687 break; 2688 default: UNSUPPORTED(); break; 2689 } 2690 break; 2691 case 0xa3: 2692 GETBYTE (); 2693 switch (op[2] & 0xff) 2694 { 2695 case 0x00: 2696 GETBYTE (); 2697 switch (op[3] & 0x00) 2698 { 2699 case 0x00: 2700 goto op_semantics_7; 2701 break; 2702 } 2703 break; 2704 case 0x02: 2705 GETBYTE (); 2706 switch (op[3] & 0x00) 2707 { 2708 case 0x00: 2709 goto op_semantics_18; 2710 break; 2711 } 2712 break; 2713 case 0x04: 2714 GETBYTE (); 2715 switch (op[3] & 0x00) 2716 { 2717 case 0x00: 2718 goto op_semantics_8; 2719 break; 2720 } 2721 break; 2722 case 0x05: 2723 GETBYTE (); 2724 switch (op[3] & 0x00) 2725 { 2726 case 0x00: 2727 goto op_semantics_9; 2728 break; 2729 } 2730 break; 2731 case 0x06: 2732 GETBYTE (); 2733 switch (op[3] & 0x00) 2734 { 2735 case 0x00: 2736 goto op_semantics_10; 2737 break; 2738 } 2739 break; 2740 case 0x07: 2741 GETBYTE (); 2742 switch (op[3] & 0x00) 2743 { 2744 case 0x00: 2745 goto op_semantics_11; 2746 break; 2747 } 2748 break; 2749 case 0x08: 2750 GETBYTE (); 2751 switch (op[3] & 0x00) 2752 { 2753 case 0x00: 2754 goto op_semantics_12; 2755 break; 2756 } 2757 break; 2758 case 0x09: 2759 GETBYTE (); 2760 switch (op[3] & 0x00) 2761 { 2762 case 0x00: 2763 goto op_semantics_13; 2764 break; 2765 } 2766 break; 2767 case 0x0c: 2768 GETBYTE (); 2769 switch (op[3] & 0x00) 2770 { 2771 case 0x00: 2772 goto op_semantics_14; 2773 break; 2774 } 2775 break; 2776 case 0x0d: 2777 GETBYTE (); 2778 switch (op[3] & 0x00) 2779 { 2780 case 0x00: 2781 goto op_semantics_15; 2782 break; 2783 } 2784 break; 2785 case 0x10: 2786 GETBYTE (); 2787 switch (op[3] & 0x00) 2788 { 2789 case 0x00: 2790 goto op_semantics_16; 2791 break; 2792 } 2793 break; 2794 case 0x11: 2795 GETBYTE (); 2796 switch (op[3] & 0x00) 2797 { 2798 case 0x00: 2799 goto op_semantics_17; 2800 break; 2801 } 2802 break; 2803 default: UNSUPPORTED(); break; 2804 } 2805 break; 2806 case 0xc0: 2807 GETBYTE (); 2808 switch (op[2] & 0x00) 2809 { 2810 case 0x00: 2811 goto op_semantics_1; 2812 break; 2813 } 2814 break; 2815 case 0xc1: 2816 GETBYTE (); 2817 switch (op[2] & 0x00) 2818 { 2819 case 0x00: 2820 goto op_semantics_1; 2821 break; 2822 } 2823 break; 2824 case 0xc2: 2825 GETBYTE (); 2826 switch (op[2] & 0x00) 2827 { 2828 case 0x00: 2829 goto op_semantics_1; 2830 break; 2831 } 2832 break; 2833 case 0xc3: 2834 GETBYTE (); 2835 switch (op[2] & 0x00) 2836 { 2837 case 0x00: 2838 goto op_semantics_1; 2839 break; 2840 } 2841 break; 2842 case 0xc4: 2843 GETBYTE (); 2844 switch (op[2] & 0x00) 2845 { 2846 case 0x00: 2847 goto op_semantics_2; 2848 break; 2849 } 2850 break; 2851 case 0xc5: 2852 GETBYTE (); 2853 switch (op[2] & 0x00) 2854 { 2855 case 0x00: 2856 goto op_semantics_2; 2857 break; 2858 } 2859 break; 2860 case 0xc6: 2861 GETBYTE (); 2862 switch (op[2] & 0x00) 2863 { 2864 case 0x00: 2865 goto op_semantics_2; 2866 break; 2867 } 2868 break; 2869 case 0xc7: 2870 GETBYTE (); 2871 switch (op[2] & 0x00) 2872 { 2873 case 0x00: 2874 goto op_semantics_2; 2875 break; 2876 } 2877 break; 2878 case 0xc8: 2879 GETBYTE (); 2880 switch (op[2] & 0x00) 2881 { 2882 case 0x00: 2883 goto op_semantics_3; 2884 break; 2885 } 2886 break; 2887 case 0xc9: 2888 GETBYTE (); 2889 switch (op[2] & 0x00) 2890 { 2891 case 0x00: 2892 goto op_semantics_3; 2893 break; 2894 } 2895 break; 2896 case 0xca: 2897 GETBYTE (); 2898 switch (op[2] & 0x00) 2899 { 2900 case 0x00: 2901 goto op_semantics_3; 2902 break; 2903 } 2904 break; 2905 case 0xcb: 2906 GETBYTE (); 2907 switch (op[2] & 0x00) 2908 { 2909 case 0x00: 2910 goto op_semantics_3; 2911 break; 2912 } 2913 break; 2914 case 0xcc: 2915 GETBYTE (); 2916 switch (op[2] & 0x00) 2917 { 2918 case 0x00: 2919 goto op_semantics_4; 2920 break; 2921 } 2922 break; 2923 case 0xcd: 2924 GETBYTE (); 2925 switch (op[2] & 0x00) 2926 { 2927 case 0x00: 2928 goto op_semantics_4; 2929 break; 2930 } 2931 break; 2932 case 0xce: 2933 GETBYTE (); 2934 switch (op[2] & 0x00) 2935 { 2936 case 0x00: 2937 goto op_semantics_4; 2938 break; 2939 } 2940 break; 2941 case 0xcf: 2942 GETBYTE (); 2943 switch (op[2] & 0x00) 2944 { 2945 case 0x00: 2946 goto op_semantics_4; 2947 break; 2948 } 2949 break; 2950 case 0xd0: 2951 GETBYTE (); 2952 switch (op[2] & 0x00) 2953 { 2954 case 0x00: 2955 goto op_semantics_5; 2956 break; 2957 } 2958 break; 2959 case 0xd1: 2960 GETBYTE (); 2961 switch (op[2] & 0x00) 2962 { 2963 case 0x00: 2964 goto op_semantics_5; 2965 break; 2966 } 2967 break; 2968 case 0xd2: 2969 GETBYTE (); 2970 switch (op[2] & 0x00) 2971 { 2972 case 0x00: 2973 goto op_semantics_5; 2974 break; 2975 } 2976 break; 2977 case 0xd3: 2978 GETBYTE (); 2979 switch (op[2] & 0x00) 2980 { 2981 case 0x00: 2982 goto op_semantics_5; 2983 break; 2984 } 2985 break; 2986 case 0xd4: 2987 GETBYTE (); 2988 switch (op[2] & 0x00) 2989 { 2990 case 0x00: 2991 goto op_semantics_6; 2992 break; 2993 } 2994 break; 2995 case 0xd5: 2996 GETBYTE (); 2997 switch (op[2] & 0x00) 2998 { 2999 case 0x00: 3000 goto op_semantics_6; 3001 break; 3002 } 3003 break; 3004 case 0xd6: 3005 GETBYTE (); 3006 switch (op[2] & 0x00) 3007 { 3008 case 0x00: 3009 goto op_semantics_6; 3010 break; 3011 } 3012 break; 3013 case 0xd7: 3014 GETBYTE (); 3015 switch (op[2] & 0x00) 3016 { 3017 case 0x00: 3018 goto op_semantics_6; 3019 break; 3020 } 3021 break; 3022 case 0xe0: 3023 GETBYTE (); 3024 switch (op[2] & 0xff) 3025 { 3026 case 0x00: 3027 GETBYTE (); 3028 switch (op[3] & 0x00) 3029 { 3030 case 0x00: 3031 goto op_semantics_7; 3032 break; 3033 } 3034 break; 3035 case 0x04: 3036 GETBYTE (); 3037 switch (op[3] & 0x00) 3038 { 3039 case 0x00: 3040 goto op_semantics_8; 3041 break; 3042 } 3043 break; 3044 case 0x05: 3045 GETBYTE (); 3046 switch (op[3] & 0x00) 3047 { 3048 case 0x00: 3049 goto op_semantics_9; 3050 break; 3051 } 3052 break; 3053 case 0x06: 3054 GETBYTE (); 3055 switch (op[3] & 0x00) 3056 { 3057 case 0x00: 3058 goto op_semantics_10; 3059 break; 3060 } 3061 break; 3062 case 0x07: 3063 GETBYTE (); 3064 switch (op[3] & 0x00) 3065 { 3066 case 0x00: 3067 goto op_semantics_11; 3068 break; 3069 } 3070 break; 3071 case 0x08: 3072 GETBYTE (); 3073 switch (op[3] & 0x00) 3074 { 3075 case 0x00: 3076 goto op_semantics_12; 3077 break; 3078 } 3079 break; 3080 case 0x09: 3081 GETBYTE (); 3082 switch (op[3] & 0x00) 3083 { 3084 case 0x00: 3085 goto op_semantics_13; 3086 break; 3087 } 3088 break; 3089 case 0x0c: 3090 GETBYTE (); 3091 switch (op[3] & 0x00) 3092 { 3093 case 0x00: 3094 goto op_semantics_14; 3095 break; 3096 } 3097 break; 3098 case 0x0d: 3099 GETBYTE (); 3100 switch (op[3] & 0x00) 3101 { 3102 case 0x00: 3103 goto op_semantics_15; 3104 break; 3105 } 3106 break; 3107 case 0x10: 3108 GETBYTE (); 3109 switch (op[3] & 0x00) 3110 { 3111 case 0x00: 3112 goto op_semantics_16; 3113 break; 3114 } 3115 break; 3116 case 0x11: 3117 GETBYTE (); 3118 switch (op[3] & 0x00) 3119 { 3120 case 0x00: 3121 goto op_semantics_17; 3122 break; 3123 } 3124 break; 3125 default: UNSUPPORTED(); break; 3126 } 3127 break; 3128 case 0xe1: 3129 GETBYTE (); 3130 switch (op[2] & 0xff) 3131 { 3132 case 0x00: 3133 GETBYTE (); 3134 switch (op[3] & 0x00) 3135 { 3136 case 0x00: 3137 goto op_semantics_7; 3138 break; 3139 } 3140 break; 3141 case 0x04: 3142 GETBYTE (); 3143 switch (op[3] & 0x00) 3144 { 3145 case 0x00: 3146 goto op_semantics_8; 3147 break; 3148 } 3149 break; 3150 case 0x05: 3151 GETBYTE (); 3152 switch (op[3] & 0x00) 3153 { 3154 case 0x00: 3155 goto op_semantics_9; 3156 break; 3157 } 3158 break; 3159 case 0x06: 3160 GETBYTE (); 3161 switch (op[3] & 0x00) 3162 { 3163 case 0x00: 3164 goto op_semantics_10; 3165 break; 3166 } 3167 break; 3168 case 0x07: 3169 GETBYTE (); 3170 switch (op[3] & 0x00) 3171 { 3172 case 0x00: 3173 goto op_semantics_11; 3174 break; 3175 } 3176 break; 3177 case 0x08: 3178 GETBYTE (); 3179 switch (op[3] & 0x00) 3180 { 3181 case 0x00: 3182 goto op_semantics_12; 3183 break; 3184 } 3185 break; 3186 case 0x09: 3187 GETBYTE (); 3188 switch (op[3] & 0x00) 3189 { 3190 case 0x00: 3191 goto op_semantics_13; 3192 break; 3193 } 3194 break; 3195 case 0x0c: 3196 GETBYTE (); 3197 switch (op[3] & 0x00) 3198 { 3199 case 0x00: 3200 goto op_semantics_14; 3201 break; 3202 } 3203 break; 3204 case 0x0d: 3205 GETBYTE (); 3206 switch (op[3] & 0x00) 3207 { 3208 case 0x00: 3209 goto op_semantics_15; 3210 break; 3211 } 3212 break; 3213 case 0x10: 3214 GETBYTE (); 3215 switch (op[3] & 0x00) 3216 { 3217 case 0x00: 3218 goto op_semantics_16; 3219 break; 3220 } 3221 break; 3222 case 0x11: 3223 GETBYTE (); 3224 switch (op[3] & 0x00) 3225 { 3226 case 0x00: 3227 goto op_semantics_17; 3228 break; 3229 } 3230 break; 3231 default: UNSUPPORTED(); break; 3232 } 3233 break; 3234 case 0xe2: 3235 GETBYTE (); 3236 switch (op[2] & 0xff) 3237 { 3238 case 0x00: 3239 GETBYTE (); 3240 switch (op[3] & 0x00) 3241 { 3242 case 0x00: 3243 goto op_semantics_7; 3244 break; 3245 } 3246 break; 3247 case 0x04: 3248 GETBYTE (); 3249 switch (op[3] & 0x00) 3250 { 3251 case 0x00: 3252 goto op_semantics_8; 3253 break; 3254 } 3255 break; 3256 case 0x05: 3257 GETBYTE (); 3258 switch (op[3] & 0x00) 3259 { 3260 case 0x00: 3261 goto op_semantics_9; 3262 break; 3263 } 3264 break; 3265 case 0x06: 3266 GETBYTE (); 3267 switch (op[3] & 0x00) 3268 { 3269 case 0x00: 3270 goto op_semantics_10; 3271 break; 3272 } 3273 break; 3274 case 0x07: 3275 GETBYTE (); 3276 switch (op[3] & 0x00) 3277 { 3278 case 0x00: 3279 goto op_semantics_11; 3280 break; 3281 } 3282 break; 3283 case 0x08: 3284 GETBYTE (); 3285 switch (op[3] & 0x00) 3286 { 3287 case 0x00: 3288 goto op_semantics_12; 3289 break; 3290 } 3291 break; 3292 case 0x09: 3293 GETBYTE (); 3294 switch (op[3] & 0x00) 3295 { 3296 case 0x00: 3297 goto op_semantics_13; 3298 break; 3299 } 3300 break; 3301 case 0x0c: 3302 GETBYTE (); 3303 switch (op[3] & 0x00) 3304 { 3305 case 0x00: 3306 goto op_semantics_14; 3307 break; 3308 } 3309 break; 3310 case 0x0d: 3311 GETBYTE (); 3312 switch (op[3] & 0x00) 3313 { 3314 case 0x00: 3315 goto op_semantics_15; 3316 break; 3317 } 3318 break; 3319 case 0x10: 3320 GETBYTE (); 3321 switch (op[3] & 0x00) 3322 { 3323 case 0x00: 3324 goto op_semantics_16; 3325 break; 3326 } 3327 break; 3328 case 0x11: 3329 GETBYTE (); 3330 switch (op[3] & 0x00) 3331 { 3332 case 0x00: 3333 goto op_semantics_17; 3334 break; 3335 } 3336 break; 3337 default: UNSUPPORTED(); break; 3338 } 3339 break; 3340 case 0xe3: 3341 GETBYTE (); 3342 switch (op[2] & 0xff) 3343 { 3344 case 0x00: 3345 GETBYTE (); 3346 switch (op[3] & 0x00) 3347 { 3348 case 0x00: 3349 goto op_semantics_7; 3350 break; 3351 } 3352 break; 3353 case 0x04: 3354 GETBYTE (); 3355 switch (op[3] & 0x00) 3356 { 3357 case 0x00: 3358 goto op_semantics_8; 3359 break; 3360 } 3361 break; 3362 case 0x05: 3363 GETBYTE (); 3364 switch (op[3] & 0x00) 3365 { 3366 case 0x00: 3367 goto op_semantics_9; 3368 break; 3369 } 3370 break; 3371 case 0x06: 3372 GETBYTE (); 3373 switch (op[3] & 0x00) 3374 { 3375 case 0x00: 3376 goto op_semantics_10; 3377 break; 3378 } 3379 break; 3380 case 0x07: 3381 GETBYTE (); 3382 switch (op[3] & 0x00) 3383 { 3384 case 0x00: 3385 goto op_semantics_11; 3386 break; 3387 } 3388 break; 3389 case 0x08: 3390 GETBYTE (); 3391 switch (op[3] & 0x00) 3392 { 3393 case 0x00: 3394 goto op_semantics_12; 3395 break; 3396 } 3397 break; 3398 case 0x09: 3399 GETBYTE (); 3400 switch (op[3] & 0x00) 3401 { 3402 case 0x00: 3403 goto op_semantics_13; 3404 break; 3405 } 3406 break; 3407 case 0x0c: 3408 GETBYTE (); 3409 switch (op[3] & 0x00) 3410 { 3411 case 0x00: 3412 goto op_semantics_14; 3413 break; 3414 } 3415 break; 3416 case 0x0d: 3417 GETBYTE (); 3418 switch (op[3] & 0x00) 3419 { 3420 case 0x00: 3421 goto op_semantics_15; 3422 break; 3423 } 3424 break; 3425 case 0x10: 3426 GETBYTE (); 3427 switch (op[3] & 0x00) 3428 { 3429 case 0x00: 3430 goto op_semantics_16; 3431 break; 3432 } 3433 break; 3434 case 0x11: 3435 GETBYTE (); 3436 switch (op[3] & 0x00) 3437 { 3438 case 0x00: 3439 goto op_semantics_17; 3440 break; 3441 } 3442 break; 3443 default: UNSUPPORTED(); break; 3444 } 3445 break; 3446 default: UNSUPPORTED(); break; 3447 } 3448 break; 3449 case 0x08: 3450 case 0x09: 3451 case 0x0a: 3452 case 0x0b: 3453 case 0x0c: 3454 case 0x0d: 3455 case 0x0e: 3456 case 0x0f: 3457 { 3458 /** 0000 1dsp bra.s %a0 */ 3459 #line 699 "rx-decode.opc" 3460 int dsp AU = op[0] & 0x07; 3461 if (trace) 3462 { 3463 printf ("\033[33m%s\033[0m %02x\n", 3464 "/** 0000 1dsp bra.s %a0 */", 3465 op[0]); 3466 printf (" dsp = 0x%x\n", dsp); 3467 } 3468 SYNTAX("bra.s %a0"); 3469 #line 699 "rx-decode.opc" 3470 ID(branch); DC(pc + dsp3map[dsp]); 3471 3472 } 3473 break; 3474 case 0x10: 3475 case 0x11: 3476 case 0x12: 3477 case 0x13: 3478 case 0x14: 3479 case 0x15: 3480 case 0x16: 3481 case 0x17: 3482 case 0x18: 3483 case 0x19: 3484 case 0x1a: 3485 case 0x1b: 3486 case 0x1c: 3487 case 0x1d: 3488 case 0x1e: 3489 case 0x1f: 3490 { 3491 /** 0001 n dsp b%1.s %a0 */ 3492 #line 689 "rx-decode.opc" 3493 int n AU = (op[0] >> 3) & 0x01; 3494 #line 689 "rx-decode.opc" 3495 int dsp AU = op[0] & 0x07; 3496 if (trace) 3497 { 3498 printf ("\033[33m%s\033[0m %02x\n", 3499 "/** 0001 n dsp b%1.s %a0 */", 3500 op[0]); 3501 printf (" n = 0x%x,", n); 3502 printf (" dsp = 0x%x\n", dsp); 3503 } 3504 SYNTAX("b%1.s %a0"); 3505 #line 689 "rx-decode.opc" 3506 ID(branch); Scc(n); DC(pc + dsp3map[dsp]); 3507 3508 } 3509 break; 3510 case 0x20: 3511 case 0x21: 3512 case 0x22: 3513 case 0x23: 3514 case 0x24: 3515 case 0x25: 3516 case 0x26: 3517 case 0x27: 3518 case 0x28: 3519 case 0x29: 3520 case 0x2a: 3521 case 0x2b: 3522 case 0x2c: 3523 case 0x2d: 3524 case 0x2f: 3525 { 3526 /** 0010 cond b%1.b %a0 */ 3527 #line 692 "rx-decode.opc" 3528 int cond AU = op[0] & 0x0f; 3529 if (trace) 3530 { 3531 printf ("\033[33m%s\033[0m %02x\n", 3532 "/** 0010 cond b%1.b %a0 */", 3533 op[0]); 3534 printf (" cond = 0x%x\n", cond); 3535 } 3536 SYNTAX("b%1.b %a0"); 3537 #line 692 "rx-decode.opc" 3538 ID(branch); Scc(cond); DC(pc + IMMex (1)); 3539 3540 } 3541 break; 3542 case 0x2e: 3543 { 3544 /** 0010 1110 bra.b %a0 */ 3545 if (trace) 3546 { 3547 printf ("\033[33m%s\033[0m %02x\n", 3548 "/** 0010 1110 bra.b %a0 */", 3549 op[0]); 3550 } 3551 SYNTAX("bra.b %a0"); 3552 #line 702 "rx-decode.opc" 3553 ID(branch); DC(pc + IMMex(1)); 3554 3555 } 3556 break; 3557 case 0x38: 3558 { 3559 /** 0011 1000 bra.w %a0 */ 3560 if (trace) 3561 { 3562 printf ("\033[33m%s\033[0m %02x\n", 3563 "/** 0011 1000 bra.w %a0 */", 3564 op[0]); 3565 } 3566 SYNTAX("bra.w %a0"); 3567 #line 705 "rx-decode.opc" 3568 ID(branch); DC(pc + IMMex(2)); 3569 3570 } 3571 break; 3572 case 0x39: 3573 { 3574 /** 0011 1001 bsr.w %a0 */ 3575 if (trace) 3576 { 3577 printf ("\033[33m%s\033[0m %02x\n", 3578 "/** 0011 1001 bsr.w %a0 */", 3579 op[0]); 3580 } 3581 SYNTAX("bsr.w %a0"); 3582 #line 721 "rx-decode.opc" 3583 ID(jsr); DC(pc + IMMex(2)); 3584 3585 } 3586 break; 3587 case 0x3a: 3588 case 0x3b: 3589 { 3590 /** 0011 101c b%1.w %a0 */ 3591 #line 695 "rx-decode.opc" 3592 int c AU = op[0] & 0x01; 3593 if (trace) 3594 { 3595 printf ("\033[33m%s\033[0m %02x\n", 3596 "/** 0011 101c b%1.w %a0 */", 3597 op[0]); 3598 printf (" c = 0x%x\n", c); 3599 } 3600 SYNTAX("b%1.w %a0"); 3601 #line 695 "rx-decode.opc" 3602 ID(branch); Scc(c); DC(pc + IMMex (2)); 3603 3604 3605 } 3606 break; 3607 case 0x3c: 3608 GETBYTE (); 3609 switch (op[1] & 0x00) 3610 { 3611 case 0x00: 3612 op_semantics_19: 3613 { 3614 /** 0011 11sz d dst sppp mov%s #%1, %0 */ 3615 #line 271 "rx-decode.opc" 3616 int sz AU = op[0] & 0x03; 3617 #line 271 "rx-decode.opc" 3618 int d AU = (op[1] >> 7) & 0x01; 3619 #line 271 "rx-decode.opc" 3620 int dst AU = (op[1] >> 4) & 0x07; 3621 #line 271 "rx-decode.opc" 3622 int sppp AU = op[1] & 0x0f; 3623 if (trace) 3624 { 3625 printf ("\033[33m%s\033[0m %02x %02x\n", 3626 "/** 0011 11sz d dst sppp mov%s #%1, %0 */", 3627 op[0], op[1]); 3628 printf (" sz = 0x%x,", sz); 3629 printf (" d = 0x%x,", d); 3630 printf (" dst = 0x%x,", dst); 3631 printf (" sppp = 0x%x\n", sppp); 3632 } 3633 SYNTAX("mov%s #%1, %0"); 3634 #line 271 "rx-decode.opc" 3635 ID(mov); sBWL (sz); DIs(dst, d*16+sppp, sz); SC(IMM(1)); F_____; 3636 3637 } 3638 break; 3639 } 3640 break; 3641 case 0x3d: 3642 GETBYTE (); 3643 switch (op[1] & 0x00) 3644 { 3645 case 0x00: 3646 goto op_semantics_19; 3647 break; 3648 } 3649 break; 3650 case 0x3e: 3651 GETBYTE (); 3652 switch (op[1] & 0x00) 3653 { 3654 case 0x00: 3655 goto op_semantics_19; 3656 break; 3657 } 3658 break; 3659 case 0x3f: 3660 GETBYTE (); 3661 switch (op[1] & 0x00) 3662 { 3663 case 0x00: 3664 { 3665 /** 0011 1111 rega regb rtsd #%1, %2-%0 */ 3666 #line 367 "rx-decode.opc" 3667 int rega AU = (op[1] >> 4) & 0x0f; 3668 #line 367 "rx-decode.opc" 3669 int regb AU = op[1] & 0x0f; 3670 if (trace) 3671 { 3672 printf ("\033[33m%s\033[0m %02x %02x\n", 3673 "/** 0011 1111 rega regb rtsd #%1, %2-%0 */", 3674 op[0], op[1]); 3675 printf (" rega = 0x%x,", rega); 3676 printf (" regb = 0x%x\n", regb); 3677 } 3678 SYNTAX("rtsd #%1, %2-%0"); 3679 #line 367 "rx-decode.opc" 3680 ID(rtsd); SC(IMM(1) * 4); S2R(rega); DR(regb); 3681 3682 /*----------------------------------------------------------------------*/ 3683 /* AND */ 3684 3685 } 3686 break; 3687 } 3688 break; 3689 case 0x40: 3690 GETBYTE (); 3691 switch (op[1] & 0x00) 3692 { 3693 case 0x00: 3694 op_semantics_20: 3695 { 3696 /** 0100 00ss rsrc rdst sub %2%S2, %1 */ 3697 #line 502 "rx-decode.opc" 3698 int ss AU = op[0] & 0x03; 3699 #line 502 "rx-decode.opc" 3700 int rsrc AU = (op[1] >> 4) & 0x0f; 3701 #line 502 "rx-decode.opc" 3702 int rdst AU = op[1] & 0x0f; 3703 if (trace) 3704 { 3705 printf ("\033[33m%s\033[0m %02x %02x\n", 3706 "/** 0100 00ss rsrc rdst sub %2%S2, %1 */", 3707 op[0], op[1]); 3708 printf (" ss = 0x%x,", ss); 3709 printf (" rsrc = 0x%x,", rsrc); 3710 printf (" rdst = 0x%x\n", rdst); 3711 } 3712 SYNTAX("sub %2%S2, %1"); 3713 #line 502 "rx-decode.opc" 3714 ID(sub); S2P(ss, rsrc); SR(rdst); DR(rdst); F_OSZC; 3715 3716 } 3717 break; 3718 } 3719 break; 3720 case 0x41: 3721 GETBYTE (); 3722 switch (op[1] & 0x00) 3723 { 3724 case 0x00: 3725 goto op_semantics_20; 3726 break; 3727 } 3728 break; 3729 case 0x42: 3730 GETBYTE (); 3731 switch (op[1] & 0x00) 3732 { 3733 case 0x00: 3734 goto op_semantics_20; 3735 break; 3736 } 3737 break; 3738 case 0x43: 3739 GETBYTE (); 3740 switch (op[1] & 0x00) 3741 { 3742 case 0x00: 3743 goto op_semantics_20; 3744 break; 3745 } 3746 break; 3747 case 0x44: 3748 GETBYTE (); 3749 switch (op[1] & 0x00) 3750 { 3751 case 0x00: 3752 op_semantics_21: 3753 { 3754 /** 0100 01ss rsrc rdst cmp %2%S2, %1 */ 3755 #line 490 "rx-decode.opc" 3756 int ss AU = op[0] & 0x03; 3757 #line 490 "rx-decode.opc" 3758 int rsrc AU = (op[1] >> 4) & 0x0f; 3759 #line 490 "rx-decode.opc" 3760 int rdst AU = op[1] & 0x0f; 3761 if (trace) 3762 { 3763 printf ("\033[33m%s\033[0m %02x %02x\n", 3764 "/** 0100 01ss rsrc rdst cmp %2%S2, %1 */", 3765 op[0], op[1]); 3766 printf (" ss = 0x%x,", ss); 3767 printf (" rsrc = 0x%x,", rsrc); 3768 printf (" rdst = 0x%x\n", rdst); 3769 } 3770 SYNTAX("cmp %2%S2, %1"); 3771 #line 490 "rx-decode.opc" 3772 ID(sub); S2P(ss, rsrc); SR(rdst); F_OSZC; 3773 3774 } 3775 break; 3776 } 3777 break; 3778 case 0x45: 3779 GETBYTE (); 3780 switch (op[1] & 0x00) 3781 { 3782 case 0x00: 3783 goto op_semantics_21; 3784 break; 3785 } 3786 break; 3787 case 0x46: 3788 GETBYTE (); 3789 switch (op[1] & 0x00) 3790 { 3791 case 0x00: 3792 goto op_semantics_21; 3793 break; 3794 } 3795 break; 3796 case 0x47: 3797 GETBYTE (); 3798 switch (op[1] & 0x00) 3799 { 3800 case 0x00: 3801 goto op_semantics_21; 3802 break; 3803 } 3804 break; 3805 case 0x48: 3806 GETBYTE (); 3807 switch (op[1] & 0x00) 3808 { 3809 case 0x00: 3810 op_semantics_22: 3811 { 3812 /** 0100 10ss rsrc rdst add %1%S1, %0 */ 3813 #line 466 "rx-decode.opc" 3814 int ss AU = op[0] & 0x03; 3815 #line 466 "rx-decode.opc" 3816 int rsrc AU = (op[1] >> 4) & 0x0f; 3817 #line 466 "rx-decode.opc" 3818 int rdst AU = op[1] & 0x0f; 3819 if (trace) 3820 { 3821 printf ("\033[33m%s\033[0m %02x %02x\n", 3822 "/** 0100 10ss rsrc rdst add %1%S1, %0 */", 3823 op[0], op[1]); 3824 printf (" ss = 0x%x,", ss); 3825 printf (" rsrc = 0x%x,", rsrc); 3826 printf (" rdst = 0x%x\n", rdst); 3827 } 3828 SYNTAX("add %1%S1, %0"); 3829 #line 466 "rx-decode.opc" 3830 ID(add); SP(ss, rsrc); DR(rdst); F_OSZC; 3831 3832 } 3833 break; 3834 } 3835 break; 3836 case 0x49: 3837 GETBYTE (); 3838 switch (op[1] & 0x00) 3839 { 3840 case 0x00: 3841 goto op_semantics_22; 3842 break; 3843 } 3844 break; 3845 case 0x4a: 3846 GETBYTE (); 3847 switch (op[1] & 0x00) 3848 { 3849 case 0x00: 3850 goto op_semantics_22; 3851 break; 3852 } 3853 break; 3854 case 0x4b: 3855 GETBYTE (); 3856 switch (op[1] & 0x00) 3857 { 3858 case 0x00: 3859 goto op_semantics_22; 3860 break; 3861 } 3862 break; 3863 case 0x4c: 3864 GETBYTE (); 3865 switch (op[1] & 0x00) 3866 { 3867 case 0x00: 3868 op_semantics_23: 3869 { 3870 /** 0100 11ss rsrc rdst mul %1%S1, %0 */ 3871 #line 570 "rx-decode.opc" 3872 int ss AU = op[0] & 0x03; 3873 #line 570 "rx-decode.opc" 3874 int rsrc AU = (op[1] >> 4) & 0x0f; 3875 #line 570 "rx-decode.opc" 3876 int rdst AU = op[1] & 0x0f; 3877 if (trace) 3878 { 3879 printf ("\033[33m%s\033[0m %02x %02x\n", 3880 "/** 0100 11ss rsrc rdst mul %1%S1, %0 */", 3881 op[0], op[1]); 3882 printf (" ss = 0x%x,", ss); 3883 printf (" rsrc = 0x%x,", rsrc); 3884 printf (" rdst = 0x%x\n", rdst); 3885 } 3886 SYNTAX("mul %1%S1, %0"); 3887 #line 570 "rx-decode.opc" 3888 ID(mul); SP(ss, rsrc); DR(rdst); F_____; 3889 3890 } 3891 break; 3892 } 3893 break; 3894 case 0x4d: 3895 GETBYTE (); 3896 switch (op[1] & 0x00) 3897 { 3898 case 0x00: 3899 goto op_semantics_23; 3900 break; 3901 } 3902 break; 3903 case 0x4e: 3904 GETBYTE (); 3905 switch (op[1] & 0x00) 3906 { 3907 case 0x00: 3908 goto op_semantics_23; 3909 break; 3910 } 3911 break; 3912 case 0x4f: 3913 GETBYTE (); 3914 switch (op[1] & 0x00) 3915 { 3916 case 0x00: 3917 goto op_semantics_23; 3918 break; 3919 } 3920 break; 3921 case 0x50: 3922 GETBYTE (); 3923 switch (op[1] & 0x00) 3924 { 3925 case 0x00: 3926 op_semantics_24: 3927 { 3928 /** 0101 00ss rsrc rdst and %1%S1, %0 */ 3929 #line 379 "rx-decode.opc" 3930 int ss AU = op[0] & 0x03; 3931 #line 379 "rx-decode.opc" 3932 int rsrc AU = (op[1] >> 4) & 0x0f; 3933 #line 379 "rx-decode.opc" 3934 int rdst AU = op[1] & 0x0f; 3935 if (trace) 3936 { 3937 printf ("\033[33m%s\033[0m %02x %02x\n", 3938 "/** 0101 00ss rsrc rdst and %1%S1, %0 */", 3939 op[0], op[1]); 3940 printf (" ss = 0x%x,", ss); 3941 printf (" rsrc = 0x%x,", rsrc); 3942 printf (" rdst = 0x%x\n", rdst); 3943 } 3944 SYNTAX("and %1%S1, %0"); 3945 #line 379 "rx-decode.opc" 3946 ID(and); SP(ss, rsrc); DR(rdst); F__SZ_; 3947 3948 } 3949 break; 3950 } 3951 break; 3952 case 0x51: 3953 GETBYTE (); 3954 switch (op[1] & 0x00) 3955 { 3956 case 0x00: 3957 goto op_semantics_24; 3958 break; 3959 } 3960 break; 3961 case 0x52: 3962 GETBYTE (); 3963 switch (op[1] & 0x00) 3964 { 3965 case 0x00: 3966 goto op_semantics_24; 3967 break; 3968 } 3969 break; 3970 case 0x53: 3971 GETBYTE (); 3972 switch (op[1] & 0x00) 3973 { 3974 case 0x00: 3975 goto op_semantics_24; 3976 break; 3977 } 3978 break; 3979 case 0x54: 3980 GETBYTE (); 3981 switch (op[1] & 0x00) 3982 { 3983 case 0x00: 3984 op_semantics_25: 3985 { 3986 /** 0101 01ss rsrc rdst or %1%S1, %0 */ 3987 #line 397 "rx-decode.opc" 3988 int ss AU = op[0] & 0x03; 3989 #line 397 "rx-decode.opc" 3990 int rsrc AU = (op[1] >> 4) & 0x0f; 3991 #line 397 "rx-decode.opc" 3992 int rdst AU = op[1] & 0x0f; 3993 if (trace) 3994 { 3995 printf ("\033[33m%s\033[0m %02x %02x\n", 3996 "/** 0101 01ss rsrc rdst or %1%S1, %0 */", 3997 op[0], op[1]); 3998 printf (" ss = 0x%x,", ss); 3999 printf (" rsrc = 0x%x,", rsrc); 4000 printf (" rdst = 0x%x\n", rdst); 4001 } 4002 SYNTAX("or %1%S1, %0"); 4003 #line 397 "rx-decode.opc" 4004 ID(or); SP(ss, rsrc); DR(rdst); F__SZ_; 4005 4006 } 4007 break; 4008 } 4009 break; 4010 case 0x55: 4011 GETBYTE (); 4012 switch (op[1] & 0x00) 4013 { 4014 case 0x00: 4015 goto op_semantics_25; 4016 break; 4017 } 4018 break; 4019 case 0x56: 4020 GETBYTE (); 4021 switch (op[1] & 0x00) 4022 { 4023 case 0x00: 4024 goto op_semantics_25; 4025 break; 4026 } 4027 break; 4028 case 0x57: 4029 GETBYTE (); 4030 switch (op[1] & 0x00) 4031 { 4032 case 0x00: 4033 goto op_semantics_25; 4034 break; 4035 } 4036 break; 4037 case 0x58: 4038 GETBYTE (); 4039 switch (op[1] & 0x00) 4040 { 4041 case 0x00: 4042 op_semantics_26: 4043 { 4044 /** 0101 1 s ss rsrc rdst movu%s %1, %0 */ 4045 #line 318 "rx-decode.opc" 4046 int s AU = (op[0] >> 2) & 0x01; 4047 #line 318 "rx-decode.opc" 4048 int ss AU = op[0] & 0x03; 4049 #line 318 "rx-decode.opc" 4050 int rsrc AU = (op[1] >> 4) & 0x0f; 4051 #line 318 "rx-decode.opc" 4052 int rdst AU = op[1] & 0x0f; 4053 if (trace) 4054 { 4055 printf ("\033[33m%s\033[0m %02x %02x\n", 4056 "/** 0101 1 s ss rsrc rdst movu%s %1, %0 */", 4057 op[0], op[1]); 4058 printf (" s = 0x%x,", s); 4059 printf (" ss = 0x%x,", ss); 4060 printf (" rsrc = 0x%x,", rsrc); 4061 printf (" rdst = 0x%x\n", rdst); 4062 } 4063 SYNTAX("movu%s %1, %0"); 4064 #line 318 "rx-decode.opc" 4065 ID(mov); uBWL(s); SD(ss, rsrc, s); DR(rdst); F_____; 4066 4067 } 4068 break; 4069 } 4070 break; 4071 case 0x59: 4072 GETBYTE (); 4073 switch (op[1] & 0x00) 4074 { 4075 case 0x00: 4076 goto op_semantics_26; 4077 break; 4078 } 4079 break; 4080 case 0x5a: 4081 GETBYTE (); 4082 switch (op[1] & 0x00) 4083 { 4084 case 0x00: 4085 goto op_semantics_26; 4086 break; 4087 } 4088 break; 4089 case 0x5b: 4090 GETBYTE (); 4091 switch (op[1] & 0x00) 4092 { 4093 case 0x00: 4094 goto op_semantics_26; 4095 break; 4096 } 4097 break; 4098 case 0x5c: 4099 GETBYTE (); 4100 switch (op[1] & 0x00) 4101 { 4102 case 0x00: 4103 goto op_semantics_26; 4104 break; 4105 } 4106 break; 4107 case 0x5d: 4108 GETBYTE (); 4109 switch (op[1] & 0x00) 4110 { 4111 case 0x00: 4112 goto op_semantics_26; 4113 break; 4114 } 4115 break; 4116 case 0x5e: 4117 GETBYTE (); 4118 switch (op[1] & 0x00) 4119 { 4120 case 0x00: 4121 goto op_semantics_26; 4122 break; 4123 } 4124 break; 4125 case 0x5f: 4126 GETBYTE (); 4127 switch (op[1] & 0x00) 4128 { 4129 case 0x00: 4130 goto op_semantics_26; 4131 break; 4132 } 4133 break; 4134 case 0x60: 4135 GETBYTE (); 4136 switch (op[1] & 0x00) 4137 { 4138 case 0x00: 4139 { 4140 /** 0110 0000 immm rdst sub #%2, %0 */ 4141 #line 499 "rx-decode.opc" 4142 int immm AU = (op[1] >> 4) & 0x0f; 4143 #line 499 "rx-decode.opc" 4144 int rdst AU = op[1] & 0x0f; 4145 if (trace) 4146 { 4147 printf ("\033[33m%s\033[0m %02x %02x\n", 4148 "/** 0110 0000 immm rdst sub #%2, %0 */", 4149 op[0], op[1]); 4150 printf (" immm = 0x%x,", immm); 4151 printf (" rdst = 0x%x\n", rdst); 4152 } 4153 SYNTAX("sub #%2, %0"); 4154 #line 499 "rx-decode.opc" 4155 ID(sub); S2C(immm); SR(rdst); DR(rdst); F_OSZC; 4156 4157 } 4158 break; 4159 } 4160 break; 4161 case 0x61: 4162 GETBYTE (); 4163 switch (op[1] & 0x00) 4164 { 4165 case 0x00: 4166 { 4167 /** 0110 0001 immm rdst cmp #%2, %1 */ 4168 #line 481 "rx-decode.opc" 4169 int immm AU = (op[1] >> 4) & 0x0f; 4170 #line 481 "rx-decode.opc" 4171 int rdst AU = op[1] & 0x0f; 4172 if (trace) 4173 { 4174 printf ("\033[33m%s\033[0m %02x %02x\n", 4175 "/** 0110 0001 immm rdst cmp #%2, %1 */", 4176 op[0], op[1]); 4177 printf (" immm = 0x%x,", immm); 4178 printf (" rdst = 0x%x\n", rdst); 4179 } 4180 SYNTAX("cmp #%2, %1"); 4181 #line 481 "rx-decode.opc" 4182 ID(sub); S2C(immm); SR(rdst); F_OSZC; 4183 4184 } 4185 break; 4186 } 4187 break; 4188 case 0x62: 4189 GETBYTE (); 4190 switch (op[1] & 0x00) 4191 { 4192 case 0x00: 4193 { 4194 /** 0110 0010 immm rdst add #%1, %0 */ 4195 #line 463 "rx-decode.opc" 4196 int immm AU = (op[1] >> 4) & 0x0f; 4197 #line 463 "rx-decode.opc" 4198 int rdst AU = op[1] & 0x0f; 4199 if (trace) 4200 { 4201 printf ("\033[33m%s\033[0m %02x %02x\n", 4202 "/** 0110 0010 immm rdst add #%1, %0 */", 4203 op[0], op[1]); 4204 printf (" immm = 0x%x,", immm); 4205 printf (" rdst = 0x%x\n", rdst); 4206 } 4207 SYNTAX("add #%1, %0"); 4208 #line 463 "rx-decode.opc" 4209 ID(add); SC(immm); DR(rdst); F_OSZC; 4210 4211 } 4212 break; 4213 } 4214 break; 4215 case 0x63: 4216 GETBYTE (); 4217 switch (op[1] & 0x00) 4218 { 4219 case 0x00: 4220 { 4221 /** 0110 0011 immm rdst mul #%1, %0 */ 4222 #line 564 "rx-decode.opc" 4223 int immm AU = (op[1] >> 4) & 0x0f; 4224 #line 564 "rx-decode.opc" 4225 int rdst AU = op[1] & 0x0f; 4226 if (trace) 4227 { 4228 printf ("\033[33m%s\033[0m %02x %02x\n", 4229 "/** 0110 0011 immm rdst mul #%1, %0 */", 4230 op[0], op[1]); 4231 printf (" immm = 0x%x,", immm); 4232 printf (" rdst = 0x%x\n", rdst); 4233 } 4234 SYNTAX("mul #%1, %0"); 4235 #line 564 "rx-decode.opc" 4236 ID(mul); DR(rdst); SC(immm); F_____; 4237 4238 } 4239 break; 4240 } 4241 break; 4242 case 0x64: 4243 GETBYTE (); 4244 switch (op[1] & 0x00) 4245 { 4246 case 0x00: 4247 { 4248 /** 0110 0100 immm rdst and #%1, %0 */ 4249 #line 373 "rx-decode.opc" 4250 int immm AU = (op[1] >> 4) & 0x0f; 4251 #line 373 "rx-decode.opc" 4252 int rdst AU = op[1] & 0x0f; 4253 if (trace) 4254 { 4255 printf ("\033[33m%s\033[0m %02x %02x\n", 4256 "/** 0110 0100 immm rdst and #%1, %0 */", 4257 op[0], op[1]); 4258 printf (" immm = 0x%x,", immm); 4259 printf (" rdst = 0x%x\n", rdst); 4260 } 4261 SYNTAX("and #%1, %0"); 4262 #line 373 "rx-decode.opc" 4263 ID(and); SC(immm); DR(rdst); F__SZ_; 4264 4265 } 4266 break; 4267 } 4268 break; 4269 case 0x65: 4270 GETBYTE (); 4271 switch (op[1] & 0x00) 4272 { 4273 case 0x00: 4274 { 4275 /** 0110 0101 immm rdst or #%1, %0 */ 4276 #line 391 "rx-decode.opc" 4277 int immm AU = (op[1] >> 4) & 0x0f; 4278 #line 391 "rx-decode.opc" 4279 int rdst AU = op[1] & 0x0f; 4280 if (trace) 4281 { 4282 printf ("\033[33m%s\033[0m %02x %02x\n", 4283 "/** 0110 0101 immm rdst or #%1, %0 */", 4284 op[0], op[1]); 4285 printf (" immm = 0x%x,", immm); 4286 printf (" rdst = 0x%x\n", rdst); 4287 } 4288 SYNTAX("or #%1, %0"); 4289 #line 391 "rx-decode.opc" 4290 ID(or); SC(immm); DR(rdst); F__SZ_; 4291 4292 } 4293 break; 4294 } 4295 break; 4296 case 0x66: 4297 GETBYTE (); 4298 switch (op[1] & 0x00) 4299 { 4300 case 0x00: 4301 { 4302 /** 0110 0110 immm rdst mov%s #%1, %0 */ 4303 #line 268 "rx-decode.opc" 4304 int immm AU = (op[1] >> 4) & 0x0f; 4305 #line 268 "rx-decode.opc" 4306 int rdst AU = op[1] & 0x0f; 4307 if (trace) 4308 { 4309 printf ("\033[33m%s\033[0m %02x %02x\n", 4310 "/** 0110 0110 immm rdst mov%s #%1, %0 */", 4311 op[0], op[1]); 4312 printf (" immm = 0x%x,", immm); 4313 printf (" rdst = 0x%x\n", rdst); 4314 } 4315 SYNTAX("mov%s #%1, %0"); 4316 #line 268 "rx-decode.opc" 4317 ID(mov); DR(rdst); SC(immm); F_____; 4318 4319 } 4320 break; 4321 } 4322 break; 4323 case 0x67: 4324 { 4325 /** 0110 0111 rtsd #%1 */ 4326 if (trace) 4327 { 4328 printf ("\033[33m%s\033[0m %02x\n", 4329 "/** 0110 0111 rtsd #%1 */", 4330 op[0]); 4331 } 4332 SYNTAX("rtsd #%1"); 4333 #line 364 "rx-decode.opc" 4334 ID(rtsd); SC(IMM(1) * 4); 4335 4336 } 4337 break; 4338 case 0x68: 4339 GETBYTE (); 4340 switch (op[1] & 0x00) 4341 { 4342 case 0x00: 4343 op_semantics_27: 4344 { 4345 /** 0110 100i mmmm rdst shlr #%2, %0 */ 4346 #line 650 "rx-decode.opc" 4347 int i AU = op[0] & 0x01; 4348 #line 650 "rx-decode.opc" 4349 int mmmm AU = (op[1] >> 4) & 0x0f; 4350 #line 650 "rx-decode.opc" 4351 int rdst AU = op[1] & 0x0f; 4352 if (trace) 4353 { 4354 printf ("\033[33m%s\033[0m %02x %02x\n", 4355 "/** 0110 100i mmmm rdst shlr #%2, %0 */", 4356 op[0], op[1]); 4357 printf (" i = 0x%x,", i); 4358 printf (" mmmm = 0x%x,", mmmm); 4359 printf (" rdst = 0x%x\n", rdst); 4360 } 4361 SYNTAX("shlr #%2, %0"); 4362 #line 650 "rx-decode.opc" 4363 ID(shlr); S2C(i*16+mmmm); SR(rdst); DR(rdst); F__SZC; 4364 4365 } 4366 break; 4367 } 4368 break; 4369 case 0x69: 4370 GETBYTE (); 4371 switch (op[1] & 0x00) 4372 { 4373 case 0x00: 4374 goto op_semantics_27; 4375 break; 4376 } 4377 break; 4378 case 0x6a: 4379 GETBYTE (); 4380 switch (op[1] & 0x00) 4381 { 4382 case 0x00: 4383 op_semantics_28: 4384 { 4385 /** 0110 101i mmmm rdst shar #%2, %0 */ 4386 #line 640 "rx-decode.opc" 4387 int i AU = op[0] & 0x01; 4388 #line 640 "rx-decode.opc" 4389 int mmmm AU = (op[1] >> 4) & 0x0f; 4390 #line 640 "rx-decode.opc" 4391 int rdst AU = op[1] & 0x0f; 4392 if (trace) 4393 { 4394 printf ("\033[33m%s\033[0m %02x %02x\n", 4395 "/** 0110 101i mmmm rdst shar #%2, %0 */", 4396 op[0], op[1]); 4397 printf (" i = 0x%x,", i); 4398 printf (" mmmm = 0x%x,", mmmm); 4399 printf (" rdst = 0x%x\n", rdst); 4400 } 4401 SYNTAX("shar #%2, %0"); 4402 #line 640 "rx-decode.opc" 4403 ID(shar); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_0SZC; 4404 4405 } 4406 break; 4407 } 4408 break; 4409 case 0x6b: 4410 GETBYTE (); 4411 switch (op[1] & 0x00) 4412 { 4413 case 0x00: 4414 goto op_semantics_28; 4415 break; 4416 } 4417 break; 4418 case 0x6c: 4419 GETBYTE (); 4420 switch (op[1] & 0x00) 4421 { 4422 case 0x00: 4423 op_semantics_29: 4424 { 4425 /** 0110 110i mmmm rdst shll #%2, %0 */ 4426 #line 630 "rx-decode.opc" 4427 int i AU = op[0] & 0x01; 4428 #line 630 "rx-decode.opc" 4429 int mmmm AU = (op[1] >> 4) & 0x0f; 4430 #line 630 "rx-decode.opc" 4431 int rdst AU = op[1] & 0x0f; 4432 if (trace) 4433 { 4434 printf ("\033[33m%s\033[0m %02x %02x\n", 4435 "/** 0110 110i mmmm rdst shll #%2, %0 */", 4436 op[0], op[1]); 4437 printf (" i = 0x%x,", i); 4438 printf (" mmmm = 0x%x,", mmmm); 4439 printf (" rdst = 0x%x\n", rdst); 4440 } 4441 SYNTAX("shll #%2, %0"); 4442 #line 630 "rx-decode.opc" 4443 ID(shll); S2C(i*16+mmmm); SR(rdst); DR(rdst); F_OSZC; 4444 4445 } 4446 break; 4447 } 4448 break; 4449 case 0x6d: 4450 GETBYTE (); 4451 switch (op[1] & 0x00) 4452 { 4453 case 0x00: 4454 goto op_semantics_29; 4455 break; 4456 } 4457 break; 4458 case 0x6e: 4459 GETBYTE (); 4460 switch (op[1] & 0x00) 4461 { 4462 case 0x00: 4463 { 4464 /** 0110 1110 dsta dstb pushm %1-%2 */ 4465 #line 331 "rx-decode.opc" 4466 int dsta AU = (op[1] >> 4) & 0x0f; 4467 #line 331 "rx-decode.opc" 4468 int dstb AU = op[1] & 0x0f; 4469 if (trace) 4470 { 4471 printf ("\033[33m%s\033[0m %02x %02x\n", 4472 "/** 0110 1110 dsta dstb pushm %1-%2 */", 4473 op[0], op[1]); 4474 printf (" dsta = 0x%x,", dsta); 4475 printf (" dstb = 0x%x\n", dstb); 4476 } 4477 SYNTAX("pushm %1-%2"); 4478 #line 331 "rx-decode.opc" 4479 ID(pushm); SR(dsta); S2R(dstb); F_____; 4480 4481 } 4482 break; 4483 } 4484 break; 4485 case 0x6f: 4486 GETBYTE (); 4487 switch (op[1] & 0x00) 4488 { 4489 case 0x00: 4490 { 4491 /** 0110 1111 dsta dstb popm %1-%2 */ 4492 #line 328 "rx-decode.opc" 4493 int dsta AU = (op[1] >> 4) & 0x0f; 4494 #line 328 "rx-decode.opc" 4495 int dstb AU = op[1] & 0x0f; 4496 if (trace) 4497 { 4498 printf ("\033[33m%s\033[0m %02x %02x\n", 4499 "/** 0110 1111 dsta dstb popm %1-%2 */", 4500 op[0], op[1]); 4501 printf (" dsta = 0x%x,", dsta); 4502 printf (" dstb = 0x%x\n", dstb); 4503 } 4504 SYNTAX("popm %1-%2"); 4505 #line 328 "rx-decode.opc" 4506 ID(popm); SR(dsta); S2R(dstb); F_____; 4507 4508 } 4509 break; 4510 } 4511 break; 4512 case 0x70: 4513 GETBYTE (); 4514 switch (op[1] & 0x00) 4515 { 4516 case 0x00: 4517 op_semantics_30: 4518 { 4519 /** 0111 00im rsrc rdst add #%1, %2, %0 */ 4520 #line 472 "rx-decode.opc" 4521 int im AU = op[0] & 0x03; 4522 #line 472 "rx-decode.opc" 4523 int rsrc AU = (op[1] >> 4) & 0x0f; 4524 #line 472 "rx-decode.opc" 4525 int rdst AU = op[1] & 0x0f; 4526 if (trace) 4527 { 4528 printf ("\033[33m%s\033[0m %02x %02x\n", 4529 "/** 0111 00im rsrc rdst add #%1, %2, %0 */", 4530 op[0], op[1]); 4531 printf (" im = 0x%x,", im); 4532 printf (" rsrc = 0x%x,", rsrc); 4533 printf (" rdst = 0x%x\n", rdst); 4534 } 4535 SYNTAX("add #%1, %2, %0"); 4536 #line 472 "rx-decode.opc" 4537 ID(add); SC(IMMex(im)); S2R(rsrc); DR(rdst); F_OSZC; 4538 4539 } 4540 break; 4541 } 4542 break; 4543 case 0x71: 4544 GETBYTE (); 4545 switch (op[1] & 0x00) 4546 { 4547 case 0x00: 4548 goto op_semantics_30; 4549 break; 4550 } 4551 break; 4552 case 0x72: 4553 GETBYTE (); 4554 switch (op[1] & 0x00) 4555 { 4556 case 0x00: 4557 goto op_semantics_30; 4558 break; 4559 } 4560 break; 4561 case 0x73: 4562 GETBYTE (); 4563 switch (op[1] & 0x00) 4564 { 4565 case 0x00: 4566 goto op_semantics_30; 4567 break; 4568 } 4569 break; 4570 case 0x74: 4571 GETBYTE (); 4572 switch (op[1] & 0xf0) 4573 { 4574 case 0x00: 4575 op_semantics_31: 4576 { 4577 /** 0111 01im 0000 rsrc cmp #%2, %1%S1 */ 4578 #line 484 "rx-decode.opc" 4579 int im AU = op[0] & 0x03; 4580 #line 484 "rx-decode.opc" 4581 int rsrc AU = op[1] & 0x0f; 4582 if (trace) 4583 { 4584 printf ("\033[33m%s\033[0m %02x %02x\n", 4585 "/** 0111 01im 0000 rsrc cmp #%2, %1%S1 */", 4586 op[0], op[1]); 4587 printf (" im = 0x%x,", im); 4588 printf (" rsrc = 0x%x\n", rsrc); 4589 } 4590 SYNTAX("cmp #%2, %1%S1"); 4591 #line 484 "rx-decode.opc" 4592 ID(sub); SR(rsrc); S2C(IMMex(im)); F_OSZC; 4593 4594 } 4595 break; 4596 case 0x10: 4597 op_semantics_32: 4598 { 4599 /** 0111 01im 0001rdst mul #%1, %0 */ 4600 #line 567 "rx-decode.opc" 4601 int im AU = op[0] & 0x03; 4602 #line 567 "rx-decode.opc" 4603 int rdst AU = op[1] & 0x0f; 4604 if (trace) 4605 { 4606 printf ("\033[33m%s\033[0m %02x %02x\n", 4607 "/** 0111 01im 0001rdst mul #%1, %0 */", 4608 op[0], op[1]); 4609 printf (" im = 0x%x,", im); 4610 printf (" rdst = 0x%x\n", rdst); 4611 } 4612 SYNTAX("mul #%1, %0"); 4613 #line 567 "rx-decode.opc" 4614 ID(mul); DR(rdst); SC(IMMex(im)); F_____; 4615 4616 } 4617 break; 4618 case 0x20: 4619 op_semantics_33: 4620 { 4621 /** 0111 01im 0010 rdst and #%1, %0 */ 4622 #line 376 "rx-decode.opc" 4623 int im AU = op[0] & 0x03; 4624 #line 376 "rx-decode.opc" 4625 int rdst AU = op[1] & 0x0f; 4626 if (trace) 4627 { 4628 printf ("\033[33m%s\033[0m %02x %02x\n", 4629 "/** 0111 01im 0010 rdst and #%1, %0 */", 4630 op[0], op[1]); 4631 printf (" im = 0x%x,", im); 4632 printf (" rdst = 0x%x\n", rdst); 4633 } 4634 SYNTAX("and #%1, %0"); 4635 #line 376 "rx-decode.opc" 4636 ID(and); SC(IMMex(im)); DR(rdst); F__SZ_; 4637 4638 } 4639 break; 4640 case 0x30: 4641 op_semantics_34: 4642 { 4643 /** 0111 01im 0011 rdst or #%1, %0 */ 4644 #line 394 "rx-decode.opc" 4645 int im AU = op[0] & 0x03; 4646 #line 394 "rx-decode.opc" 4647 int rdst AU = op[1] & 0x0f; 4648 if (trace) 4649 { 4650 printf ("\033[33m%s\033[0m %02x %02x\n", 4651 "/** 0111 01im 0011 rdst or #%1, %0 */", 4652 op[0], op[1]); 4653 printf (" im = 0x%x,", im); 4654 printf (" rdst = 0x%x\n", rdst); 4655 } 4656 SYNTAX("or #%1, %0"); 4657 #line 394 "rx-decode.opc" 4658 ID(or); SC(IMMex(im)); DR(rdst); F__SZ_; 4659 4660 } 4661 break; 4662 default: UNSUPPORTED(); break; 4663 } 4664 break; 4665 case 0x75: 4666 GETBYTE (); 4667 switch (op[1] & 0xff) 4668 { 4669 case 0x00: 4670 case 0x01: 4671 case 0x02: 4672 case 0x03: 4673 case 0x04: 4674 case 0x05: 4675 case 0x06: 4676 case 0x07: 4677 case 0x08: 4678 case 0x09: 4679 case 0x0a: 4680 case 0x0b: 4681 case 0x0c: 4682 case 0x0d: 4683 case 0x0e: 4684 case 0x0f: 4685 goto op_semantics_31; 4686 break; 4687 case 0x10: 4688 case 0x11: 4689 case 0x12: 4690 case 0x13: 4691 case 0x14: 4692 case 0x15: 4693 case 0x16: 4694 case 0x17: 4695 case 0x18: 4696 case 0x19: 4697 case 0x1a: 4698 case 0x1b: 4699 case 0x1c: 4700 case 0x1d: 4701 case 0x1e: 4702 case 0x1f: 4703 goto op_semantics_32; 4704 break; 4705 case 0x20: 4706 case 0x21: 4707 case 0x22: 4708 case 0x23: 4709 case 0x24: 4710 case 0x25: 4711 case 0x26: 4712 case 0x27: 4713 case 0x28: 4714 case 0x29: 4715 case 0x2a: 4716 case 0x2b: 4717 case 0x2c: 4718 case 0x2d: 4719 case 0x2e: 4720 case 0x2f: 4721 goto op_semantics_33; 4722 break; 4723 case 0x30: 4724 case 0x31: 4725 case 0x32: 4726 case 0x33: 4727 case 0x34: 4728 case 0x35: 4729 case 0x36: 4730 case 0x37: 4731 case 0x38: 4732 case 0x39: 4733 case 0x3a: 4734 case 0x3b: 4735 case 0x3c: 4736 case 0x3d: 4737 case 0x3e: 4738 case 0x3f: 4739 goto op_semantics_34; 4740 break; 4741 case 0x40: 4742 case 0x41: 4743 case 0x42: 4744 case 0x43: 4745 case 0x44: 4746 case 0x45: 4747 case 0x46: 4748 case 0x47: 4749 case 0x48: 4750 case 0x49: 4751 case 0x4a: 4752 case 0x4b: 4753 case 0x4c: 4754 case 0x4d: 4755 case 0x4e: 4756 case 0x4f: 4757 { 4758 /** 0111 0101 0100 rdst mov%s #%1, %0 */ 4759 #line 262 "rx-decode.opc" 4760 int rdst AU = op[1] & 0x0f; 4761 if (trace) 4762 { 4763 printf ("\033[33m%s\033[0m %02x %02x\n", 4764 "/** 0111 0101 0100 rdst mov%s #%1, %0 */", 4765 op[0], op[1]); 4766 printf (" rdst = 0x%x\n", rdst); 4767 } 4768 SYNTAX("mov%s #%1, %0"); 4769 #line 262 "rx-decode.opc" 4770 ID(mov); DR(rdst); SC(IMM (1)); F_____; 4771 4772 } 4773 break; 4774 case 0x50: 4775 case 0x51: 4776 case 0x52: 4777 case 0x53: 4778 case 0x54: 4779 case 0x55: 4780 case 0x56: 4781 case 0x57: 4782 case 0x58: 4783 case 0x59: 4784 case 0x5a: 4785 case 0x5b: 4786 case 0x5c: 4787 case 0x5d: 4788 case 0x5e: 4789 case 0x5f: 4790 { 4791 /** 0111 0101 0101 rsrc cmp #%2, %1 */ 4792 #line 487 "rx-decode.opc" 4793 int rsrc AU = op[1] & 0x0f; 4794 if (trace) 4795 { 4796 printf ("\033[33m%s\033[0m %02x %02x\n", 4797 "/** 0111 0101 0101 rsrc cmp #%2, %1 */", 4798 op[0], op[1]); 4799 printf (" rsrc = 0x%x\n", rsrc); 4800 } 4801 SYNTAX("cmp #%2, %1"); 4802 #line 487 "rx-decode.opc" 4803 ID(sub); SR(rsrc); S2C(IMM(1)); F_OSZC; 4804 4805 } 4806 break; 4807 case 0x60: 4808 { 4809 /** 0111 0101 0110 0000 int #%1 */ 4810 if (trace) 4811 { 4812 printf ("\033[33m%s\033[0m %02x %02x\n", 4813 "/** 0111 0101 0110 0000 int #%1 */", 4814 op[0], op[1]); 4815 } 4816 SYNTAX("int #%1"); 4817 #line 947 "rx-decode.opc" 4818 ID(int); SC(IMM(1)); 4819 4820 } 4821 break; 4822 case 0x70: 4823 GETBYTE (); 4824 switch (op[2] & 0xf0) 4825 { 4826 case 0x00: 4827 { 4828 /** 0111 0101 0111 0000 0000 immm mvtipl #%1 */ 4829 #line 914 "rx-decode.opc" 4830 int immm AU = op[2] & 0x0f; 4831 if (trace) 4832 { 4833 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 4834 "/** 0111 0101 0111 0000 0000 immm mvtipl #%1 */", 4835 op[0], op[1], op[2]); 4836 printf (" immm = 0x%x\n", immm); 4837 } 4838 SYNTAX("mvtipl #%1"); 4839 #line 914 "rx-decode.opc" 4840 ID(mvtipl); SC(immm); 4841 4842 } 4843 break; 4844 default: UNSUPPORTED(); break; 4845 } 4846 break; 4847 default: UNSUPPORTED(); break; 4848 } 4849 break; 4850 case 0x76: 4851 GETBYTE (); 4852 switch (op[1] & 0xf0) 4853 { 4854 case 0x00: 4855 goto op_semantics_31; 4856 break; 4857 case 0x10: 4858 goto op_semantics_32; 4859 break; 4860 case 0x20: 4861 goto op_semantics_33; 4862 break; 4863 case 0x30: 4864 goto op_semantics_34; 4865 break; 4866 default: UNSUPPORTED(); break; 4867 } 4868 break; 4869 case 0x77: 4870 GETBYTE (); 4871 switch (op[1] & 0xf0) 4872 { 4873 case 0x00: 4874 goto op_semantics_31; 4875 break; 4876 case 0x10: 4877 goto op_semantics_32; 4878 break; 4879 case 0x20: 4880 goto op_semantics_33; 4881 break; 4882 case 0x30: 4883 goto op_semantics_34; 4884 break; 4885 default: UNSUPPORTED(); break; 4886 } 4887 break; 4888 case 0x78: 4889 GETBYTE (); 4890 switch (op[1] & 0x00) 4891 { 4892 case 0x00: 4893 op_semantics_35: 4894 { 4895 /** 0111 100b ittt rdst bset #%1, %0 */ 4896 #line 865 "rx-decode.opc" 4897 int b AU = op[0] & 0x01; 4898 #line 865 "rx-decode.opc" 4899 int ittt AU = (op[1] >> 4) & 0x0f; 4900 #line 865 "rx-decode.opc" 4901 int rdst AU = op[1] & 0x0f; 4902 if (trace) 4903 { 4904 printf ("\033[33m%s\033[0m %02x %02x\n", 4905 "/** 0111 100b ittt rdst bset #%1, %0 */", 4906 op[0], op[1]); 4907 printf (" b = 0x%x,", b); 4908 printf (" ittt = 0x%x,", ittt); 4909 printf (" rdst = 0x%x\n", rdst); 4910 } 4911 SYNTAX("bset #%1, %0"); 4912 #line 865 "rx-decode.opc" 4913 ID(bset); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 4914 4915 4916 } 4917 break; 4918 } 4919 break; 4920 case 0x79: 4921 GETBYTE (); 4922 switch (op[1] & 0x00) 4923 { 4924 case 0x00: 4925 goto op_semantics_35; 4926 break; 4927 } 4928 break; 4929 case 0x7a: 4930 GETBYTE (); 4931 switch (op[1] & 0x00) 4932 { 4933 case 0x00: 4934 op_semantics_36: 4935 { 4936 /** 0111 101b ittt rdst bclr #%1, %0 */ 4937 #line 875 "rx-decode.opc" 4938 int b AU = op[0] & 0x01; 4939 #line 875 "rx-decode.opc" 4940 int ittt AU = (op[1] >> 4) & 0x0f; 4941 #line 875 "rx-decode.opc" 4942 int rdst AU = op[1] & 0x0f; 4943 if (trace) 4944 { 4945 printf ("\033[33m%s\033[0m %02x %02x\n", 4946 "/** 0111 101b ittt rdst bclr #%1, %0 */", 4947 op[0], op[1]); 4948 printf (" b = 0x%x,", b); 4949 printf (" ittt = 0x%x,", ittt); 4950 printf (" rdst = 0x%x\n", rdst); 4951 } 4952 SYNTAX("bclr #%1, %0"); 4953 #line 875 "rx-decode.opc" 4954 ID(bclr); BWL(LSIZE); SC(b*16+ittt); DR(rdst); F_____; 4955 4956 4957 } 4958 break; 4959 } 4960 break; 4961 case 0x7b: 4962 GETBYTE (); 4963 switch (op[1] & 0x00) 4964 { 4965 case 0x00: 4966 goto op_semantics_36; 4967 break; 4968 } 4969 break; 4970 case 0x7c: 4971 GETBYTE (); 4972 switch (op[1] & 0x00) 4973 { 4974 case 0x00: 4975 op_semantics_37: 4976 { 4977 /** 0111 110b ittt rdst btst #%2, %1 */ 4978 #line 885 "rx-decode.opc" 4979 int b AU = op[0] & 0x01; 4980 #line 885 "rx-decode.opc" 4981 int ittt AU = (op[1] >> 4) & 0x0f; 4982 #line 885 "rx-decode.opc" 4983 int rdst AU = op[1] & 0x0f; 4984 if (trace) 4985 { 4986 printf ("\033[33m%s\033[0m %02x %02x\n", 4987 "/** 0111 110b ittt rdst btst #%2, %1 */", 4988 op[0], op[1]); 4989 printf (" b = 0x%x,", b); 4990 printf (" ittt = 0x%x,", ittt); 4991 printf (" rdst = 0x%x\n", rdst); 4992 } 4993 SYNTAX("btst #%2, %1"); 4994 #line 885 "rx-decode.opc" 4995 ID(btst); BWL(LSIZE); S2C(b*16+ittt); SR(rdst); F___ZC; 4996 4997 4998 } 4999 break; 5000 } 5001 break; 5002 case 0x7d: 5003 GETBYTE (); 5004 switch (op[1] & 0x00) 5005 { 5006 case 0x00: 5007 goto op_semantics_37; 5008 break; 5009 } 5010 break; 5011 case 0x7e: 5012 GETBYTE (); 5013 switch (op[1] & 0xf0) 5014 { 5015 case 0x00: 5016 { 5017 /** 0111 1110 0000 rdst not %0 */ 5018 #line 421 "rx-decode.opc" 5019 int rdst AU = op[1] & 0x0f; 5020 if (trace) 5021 { 5022 printf ("\033[33m%s\033[0m %02x %02x\n", 5023 "/** 0111 1110 0000 rdst not %0 */", 5024 op[0], op[1]); 5025 printf (" rdst = 0x%x\n", rdst); 5026 } 5027 SYNTAX("not %0"); 5028 #line 421 "rx-decode.opc" 5029 ID(xor); DR(rdst); SR(rdst); S2C(~0); F__SZ_; 5030 5031 } 5032 break; 5033 case 0x10: 5034 { 5035 /** 0111 1110 0001 rdst neg %0 */ 5036 #line 442 "rx-decode.opc" 5037 int rdst AU = op[1] & 0x0f; 5038 if (trace) 5039 { 5040 printf ("\033[33m%s\033[0m %02x %02x\n", 5041 "/** 0111 1110 0001 rdst neg %0 */", 5042 op[0], op[1]); 5043 printf (" rdst = 0x%x\n", rdst); 5044 } 5045 SYNTAX("neg %0"); 5046 #line 442 "rx-decode.opc" 5047 ID(sub); DR(rdst); SC(0); S2R(rdst); F_OSZC; 5048 5049 } 5050 break; 5051 case 0x20: 5052 { 5053 /** 0111 1110 0010 rdst abs %0 */ 5054 #line 524 "rx-decode.opc" 5055 int rdst AU = op[1] & 0x0f; 5056 if (trace) 5057 { 5058 printf ("\033[33m%s\033[0m %02x %02x\n", 5059 "/** 0111 1110 0010 rdst abs %0 */", 5060 op[0], op[1]); 5061 printf (" rdst = 0x%x\n", rdst); 5062 } 5063 SYNTAX("abs %0"); 5064 #line 524 "rx-decode.opc" 5065 ID(abs); DR(rdst); SR(rdst); F_OSZ_; 5066 5067 } 5068 break; 5069 case 0x30: 5070 { 5071 /** 0111 1110 0011 rdst sat %0 */ 5072 #line 805 "rx-decode.opc" 5073 int rdst AU = op[1] & 0x0f; 5074 if (trace) 5075 { 5076 printf ("\033[33m%s\033[0m %02x %02x\n", 5077 "/** 0111 1110 0011 rdst sat %0 */", 5078 op[0], op[1]); 5079 printf (" rdst = 0x%x\n", rdst); 5080 } 5081 SYNTAX("sat %0"); 5082 #line 805 "rx-decode.opc" 5083 ID(sat); DR (rdst); 5084 5085 } 5086 break; 5087 case 0x40: 5088 { 5089 /** 0111 1110 0100 rdst rorc %0 */ 5090 #line 665 "rx-decode.opc" 5091 int rdst AU = op[1] & 0x0f; 5092 if (trace) 5093 { 5094 printf ("\033[33m%s\033[0m %02x %02x\n", 5095 "/** 0111 1110 0100 rdst rorc %0 */", 5096 op[0], op[1]); 5097 printf (" rdst = 0x%x\n", rdst); 5098 } 5099 SYNTAX("rorc %0"); 5100 #line 665 "rx-decode.opc" 5101 ID(rorc); DR(rdst); F__SZC; 5102 5103 } 5104 break; 5105 case 0x50: 5106 { 5107 /** 0111 1110 0101 rdst rolc %0 */ 5108 #line 662 "rx-decode.opc" 5109 int rdst AU = op[1] & 0x0f; 5110 if (trace) 5111 { 5112 printf ("\033[33m%s\033[0m %02x %02x\n", 5113 "/** 0111 1110 0101 rdst rolc %0 */", 5114 op[0], op[1]); 5115 printf (" rdst = 0x%x\n", rdst); 5116 } 5117 SYNTAX("rolc %0"); 5118 #line 662 "rx-decode.opc" 5119 ID(rolc); DR(rdst); F__SZC; 5120 5121 } 5122 break; 5123 case 0x80: 5124 case 0x90: 5125 case 0xa0: 5126 { 5127 /** 0111 1110 10sz rsrc push%s %1 */ 5128 #line 337 "rx-decode.opc" 5129 int sz AU = (op[1] >> 4) & 0x03; 5130 #line 337 "rx-decode.opc" 5131 int rsrc AU = op[1] & 0x0f; 5132 if (trace) 5133 { 5134 printf ("\033[33m%s\033[0m %02x %02x\n", 5135 "/** 0111 1110 10sz rsrc push%s %1 */", 5136 op[0], op[1]); 5137 printf (" sz = 0x%x,", sz); 5138 printf (" rsrc = 0x%x\n", rsrc); 5139 } 5140 SYNTAX("push%s %1"); 5141 #line 337 "rx-decode.opc" 5142 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SR(rsrc); F_____; 5143 5144 } 5145 break; 5146 case 0xb0: 5147 { 5148 /** 0111 1110 1011 rdst pop %0 */ 5149 #line 334 "rx-decode.opc" 5150 int rdst AU = op[1] & 0x0f; 5151 if (trace) 5152 { 5153 printf ("\033[33m%s\033[0m %02x %02x\n", 5154 "/** 0111 1110 1011 rdst pop %0 */", 5155 op[0], op[1]); 5156 printf (" rdst = 0x%x\n", rdst); 5157 } 5158 SYNTAX("pop %0"); 5159 #line 334 "rx-decode.opc" 5160 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(rdst); F_____; 5161 5162 } 5163 break; 5164 case 0xc0: 5165 case 0xd0: 5166 { 5167 /** 0111 1110 110 crsrc pushc %1 */ 5168 #line 920 "rx-decode.opc" 5169 int crsrc AU = op[1] & 0x1f; 5170 if (trace) 5171 { 5172 printf ("\033[33m%s\033[0m %02x %02x\n", 5173 "/** 0111 1110 110 crsrc pushc %1 */", 5174 op[0], op[1]); 5175 printf (" crsrc = 0x%x\n", crsrc); 5176 } 5177 SYNTAX("pushc %1"); 5178 #line 920 "rx-decode.opc" 5179 ID(mov); OP(0, RX_Operand_Predec, 0, 0); SR(crsrc + 16); 5180 5181 } 5182 break; 5183 case 0xe0: 5184 case 0xf0: 5185 { 5186 /** 0111 1110 111 crdst popc %0 */ 5187 #line 917 "rx-decode.opc" 5188 int crdst AU = op[1] & 0x1f; 5189 if (trace) 5190 { 5191 printf ("\033[33m%s\033[0m %02x %02x\n", 5192 "/** 0111 1110 111 crdst popc %0 */", 5193 op[0], op[1]); 5194 printf (" crdst = 0x%x\n", crdst); 5195 } 5196 SYNTAX("popc %0"); 5197 #line 917 "rx-decode.opc" 5198 ID(mov); OP(1, RX_Operand_Postinc, 0, 0); DR(crdst + 16); 5199 5200 } 5201 break; 5202 default: UNSUPPORTED(); break; 5203 } 5204 break; 5205 case 0x7f: 5206 GETBYTE (); 5207 switch (op[1] & 0xff) 5208 { 5209 case 0x00: 5210 case 0x01: 5211 case 0x02: 5212 case 0x03: 5213 case 0x04: 5214 case 0x05: 5215 case 0x06: 5216 case 0x07: 5217 case 0x08: 5218 case 0x09: 5219 case 0x0a: 5220 case 0x0b: 5221 case 0x0c: 5222 case 0x0d: 5223 case 0x0e: 5224 case 0x0f: 5225 { 5226 /** 0111 1111 0000 rsrc jmp %0 */ 5227 #line 715 "rx-decode.opc" 5228 int rsrc AU = op[1] & 0x0f; 5229 if (trace) 5230 { 5231 printf ("\033[33m%s\033[0m %02x %02x\n", 5232 "/** 0111 1111 0000 rsrc jmp %0 */", 5233 op[0], op[1]); 5234 printf (" rsrc = 0x%x\n", rsrc); 5235 } 5236 SYNTAX("jmp %0"); 5237 #line 715 "rx-decode.opc" 5238 ID(branch); DR(rsrc); 5239 5240 } 5241 break; 5242 case 0x10: 5243 case 0x11: 5244 case 0x12: 5245 case 0x13: 5246 case 0x14: 5247 case 0x15: 5248 case 0x16: 5249 case 0x17: 5250 case 0x18: 5251 case 0x19: 5252 case 0x1a: 5253 case 0x1b: 5254 case 0x1c: 5255 case 0x1d: 5256 case 0x1e: 5257 case 0x1f: 5258 { 5259 /** 0111 1111 0001 rsrc jsr %0 */ 5260 #line 718 "rx-decode.opc" 5261 int rsrc AU = op[1] & 0x0f; 5262 if (trace) 5263 { 5264 printf ("\033[33m%s\033[0m %02x %02x\n", 5265 "/** 0111 1111 0001 rsrc jsr %0 */", 5266 op[0], op[1]); 5267 printf (" rsrc = 0x%x\n", rsrc); 5268 } 5269 SYNTAX("jsr %0"); 5270 #line 718 "rx-decode.opc" 5271 ID(jsr); DR(rsrc); 5272 5273 } 5274 break; 5275 case 0x40: 5276 case 0x41: 5277 case 0x42: 5278 case 0x43: 5279 case 0x44: 5280 case 0x45: 5281 case 0x46: 5282 case 0x47: 5283 case 0x48: 5284 case 0x49: 5285 case 0x4a: 5286 case 0x4b: 5287 case 0x4c: 5288 case 0x4d: 5289 case 0x4e: 5290 case 0x4f: 5291 { 5292 /** 0111 1111 0100 rsrc bra.l %0 */ 5293 #line 711 "rx-decode.opc" 5294 int rsrc AU = op[1] & 0x0f; 5295 if (trace) 5296 { 5297 printf ("\033[33m%s\033[0m %02x %02x\n", 5298 "/** 0111 1111 0100 rsrc bra.l %0 */", 5299 op[0], op[1]); 5300 printf (" rsrc = 0x%x\n", rsrc); 5301 } 5302 SYNTAX("bra.l %0"); 5303 #line 711 "rx-decode.opc" 5304 ID(branchrel); DR(rsrc); 5305 5306 5307 } 5308 break; 5309 case 0x50: 5310 case 0x51: 5311 case 0x52: 5312 case 0x53: 5313 case 0x54: 5314 case 0x55: 5315 case 0x56: 5316 case 0x57: 5317 case 0x58: 5318 case 0x59: 5319 case 0x5a: 5320 case 0x5b: 5321 case 0x5c: 5322 case 0x5d: 5323 case 0x5e: 5324 case 0x5f: 5325 { 5326 /** 0111 1111 0101 rsrc bsr.l %0 */ 5327 #line 727 "rx-decode.opc" 5328 int rsrc AU = op[1] & 0x0f; 5329 if (trace) 5330 { 5331 printf ("\033[33m%s\033[0m %02x %02x\n", 5332 "/** 0111 1111 0101 rsrc bsr.l %0 */", 5333 op[0], op[1]); 5334 printf (" rsrc = 0x%x\n", rsrc); 5335 } 5336 SYNTAX("bsr.l %0"); 5337 #line 727 "rx-decode.opc" 5338 ID(jsrrel); DR(rsrc); 5339 5340 } 5341 break; 5342 case 0x80: 5343 case 0x81: 5344 case 0x82: 5345 { 5346 /** 0111 1111 1000 00sz suntil%s */ 5347 #line 751 "rx-decode.opc" 5348 int sz AU = op[1] & 0x03; 5349 if (trace) 5350 { 5351 printf ("\033[33m%s\033[0m %02x %02x\n", 5352 "/** 0111 1111 1000 00sz suntil%s */", 5353 op[0], op[1]); 5354 printf (" sz = 0x%x\n", sz); 5355 } 5356 SYNTAX("suntil%s"); 5357 #line 751 "rx-decode.opc" 5358 ID(suntil); BWL(sz); F___ZC; 5359 5360 } 5361 break; 5362 case 0x83: 5363 { 5364 /** 0111 1111 1000 0011 scmpu */ 5365 if (trace) 5366 { 5367 printf ("\033[33m%s\033[0m %02x %02x\n", 5368 "/** 0111 1111 1000 0011 scmpu */", 5369 op[0], op[1]); 5370 } 5371 SYNTAX("scmpu"); 5372 #line 742 "rx-decode.opc" 5373 ID(scmpu); F___ZC; 5374 5375 } 5376 break; 5377 case 0x84: 5378 case 0x85: 5379 case 0x86: 5380 { 5381 /** 0111 1111 1000 01sz swhile%s */ 5382 #line 754 "rx-decode.opc" 5383 int sz AU = op[1] & 0x03; 5384 if (trace) 5385 { 5386 printf ("\033[33m%s\033[0m %02x %02x\n", 5387 "/** 0111 1111 1000 01sz swhile%s */", 5388 op[0], op[1]); 5389 printf (" sz = 0x%x\n", sz); 5390 } 5391 SYNTAX("swhile%s"); 5392 #line 754 "rx-decode.opc" 5393 ID(swhile); BWL(sz); F___ZC; 5394 5395 } 5396 break; 5397 case 0x87: 5398 { 5399 /** 0111 1111 1000 0111 smovu */ 5400 if (trace) 5401 { 5402 printf ("\033[33m%s\033[0m %02x %02x\n", 5403 "/** 0111 1111 1000 0111 smovu */", 5404 op[0], op[1]); 5405 } 5406 SYNTAX("smovu"); 5407 #line 745 "rx-decode.opc" 5408 ID(smovu); 5409 5410 } 5411 break; 5412 case 0x88: 5413 case 0x89: 5414 case 0x8a: 5415 { 5416 /** 0111 1111 1000 10sz sstr%s */ 5417 #line 760 "rx-decode.opc" 5418 int sz AU = op[1] & 0x03; 5419 if (trace) 5420 { 5421 printf ("\033[33m%s\033[0m %02x %02x\n", 5422 "/** 0111 1111 1000 10sz sstr%s */", 5423 op[0], op[1]); 5424 printf (" sz = 0x%x\n", sz); 5425 } 5426 SYNTAX("sstr%s"); 5427 #line 760 "rx-decode.opc" 5428 ID(sstr); BWL(sz); 5429 5430 /*----------------------------------------------------------------------*/ 5431 /* RMPA */ 5432 5433 } 5434 break; 5435 case 0x8b: 5436 { 5437 /** 0111 1111 1000 1011 smovb */ 5438 if (trace) 5439 { 5440 printf ("\033[33m%s\033[0m %02x %02x\n", 5441 "/** 0111 1111 1000 1011 smovb */", 5442 op[0], op[1]); 5443 } 5444 SYNTAX("smovb"); 5445 #line 748 "rx-decode.opc" 5446 ID(smovb); 5447 5448 } 5449 break; 5450 case 0x8c: 5451 case 0x8d: 5452 case 0x8e: 5453 { 5454 /** 0111 1111 1000 11sz rmpa%s */ 5455 #line 766 "rx-decode.opc" 5456 int sz AU = op[1] & 0x03; 5457 if (trace) 5458 { 5459 printf ("\033[33m%s\033[0m %02x %02x\n", 5460 "/** 0111 1111 1000 11sz rmpa%s */", 5461 op[0], op[1]); 5462 printf (" sz = 0x%x\n", sz); 5463 } 5464 SYNTAX("rmpa%s"); 5465 #line 766 "rx-decode.opc" 5466 ID(rmpa); BWL(sz); F_OS__; 5467 5468 /*----------------------------------------------------------------------*/ 5469 /* HI/LO stuff */ 5470 5471 } 5472 break; 5473 case 0x8f: 5474 { 5475 /** 0111 1111 1000 1111 smovf */ 5476 if (trace) 5477 { 5478 printf ("\033[33m%s\033[0m %02x %02x\n", 5479 "/** 0111 1111 1000 1111 smovf */", 5480 op[0], op[1]); 5481 } 5482 SYNTAX("smovf"); 5483 #line 757 "rx-decode.opc" 5484 ID(smovf); 5485 5486 } 5487 break; 5488 case 0x93: 5489 { 5490 /** 0111 1111 1001 0011 satr */ 5491 if (trace) 5492 { 5493 printf ("\033[33m%s\033[0m %02x %02x\n", 5494 "/** 0111 1111 1001 0011 satr */", 5495 op[0], op[1]); 5496 } 5497 SYNTAX("satr"); 5498 #line 808 "rx-decode.opc" 5499 ID(satr); 5500 5501 /*----------------------------------------------------------------------*/ 5502 /* FLOAT */ 5503 5504 } 5505 break; 5506 case 0x94: 5507 { 5508 /** 0111 1111 1001 0100 rtfi */ 5509 if (trace) 5510 { 5511 printf ("\033[33m%s\033[0m %02x %02x\n", 5512 "/** 0111 1111 1001 0100 rtfi */", 5513 op[0], op[1]); 5514 } 5515 SYNTAX("rtfi"); 5516 #line 935 "rx-decode.opc" 5517 ID(rtfi); 5518 5519 } 5520 break; 5521 case 0x95: 5522 { 5523 /** 0111 1111 1001 0101 rte */ 5524 if (trace) 5525 { 5526 printf ("\033[33m%s\033[0m %02x %02x\n", 5527 "/** 0111 1111 1001 0101 rte */", 5528 op[0], op[1]); 5529 } 5530 SYNTAX("rte"); 5531 #line 938 "rx-decode.opc" 5532 ID(rte); 5533 5534 } 5535 break; 5536 case 0x96: 5537 { 5538 /** 0111 1111 1001 0110 wait */ 5539 if (trace) 5540 { 5541 printf ("\033[33m%s\033[0m %02x %02x\n", 5542 "/** 0111 1111 1001 0110 wait */", 5543 op[0], op[1]); 5544 } 5545 SYNTAX("wait"); 5546 #line 950 "rx-decode.opc" 5547 ID(wait); 5548 5549 /*----------------------------------------------------------------------*/ 5550 /* SCcnd */ 5551 5552 } 5553 break; 5554 case 0xa0: 5555 case 0xa1: 5556 case 0xa2: 5557 case 0xa3: 5558 case 0xa4: 5559 case 0xa5: 5560 case 0xa6: 5561 case 0xa7: 5562 case 0xa8: 5563 case 0xa9: 5564 case 0xaa: 5565 case 0xab: 5566 case 0xac: 5567 case 0xad: 5568 case 0xae: 5569 case 0xaf: 5570 { 5571 /** 0111 1111 1010 rdst setpsw %0 */ 5572 #line 911 "rx-decode.opc" 5573 int rdst AU = op[1] & 0x0f; 5574 if (trace) 5575 { 5576 printf ("\033[33m%s\033[0m %02x %02x\n", 5577 "/** 0111 1111 1010 rdst setpsw %0 */", 5578 op[0], op[1]); 5579 printf (" rdst = 0x%x\n", rdst); 5580 } 5581 SYNTAX("setpsw %0"); 5582 #line 911 "rx-decode.opc" 5583 ID(setpsw); DF(rdst); 5584 5585 } 5586 break; 5587 case 0xb0: 5588 case 0xb1: 5589 case 0xb2: 5590 case 0xb3: 5591 case 0xb4: 5592 case 0xb5: 5593 case 0xb6: 5594 case 0xb7: 5595 case 0xb8: 5596 case 0xb9: 5597 case 0xba: 5598 case 0xbb: 5599 case 0xbc: 5600 case 0xbd: 5601 case 0xbe: 5602 case 0xbf: 5603 { 5604 /** 0111 1111 1011 rdst clrpsw %0 */ 5605 #line 908 "rx-decode.opc" 5606 int rdst AU = op[1] & 0x0f; 5607 if (trace) 5608 { 5609 printf ("\033[33m%s\033[0m %02x %02x\n", 5610 "/** 0111 1111 1011 rdst clrpsw %0 */", 5611 op[0], op[1]); 5612 printf (" rdst = 0x%x\n", rdst); 5613 } 5614 SYNTAX("clrpsw %0"); 5615 #line 908 "rx-decode.opc" 5616 ID(clrpsw); DF(rdst); 5617 5618 } 5619 break; 5620 default: UNSUPPORTED(); break; 5621 } 5622 break; 5623 case 0x80: 5624 GETBYTE (); 5625 switch (op[1] & 0x00) 5626 { 5627 case 0x00: 5628 op_semantics_38: 5629 { 5630 /** 10sz 0dsp a dst b src mov%s %1, %0 */ 5631 #line 295 "rx-decode.opc" 5632 int sz AU = (op[0] >> 4) & 0x03; 5633 #line 295 "rx-decode.opc" 5634 int dsp AU = op[0] & 0x07; 5635 #line 295 "rx-decode.opc" 5636 int a AU = (op[1] >> 7) & 0x01; 5637 #line 295 "rx-decode.opc" 5638 int dst AU = (op[1] >> 4) & 0x07; 5639 #line 295 "rx-decode.opc" 5640 int b AU = (op[1] >> 3) & 0x01; 5641 #line 295 "rx-decode.opc" 5642 int src AU = op[1] & 0x07; 5643 if (trace) 5644 { 5645 printf ("\033[33m%s\033[0m %02x %02x\n", 5646 "/** 10sz 0dsp a dst b src mov%s %1, %0 */", 5647 op[0], op[1]); 5648 printf (" sz = 0x%x,", sz); 5649 printf (" dsp = 0x%x,", dsp); 5650 printf (" a = 0x%x,", a); 5651 printf (" dst = 0x%x,", dst); 5652 printf (" b = 0x%x,", b); 5653 printf (" src = 0x%x\n", src); 5654 } 5655 SYNTAX("mov%s %1, %0"); 5656 #line 295 "rx-decode.opc" 5657 ID(mov); sBWL(sz); DIs(dst, dsp*4+a*2+b, sz); SR(src); F_____; 5658 5659 } 5660 break; 5661 } 5662 break; 5663 case 0x81: 5664 GETBYTE (); 5665 switch (op[1] & 0x00) 5666 { 5667 case 0x00: 5668 goto op_semantics_38; 5669 break; 5670 } 5671 break; 5672 case 0x82: 5673 GETBYTE (); 5674 switch (op[1] & 0x00) 5675 { 5676 case 0x00: 5677 goto op_semantics_38; 5678 break; 5679 } 5680 break; 5681 case 0x83: 5682 GETBYTE (); 5683 switch (op[1] & 0x00) 5684 { 5685 case 0x00: 5686 goto op_semantics_38; 5687 break; 5688 } 5689 break; 5690 case 0x84: 5691 GETBYTE (); 5692 switch (op[1] & 0x00) 5693 { 5694 case 0x00: 5695 goto op_semantics_38; 5696 break; 5697 } 5698 break; 5699 case 0x85: 5700 GETBYTE (); 5701 switch (op[1] & 0x00) 5702 { 5703 case 0x00: 5704 goto op_semantics_38; 5705 break; 5706 } 5707 break; 5708 case 0x86: 5709 GETBYTE (); 5710 switch (op[1] & 0x00) 5711 { 5712 case 0x00: 5713 goto op_semantics_38; 5714 break; 5715 } 5716 break; 5717 case 0x87: 5718 GETBYTE (); 5719 switch (op[1] & 0x00) 5720 { 5721 case 0x00: 5722 goto op_semantics_38; 5723 break; 5724 } 5725 break; 5726 case 0x88: 5727 GETBYTE (); 5728 switch (op[1] & 0x00) 5729 { 5730 case 0x00: 5731 op_semantics_39: 5732 { 5733 /** 10sz 1dsp a src b dst mov%s %1, %0 */ 5734 #line 292 "rx-decode.opc" 5735 int sz AU = (op[0] >> 4) & 0x03; 5736 #line 292 "rx-decode.opc" 5737 int dsp AU = op[0] & 0x07; 5738 #line 292 "rx-decode.opc" 5739 int a AU = (op[1] >> 7) & 0x01; 5740 #line 292 "rx-decode.opc" 5741 int src AU = (op[1] >> 4) & 0x07; 5742 #line 292 "rx-decode.opc" 5743 int b AU = (op[1] >> 3) & 0x01; 5744 #line 292 "rx-decode.opc" 5745 int dst AU = op[1] & 0x07; 5746 if (trace) 5747 { 5748 printf ("\033[33m%s\033[0m %02x %02x\n", 5749 "/** 10sz 1dsp a src b dst mov%s %1, %0 */", 5750 op[0], op[1]); 5751 printf (" sz = 0x%x,", sz); 5752 printf (" dsp = 0x%x,", dsp); 5753 printf (" a = 0x%x,", a); 5754 printf (" src = 0x%x,", src); 5755 printf (" b = 0x%x,", b); 5756 printf (" dst = 0x%x\n", dst); 5757 } 5758 SYNTAX("mov%s %1, %0"); 5759 #line 292 "rx-decode.opc" 5760 ID(mov); sBWL(sz); DR(dst); SIs(src, dsp*4+a*2+b, sz); F_____; 5761 5762 } 5763 break; 5764 } 5765 break; 5766 case 0x89: 5767 GETBYTE (); 5768 switch (op[1] & 0x00) 5769 { 5770 case 0x00: 5771 goto op_semantics_39; 5772 break; 5773 } 5774 break; 5775 case 0x8a: 5776 GETBYTE (); 5777 switch (op[1] & 0x00) 5778 { 5779 case 0x00: 5780 goto op_semantics_39; 5781 break; 5782 } 5783 break; 5784 case 0x8b: 5785 GETBYTE (); 5786 switch (op[1] & 0x00) 5787 { 5788 case 0x00: 5789 goto op_semantics_39; 5790 break; 5791 } 5792 break; 5793 case 0x8c: 5794 GETBYTE (); 5795 switch (op[1] & 0x00) 5796 { 5797 case 0x00: 5798 goto op_semantics_39; 5799 break; 5800 } 5801 break; 5802 case 0x8d: 5803 GETBYTE (); 5804 switch (op[1] & 0x00) 5805 { 5806 case 0x00: 5807 goto op_semantics_39; 5808 break; 5809 } 5810 break; 5811 case 0x8e: 5812 GETBYTE (); 5813 switch (op[1] & 0x00) 5814 { 5815 case 0x00: 5816 goto op_semantics_39; 5817 break; 5818 } 5819 break; 5820 case 0x8f: 5821 GETBYTE (); 5822 switch (op[1] & 0x00) 5823 { 5824 case 0x00: 5825 goto op_semantics_39; 5826 break; 5827 } 5828 break; 5829 case 0x90: 5830 GETBYTE (); 5831 switch (op[1] & 0x00) 5832 { 5833 case 0x00: 5834 goto op_semantics_38; 5835 break; 5836 } 5837 break; 5838 case 0x91: 5839 GETBYTE (); 5840 switch (op[1] & 0x00) 5841 { 5842 case 0x00: 5843 goto op_semantics_38; 5844 break; 5845 } 5846 break; 5847 case 0x92: 5848 GETBYTE (); 5849 switch (op[1] & 0x00) 5850 { 5851 case 0x00: 5852 goto op_semantics_38; 5853 break; 5854 } 5855 break; 5856 case 0x93: 5857 GETBYTE (); 5858 switch (op[1] & 0x00) 5859 { 5860 case 0x00: 5861 goto op_semantics_38; 5862 break; 5863 } 5864 break; 5865 case 0x94: 5866 GETBYTE (); 5867 switch (op[1] & 0x00) 5868 { 5869 case 0x00: 5870 goto op_semantics_38; 5871 break; 5872 } 5873 break; 5874 case 0x95: 5875 GETBYTE (); 5876 switch (op[1] & 0x00) 5877 { 5878 case 0x00: 5879 goto op_semantics_38; 5880 break; 5881 } 5882 break; 5883 case 0x96: 5884 GETBYTE (); 5885 switch (op[1] & 0x00) 5886 { 5887 case 0x00: 5888 goto op_semantics_38; 5889 break; 5890 } 5891 break; 5892 case 0x97: 5893 GETBYTE (); 5894 switch (op[1] & 0x00) 5895 { 5896 case 0x00: 5897 goto op_semantics_38; 5898 break; 5899 } 5900 break; 5901 case 0x98: 5902 GETBYTE (); 5903 switch (op[1] & 0x00) 5904 { 5905 case 0x00: 5906 goto op_semantics_39; 5907 break; 5908 } 5909 break; 5910 case 0x99: 5911 GETBYTE (); 5912 switch (op[1] & 0x00) 5913 { 5914 case 0x00: 5915 goto op_semantics_39; 5916 break; 5917 } 5918 break; 5919 case 0x9a: 5920 GETBYTE (); 5921 switch (op[1] & 0x00) 5922 { 5923 case 0x00: 5924 goto op_semantics_39; 5925 break; 5926 } 5927 break; 5928 case 0x9b: 5929 GETBYTE (); 5930 switch (op[1] & 0x00) 5931 { 5932 case 0x00: 5933 goto op_semantics_39; 5934 break; 5935 } 5936 break; 5937 case 0x9c: 5938 GETBYTE (); 5939 switch (op[1] & 0x00) 5940 { 5941 case 0x00: 5942 goto op_semantics_39; 5943 break; 5944 } 5945 break; 5946 case 0x9d: 5947 GETBYTE (); 5948 switch (op[1] & 0x00) 5949 { 5950 case 0x00: 5951 goto op_semantics_39; 5952 break; 5953 } 5954 break; 5955 case 0x9e: 5956 GETBYTE (); 5957 switch (op[1] & 0x00) 5958 { 5959 case 0x00: 5960 goto op_semantics_39; 5961 break; 5962 } 5963 break; 5964 case 0x9f: 5965 GETBYTE (); 5966 switch (op[1] & 0x00) 5967 { 5968 case 0x00: 5969 goto op_semantics_39; 5970 break; 5971 } 5972 break; 5973 case 0xa0: 5974 GETBYTE (); 5975 switch (op[1] & 0x00) 5976 { 5977 case 0x00: 5978 goto op_semantics_38; 5979 break; 5980 } 5981 break; 5982 case 0xa1: 5983 GETBYTE (); 5984 switch (op[1] & 0x00) 5985 { 5986 case 0x00: 5987 goto op_semantics_38; 5988 break; 5989 } 5990 break; 5991 case 0xa2: 5992 GETBYTE (); 5993 switch (op[1] & 0x00) 5994 { 5995 case 0x00: 5996 goto op_semantics_38; 5997 break; 5998 } 5999 break; 6000 case 0xa3: 6001 GETBYTE (); 6002 switch (op[1] & 0x00) 6003 { 6004 case 0x00: 6005 goto op_semantics_38; 6006 break; 6007 } 6008 break; 6009 case 0xa4: 6010 GETBYTE (); 6011 switch (op[1] & 0x00) 6012 { 6013 case 0x00: 6014 goto op_semantics_38; 6015 break; 6016 } 6017 break; 6018 case 0xa5: 6019 GETBYTE (); 6020 switch (op[1] & 0x00) 6021 { 6022 case 0x00: 6023 goto op_semantics_38; 6024 break; 6025 } 6026 break; 6027 case 0xa6: 6028 GETBYTE (); 6029 switch (op[1] & 0x00) 6030 { 6031 case 0x00: 6032 goto op_semantics_38; 6033 break; 6034 } 6035 break; 6036 case 0xa7: 6037 GETBYTE (); 6038 switch (op[1] & 0x00) 6039 { 6040 case 0x00: 6041 goto op_semantics_38; 6042 break; 6043 } 6044 break; 6045 case 0xa8: 6046 GETBYTE (); 6047 switch (op[1] & 0x00) 6048 { 6049 case 0x00: 6050 goto op_semantics_39; 6051 break; 6052 } 6053 break; 6054 case 0xa9: 6055 GETBYTE (); 6056 switch (op[1] & 0x00) 6057 { 6058 case 0x00: 6059 goto op_semantics_39; 6060 break; 6061 } 6062 break; 6063 case 0xaa: 6064 GETBYTE (); 6065 switch (op[1] & 0x00) 6066 { 6067 case 0x00: 6068 goto op_semantics_39; 6069 break; 6070 } 6071 break; 6072 case 0xab: 6073 GETBYTE (); 6074 switch (op[1] & 0x00) 6075 { 6076 case 0x00: 6077 goto op_semantics_39; 6078 break; 6079 } 6080 break; 6081 case 0xac: 6082 GETBYTE (); 6083 switch (op[1] & 0x00) 6084 { 6085 case 0x00: 6086 goto op_semantics_39; 6087 break; 6088 } 6089 break; 6090 case 0xad: 6091 GETBYTE (); 6092 switch (op[1] & 0x00) 6093 { 6094 case 0x00: 6095 goto op_semantics_39; 6096 break; 6097 } 6098 break; 6099 case 0xae: 6100 GETBYTE (); 6101 switch (op[1] & 0x00) 6102 { 6103 case 0x00: 6104 goto op_semantics_39; 6105 break; 6106 } 6107 break; 6108 case 0xaf: 6109 GETBYTE (); 6110 switch (op[1] & 0x00) 6111 { 6112 case 0x00: 6113 goto op_semantics_39; 6114 break; 6115 } 6116 break; 6117 case 0xb0: 6118 GETBYTE (); 6119 switch (op[1] & 0x00) 6120 { 6121 case 0x00: 6122 op_semantics_40: 6123 { 6124 /** 1011 w dsp a src b dst movu%s %1, %0 */ 6125 #line 315 "rx-decode.opc" 6126 int w AU = (op[0] >> 3) & 0x01; 6127 #line 315 "rx-decode.opc" 6128 int dsp AU = op[0] & 0x07; 6129 #line 315 "rx-decode.opc" 6130 int a AU = (op[1] >> 7) & 0x01; 6131 #line 315 "rx-decode.opc" 6132 int src AU = (op[1] >> 4) & 0x07; 6133 #line 315 "rx-decode.opc" 6134 int b AU = (op[1] >> 3) & 0x01; 6135 #line 315 "rx-decode.opc" 6136 int dst AU = op[1] & 0x07; 6137 if (trace) 6138 { 6139 printf ("\033[33m%s\033[0m %02x %02x\n", 6140 "/** 1011 w dsp a src b dst movu%s %1, %0 */", 6141 op[0], op[1]); 6142 printf (" w = 0x%x,", w); 6143 printf (" dsp = 0x%x,", dsp); 6144 printf (" a = 0x%x,", a); 6145 printf (" src = 0x%x,", src); 6146 printf (" b = 0x%x,", b); 6147 printf (" dst = 0x%x\n", dst); 6148 } 6149 SYNTAX("movu%s %1, %0"); 6150 #line 315 "rx-decode.opc" 6151 ID(mov); uBWL(w); DR(dst); SIs(src, dsp*4+a*2+b, w); F_____; 6152 6153 } 6154 break; 6155 } 6156 break; 6157 case 0xb1: 6158 GETBYTE (); 6159 switch (op[1] & 0x00) 6160 { 6161 case 0x00: 6162 goto op_semantics_40; 6163 break; 6164 } 6165 break; 6166 case 0xb2: 6167 GETBYTE (); 6168 switch (op[1] & 0x00) 6169 { 6170 case 0x00: 6171 goto op_semantics_40; 6172 break; 6173 } 6174 break; 6175 case 0xb3: 6176 GETBYTE (); 6177 switch (op[1] & 0x00) 6178 { 6179 case 0x00: 6180 goto op_semantics_40; 6181 break; 6182 } 6183 break; 6184 case 0xb4: 6185 GETBYTE (); 6186 switch (op[1] & 0x00) 6187 { 6188 case 0x00: 6189 goto op_semantics_40; 6190 break; 6191 } 6192 break; 6193 case 0xb5: 6194 GETBYTE (); 6195 switch (op[1] & 0x00) 6196 { 6197 case 0x00: 6198 goto op_semantics_40; 6199 break; 6200 } 6201 break; 6202 case 0xb6: 6203 GETBYTE (); 6204 switch (op[1] & 0x00) 6205 { 6206 case 0x00: 6207 goto op_semantics_40; 6208 break; 6209 } 6210 break; 6211 case 0xb7: 6212 GETBYTE (); 6213 switch (op[1] & 0x00) 6214 { 6215 case 0x00: 6216 goto op_semantics_40; 6217 break; 6218 } 6219 break; 6220 case 0xb8: 6221 GETBYTE (); 6222 switch (op[1] & 0x00) 6223 { 6224 case 0x00: 6225 goto op_semantics_40; 6226 break; 6227 } 6228 break; 6229 case 0xb9: 6230 GETBYTE (); 6231 switch (op[1] & 0x00) 6232 { 6233 case 0x00: 6234 goto op_semantics_40; 6235 break; 6236 } 6237 break; 6238 case 0xba: 6239 GETBYTE (); 6240 switch (op[1] & 0x00) 6241 { 6242 case 0x00: 6243 goto op_semantics_40; 6244 break; 6245 } 6246 break; 6247 case 0xbb: 6248 GETBYTE (); 6249 switch (op[1] & 0x00) 6250 { 6251 case 0x00: 6252 goto op_semantics_40; 6253 break; 6254 } 6255 break; 6256 case 0xbc: 6257 GETBYTE (); 6258 switch (op[1] & 0x00) 6259 { 6260 case 0x00: 6261 goto op_semantics_40; 6262 break; 6263 } 6264 break; 6265 case 0xbd: 6266 GETBYTE (); 6267 switch (op[1] & 0x00) 6268 { 6269 case 0x00: 6270 goto op_semantics_40; 6271 break; 6272 } 6273 break; 6274 case 0xbe: 6275 GETBYTE (); 6276 switch (op[1] & 0x00) 6277 { 6278 case 0x00: 6279 goto op_semantics_40; 6280 break; 6281 } 6282 break; 6283 case 0xbf: 6284 GETBYTE (); 6285 switch (op[1] & 0x00) 6286 { 6287 case 0x00: 6288 goto op_semantics_40; 6289 break; 6290 } 6291 break; 6292 case 0xc0: 6293 GETBYTE (); 6294 switch (op[1] & 0x00) 6295 { 6296 case 0x00: 6297 op_semantics_41: 6298 { 6299 /** 11sz sd ss rsrc rdst mov%s %1, %0 */ 6300 #line 274 "rx-decode.opc" 6301 int sz AU = (op[0] >> 4) & 0x03; 6302 #line 274 "rx-decode.opc" 6303 int sd AU = (op[0] >> 2) & 0x03; 6304 #line 274 "rx-decode.opc" 6305 int ss AU = op[0] & 0x03; 6306 #line 274 "rx-decode.opc" 6307 int rsrc AU = (op[1] >> 4) & 0x0f; 6308 #line 274 "rx-decode.opc" 6309 int rdst AU = op[1] & 0x0f; 6310 if (trace) 6311 { 6312 printf ("\033[33m%s\033[0m %02x %02x\n", 6313 "/** 11sz sd ss rsrc rdst mov%s %1, %0 */", 6314 op[0], op[1]); 6315 printf (" sz = 0x%x,", sz); 6316 printf (" sd = 0x%x,", sd); 6317 printf (" ss = 0x%x,", ss); 6318 printf (" rsrc = 0x%x,", rsrc); 6319 printf (" rdst = 0x%x\n", rdst); 6320 } 6321 SYNTAX("mov%s %1, %0"); 6322 #line 274 "rx-decode.opc" 6323 if (ss == 3 && sz == 2 && rsrc == 0 && rdst == 0) 6324 { 6325 ID(nop2); 6326 } 6327 else 6328 { 6329 ID(mov); sBWL(sz); F_____; 6330 if ((ss == 3) && (sd != 3)) 6331 { 6332 SD(ss, rdst, sz); DD(sd, rsrc, sz); 6333 } 6334 else 6335 { 6336 SD(ss, rsrc, sz); DD(sd, rdst, sz); 6337 } 6338 } 6339 6340 } 6341 break; 6342 } 6343 break; 6344 case 0xc1: 6345 GETBYTE (); 6346 switch (op[1] & 0x00) 6347 { 6348 case 0x00: 6349 goto op_semantics_41; 6350 break; 6351 } 6352 break; 6353 case 0xc2: 6354 GETBYTE (); 6355 switch (op[1] & 0x00) 6356 { 6357 case 0x00: 6358 goto op_semantics_41; 6359 break; 6360 } 6361 break; 6362 case 0xc3: 6363 GETBYTE (); 6364 switch (op[1] & 0x00) 6365 { 6366 case 0x00: 6367 goto op_semantics_41; 6368 break; 6369 } 6370 break; 6371 case 0xc4: 6372 GETBYTE (); 6373 switch (op[1] & 0x00) 6374 { 6375 case 0x00: 6376 goto op_semantics_41; 6377 break; 6378 } 6379 break; 6380 case 0xc5: 6381 GETBYTE (); 6382 switch (op[1] & 0x00) 6383 { 6384 case 0x00: 6385 goto op_semantics_41; 6386 break; 6387 } 6388 break; 6389 case 0xc6: 6390 GETBYTE (); 6391 switch (op[1] & 0x00) 6392 { 6393 case 0x00: 6394 goto op_semantics_41; 6395 break; 6396 } 6397 break; 6398 case 0xc7: 6399 GETBYTE (); 6400 switch (op[1] & 0x00) 6401 { 6402 case 0x00: 6403 goto op_semantics_41; 6404 break; 6405 } 6406 break; 6407 case 0xc8: 6408 GETBYTE (); 6409 switch (op[1] & 0x00) 6410 { 6411 case 0x00: 6412 goto op_semantics_41; 6413 break; 6414 } 6415 break; 6416 case 0xc9: 6417 GETBYTE (); 6418 switch (op[1] & 0x00) 6419 { 6420 case 0x00: 6421 goto op_semantics_41; 6422 break; 6423 } 6424 break; 6425 case 0xca: 6426 GETBYTE (); 6427 switch (op[1] & 0x00) 6428 { 6429 case 0x00: 6430 goto op_semantics_41; 6431 break; 6432 } 6433 break; 6434 case 0xcb: 6435 GETBYTE (); 6436 switch (op[1] & 0x00) 6437 { 6438 case 0x00: 6439 goto op_semantics_41; 6440 break; 6441 } 6442 break; 6443 case 0xcc: 6444 GETBYTE (); 6445 switch (op[1] & 0x00) 6446 { 6447 case 0x00: 6448 goto op_semantics_41; 6449 break; 6450 } 6451 break; 6452 case 0xcd: 6453 GETBYTE (); 6454 switch (op[1] & 0x00) 6455 { 6456 case 0x00: 6457 goto op_semantics_41; 6458 break; 6459 } 6460 break; 6461 case 0xce: 6462 GETBYTE (); 6463 switch (op[1] & 0x00) 6464 { 6465 case 0x00: 6466 goto op_semantics_41; 6467 break; 6468 } 6469 break; 6470 case 0xcf: 6471 GETBYTE (); 6472 switch (op[1] & 0x00) 6473 { 6474 case 0x00: 6475 goto op_semantics_41; 6476 break; 6477 } 6478 break; 6479 case 0xd0: 6480 GETBYTE (); 6481 switch (op[1] & 0x00) 6482 { 6483 case 0x00: 6484 goto op_semantics_41; 6485 break; 6486 } 6487 break; 6488 case 0xd1: 6489 GETBYTE (); 6490 switch (op[1] & 0x00) 6491 { 6492 case 0x00: 6493 goto op_semantics_41; 6494 break; 6495 } 6496 break; 6497 case 0xd2: 6498 GETBYTE (); 6499 switch (op[1] & 0x00) 6500 { 6501 case 0x00: 6502 goto op_semantics_41; 6503 break; 6504 } 6505 break; 6506 case 0xd3: 6507 GETBYTE (); 6508 switch (op[1] & 0x00) 6509 { 6510 case 0x00: 6511 goto op_semantics_41; 6512 break; 6513 } 6514 break; 6515 case 0xd4: 6516 GETBYTE (); 6517 switch (op[1] & 0x00) 6518 { 6519 case 0x00: 6520 goto op_semantics_41; 6521 break; 6522 } 6523 break; 6524 case 0xd5: 6525 GETBYTE (); 6526 switch (op[1] & 0x00) 6527 { 6528 case 0x00: 6529 goto op_semantics_41; 6530 break; 6531 } 6532 break; 6533 case 0xd6: 6534 GETBYTE (); 6535 switch (op[1] & 0x00) 6536 { 6537 case 0x00: 6538 goto op_semantics_41; 6539 break; 6540 } 6541 break; 6542 case 0xd7: 6543 GETBYTE (); 6544 switch (op[1] & 0x00) 6545 { 6546 case 0x00: 6547 goto op_semantics_41; 6548 break; 6549 } 6550 break; 6551 case 0xd8: 6552 GETBYTE (); 6553 switch (op[1] & 0x00) 6554 { 6555 case 0x00: 6556 goto op_semantics_41; 6557 break; 6558 } 6559 break; 6560 case 0xd9: 6561 GETBYTE (); 6562 switch (op[1] & 0x00) 6563 { 6564 case 0x00: 6565 goto op_semantics_41; 6566 break; 6567 } 6568 break; 6569 case 0xda: 6570 GETBYTE (); 6571 switch (op[1] & 0x00) 6572 { 6573 case 0x00: 6574 goto op_semantics_41; 6575 break; 6576 } 6577 break; 6578 case 0xdb: 6579 GETBYTE (); 6580 switch (op[1] & 0x00) 6581 { 6582 case 0x00: 6583 goto op_semantics_41; 6584 break; 6585 } 6586 break; 6587 case 0xdc: 6588 GETBYTE (); 6589 switch (op[1] & 0x00) 6590 { 6591 case 0x00: 6592 goto op_semantics_41; 6593 break; 6594 } 6595 break; 6596 case 0xdd: 6597 GETBYTE (); 6598 switch (op[1] & 0x00) 6599 { 6600 case 0x00: 6601 goto op_semantics_41; 6602 break; 6603 } 6604 break; 6605 case 0xde: 6606 GETBYTE (); 6607 switch (op[1] & 0x00) 6608 { 6609 case 0x00: 6610 goto op_semantics_41; 6611 break; 6612 } 6613 break; 6614 case 0xdf: 6615 GETBYTE (); 6616 switch (op[1] & 0x00) 6617 { 6618 case 0x00: 6619 goto op_semantics_41; 6620 break; 6621 } 6622 break; 6623 case 0xe0: 6624 GETBYTE (); 6625 switch (op[1] & 0x00) 6626 { 6627 case 0x00: 6628 goto op_semantics_41; 6629 break; 6630 } 6631 break; 6632 case 0xe1: 6633 GETBYTE (); 6634 switch (op[1] & 0x00) 6635 { 6636 case 0x00: 6637 goto op_semantics_41; 6638 break; 6639 } 6640 break; 6641 case 0xe2: 6642 GETBYTE (); 6643 switch (op[1] & 0x00) 6644 { 6645 case 0x00: 6646 goto op_semantics_41; 6647 break; 6648 } 6649 break; 6650 case 0xe3: 6651 GETBYTE (); 6652 switch (op[1] & 0x00) 6653 { 6654 case 0x00: 6655 goto op_semantics_41; 6656 break; 6657 } 6658 break; 6659 case 0xe4: 6660 GETBYTE (); 6661 switch (op[1] & 0x00) 6662 { 6663 case 0x00: 6664 goto op_semantics_41; 6665 break; 6666 } 6667 break; 6668 case 0xe5: 6669 GETBYTE (); 6670 switch (op[1] & 0x00) 6671 { 6672 case 0x00: 6673 goto op_semantics_41; 6674 break; 6675 } 6676 break; 6677 case 0xe6: 6678 GETBYTE (); 6679 switch (op[1] & 0x00) 6680 { 6681 case 0x00: 6682 goto op_semantics_41; 6683 break; 6684 } 6685 break; 6686 case 0xe7: 6687 GETBYTE (); 6688 switch (op[1] & 0x00) 6689 { 6690 case 0x00: 6691 goto op_semantics_41; 6692 break; 6693 } 6694 break; 6695 case 0xe8: 6696 GETBYTE (); 6697 switch (op[1] & 0x00) 6698 { 6699 case 0x00: 6700 goto op_semantics_41; 6701 break; 6702 } 6703 break; 6704 case 0xe9: 6705 GETBYTE (); 6706 switch (op[1] & 0x00) 6707 { 6708 case 0x00: 6709 goto op_semantics_41; 6710 break; 6711 } 6712 break; 6713 case 0xea: 6714 GETBYTE (); 6715 switch (op[1] & 0x00) 6716 { 6717 case 0x00: 6718 goto op_semantics_41; 6719 break; 6720 } 6721 break; 6722 case 0xeb: 6723 GETBYTE (); 6724 switch (op[1] & 0x00) 6725 { 6726 case 0x00: 6727 goto op_semantics_41; 6728 break; 6729 } 6730 break; 6731 case 0xec: 6732 GETBYTE (); 6733 switch (op[1] & 0x00) 6734 { 6735 case 0x00: 6736 goto op_semantics_41; 6737 break; 6738 } 6739 break; 6740 case 0xed: 6741 GETBYTE (); 6742 switch (op[1] & 0x00) 6743 { 6744 case 0x00: 6745 goto op_semantics_41; 6746 break; 6747 } 6748 break; 6749 case 0xee: 6750 GETBYTE (); 6751 switch (op[1] & 0x00) 6752 { 6753 case 0x00: 6754 goto op_semantics_41; 6755 break; 6756 } 6757 break; 6758 case 0xef: 6759 GETBYTE (); 6760 switch (op[1] & 0x00) 6761 { 6762 case 0x00: 6763 goto op_semantics_41; 6764 break; 6765 } 6766 break; 6767 case 0xf0: 6768 GETBYTE (); 6769 switch (op[1] & 0x08) 6770 { 6771 case 0x00: 6772 op_semantics_42: 6773 { 6774 /** 1111 00sd rdst 0bit bset #%1, %0%S0 */ 6775 #line 859 "rx-decode.opc" 6776 int sd AU = op[0] & 0x03; 6777 #line 859 "rx-decode.opc" 6778 int rdst AU = (op[1] >> 4) & 0x0f; 6779 #line 859 "rx-decode.opc" 6780 int bit AU = op[1] & 0x07; 6781 if (trace) 6782 { 6783 printf ("\033[33m%s\033[0m %02x %02x\n", 6784 "/** 1111 00sd rdst 0bit bset #%1, %0%S0 */", 6785 op[0], op[1]); 6786 printf (" sd = 0x%x,", sd); 6787 printf (" rdst = 0x%x,", rdst); 6788 printf (" bit = 0x%x\n", bit); 6789 } 6790 SYNTAX("bset #%1, %0%S0"); 6791 #line 859 "rx-decode.opc" 6792 ID(bset); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 6793 6794 } 6795 break; 6796 case 0x08: 6797 op_semantics_43: 6798 { 6799 /** 1111 00sd rdst 1bit bclr #%1, %0%S0 */ 6800 #line 869 "rx-decode.opc" 6801 int sd AU = op[0] & 0x03; 6802 #line 869 "rx-decode.opc" 6803 int rdst AU = (op[1] >> 4) & 0x0f; 6804 #line 869 "rx-decode.opc" 6805 int bit AU = op[1] & 0x07; 6806 if (trace) 6807 { 6808 printf ("\033[33m%s\033[0m %02x %02x\n", 6809 "/** 1111 00sd rdst 1bit bclr #%1, %0%S0 */", 6810 op[0], op[1]); 6811 printf (" sd = 0x%x,", sd); 6812 printf (" rdst = 0x%x,", rdst); 6813 printf (" bit = 0x%x\n", bit); 6814 } 6815 SYNTAX("bclr #%1, %0%S0"); 6816 #line 869 "rx-decode.opc" 6817 ID(bclr); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); F_____; 6818 6819 } 6820 break; 6821 } 6822 break; 6823 case 0xf1: 6824 GETBYTE (); 6825 switch (op[1] & 0x08) 6826 { 6827 case 0x00: 6828 goto op_semantics_42; 6829 break; 6830 case 0x08: 6831 goto op_semantics_43; 6832 break; 6833 } 6834 break; 6835 case 0xf2: 6836 GETBYTE (); 6837 switch (op[1] & 0x08) 6838 { 6839 case 0x00: 6840 goto op_semantics_42; 6841 break; 6842 case 0x08: 6843 goto op_semantics_43; 6844 break; 6845 } 6846 break; 6847 case 0xf3: 6848 GETBYTE (); 6849 switch (op[1] & 0x08) 6850 { 6851 case 0x00: 6852 goto op_semantics_42; 6853 break; 6854 case 0x08: 6855 goto op_semantics_43; 6856 break; 6857 } 6858 break; 6859 case 0xf4: 6860 GETBYTE (); 6861 switch (op[1] & 0x0c) 6862 { 6863 case 0x00: 6864 case 0x04: 6865 op_semantics_44: 6866 { 6867 /** 1111 01sd rdst 0bit btst #%2, %1%S1 */ 6868 #line 879 "rx-decode.opc" 6869 int sd AU = op[0] & 0x03; 6870 #line 879 "rx-decode.opc" 6871 int rdst AU = (op[1] >> 4) & 0x0f; 6872 #line 879 "rx-decode.opc" 6873 int bit AU = op[1] & 0x07; 6874 if (trace) 6875 { 6876 printf ("\033[33m%s\033[0m %02x %02x\n", 6877 "/** 1111 01sd rdst 0bit btst #%2, %1%S1 */", 6878 op[0], op[1]); 6879 printf (" sd = 0x%x,", sd); 6880 printf (" rdst = 0x%x,", rdst); 6881 printf (" bit = 0x%x\n", bit); 6882 } 6883 SYNTAX("btst #%2, %1%S1"); 6884 #line 879 "rx-decode.opc" 6885 ID(btst); BWL(BSIZE); S2C(bit); SD(sd, rdst, BSIZE); F___ZC; 6886 6887 } 6888 break; 6889 case 0x08: 6890 op_semantics_45: 6891 { 6892 /** 1111 01ss rsrc 10sz push%s %1 */ 6893 #line 340 "rx-decode.opc" 6894 int ss AU = op[0] & 0x03; 6895 #line 340 "rx-decode.opc" 6896 int rsrc AU = (op[1] >> 4) & 0x0f; 6897 #line 340 "rx-decode.opc" 6898 int sz AU = op[1] & 0x03; 6899 if (trace) 6900 { 6901 printf ("\033[33m%s\033[0m %02x %02x\n", 6902 "/** 1111 01ss rsrc 10sz push%s %1 */", 6903 op[0], op[1]); 6904 printf (" ss = 0x%x,", ss); 6905 printf (" rsrc = 0x%x,", rsrc); 6906 printf (" sz = 0x%x\n", sz); 6907 } 6908 SYNTAX("push%s %1"); 6909 #line 340 "rx-decode.opc" 6910 ID(mov); BWL(sz); OP(0, RX_Operand_Predec, 0, 0); SD(ss, rsrc, sz); F_____; 6911 6912 /*----------------------------------------------------------------------*/ 6913 /* XCHG */ 6914 6915 } 6916 break; 6917 default: UNSUPPORTED(); break; 6918 } 6919 break; 6920 case 0xf5: 6921 GETBYTE (); 6922 switch (op[1] & 0x0c) 6923 { 6924 case 0x00: 6925 case 0x04: 6926 goto op_semantics_44; 6927 break; 6928 case 0x08: 6929 goto op_semantics_45; 6930 break; 6931 default: UNSUPPORTED(); break; 6932 } 6933 break; 6934 case 0xf6: 6935 GETBYTE (); 6936 switch (op[1] & 0x0c) 6937 { 6938 case 0x00: 6939 case 0x04: 6940 goto op_semantics_44; 6941 break; 6942 case 0x08: 6943 goto op_semantics_45; 6944 break; 6945 default: UNSUPPORTED(); break; 6946 } 6947 break; 6948 case 0xf7: 6949 GETBYTE (); 6950 switch (op[1] & 0x0c) 6951 { 6952 case 0x00: 6953 case 0x04: 6954 goto op_semantics_44; 6955 break; 6956 case 0x08: 6957 goto op_semantics_45; 6958 break; 6959 default: UNSUPPORTED(); break; 6960 } 6961 break; 6962 case 0xf8: 6963 GETBYTE (); 6964 switch (op[1] & 0x00) 6965 { 6966 case 0x00: 6967 op_semantics_46: 6968 { 6969 /** 1111 10sd rdst im sz mov%s #%1, %0 */ 6970 #line 265 "rx-decode.opc" 6971 int sd AU = op[0] & 0x03; 6972 #line 265 "rx-decode.opc" 6973 int rdst AU = (op[1] >> 4) & 0x0f; 6974 #line 265 "rx-decode.opc" 6975 int im AU = (op[1] >> 2) & 0x03; 6976 #line 265 "rx-decode.opc" 6977 int sz AU = op[1] & 0x03; 6978 if (trace) 6979 { 6980 printf ("\033[33m%s\033[0m %02x %02x\n", 6981 "/** 1111 10sd rdst im sz mov%s #%1, %0 */", 6982 op[0], op[1]); 6983 printf (" sd = 0x%x,", sd); 6984 printf (" rdst = 0x%x,", rdst); 6985 printf (" im = 0x%x,", im); 6986 printf (" sz = 0x%x\n", sz); 6987 } 6988 SYNTAX("mov%s #%1, %0"); 6989 #line 265 "rx-decode.opc" 6990 ID(mov); sBWL (sz); DD(sd, rdst, sz); SC(IMMex(im)); F_____; 6991 6992 } 6993 break; 6994 } 6995 break; 6996 case 0xf9: 6997 GETBYTE (); 6998 switch (op[1] & 0x00) 6999 { 7000 case 0x00: 7001 goto op_semantics_46; 7002 break; 7003 } 7004 break; 7005 case 0xfa: 7006 GETBYTE (); 7007 switch (op[1] & 0x00) 7008 { 7009 case 0x00: 7010 goto op_semantics_46; 7011 break; 7012 } 7013 break; 7014 case 0xfb: 7015 GETBYTE (); 7016 switch (op[1] & 0x00) 7017 { 7018 case 0x00: 7019 goto op_semantics_46; 7020 break; 7021 } 7022 break; 7023 case 0xfc: 7024 GETBYTE (); 7025 switch (op[1] & 0xff) 7026 { 7027 case 0x03: 7028 GETBYTE (); 7029 switch (op[2] & 0x00) 7030 { 7031 case 0x00: 7032 { 7033 /** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */ 7034 #line 514 "rx-decode.opc" 7035 int rsrc AU = (op[2] >> 4) & 0x0f; 7036 #line 514 "rx-decode.opc" 7037 int rdst AU = op[2] & 0x0f; 7038 if (trace) 7039 { 7040 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7041 "/** 1111 1100 0000 0011 rsrc rdst sbb %1, %0 */", 7042 op[0], op[1], op[2]); 7043 printf (" rsrc = 0x%x,", rsrc); 7044 printf (" rdst = 0x%x\n", rdst); 7045 } 7046 SYNTAX("sbb %1, %0"); 7047 #line 514 "rx-decode.opc" 7048 ID(sbb); SR (rsrc); DR(rdst); F_OSZC; 7049 7050 /* FIXME: only supports .L */ 7051 } 7052 break; 7053 } 7054 break; 7055 case 0x07: 7056 GETBYTE (); 7057 switch (op[2] & 0x00) 7058 { 7059 case 0x00: 7060 { 7061 /** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */ 7062 #line 445 "rx-decode.opc" 7063 int rsrc AU = (op[2] >> 4) & 0x0f; 7064 #line 445 "rx-decode.opc" 7065 int rdst AU = op[2] & 0x0f; 7066 if (trace) 7067 { 7068 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7069 "/** 1111 1100 0000 0111 rsrc rdst neg %2, %0 */", 7070 op[0], op[1], op[2]); 7071 printf (" rsrc = 0x%x,", rsrc); 7072 printf (" rdst = 0x%x\n", rdst); 7073 } 7074 SYNTAX("neg %2, %0"); 7075 #line 445 "rx-decode.opc" 7076 ID(sub); DR(rdst); SC(0); S2R(rsrc); F_OSZC; 7077 7078 /*----------------------------------------------------------------------*/ 7079 /* ADC */ 7080 7081 } 7082 break; 7083 } 7084 break; 7085 case 0x0b: 7086 GETBYTE (); 7087 switch (op[2] & 0x00) 7088 { 7089 case 0x00: 7090 { 7091 /** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */ 7092 #line 454 "rx-decode.opc" 7093 int rsrc AU = (op[2] >> 4) & 0x0f; 7094 #line 454 "rx-decode.opc" 7095 int rdst AU = op[2] & 0x0f; 7096 if (trace) 7097 { 7098 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7099 "/** 1111 1100 0000 1011 rsrc rdst adc %1, %0 */", 7100 op[0], op[1], op[2]); 7101 printf (" rsrc = 0x%x,", rsrc); 7102 printf (" rdst = 0x%x\n", rdst); 7103 } 7104 SYNTAX("adc %1, %0"); 7105 #line 454 "rx-decode.opc" 7106 ID(adc); SR(rsrc); DR(rdst); F_OSZC; 7107 7108 } 7109 break; 7110 } 7111 break; 7112 case 0x0f: 7113 GETBYTE (); 7114 switch (op[2] & 0x00) 7115 { 7116 case 0x00: 7117 { 7118 /** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */ 7119 #line 527 "rx-decode.opc" 7120 int rsrc AU = (op[2] >> 4) & 0x0f; 7121 #line 527 "rx-decode.opc" 7122 int rdst AU = op[2] & 0x0f; 7123 if (trace) 7124 { 7125 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7126 "/** 1111 1100 0000 1111 rsrc rdst abs %1, %0 */", 7127 op[0], op[1], op[2]); 7128 printf (" rsrc = 0x%x,", rsrc); 7129 printf (" rdst = 0x%x\n", rdst); 7130 } 7131 SYNTAX("abs %1, %0"); 7132 #line 527 "rx-decode.opc" 7133 ID(abs); DR(rdst); SR(rsrc); F_OSZ_; 7134 7135 /*----------------------------------------------------------------------*/ 7136 /* MAX */ 7137 7138 } 7139 break; 7140 } 7141 break; 7142 case 0x10: 7143 GETBYTE (); 7144 switch (op[2] & 0x00) 7145 { 7146 case 0x00: 7147 op_semantics_47: 7148 { 7149 /** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */ 7150 #line 536 "rx-decode.opc" 7151 int ss AU = op[1] & 0x03; 7152 #line 536 "rx-decode.opc" 7153 int rsrc AU = (op[2] >> 4) & 0x0f; 7154 #line 536 "rx-decode.opc" 7155 int rdst AU = op[2] & 0x0f; 7156 if (trace) 7157 { 7158 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7159 "/** 1111 1100 0001 00ss rsrc rdst max %1%S1, %0 */", 7160 op[0], op[1], op[2]); 7161 printf (" ss = 0x%x,", ss); 7162 printf (" rsrc = 0x%x,", rsrc); 7163 printf (" rdst = 0x%x\n", rdst); 7164 } 7165 SYNTAX("max %1%S1, %0"); 7166 #line 536 "rx-decode.opc" 7167 if (ss == 3 && rsrc == 0 && rdst == 0) 7168 { 7169 ID(nop3); 7170 } 7171 else 7172 { 7173 ID(max); SP(ss, rsrc); DR(rdst); 7174 } 7175 7176 } 7177 break; 7178 } 7179 break; 7180 case 0x11: 7181 GETBYTE (); 7182 switch (op[2] & 0x00) 7183 { 7184 case 0x00: 7185 goto op_semantics_47; 7186 break; 7187 } 7188 break; 7189 case 0x12: 7190 GETBYTE (); 7191 switch (op[2] & 0x00) 7192 { 7193 case 0x00: 7194 goto op_semantics_47; 7195 break; 7196 } 7197 break; 7198 case 0x13: 7199 GETBYTE (); 7200 switch (op[2] & 0x00) 7201 { 7202 case 0x00: 7203 goto op_semantics_47; 7204 break; 7205 } 7206 break; 7207 case 0x14: 7208 GETBYTE (); 7209 switch (op[2] & 0x00) 7210 { 7211 case 0x00: 7212 op_semantics_48: 7213 { 7214 /** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */ 7215 #line 555 "rx-decode.opc" 7216 int ss AU = op[1] & 0x03; 7217 #line 555 "rx-decode.opc" 7218 int rsrc AU = (op[2] >> 4) & 0x0f; 7219 #line 555 "rx-decode.opc" 7220 int rdst AU = op[2] & 0x0f; 7221 if (trace) 7222 { 7223 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7224 "/** 1111 1100 0001 01ss rsrc rdst min %1%S1, %0 */", 7225 op[0], op[1], op[2]); 7226 printf (" ss = 0x%x,", ss); 7227 printf (" rsrc = 0x%x,", rsrc); 7228 printf (" rdst = 0x%x\n", rdst); 7229 } 7230 SYNTAX("min %1%S1, %0"); 7231 #line 555 "rx-decode.opc" 7232 ID(min); SP(ss, rsrc); DR(rdst); 7233 7234 } 7235 break; 7236 } 7237 break; 7238 case 0x15: 7239 GETBYTE (); 7240 switch (op[2] & 0x00) 7241 { 7242 case 0x00: 7243 goto op_semantics_48; 7244 break; 7245 } 7246 break; 7247 case 0x16: 7248 GETBYTE (); 7249 switch (op[2] & 0x00) 7250 { 7251 case 0x00: 7252 goto op_semantics_48; 7253 break; 7254 } 7255 break; 7256 case 0x17: 7257 GETBYTE (); 7258 switch (op[2] & 0x00) 7259 { 7260 case 0x00: 7261 goto op_semantics_48; 7262 break; 7263 } 7264 break; 7265 case 0x18: 7266 GETBYTE (); 7267 switch (op[2] & 0x00) 7268 { 7269 case 0x00: 7270 op_semantics_49: 7271 { 7272 /** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */ 7273 #line 585 "rx-decode.opc" 7274 int ss AU = op[1] & 0x03; 7275 #line 585 "rx-decode.opc" 7276 int rsrc AU = (op[2] >> 4) & 0x0f; 7277 #line 585 "rx-decode.opc" 7278 int rdst AU = op[2] & 0x0f; 7279 if (trace) 7280 { 7281 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7282 "/** 1111 1100 0001 10ss rsrc rdst emul %1%S1, %0 */", 7283 op[0], op[1], op[2]); 7284 printf (" ss = 0x%x,", ss); 7285 printf (" rsrc = 0x%x,", rsrc); 7286 printf (" rdst = 0x%x\n", rdst); 7287 } 7288 SYNTAX("emul %1%S1, %0"); 7289 #line 585 "rx-decode.opc" 7290 ID(emul); SP(ss, rsrc); DR(rdst); 7291 7292 } 7293 break; 7294 } 7295 break; 7296 case 0x19: 7297 GETBYTE (); 7298 switch (op[2] & 0x00) 7299 { 7300 case 0x00: 7301 goto op_semantics_49; 7302 break; 7303 } 7304 break; 7305 case 0x1a: 7306 GETBYTE (); 7307 switch (op[2] & 0x00) 7308 { 7309 case 0x00: 7310 goto op_semantics_49; 7311 break; 7312 } 7313 break; 7314 case 0x1b: 7315 GETBYTE (); 7316 switch (op[2] & 0x00) 7317 { 7318 case 0x00: 7319 goto op_semantics_49; 7320 break; 7321 } 7322 break; 7323 case 0x1c: 7324 GETBYTE (); 7325 switch (op[2] & 0x00) 7326 { 7327 case 0x00: 7328 op_semantics_50: 7329 { 7330 /** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */ 7331 #line 597 "rx-decode.opc" 7332 int ss AU = op[1] & 0x03; 7333 #line 597 "rx-decode.opc" 7334 int rsrc AU = (op[2] >> 4) & 0x0f; 7335 #line 597 "rx-decode.opc" 7336 int rdst AU = op[2] & 0x0f; 7337 if (trace) 7338 { 7339 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7340 "/** 1111 1100 0001 11ss rsrc rdst emulu %1%S1, %0 */", 7341 op[0], op[1], op[2]); 7342 printf (" ss = 0x%x,", ss); 7343 printf (" rsrc = 0x%x,", rsrc); 7344 printf (" rdst = 0x%x\n", rdst); 7345 } 7346 SYNTAX("emulu %1%S1, %0"); 7347 #line 597 "rx-decode.opc" 7348 ID(emulu); SP(ss, rsrc); DR(rdst); 7349 7350 } 7351 break; 7352 } 7353 break; 7354 case 0x1d: 7355 GETBYTE (); 7356 switch (op[2] & 0x00) 7357 { 7358 case 0x00: 7359 goto op_semantics_50; 7360 break; 7361 } 7362 break; 7363 case 0x1e: 7364 GETBYTE (); 7365 switch (op[2] & 0x00) 7366 { 7367 case 0x00: 7368 goto op_semantics_50; 7369 break; 7370 } 7371 break; 7372 case 0x1f: 7373 GETBYTE (); 7374 switch (op[2] & 0x00) 7375 { 7376 case 0x00: 7377 goto op_semantics_50; 7378 break; 7379 } 7380 break; 7381 case 0x20: 7382 GETBYTE (); 7383 switch (op[2] & 0x00) 7384 { 7385 case 0x00: 7386 op_semantics_51: 7387 { 7388 /** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */ 7389 #line 609 "rx-decode.opc" 7390 int ss AU = op[1] & 0x03; 7391 #line 609 "rx-decode.opc" 7392 int rsrc AU = (op[2] >> 4) & 0x0f; 7393 #line 609 "rx-decode.opc" 7394 int rdst AU = op[2] & 0x0f; 7395 if (trace) 7396 { 7397 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7398 "/** 1111 1100 0010 00ss rsrc rdst div %1%S1, %0 */", 7399 op[0], op[1], op[2]); 7400 printf (" ss = 0x%x,", ss); 7401 printf (" rsrc = 0x%x,", rsrc); 7402 printf (" rdst = 0x%x\n", rdst); 7403 } 7404 SYNTAX("div %1%S1, %0"); 7405 #line 609 "rx-decode.opc" 7406 ID(div); SP(ss, rsrc); DR(rdst); F_O___; 7407 7408 } 7409 break; 7410 } 7411 break; 7412 case 0x21: 7413 GETBYTE (); 7414 switch (op[2] & 0x00) 7415 { 7416 case 0x00: 7417 goto op_semantics_51; 7418 break; 7419 } 7420 break; 7421 case 0x22: 7422 GETBYTE (); 7423 switch (op[2] & 0x00) 7424 { 7425 case 0x00: 7426 goto op_semantics_51; 7427 break; 7428 } 7429 break; 7430 case 0x23: 7431 GETBYTE (); 7432 switch (op[2] & 0x00) 7433 { 7434 case 0x00: 7435 goto op_semantics_51; 7436 break; 7437 } 7438 break; 7439 case 0x24: 7440 GETBYTE (); 7441 switch (op[2] & 0x00) 7442 { 7443 case 0x00: 7444 op_semantics_52: 7445 { 7446 /** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */ 7447 #line 621 "rx-decode.opc" 7448 int ss AU = op[1] & 0x03; 7449 #line 621 "rx-decode.opc" 7450 int rsrc AU = (op[2] >> 4) & 0x0f; 7451 #line 621 "rx-decode.opc" 7452 int rdst AU = op[2] & 0x0f; 7453 if (trace) 7454 { 7455 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7456 "/** 1111 1100 0010 01ss rsrc rdst divu %1%S1, %0 */", 7457 op[0], op[1], op[2]); 7458 printf (" ss = 0x%x,", ss); 7459 printf (" rsrc = 0x%x,", rsrc); 7460 printf (" rdst = 0x%x\n", rdst); 7461 } 7462 SYNTAX("divu %1%S1, %0"); 7463 #line 621 "rx-decode.opc" 7464 ID(divu); SP(ss, rsrc); DR(rdst); F_O___; 7465 7466 } 7467 break; 7468 } 7469 break; 7470 case 0x25: 7471 GETBYTE (); 7472 switch (op[2] & 0x00) 7473 { 7474 case 0x00: 7475 goto op_semantics_52; 7476 break; 7477 } 7478 break; 7479 case 0x26: 7480 GETBYTE (); 7481 switch (op[2] & 0x00) 7482 { 7483 case 0x00: 7484 goto op_semantics_52; 7485 break; 7486 } 7487 break; 7488 case 0x27: 7489 GETBYTE (); 7490 switch (op[2] & 0x00) 7491 { 7492 case 0x00: 7493 goto op_semantics_52; 7494 break; 7495 } 7496 break; 7497 case 0x30: 7498 GETBYTE (); 7499 switch (op[2] & 0x00) 7500 { 7501 case 0x00: 7502 op_semantics_53: 7503 { 7504 /** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */ 7505 #line 433 "rx-decode.opc" 7506 int ss AU = op[1] & 0x03; 7507 #line 433 "rx-decode.opc" 7508 int rsrc AU = (op[2] >> 4) & 0x0f; 7509 #line 433 "rx-decode.opc" 7510 int rdst AU = op[2] & 0x0f; 7511 if (trace) 7512 { 7513 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7514 "/** 1111 1100 0011 00ss rsrc rdst tst %1%S1, %2 */", 7515 op[0], op[1], op[2]); 7516 printf (" ss = 0x%x,", ss); 7517 printf (" rsrc = 0x%x,", rsrc); 7518 printf (" rdst = 0x%x\n", rdst); 7519 } 7520 SYNTAX("tst %1%S1, %2"); 7521 #line 433 "rx-decode.opc" 7522 ID(and); SP(ss, rsrc); S2R(rdst); F__SZ_; 7523 7524 } 7525 break; 7526 } 7527 break; 7528 case 0x31: 7529 GETBYTE (); 7530 switch (op[2] & 0x00) 7531 { 7532 case 0x00: 7533 goto op_semantics_53; 7534 break; 7535 } 7536 break; 7537 case 0x32: 7538 GETBYTE (); 7539 switch (op[2] & 0x00) 7540 { 7541 case 0x00: 7542 goto op_semantics_53; 7543 break; 7544 } 7545 break; 7546 case 0x33: 7547 GETBYTE (); 7548 switch (op[2] & 0x00) 7549 { 7550 case 0x00: 7551 goto op_semantics_53; 7552 break; 7553 } 7554 break; 7555 case 0x34: 7556 GETBYTE (); 7557 switch (op[2] & 0x00) 7558 { 7559 case 0x00: 7560 op_semantics_54: 7561 { 7562 /** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */ 7563 #line 412 "rx-decode.opc" 7564 int ss AU = op[1] & 0x03; 7565 #line 412 "rx-decode.opc" 7566 int rsrc AU = (op[2] >> 4) & 0x0f; 7567 #line 412 "rx-decode.opc" 7568 int rdst AU = op[2] & 0x0f; 7569 if (trace) 7570 { 7571 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7572 "/** 1111 1100 0011 01ss rsrc rdst xor %1%S1, %0 */", 7573 op[0], op[1], op[2]); 7574 printf (" ss = 0x%x,", ss); 7575 printf (" rsrc = 0x%x,", rsrc); 7576 printf (" rdst = 0x%x\n", rdst); 7577 } 7578 SYNTAX("xor %1%S1, %0"); 7579 #line 412 "rx-decode.opc" 7580 ID(xor); SP(ss, rsrc); DR(rdst); F__SZ_; 7581 7582 } 7583 break; 7584 } 7585 break; 7586 case 0x35: 7587 GETBYTE (); 7588 switch (op[2] & 0x00) 7589 { 7590 case 0x00: 7591 goto op_semantics_54; 7592 break; 7593 } 7594 break; 7595 case 0x36: 7596 GETBYTE (); 7597 switch (op[2] & 0x00) 7598 { 7599 case 0x00: 7600 goto op_semantics_54; 7601 break; 7602 } 7603 break; 7604 case 0x37: 7605 GETBYTE (); 7606 switch (op[2] & 0x00) 7607 { 7608 case 0x00: 7609 goto op_semantics_54; 7610 break; 7611 } 7612 break; 7613 case 0x3b: 7614 GETBYTE (); 7615 switch (op[2] & 0x00) 7616 { 7617 case 0x00: 7618 { 7619 /** 1111 1100 0011 1011 rsrc rdst not %1, %0 */ 7620 #line 424 "rx-decode.opc" 7621 int rsrc AU = (op[2] >> 4) & 0x0f; 7622 #line 424 "rx-decode.opc" 7623 int rdst AU = op[2] & 0x0f; 7624 if (trace) 7625 { 7626 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7627 "/** 1111 1100 0011 1011 rsrc rdst not %1, %0 */", 7628 op[0], op[1], op[2]); 7629 printf (" rsrc = 0x%x,", rsrc); 7630 printf (" rdst = 0x%x\n", rdst); 7631 } 7632 SYNTAX("not %1, %0"); 7633 #line 424 "rx-decode.opc" 7634 ID(xor); DR(rdst); SR(rsrc); S2C(~0); F__SZ_; 7635 7636 /*----------------------------------------------------------------------*/ 7637 /* TST */ 7638 7639 } 7640 break; 7641 } 7642 break; 7643 case 0x40: 7644 GETBYTE (); 7645 switch (op[2] & 0x00) 7646 { 7647 case 0x00: 7648 op_semantics_55: 7649 { 7650 /** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */ 7651 #line 346 "rx-decode.opc" 7652 int ss AU = op[1] & 0x03; 7653 #line 346 "rx-decode.opc" 7654 int rsrc AU = (op[2] >> 4) & 0x0f; 7655 #line 346 "rx-decode.opc" 7656 int rdst AU = op[2] & 0x0f; 7657 if (trace) 7658 { 7659 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7660 "/** 1111 1100 0100 00ss rsrc rdst xchg %1%S1, %0 */", 7661 op[0], op[1], op[2]); 7662 printf (" ss = 0x%x,", ss); 7663 printf (" rsrc = 0x%x,", rsrc); 7664 printf (" rdst = 0x%x\n", rdst); 7665 } 7666 SYNTAX("xchg %1%S1, %0"); 7667 #line 346 "rx-decode.opc" 7668 ID(xchg); DR(rdst); SP(ss, rsrc); 7669 7670 } 7671 break; 7672 } 7673 break; 7674 case 0x41: 7675 GETBYTE (); 7676 switch (op[2] & 0x00) 7677 { 7678 case 0x00: 7679 goto op_semantics_55; 7680 break; 7681 } 7682 break; 7683 case 0x42: 7684 GETBYTE (); 7685 switch (op[2] & 0x00) 7686 { 7687 case 0x00: 7688 goto op_semantics_55; 7689 break; 7690 } 7691 break; 7692 case 0x43: 7693 GETBYTE (); 7694 switch (op[2] & 0x00) 7695 { 7696 case 0x00: 7697 goto op_semantics_55; 7698 break; 7699 } 7700 break; 7701 case 0x44: 7702 GETBYTE (); 7703 switch (op[2] & 0x00) 7704 { 7705 case 0x00: 7706 op_semantics_56: 7707 { 7708 /** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */ 7709 #line 850 "rx-decode.opc" 7710 int sd AU = op[1] & 0x03; 7711 #line 850 "rx-decode.opc" 7712 int rsrc AU = (op[2] >> 4) & 0x0f; 7713 #line 850 "rx-decode.opc" 7714 int rdst AU = op[2] & 0x0f; 7715 if (trace) 7716 { 7717 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7718 "/** 1111 1100 0100 01sd rsrc rdst itof %1%S1, %0 */", 7719 op[0], op[1], op[2]); 7720 printf (" sd = 0x%x,", sd); 7721 printf (" rsrc = 0x%x,", rsrc); 7722 printf (" rdst = 0x%x\n", rdst); 7723 } 7724 SYNTAX("itof %1%S1, %0"); 7725 #line 850 "rx-decode.opc" 7726 ID(itof); DR (rdst); SP(sd, rsrc); F__SZ_; 7727 7728 } 7729 break; 7730 } 7731 break; 7732 case 0x45: 7733 GETBYTE (); 7734 switch (op[2] & 0x00) 7735 { 7736 case 0x00: 7737 goto op_semantics_56; 7738 break; 7739 } 7740 break; 7741 case 0x46: 7742 GETBYTE (); 7743 switch (op[2] & 0x00) 7744 { 7745 case 0x00: 7746 goto op_semantics_56; 7747 break; 7748 } 7749 break; 7750 case 0x47: 7751 GETBYTE (); 7752 switch (op[2] & 0x00) 7753 { 7754 case 0x00: 7755 goto op_semantics_56; 7756 break; 7757 } 7758 break; 7759 case 0x60: 7760 GETBYTE (); 7761 switch (op[2] & 0x00) 7762 { 7763 case 0x00: 7764 op_semantics_57: 7765 { 7766 /** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */ 7767 #line 862 "rx-decode.opc" 7768 int sd AU = op[1] & 0x03; 7769 #line 862 "rx-decode.opc" 7770 int rdst AU = (op[2] >> 4) & 0x0f; 7771 #line 862 "rx-decode.opc" 7772 int rsrc AU = op[2] & 0x0f; 7773 if (trace) 7774 { 7775 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7776 "/** 1111 1100 0110 00sd rdst rsrc bset %1, %0%S0 */", 7777 op[0], op[1], op[2]); 7778 printf (" sd = 0x%x,", sd); 7779 printf (" rdst = 0x%x,", rdst); 7780 printf (" rsrc = 0x%x\n", rsrc); 7781 } 7782 SYNTAX("bset %1, %0%S0"); 7783 #line 862 "rx-decode.opc" 7784 ID(bset); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 7785 7786 } 7787 break; 7788 } 7789 break; 7790 case 0x61: 7791 GETBYTE (); 7792 switch (op[2] & 0x00) 7793 { 7794 case 0x00: 7795 goto op_semantics_57; 7796 break; 7797 } 7798 break; 7799 case 0x62: 7800 GETBYTE (); 7801 switch (op[2] & 0x00) 7802 { 7803 case 0x00: 7804 goto op_semantics_57; 7805 break; 7806 } 7807 break; 7808 case 0x63: 7809 GETBYTE (); 7810 switch (op[2] & 0x00) 7811 { 7812 case 0x00: 7813 goto op_semantics_57; 7814 break; 7815 } 7816 break; 7817 case 0x64: 7818 GETBYTE (); 7819 switch (op[2] & 0x00) 7820 { 7821 case 0x00: 7822 op_semantics_58: 7823 { 7824 /** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */ 7825 #line 872 "rx-decode.opc" 7826 int sd AU = op[1] & 0x03; 7827 #line 872 "rx-decode.opc" 7828 int rdst AU = (op[2] >> 4) & 0x0f; 7829 #line 872 "rx-decode.opc" 7830 int rsrc AU = op[2] & 0x0f; 7831 if (trace) 7832 { 7833 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7834 "/** 1111 1100 0110 01sd rdst rsrc bclr %1, %0%S0 */", 7835 op[0], op[1], op[2]); 7836 printf (" sd = 0x%x,", sd); 7837 printf (" rdst = 0x%x,", rdst); 7838 printf (" rsrc = 0x%x\n", rsrc); 7839 } 7840 SYNTAX("bclr %1, %0%S0"); 7841 #line 872 "rx-decode.opc" 7842 ID(bclr); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); F_____; 7843 7844 } 7845 break; 7846 } 7847 break; 7848 case 0x65: 7849 GETBYTE (); 7850 switch (op[2] & 0x00) 7851 { 7852 case 0x00: 7853 goto op_semantics_58; 7854 break; 7855 } 7856 break; 7857 case 0x66: 7858 GETBYTE (); 7859 switch (op[2] & 0x00) 7860 { 7861 case 0x00: 7862 goto op_semantics_58; 7863 break; 7864 } 7865 break; 7866 case 0x67: 7867 GETBYTE (); 7868 switch (op[2] & 0x00) 7869 { 7870 case 0x00: 7871 goto op_semantics_58; 7872 break; 7873 } 7874 break; 7875 case 0x68: 7876 GETBYTE (); 7877 switch (op[2] & 0x00) 7878 { 7879 case 0x00: 7880 op_semantics_59: 7881 { 7882 /** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */ 7883 #line 882 "rx-decode.opc" 7884 int sd AU = op[1] & 0x03; 7885 #line 882 "rx-decode.opc" 7886 int rdst AU = (op[2] >> 4) & 0x0f; 7887 #line 882 "rx-decode.opc" 7888 int rsrc AU = op[2] & 0x0f; 7889 if (trace) 7890 { 7891 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7892 "/** 1111 1100 0110 10sd rdst rsrc btst %2, %1%S1 */", 7893 op[0], op[1], op[2]); 7894 printf (" sd = 0x%x,", sd); 7895 printf (" rdst = 0x%x,", rdst); 7896 printf (" rsrc = 0x%x\n", rsrc); 7897 } 7898 SYNTAX("btst %2, %1%S1"); 7899 #line 882 "rx-decode.opc" 7900 ID(btst); BWL(BSIZE); S2R(rsrc); SD(sd, rdst, BSIZE); F___ZC; 7901 7902 } 7903 break; 7904 } 7905 break; 7906 case 0x69: 7907 GETBYTE (); 7908 switch (op[2] & 0x00) 7909 { 7910 case 0x00: 7911 goto op_semantics_59; 7912 break; 7913 } 7914 break; 7915 case 0x6a: 7916 GETBYTE (); 7917 switch (op[2] & 0x00) 7918 { 7919 case 0x00: 7920 goto op_semantics_59; 7921 break; 7922 } 7923 break; 7924 case 0x6b: 7925 GETBYTE (); 7926 switch (op[2] & 0x00) 7927 { 7928 case 0x00: 7929 goto op_semantics_59; 7930 break; 7931 } 7932 break; 7933 case 0x6c: 7934 GETBYTE (); 7935 switch (op[2] & 0x00) 7936 { 7937 case 0x00: 7938 op_semantics_60: 7939 { 7940 /** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */ 7941 #line 892 "rx-decode.opc" 7942 int sd AU = op[1] & 0x03; 7943 #line 892 "rx-decode.opc" 7944 int rdst AU = (op[2] >> 4) & 0x0f; 7945 #line 892 "rx-decode.opc" 7946 int rsrc AU = op[2] & 0x0f; 7947 if (trace) 7948 { 7949 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 7950 "/** 1111 1100 0110 11sd rdst rsrc bnot %1, %0%S0 */", 7951 op[0], op[1], op[2]); 7952 printf (" sd = 0x%x,", sd); 7953 printf (" rdst = 0x%x,", rdst); 7954 printf (" rsrc = 0x%x\n", rsrc); 7955 } 7956 SYNTAX("bnot %1, %0%S0"); 7957 #line 892 "rx-decode.opc" 7958 ID(bnot); BWL(BSIZE); SR(rsrc); DD(sd, rdst, BSIZE); 7959 7960 } 7961 break; 7962 } 7963 break; 7964 case 0x6d: 7965 GETBYTE (); 7966 switch (op[2] & 0x00) 7967 { 7968 case 0x00: 7969 goto op_semantics_60; 7970 break; 7971 } 7972 break; 7973 case 0x6e: 7974 GETBYTE (); 7975 switch (op[2] & 0x00) 7976 { 7977 case 0x00: 7978 goto op_semantics_60; 7979 break; 7980 } 7981 break; 7982 case 0x6f: 7983 GETBYTE (); 7984 switch (op[2] & 0x00) 7985 { 7986 case 0x00: 7987 goto op_semantics_60; 7988 break; 7989 } 7990 break; 7991 case 0x80: 7992 GETBYTE (); 7993 switch (op[2] & 0x00) 7994 { 7995 case 0x00: 7996 op_semantics_61: 7997 { 7998 /** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */ 7999 #line 829 "rx-decode.opc" 8000 int sd AU = op[1] & 0x03; 8001 #line 829 "rx-decode.opc" 8002 int rsrc AU = (op[2] >> 4) & 0x0f; 8003 #line 829 "rx-decode.opc" 8004 int rdst AU = op[2] & 0x0f; 8005 if (trace) 8006 { 8007 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8008 "/** 1111 1100 1000 00sd rsrc rdst fsub %1%S1, %0 */", 8009 op[0], op[1], op[2]); 8010 printf (" sd = 0x%x,", sd); 8011 printf (" rsrc = 0x%x,", rsrc); 8012 printf (" rdst = 0x%x\n", rdst); 8013 } 8014 SYNTAX("fsub %1%S1, %0"); 8015 #line 829 "rx-decode.opc" 8016 ID(fsub); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8017 8018 } 8019 break; 8020 } 8021 break; 8022 case 0x81: 8023 GETBYTE (); 8024 switch (op[2] & 0x00) 8025 { 8026 case 0x00: 8027 goto op_semantics_61; 8028 break; 8029 } 8030 break; 8031 case 0x82: 8032 GETBYTE (); 8033 switch (op[2] & 0x00) 8034 { 8035 case 0x00: 8036 goto op_semantics_61; 8037 break; 8038 } 8039 break; 8040 case 0x83: 8041 GETBYTE (); 8042 switch (op[2] & 0x00) 8043 { 8044 case 0x00: 8045 goto op_semantics_61; 8046 break; 8047 } 8048 break; 8049 case 0x84: 8050 GETBYTE (); 8051 switch (op[2] & 0x00) 8052 { 8053 case 0x00: 8054 op_semantics_62: 8055 { 8056 /** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */ 8057 #line 823 "rx-decode.opc" 8058 int sd AU = op[1] & 0x03; 8059 #line 823 "rx-decode.opc" 8060 int rsrc AU = (op[2] >> 4) & 0x0f; 8061 #line 823 "rx-decode.opc" 8062 int rdst AU = op[2] & 0x0f; 8063 if (trace) 8064 { 8065 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8066 "/** 1111 1100 1000 01sd rsrc rdst fcmp %1%S1, %0 */", 8067 op[0], op[1], op[2]); 8068 printf (" sd = 0x%x,", sd); 8069 printf (" rsrc = 0x%x,", rsrc); 8070 printf (" rdst = 0x%x\n", rdst); 8071 } 8072 SYNTAX("fcmp %1%S1, %0"); 8073 #line 823 "rx-decode.opc" 8074 ID(fcmp); DR(rdst); SD(sd, rsrc, LSIZE); F_OSZ_; 8075 8076 } 8077 break; 8078 } 8079 break; 8080 case 0x85: 8081 GETBYTE (); 8082 switch (op[2] & 0x00) 8083 { 8084 case 0x00: 8085 goto op_semantics_62; 8086 break; 8087 } 8088 break; 8089 case 0x86: 8090 GETBYTE (); 8091 switch (op[2] & 0x00) 8092 { 8093 case 0x00: 8094 goto op_semantics_62; 8095 break; 8096 } 8097 break; 8098 case 0x87: 8099 GETBYTE (); 8100 switch (op[2] & 0x00) 8101 { 8102 case 0x00: 8103 goto op_semantics_62; 8104 break; 8105 } 8106 break; 8107 case 0x88: 8108 GETBYTE (); 8109 switch (op[2] & 0x00) 8110 { 8111 case 0x00: 8112 op_semantics_63: 8113 { 8114 /** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */ 8115 #line 817 "rx-decode.opc" 8116 int sd AU = op[1] & 0x03; 8117 #line 817 "rx-decode.opc" 8118 int rsrc AU = (op[2] >> 4) & 0x0f; 8119 #line 817 "rx-decode.opc" 8120 int rdst AU = op[2] & 0x0f; 8121 if (trace) 8122 { 8123 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8124 "/** 1111 1100 1000 10sd rsrc rdst fadd %1%S1, %0 */", 8125 op[0], op[1], op[2]); 8126 printf (" sd = 0x%x,", sd); 8127 printf (" rsrc = 0x%x,", rsrc); 8128 printf (" rdst = 0x%x\n", rdst); 8129 } 8130 SYNTAX("fadd %1%S1, %0"); 8131 #line 817 "rx-decode.opc" 8132 ID(fadd); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8133 8134 } 8135 break; 8136 } 8137 break; 8138 case 0x89: 8139 GETBYTE (); 8140 switch (op[2] & 0x00) 8141 { 8142 case 0x00: 8143 goto op_semantics_63; 8144 break; 8145 } 8146 break; 8147 case 0x8a: 8148 GETBYTE (); 8149 switch (op[2] & 0x00) 8150 { 8151 case 0x00: 8152 goto op_semantics_63; 8153 break; 8154 } 8155 break; 8156 case 0x8b: 8157 GETBYTE (); 8158 switch (op[2] & 0x00) 8159 { 8160 case 0x00: 8161 goto op_semantics_63; 8162 break; 8163 } 8164 break; 8165 case 0x8c: 8166 GETBYTE (); 8167 switch (op[2] & 0x00) 8168 { 8169 case 0x00: 8170 op_semantics_64: 8171 { 8172 /** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */ 8173 #line 838 "rx-decode.opc" 8174 int sd AU = op[1] & 0x03; 8175 #line 838 "rx-decode.opc" 8176 int rsrc AU = (op[2] >> 4) & 0x0f; 8177 #line 838 "rx-decode.opc" 8178 int rdst AU = op[2] & 0x0f; 8179 if (trace) 8180 { 8181 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8182 "/** 1111 1100 1000 11sd rsrc rdst fmul %1%S1, %0 */", 8183 op[0], op[1], op[2]); 8184 printf (" sd = 0x%x,", sd); 8185 printf (" rsrc = 0x%x,", rsrc); 8186 printf (" rdst = 0x%x\n", rdst); 8187 } 8188 SYNTAX("fmul %1%S1, %0"); 8189 #line 838 "rx-decode.opc" 8190 ID(fmul); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8191 8192 } 8193 break; 8194 } 8195 break; 8196 case 0x8d: 8197 GETBYTE (); 8198 switch (op[2] & 0x00) 8199 { 8200 case 0x00: 8201 goto op_semantics_64; 8202 break; 8203 } 8204 break; 8205 case 0x8e: 8206 GETBYTE (); 8207 switch (op[2] & 0x00) 8208 { 8209 case 0x00: 8210 goto op_semantics_64; 8211 break; 8212 } 8213 break; 8214 case 0x8f: 8215 GETBYTE (); 8216 switch (op[2] & 0x00) 8217 { 8218 case 0x00: 8219 goto op_semantics_64; 8220 break; 8221 } 8222 break; 8223 case 0x90: 8224 GETBYTE (); 8225 switch (op[2] & 0x00) 8226 { 8227 case 0x00: 8228 op_semantics_65: 8229 { 8230 /** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */ 8231 #line 844 "rx-decode.opc" 8232 int sd AU = op[1] & 0x03; 8233 #line 844 "rx-decode.opc" 8234 int rsrc AU = (op[2] >> 4) & 0x0f; 8235 #line 844 "rx-decode.opc" 8236 int rdst AU = op[2] & 0x0f; 8237 if (trace) 8238 { 8239 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8240 "/** 1111 1100 1001 00sd rsrc rdst fdiv %1%S1, %0 */", 8241 op[0], op[1], op[2]); 8242 printf (" sd = 0x%x,", sd); 8243 printf (" rsrc = 0x%x,", rsrc); 8244 printf (" rdst = 0x%x\n", rdst); 8245 } 8246 SYNTAX("fdiv %1%S1, %0"); 8247 #line 844 "rx-decode.opc" 8248 ID(fdiv); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8249 8250 } 8251 break; 8252 } 8253 break; 8254 case 0x91: 8255 GETBYTE (); 8256 switch (op[2] & 0x00) 8257 { 8258 case 0x00: 8259 goto op_semantics_65; 8260 break; 8261 } 8262 break; 8263 case 0x92: 8264 GETBYTE (); 8265 switch (op[2] & 0x00) 8266 { 8267 case 0x00: 8268 goto op_semantics_65; 8269 break; 8270 } 8271 break; 8272 case 0x93: 8273 GETBYTE (); 8274 switch (op[2] & 0x00) 8275 { 8276 case 0x00: 8277 goto op_semantics_65; 8278 break; 8279 } 8280 break; 8281 case 0x94: 8282 GETBYTE (); 8283 switch (op[2] & 0x00) 8284 { 8285 case 0x00: 8286 op_semantics_66: 8287 { 8288 /** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */ 8289 #line 832 "rx-decode.opc" 8290 int sd AU = op[1] & 0x03; 8291 #line 832 "rx-decode.opc" 8292 int rsrc AU = (op[2] >> 4) & 0x0f; 8293 #line 832 "rx-decode.opc" 8294 int rdst AU = op[2] & 0x0f; 8295 if (trace) 8296 { 8297 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8298 "/** 1111 1100 1001 01sd rsrc rdst ftoi %1%S1, %0 */", 8299 op[0], op[1], op[2]); 8300 printf (" sd = 0x%x,", sd); 8301 printf (" rsrc = 0x%x,", rsrc); 8302 printf (" rdst = 0x%x\n", rdst); 8303 } 8304 SYNTAX("ftoi %1%S1, %0"); 8305 #line 832 "rx-decode.opc" 8306 ID(ftoi); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8307 8308 } 8309 break; 8310 } 8311 break; 8312 case 0x95: 8313 GETBYTE (); 8314 switch (op[2] & 0x00) 8315 { 8316 case 0x00: 8317 goto op_semantics_66; 8318 break; 8319 } 8320 break; 8321 case 0x96: 8322 GETBYTE (); 8323 switch (op[2] & 0x00) 8324 { 8325 case 0x00: 8326 goto op_semantics_66; 8327 break; 8328 } 8329 break; 8330 case 0x97: 8331 GETBYTE (); 8332 switch (op[2] & 0x00) 8333 { 8334 case 0x00: 8335 goto op_semantics_66; 8336 break; 8337 } 8338 break; 8339 case 0x98: 8340 GETBYTE (); 8341 switch (op[2] & 0x00) 8342 { 8343 case 0x00: 8344 op_semantics_67: 8345 { 8346 /** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */ 8347 #line 847 "rx-decode.opc" 8348 int sd AU = op[1] & 0x03; 8349 #line 847 "rx-decode.opc" 8350 int rsrc AU = (op[2] >> 4) & 0x0f; 8351 #line 847 "rx-decode.opc" 8352 int rdst AU = op[2] & 0x0f; 8353 if (trace) 8354 { 8355 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8356 "/** 1111 1100 1001 10sd rsrc rdst round %1%S1, %0 */", 8357 op[0], op[1], op[2]); 8358 printf (" sd = 0x%x,", sd); 8359 printf (" rsrc = 0x%x,", rsrc); 8360 printf (" rdst = 0x%x\n", rdst); 8361 } 8362 SYNTAX("round %1%S1, %0"); 8363 #line 847 "rx-decode.opc" 8364 ID(round); DR(rdst); SD(sd, rsrc, LSIZE); F__SZ_; 8365 8366 } 8367 break; 8368 } 8369 break; 8370 case 0x99: 8371 GETBYTE (); 8372 switch (op[2] & 0x00) 8373 { 8374 case 0x00: 8375 goto op_semantics_67; 8376 break; 8377 } 8378 break; 8379 case 0x9a: 8380 GETBYTE (); 8381 switch (op[2] & 0x00) 8382 { 8383 case 0x00: 8384 goto op_semantics_67; 8385 break; 8386 } 8387 break; 8388 case 0x9b: 8389 GETBYTE (); 8390 switch (op[2] & 0x00) 8391 { 8392 case 0x00: 8393 goto op_semantics_67; 8394 break; 8395 } 8396 break; 8397 case 0xd0: 8398 GETBYTE (); 8399 switch (op[2] & 0x00) 8400 { 8401 case 0x00: 8402 op_semantics_68: 8403 { 8404 /** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */ 8405 #line 956 "rx-decode.opc" 8406 int sz AU = (op[1] >> 2) & 0x03; 8407 #line 956 "rx-decode.opc" 8408 int sd AU = op[1] & 0x03; 8409 #line 956 "rx-decode.opc" 8410 int rdst AU = (op[2] >> 4) & 0x0f; 8411 #line 956 "rx-decode.opc" 8412 int cond AU = op[2] & 0x0f; 8413 if (trace) 8414 { 8415 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8416 "/** 1111 1100 1101 sz sd rdst cond sc%1%s %0 */", 8417 op[0], op[1], op[2]); 8418 printf (" sz = 0x%x,", sz); 8419 printf (" sd = 0x%x,", sd); 8420 printf (" rdst = 0x%x,", rdst); 8421 printf (" cond = 0x%x\n", cond); 8422 } 8423 SYNTAX("sc%1%s %0"); 8424 #line 956 "rx-decode.opc" 8425 ID(sccnd); BWL(sz); DD (sd, rdst, sz); Scc(cond); 8426 8427 } 8428 break; 8429 } 8430 break; 8431 case 0xd1: 8432 GETBYTE (); 8433 switch (op[2] & 0x00) 8434 { 8435 case 0x00: 8436 goto op_semantics_68; 8437 break; 8438 } 8439 break; 8440 case 0xd2: 8441 GETBYTE (); 8442 switch (op[2] & 0x00) 8443 { 8444 case 0x00: 8445 goto op_semantics_68; 8446 break; 8447 } 8448 break; 8449 case 0xd3: 8450 GETBYTE (); 8451 switch (op[2] & 0x00) 8452 { 8453 case 0x00: 8454 goto op_semantics_68; 8455 break; 8456 } 8457 break; 8458 case 0xd4: 8459 GETBYTE (); 8460 switch (op[2] & 0x00) 8461 { 8462 case 0x00: 8463 goto op_semantics_68; 8464 break; 8465 } 8466 break; 8467 case 0xd5: 8468 GETBYTE (); 8469 switch (op[2] & 0x00) 8470 { 8471 case 0x00: 8472 goto op_semantics_68; 8473 break; 8474 } 8475 break; 8476 case 0xd6: 8477 GETBYTE (); 8478 switch (op[2] & 0x00) 8479 { 8480 case 0x00: 8481 goto op_semantics_68; 8482 break; 8483 } 8484 break; 8485 case 0xd7: 8486 GETBYTE (); 8487 switch (op[2] & 0x00) 8488 { 8489 case 0x00: 8490 goto op_semantics_68; 8491 break; 8492 } 8493 break; 8494 case 0xd8: 8495 GETBYTE (); 8496 switch (op[2] & 0x00) 8497 { 8498 case 0x00: 8499 goto op_semantics_68; 8500 break; 8501 } 8502 break; 8503 case 0xd9: 8504 GETBYTE (); 8505 switch (op[2] & 0x00) 8506 { 8507 case 0x00: 8508 goto op_semantics_68; 8509 break; 8510 } 8511 break; 8512 case 0xda: 8513 GETBYTE (); 8514 switch (op[2] & 0x00) 8515 { 8516 case 0x00: 8517 goto op_semantics_68; 8518 break; 8519 } 8520 break; 8521 case 0xdb: 8522 GETBYTE (); 8523 switch (op[2] & 0x00) 8524 { 8525 case 0x00: 8526 goto op_semantics_68; 8527 break; 8528 } 8529 break; 8530 case 0xe0: 8531 GETBYTE (); 8532 switch (op[2] & 0x0f) 8533 { 8534 case 0x00: 8535 case 0x01: 8536 case 0x02: 8537 case 0x03: 8538 case 0x04: 8539 case 0x05: 8540 case 0x06: 8541 case 0x07: 8542 case 0x08: 8543 case 0x09: 8544 case 0x0a: 8545 case 0x0b: 8546 case 0x0c: 8547 case 0x0d: 8548 case 0x0e: 8549 op_semantics_69: 8550 { 8551 /** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */ 8552 #line 899 "rx-decode.opc" 8553 int bit AU = (op[1] >> 2) & 0x07; 8554 #line 899 "rx-decode.opc" 8555 int sd AU = op[1] & 0x03; 8556 #line 899 "rx-decode.opc" 8557 int rdst AU = (op[2] >> 4) & 0x0f; 8558 #line 899 "rx-decode.opc" 8559 int cond AU = op[2] & 0x0f; 8560 if (trace) 8561 { 8562 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8563 "/** 1111 1100 111bit sd rdst cond bm%2 #%1, %0%S0 */", 8564 op[0], op[1], op[2]); 8565 printf (" bit = 0x%x,", bit); 8566 printf (" sd = 0x%x,", sd); 8567 printf (" rdst = 0x%x,", rdst); 8568 printf (" cond = 0x%x\n", cond); 8569 } 8570 SYNTAX("bm%2 #%1, %0%S0"); 8571 #line 899 "rx-decode.opc" 8572 ID(bmcc); BWL(BSIZE); S2cc(cond); SC(bit); DD(sd, rdst, BSIZE); 8573 8574 } 8575 break; 8576 case 0x0f: 8577 op_semantics_70: 8578 { 8579 /** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */ 8580 #line 889 "rx-decode.opc" 8581 int bit AU = (op[1] >> 2) & 0x07; 8582 #line 889 "rx-decode.opc" 8583 int sd AU = op[1] & 0x03; 8584 #line 889 "rx-decode.opc" 8585 int rdst AU = (op[2] >> 4) & 0x0f; 8586 if (trace) 8587 { 8588 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 8589 "/** 1111 1100 111bit sd rdst 1111 bnot #%1, %0%S0 */", 8590 op[0], op[1], op[2]); 8591 printf (" bit = 0x%x,", bit); 8592 printf (" sd = 0x%x,", sd); 8593 printf (" rdst = 0x%x\n", rdst); 8594 } 8595 SYNTAX("bnot #%1, %0%S0"); 8596 #line 889 "rx-decode.opc" 8597 ID(bnot); BWL(BSIZE); SC(bit); DD(sd, rdst, BSIZE); 8598 8599 } 8600 break; 8601 } 8602 break; 8603 case 0xe1: 8604 GETBYTE (); 8605 switch (op[2] & 0x0f) 8606 { 8607 case 0x00: 8608 case 0x01: 8609 case 0x02: 8610 case 0x03: 8611 case 0x04: 8612 case 0x05: 8613 case 0x06: 8614 case 0x07: 8615 case 0x08: 8616 case 0x09: 8617 case 0x0a: 8618 case 0x0b: 8619 case 0x0c: 8620 case 0x0d: 8621 case 0x0e: 8622 goto op_semantics_69; 8623 break; 8624 case 0x0f: 8625 goto op_semantics_70; 8626 break; 8627 } 8628 break; 8629 case 0xe2: 8630 GETBYTE (); 8631 switch (op[2] & 0x0f) 8632 { 8633 case 0x00: 8634 case 0x01: 8635 case 0x02: 8636 case 0x03: 8637 case 0x04: 8638 case 0x05: 8639 case 0x06: 8640 case 0x07: 8641 case 0x08: 8642 case 0x09: 8643 case 0x0a: 8644 case 0x0b: 8645 case 0x0c: 8646 case 0x0d: 8647 case 0x0e: 8648 goto op_semantics_69; 8649 break; 8650 case 0x0f: 8651 goto op_semantics_70; 8652 break; 8653 } 8654 break; 8655 case 0xe3: 8656 GETBYTE (); 8657 switch (op[2] & 0x0f) 8658 { 8659 case 0x00: 8660 case 0x01: 8661 case 0x02: 8662 case 0x03: 8663 case 0x04: 8664 case 0x05: 8665 case 0x06: 8666 case 0x07: 8667 case 0x08: 8668 case 0x09: 8669 case 0x0a: 8670 case 0x0b: 8671 case 0x0c: 8672 case 0x0d: 8673 case 0x0e: 8674 goto op_semantics_69; 8675 break; 8676 case 0x0f: 8677 goto op_semantics_70; 8678 break; 8679 } 8680 break; 8681 case 0xe4: 8682 GETBYTE (); 8683 switch (op[2] & 0x0f) 8684 { 8685 case 0x00: 8686 case 0x01: 8687 case 0x02: 8688 case 0x03: 8689 case 0x04: 8690 case 0x05: 8691 case 0x06: 8692 case 0x07: 8693 case 0x08: 8694 case 0x09: 8695 case 0x0a: 8696 case 0x0b: 8697 case 0x0c: 8698 case 0x0d: 8699 case 0x0e: 8700 goto op_semantics_69; 8701 break; 8702 case 0x0f: 8703 goto op_semantics_70; 8704 break; 8705 } 8706 break; 8707 case 0xe5: 8708 GETBYTE (); 8709 switch (op[2] & 0x0f) 8710 { 8711 case 0x00: 8712 case 0x01: 8713 case 0x02: 8714 case 0x03: 8715 case 0x04: 8716 case 0x05: 8717 case 0x06: 8718 case 0x07: 8719 case 0x08: 8720 case 0x09: 8721 case 0x0a: 8722 case 0x0b: 8723 case 0x0c: 8724 case 0x0d: 8725 case 0x0e: 8726 goto op_semantics_69; 8727 break; 8728 case 0x0f: 8729 goto op_semantics_70; 8730 break; 8731 } 8732 break; 8733 case 0xe6: 8734 GETBYTE (); 8735 switch (op[2] & 0x0f) 8736 { 8737 case 0x00: 8738 case 0x01: 8739 case 0x02: 8740 case 0x03: 8741 case 0x04: 8742 case 0x05: 8743 case 0x06: 8744 case 0x07: 8745 case 0x08: 8746 case 0x09: 8747 case 0x0a: 8748 case 0x0b: 8749 case 0x0c: 8750 case 0x0d: 8751 case 0x0e: 8752 goto op_semantics_69; 8753 break; 8754 case 0x0f: 8755 goto op_semantics_70; 8756 break; 8757 } 8758 break; 8759 case 0xe7: 8760 GETBYTE (); 8761 switch (op[2] & 0x0f) 8762 { 8763 case 0x00: 8764 case 0x01: 8765 case 0x02: 8766 case 0x03: 8767 case 0x04: 8768 case 0x05: 8769 case 0x06: 8770 case 0x07: 8771 case 0x08: 8772 case 0x09: 8773 case 0x0a: 8774 case 0x0b: 8775 case 0x0c: 8776 case 0x0d: 8777 case 0x0e: 8778 goto op_semantics_69; 8779 break; 8780 case 0x0f: 8781 goto op_semantics_70; 8782 break; 8783 } 8784 break; 8785 case 0xe8: 8786 GETBYTE (); 8787 switch (op[2] & 0x0f) 8788 { 8789 case 0x00: 8790 case 0x01: 8791 case 0x02: 8792 case 0x03: 8793 case 0x04: 8794 case 0x05: 8795 case 0x06: 8796 case 0x07: 8797 case 0x08: 8798 case 0x09: 8799 case 0x0a: 8800 case 0x0b: 8801 case 0x0c: 8802 case 0x0d: 8803 case 0x0e: 8804 goto op_semantics_69; 8805 break; 8806 case 0x0f: 8807 goto op_semantics_70; 8808 break; 8809 } 8810 break; 8811 case 0xe9: 8812 GETBYTE (); 8813 switch (op[2] & 0x0f) 8814 { 8815 case 0x00: 8816 case 0x01: 8817 case 0x02: 8818 case 0x03: 8819 case 0x04: 8820 case 0x05: 8821 case 0x06: 8822 case 0x07: 8823 case 0x08: 8824 case 0x09: 8825 case 0x0a: 8826 case 0x0b: 8827 case 0x0c: 8828 case 0x0d: 8829 case 0x0e: 8830 goto op_semantics_69; 8831 break; 8832 case 0x0f: 8833 goto op_semantics_70; 8834 break; 8835 } 8836 break; 8837 case 0xea: 8838 GETBYTE (); 8839 switch (op[2] & 0x0f) 8840 { 8841 case 0x00: 8842 case 0x01: 8843 case 0x02: 8844 case 0x03: 8845 case 0x04: 8846 case 0x05: 8847 case 0x06: 8848 case 0x07: 8849 case 0x08: 8850 case 0x09: 8851 case 0x0a: 8852 case 0x0b: 8853 case 0x0c: 8854 case 0x0d: 8855 case 0x0e: 8856 goto op_semantics_69; 8857 break; 8858 case 0x0f: 8859 goto op_semantics_70; 8860 break; 8861 } 8862 break; 8863 case 0xeb: 8864 GETBYTE (); 8865 switch (op[2] & 0x0f) 8866 { 8867 case 0x00: 8868 case 0x01: 8869 case 0x02: 8870 case 0x03: 8871 case 0x04: 8872 case 0x05: 8873 case 0x06: 8874 case 0x07: 8875 case 0x08: 8876 case 0x09: 8877 case 0x0a: 8878 case 0x0b: 8879 case 0x0c: 8880 case 0x0d: 8881 case 0x0e: 8882 goto op_semantics_69; 8883 break; 8884 case 0x0f: 8885 goto op_semantics_70; 8886 break; 8887 } 8888 break; 8889 case 0xec: 8890 GETBYTE (); 8891 switch (op[2] & 0x0f) 8892 { 8893 case 0x00: 8894 case 0x01: 8895 case 0x02: 8896 case 0x03: 8897 case 0x04: 8898 case 0x05: 8899 case 0x06: 8900 case 0x07: 8901 case 0x08: 8902 case 0x09: 8903 case 0x0a: 8904 case 0x0b: 8905 case 0x0c: 8906 case 0x0d: 8907 case 0x0e: 8908 goto op_semantics_69; 8909 break; 8910 case 0x0f: 8911 goto op_semantics_70; 8912 break; 8913 } 8914 break; 8915 case 0xed: 8916 GETBYTE (); 8917 switch (op[2] & 0x0f) 8918 { 8919 case 0x00: 8920 case 0x01: 8921 case 0x02: 8922 case 0x03: 8923 case 0x04: 8924 case 0x05: 8925 case 0x06: 8926 case 0x07: 8927 case 0x08: 8928 case 0x09: 8929 case 0x0a: 8930 case 0x0b: 8931 case 0x0c: 8932 case 0x0d: 8933 case 0x0e: 8934 goto op_semantics_69; 8935 break; 8936 case 0x0f: 8937 goto op_semantics_70; 8938 break; 8939 } 8940 break; 8941 case 0xee: 8942 GETBYTE (); 8943 switch (op[2] & 0x0f) 8944 { 8945 case 0x00: 8946 case 0x01: 8947 case 0x02: 8948 case 0x03: 8949 case 0x04: 8950 case 0x05: 8951 case 0x06: 8952 case 0x07: 8953 case 0x08: 8954 case 0x09: 8955 case 0x0a: 8956 case 0x0b: 8957 case 0x0c: 8958 case 0x0d: 8959 case 0x0e: 8960 goto op_semantics_69; 8961 break; 8962 case 0x0f: 8963 goto op_semantics_70; 8964 break; 8965 } 8966 break; 8967 case 0xef: 8968 GETBYTE (); 8969 switch (op[2] & 0x0f) 8970 { 8971 case 0x00: 8972 case 0x01: 8973 case 0x02: 8974 case 0x03: 8975 case 0x04: 8976 case 0x05: 8977 case 0x06: 8978 case 0x07: 8979 case 0x08: 8980 case 0x09: 8981 case 0x0a: 8982 case 0x0b: 8983 case 0x0c: 8984 case 0x0d: 8985 case 0x0e: 8986 goto op_semantics_69; 8987 break; 8988 case 0x0f: 8989 goto op_semantics_70; 8990 break; 8991 } 8992 break; 8993 case 0xf0: 8994 GETBYTE (); 8995 switch (op[2] & 0x0f) 8996 { 8997 case 0x00: 8998 case 0x01: 8999 case 0x02: 9000 case 0x03: 9001 case 0x04: 9002 case 0x05: 9003 case 0x06: 9004 case 0x07: 9005 case 0x08: 9006 case 0x09: 9007 case 0x0a: 9008 case 0x0b: 9009 case 0x0c: 9010 case 0x0d: 9011 case 0x0e: 9012 goto op_semantics_69; 9013 break; 9014 case 0x0f: 9015 goto op_semantics_70; 9016 break; 9017 } 9018 break; 9019 case 0xf1: 9020 GETBYTE (); 9021 switch (op[2] & 0x0f) 9022 { 9023 case 0x00: 9024 case 0x01: 9025 case 0x02: 9026 case 0x03: 9027 case 0x04: 9028 case 0x05: 9029 case 0x06: 9030 case 0x07: 9031 case 0x08: 9032 case 0x09: 9033 case 0x0a: 9034 case 0x0b: 9035 case 0x0c: 9036 case 0x0d: 9037 case 0x0e: 9038 goto op_semantics_69; 9039 break; 9040 case 0x0f: 9041 goto op_semantics_70; 9042 break; 9043 } 9044 break; 9045 case 0xf2: 9046 GETBYTE (); 9047 switch (op[2] & 0x0f) 9048 { 9049 case 0x00: 9050 case 0x01: 9051 case 0x02: 9052 case 0x03: 9053 case 0x04: 9054 case 0x05: 9055 case 0x06: 9056 case 0x07: 9057 case 0x08: 9058 case 0x09: 9059 case 0x0a: 9060 case 0x0b: 9061 case 0x0c: 9062 case 0x0d: 9063 case 0x0e: 9064 goto op_semantics_69; 9065 break; 9066 case 0x0f: 9067 goto op_semantics_70; 9068 break; 9069 } 9070 break; 9071 case 0xf3: 9072 GETBYTE (); 9073 switch (op[2] & 0x0f) 9074 { 9075 case 0x00: 9076 case 0x01: 9077 case 0x02: 9078 case 0x03: 9079 case 0x04: 9080 case 0x05: 9081 case 0x06: 9082 case 0x07: 9083 case 0x08: 9084 case 0x09: 9085 case 0x0a: 9086 case 0x0b: 9087 case 0x0c: 9088 case 0x0d: 9089 case 0x0e: 9090 goto op_semantics_69; 9091 break; 9092 case 0x0f: 9093 goto op_semantics_70; 9094 break; 9095 } 9096 break; 9097 case 0xf4: 9098 GETBYTE (); 9099 switch (op[2] & 0x0f) 9100 { 9101 case 0x00: 9102 case 0x01: 9103 case 0x02: 9104 case 0x03: 9105 case 0x04: 9106 case 0x05: 9107 case 0x06: 9108 case 0x07: 9109 case 0x08: 9110 case 0x09: 9111 case 0x0a: 9112 case 0x0b: 9113 case 0x0c: 9114 case 0x0d: 9115 case 0x0e: 9116 goto op_semantics_69; 9117 break; 9118 case 0x0f: 9119 goto op_semantics_70; 9120 break; 9121 } 9122 break; 9123 case 0xf5: 9124 GETBYTE (); 9125 switch (op[2] & 0x0f) 9126 { 9127 case 0x00: 9128 case 0x01: 9129 case 0x02: 9130 case 0x03: 9131 case 0x04: 9132 case 0x05: 9133 case 0x06: 9134 case 0x07: 9135 case 0x08: 9136 case 0x09: 9137 case 0x0a: 9138 case 0x0b: 9139 case 0x0c: 9140 case 0x0d: 9141 case 0x0e: 9142 goto op_semantics_69; 9143 break; 9144 case 0x0f: 9145 goto op_semantics_70; 9146 break; 9147 } 9148 break; 9149 case 0xf6: 9150 GETBYTE (); 9151 switch (op[2] & 0x0f) 9152 { 9153 case 0x00: 9154 case 0x01: 9155 case 0x02: 9156 case 0x03: 9157 case 0x04: 9158 case 0x05: 9159 case 0x06: 9160 case 0x07: 9161 case 0x08: 9162 case 0x09: 9163 case 0x0a: 9164 case 0x0b: 9165 case 0x0c: 9166 case 0x0d: 9167 case 0x0e: 9168 goto op_semantics_69; 9169 break; 9170 case 0x0f: 9171 goto op_semantics_70; 9172 break; 9173 } 9174 break; 9175 case 0xf7: 9176 GETBYTE (); 9177 switch (op[2] & 0x0f) 9178 { 9179 case 0x00: 9180 case 0x01: 9181 case 0x02: 9182 case 0x03: 9183 case 0x04: 9184 case 0x05: 9185 case 0x06: 9186 case 0x07: 9187 case 0x08: 9188 case 0x09: 9189 case 0x0a: 9190 case 0x0b: 9191 case 0x0c: 9192 case 0x0d: 9193 case 0x0e: 9194 goto op_semantics_69; 9195 break; 9196 case 0x0f: 9197 goto op_semantics_70; 9198 break; 9199 } 9200 break; 9201 case 0xf8: 9202 GETBYTE (); 9203 switch (op[2] & 0x0f) 9204 { 9205 case 0x00: 9206 case 0x01: 9207 case 0x02: 9208 case 0x03: 9209 case 0x04: 9210 case 0x05: 9211 case 0x06: 9212 case 0x07: 9213 case 0x08: 9214 case 0x09: 9215 case 0x0a: 9216 case 0x0b: 9217 case 0x0c: 9218 case 0x0d: 9219 case 0x0e: 9220 goto op_semantics_69; 9221 break; 9222 case 0x0f: 9223 goto op_semantics_70; 9224 break; 9225 } 9226 break; 9227 case 0xf9: 9228 GETBYTE (); 9229 switch (op[2] & 0x0f) 9230 { 9231 case 0x00: 9232 case 0x01: 9233 case 0x02: 9234 case 0x03: 9235 case 0x04: 9236 case 0x05: 9237 case 0x06: 9238 case 0x07: 9239 case 0x08: 9240 case 0x09: 9241 case 0x0a: 9242 case 0x0b: 9243 case 0x0c: 9244 case 0x0d: 9245 case 0x0e: 9246 goto op_semantics_69; 9247 break; 9248 case 0x0f: 9249 goto op_semantics_70; 9250 break; 9251 } 9252 break; 9253 case 0xfa: 9254 GETBYTE (); 9255 switch (op[2] & 0x0f) 9256 { 9257 case 0x00: 9258 case 0x01: 9259 case 0x02: 9260 case 0x03: 9261 case 0x04: 9262 case 0x05: 9263 case 0x06: 9264 case 0x07: 9265 case 0x08: 9266 case 0x09: 9267 case 0x0a: 9268 case 0x0b: 9269 case 0x0c: 9270 case 0x0d: 9271 case 0x0e: 9272 goto op_semantics_69; 9273 break; 9274 case 0x0f: 9275 goto op_semantics_70; 9276 break; 9277 } 9278 break; 9279 case 0xfb: 9280 GETBYTE (); 9281 switch (op[2] & 0x0f) 9282 { 9283 case 0x00: 9284 case 0x01: 9285 case 0x02: 9286 case 0x03: 9287 case 0x04: 9288 case 0x05: 9289 case 0x06: 9290 case 0x07: 9291 case 0x08: 9292 case 0x09: 9293 case 0x0a: 9294 case 0x0b: 9295 case 0x0c: 9296 case 0x0d: 9297 case 0x0e: 9298 goto op_semantics_69; 9299 break; 9300 case 0x0f: 9301 goto op_semantics_70; 9302 break; 9303 } 9304 break; 9305 case 0xfc: 9306 GETBYTE (); 9307 switch (op[2] & 0x0f) 9308 { 9309 case 0x00: 9310 case 0x01: 9311 case 0x02: 9312 case 0x03: 9313 case 0x04: 9314 case 0x05: 9315 case 0x06: 9316 case 0x07: 9317 case 0x08: 9318 case 0x09: 9319 case 0x0a: 9320 case 0x0b: 9321 case 0x0c: 9322 case 0x0d: 9323 case 0x0e: 9324 goto op_semantics_69; 9325 break; 9326 case 0x0f: 9327 goto op_semantics_70; 9328 break; 9329 } 9330 break; 9331 case 0xfd: 9332 GETBYTE (); 9333 switch (op[2] & 0x0f) 9334 { 9335 case 0x00: 9336 case 0x01: 9337 case 0x02: 9338 case 0x03: 9339 case 0x04: 9340 case 0x05: 9341 case 0x06: 9342 case 0x07: 9343 case 0x08: 9344 case 0x09: 9345 case 0x0a: 9346 case 0x0b: 9347 case 0x0c: 9348 case 0x0d: 9349 case 0x0e: 9350 goto op_semantics_69; 9351 break; 9352 case 0x0f: 9353 goto op_semantics_70; 9354 break; 9355 } 9356 break; 9357 case 0xfe: 9358 GETBYTE (); 9359 switch (op[2] & 0x0f) 9360 { 9361 case 0x00: 9362 case 0x01: 9363 case 0x02: 9364 case 0x03: 9365 case 0x04: 9366 case 0x05: 9367 case 0x06: 9368 case 0x07: 9369 case 0x08: 9370 case 0x09: 9371 case 0x0a: 9372 case 0x0b: 9373 case 0x0c: 9374 case 0x0d: 9375 case 0x0e: 9376 goto op_semantics_69; 9377 break; 9378 case 0x0f: 9379 goto op_semantics_70; 9380 break; 9381 } 9382 break; 9383 case 0xff: 9384 GETBYTE (); 9385 switch (op[2] & 0x0f) 9386 { 9387 case 0x00: 9388 case 0x01: 9389 case 0x02: 9390 case 0x03: 9391 case 0x04: 9392 case 0x05: 9393 case 0x06: 9394 case 0x07: 9395 case 0x08: 9396 case 0x09: 9397 case 0x0a: 9398 case 0x0b: 9399 case 0x0c: 9400 case 0x0d: 9401 case 0x0e: 9402 goto op_semantics_69; 9403 break; 9404 case 0x0f: 9405 goto op_semantics_70; 9406 break; 9407 } 9408 break; 9409 default: UNSUPPORTED(); break; 9410 } 9411 break; 9412 case 0xfd: 9413 GETBYTE (); 9414 switch (op[1] & 0xff) 9415 { 9416 case 0x00: 9417 GETBYTE (); 9418 switch (op[2] & 0x00) 9419 { 9420 case 0x00: 9421 { 9422 /** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */ 9423 #line 772 "rx-decode.opc" 9424 int srca AU = (op[2] >> 4) & 0x0f; 9425 #line 772 "rx-decode.opc" 9426 int srcb AU = op[2] & 0x0f; 9427 if (trace) 9428 { 9429 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9430 "/** 1111 1101 0000 0000 srca srcb mulhi %1, %2 */", 9431 op[0], op[1], op[2]); 9432 printf (" srca = 0x%x,", srca); 9433 printf (" srcb = 0x%x\n", srcb); 9434 } 9435 SYNTAX("mulhi %1, %2"); 9436 #line 772 "rx-decode.opc" 9437 ID(mulhi); SR(srca); S2R(srcb); F_____; 9438 9439 } 9440 break; 9441 } 9442 break; 9443 case 0x01: 9444 GETBYTE (); 9445 switch (op[2] & 0x00) 9446 { 9447 case 0x00: 9448 { 9449 /** 1111 1101 0000 0001 srca srcb mullo %1, %2 */ 9450 #line 775 "rx-decode.opc" 9451 int srca AU = (op[2] >> 4) & 0x0f; 9452 #line 775 "rx-decode.opc" 9453 int srcb AU = op[2] & 0x0f; 9454 if (trace) 9455 { 9456 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9457 "/** 1111 1101 0000 0001 srca srcb mullo %1, %2 */", 9458 op[0], op[1], op[2]); 9459 printf (" srca = 0x%x,", srca); 9460 printf (" srcb = 0x%x\n", srcb); 9461 } 9462 SYNTAX("mullo %1, %2"); 9463 #line 775 "rx-decode.opc" 9464 ID(mullo); SR(srca); S2R(srcb); F_____; 9465 9466 } 9467 break; 9468 } 9469 break; 9470 case 0x04: 9471 GETBYTE (); 9472 switch (op[2] & 0x00) 9473 { 9474 case 0x00: 9475 { 9476 /** 1111 1101 0000 0100 srca srcb machi %1, %2 */ 9477 #line 778 "rx-decode.opc" 9478 int srca AU = (op[2] >> 4) & 0x0f; 9479 #line 778 "rx-decode.opc" 9480 int srcb AU = op[2] & 0x0f; 9481 if (trace) 9482 { 9483 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9484 "/** 1111 1101 0000 0100 srca srcb machi %1, %2 */", 9485 op[0], op[1], op[2]); 9486 printf (" srca = 0x%x,", srca); 9487 printf (" srcb = 0x%x\n", srcb); 9488 } 9489 SYNTAX("machi %1, %2"); 9490 #line 778 "rx-decode.opc" 9491 ID(machi); SR(srca); S2R(srcb); F_____; 9492 9493 } 9494 break; 9495 } 9496 break; 9497 case 0x05: 9498 GETBYTE (); 9499 switch (op[2] & 0x00) 9500 { 9501 case 0x00: 9502 { 9503 /** 1111 1101 0000 0101 srca srcb maclo %1, %2 */ 9504 #line 781 "rx-decode.opc" 9505 int srca AU = (op[2] >> 4) & 0x0f; 9506 #line 781 "rx-decode.opc" 9507 int srcb AU = op[2] & 0x0f; 9508 if (trace) 9509 { 9510 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9511 "/** 1111 1101 0000 0101 srca srcb maclo %1, %2 */", 9512 op[0], op[1], op[2]); 9513 printf (" srca = 0x%x,", srca); 9514 printf (" srcb = 0x%x\n", srcb); 9515 } 9516 SYNTAX("maclo %1, %2"); 9517 #line 781 "rx-decode.opc" 9518 ID(maclo); SR(srca); S2R(srcb); F_____; 9519 9520 } 9521 break; 9522 } 9523 break; 9524 case 0x17: 9525 GETBYTE (); 9526 switch (op[2] & 0xf0) 9527 { 9528 case 0x00: 9529 { 9530 /** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */ 9531 #line 784 "rx-decode.opc" 9532 int rsrc AU = op[2] & 0x0f; 9533 if (trace) 9534 { 9535 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9536 "/** 1111 1101 0001 0111 0000 rsrc mvtachi %1 */", 9537 op[0], op[1], op[2]); 9538 printf (" rsrc = 0x%x\n", rsrc); 9539 } 9540 SYNTAX("mvtachi %1"); 9541 #line 784 "rx-decode.opc" 9542 ID(mvtachi); SR(rsrc); F_____; 9543 9544 } 9545 break; 9546 case 0x10: 9547 { 9548 /** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */ 9549 #line 787 "rx-decode.opc" 9550 int rsrc AU = op[2] & 0x0f; 9551 if (trace) 9552 { 9553 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9554 "/** 1111 1101 0001 0111 0001 rsrc mvtaclo %1 */", 9555 op[0], op[1], op[2]); 9556 printf (" rsrc = 0x%x\n", rsrc); 9557 } 9558 SYNTAX("mvtaclo %1"); 9559 #line 787 "rx-decode.opc" 9560 ID(mvtaclo); SR(rsrc); F_____; 9561 9562 } 9563 break; 9564 default: UNSUPPORTED(); break; 9565 } 9566 break; 9567 case 0x18: 9568 GETBYTE (); 9569 switch (op[2] & 0xef) 9570 { 9571 case 0x00: 9572 { 9573 /** 1111 1101 0001 1000 000i 0000 racw #%1 */ 9574 #line 799 "rx-decode.opc" 9575 int i AU = (op[2] >> 4) & 0x01; 9576 if (trace) 9577 { 9578 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9579 "/** 1111 1101 0001 1000 000i 0000 racw #%1 */", 9580 op[0], op[1], op[2]); 9581 printf (" i = 0x%x\n", i); 9582 } 9583 SYNTAX("racw #%1"); 9584 #line 799 "rx-decode.opc" 9585 ID(racw); SC(i+1); F_____; 9586 9587 /*----------------------------------------------------------------------*/ 9588 /* SAT */ 9589 9590 } 9591 break; 9592 default: UNSUPPORTED(); break; 9593 } 9594 break; 9595 case 0x1f: 9596 GETBYTE (); 9597 switch (op[2] & 0xf0) 9598 { 9599 case 0x00: 9600 { 9601 /** 1111 1101 0001 1111 0000 rdst mvfachi %0 */ 9602 #line 790 "rx-decode.opc" 9603 int rdst AU = op[2] & 0x0f; 9604 if (trace) 9605 { 9606 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9607 "/** 1111 1101 0001 1111 0000 rdst mvfachi %0 */", 9608 op[0], op[1], op[2]); 9609 printf (" rdst = 0x%x\n", rdst); 9610 } 9611 SYNTAX("mvfachi %0"); 9612 #line 790 "rx-decode.opc" 9613 ID(mvfachi); DR(rdst); F_____; 9614 9615 } 9616 break; 9617 case 0x10: 9618 { 9619 /** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */ 9620 #line 796 "rx-decode.opc" 9621 int rdst AU = op[2] & 0x0f; 9622 if (trace) 9623 { 9624 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9625 "/** 1111 1101 0001 1111 0001 rdst mvfaclo %0 */", 9626 op[0], op[1], op[2]); 9627 printf (" rdst = 0x%x\n", rdst); 9628 } 9629 SYNTAX("mvfaclo %0"); 9630 #line 796 "rx-decode.opc" 9631 ID(mvfaclo); DR(rdst); F_____; 9632 9633 } 9634 break; 9635 case 0x20: 9636 { 9637 /** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */ 9638 #line 793 "rx-decode.opc" 9639 int rdst AU = op[2] & 0x0f; 9640 if (trace) 9641 { 9642 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9643 "/** 1111 1101 0001 1111 0010 rdst mvfacmi %0 */", 9644 op[0], op[1], op[2]); 9645 printf (" rdst = 0x%x\n", rdst); 9646 } 9647 SYNTAX("mvfacmi %0"); 9648 #line 793 "rx-decode.opc" 9649 ID(mvfacmi); DR(rdst); F_____; 9650 9651 } 9652 break; 9653 default: UNSUPPORTED(); break; 9654 } 9655 break; 9656 case 0x20: 9657 GETBYTE (); 9658 switch (op[2] & 0x00) 9659 { 9660 case 0x00: 9661 op_semantics_71: 9662 { 9663 /** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */ 9664 #line 307 "rx-decode.opc" 9665 int p AU = (op[1] >> 2) & 0x01; 9666 #line 307 "rx-decode.opc" 9667 int sz AU = op[1] & 0x03; 9668 #line 307 "rx-decode.opc" 9669 int rdst AU = (op[2] >> 4) & 0x0f; 9670 #line 307 "rx-decode.opc" 9671 int rsrc AU = op[2] & 0x0f; 9672 if (trace) 9673 { 9674 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9675 "/** 1111 1101 0010 0p sz rdst rsrc mov%s %1, %0 */", 9676 op[0], op[1], op[2]); 9677 printf (" p = 0x%x,", p); 9678 printf (" sz = 0x%x,", sz); 9679 printf (" rdst = 0x%x,", rdst); 9680 printf (" rsrc = 0x%x\n", rsrc); 9681 } 9682 SYNTAX("mov%s %1, %0"); 9683 #line 307 "rx-decode.opc" 9684 ID(mov); sBWL (sz); SR(rsrc); F_____; 9685 OP(0, p ? RX_Operand_Predec : RX_Operand_Postinc, rdst, 0); 9686 9687 } 9688 break; 9689 } 9690 break; 9691 case 0x21: 9692 GETBYTE (); 9693 switch (op[2] & 0x00) 9694 { 9695 case 0x00: 9696 goto op_semantics_71; 9697 break; 9698 } 9699 break; 9700 case 0x22: 9701 GETBYTE (); 9702 switch (op[2] & 0x00) 9703 { 9704 case 0x00: 9705 goto op_semantics_71; 9706 break; 9707 } 9708 break; 9709 case 0x24: 9710 GETBYTE (); 9711 switch (op[2] & 0x00) 9712 { 9713 case 0x00: 9714 goto op_semantics_71; 9715 break; 9716 } 9717 break; 9718 case 0x25: 9719 GETBYTE (); 9720 switch (op[2] & 0x00) 9721 { 9722 case 0x00: 9723 goto op_semantics_71; 9724 break; 9725 } 9726 break; 9727 case 0x26: 9728 GETBYTE (); 9729 switch (op[2] & 0x00) 9730 { 9731 case 0x00: 9732 goto op_semantics_71; 9733 break; 9734 } 9735 break; 9736 case 0x28: 9737 GETBYTE (); 9738 switch (op[2] & 0x00) 9739 { 9740 case 0x00: 9741 op_semantics_72: 9742 { 9743 /** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */ 9744 #line 311 "rx-decode.opc" 9745 int p AU = (op[1] >> 2) & 0x01; 9746 #line 311 "rx-decode.opc" 9747 int sz AU = op[1] & 0x03; 9748 #line 311 "rx-decode.opc" 9749 int rsrc AU = (op[2] >> 4) & 0x0f; 9750 #line 311 "rx-decode.opc" 9751 int rdst AU = op[2] & 0x0f; 9752 if (trace) 9753 { 9754 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9755 "/** 1111 1101 0010 1p sz rsrc rdst mov%s %1, %0 */", 9756 op[0], op[1], op[2]); 9757 printf (" p = 0x%x,", p); 9758 printf (" sz = 0x%x,", sz); 9759 printf (" rsrc = 0x%x,", rsrc); 9760 printf (" rdst = 0x%x\n", rdst); 9761 } 9762 SYNTAX("mov%s %1, %0"); 9763 #line 311 "rx-decode.opc" 9764 ID(mov); sBWL (sz); DR(rdst); F_____; 9765 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 9766 9767 } 9768 break; 9769 } 9770 break; 9771 case 0x29: 9772 GETBYTE (); 9773 switch (op[2] & 0x00) 9774 { 9775 case 0x00: 9776 goto op_semantics_72; 9777 break; 9778 } 9779 break; 9780 case 0x2a: 9781 GETBYTE (); 9782 switch (op[2] & 0x00) 9783 { 9784 case 0x00: 9785 goto op_semantics_72; 9786 break; 9787 } 9788 break; 9789 case 0x2c: 9790 GETBYTE (); 9791 switch (op[2] & 0x00) 9792 { 9793 case 0x00: 9794 goto op_semantics_72; 9795 break; 9796 } 9797 break; 9798 case 0x2d: 9799 GETBYTE (); 9800 switch (op[2] & 0x00) 9801 { 9802 case 0x00: 9803 goto op_semantics_72; 9804 break; 9805 } 9806 break; 9807 case 0x2e: 9808 GETBYTE (); 9809 switch (op[2] & 0x00) 9810 { 9811 case 0x00: 9812 goto op_semantics_72; 9813 break; 9814 } 9815 break; 9816 case 0x38: 9817 GETBYTE (); 9818 switch (op[2] & 0x00) 9819 { 9820 case 0x00: 9821 op_semantics_73: 9822 { 9823 /** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */ 9824 #line 321 "rx-decode.opc" 9825 int p AU = (op[1] >> 2) & 0x01; 9826 #line 321 "rx-decode.opc" 9827 int sz AU = op[1] & 0x03; 9828 #line 321 "rx-decode.opc" 9829 int rsrc AU = (op[2] >> 4) & 0x0f; 9830 #line 321 "rx-decode.opc" 9831 int rdst AU = op[2] & 0x0f; 9832 if (trace) 9833 { 9834 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9835 "/** 1111 1101 0011 1p sz rsrc rdst movu%s %1, %0 */", 9836 op[0], op[1], op[2]); 9837 printf (" p = 0x%x,", p); 9838 printf (" sz = 0x%x,", sz); 9839 printf (" rsrc = 0x%x,", rsrc); 9840 printf (" rdst = 0x%x\n", rdst); 9841 } 9842 SYNTAX("movu%s %1, %0"); 9843 #line 321 "rx-decode.opc" 9844 ID(mov); uBWL (sz); DR(rdst); F_____; 9845 OP(1, p ? RX_Operand_Predec : RX_Operand_Postinc, rsrc, 0); 9846 9847 /*----------------------------------------------------------------------*/ 9848 /* PUSH/POP */ 9849 9850 } 9851 break; 9852 } 9853 break; 9854 case 0x39: 9855 GETBYTE (); 9856 switch (op[2] & 0x00) 9857 { 9858 case 0x00: 9859 goto op_semantics_73; 9860 break; 9861 } 9862 break; 9863 case 0x3a: 9864 GETBYTE (); 9865 switch (op[2] & 0x00) 9866 { 9867 case 0x00: 9868 goto op_semantics_73; 9869 break; 9870 } 9871 break; 9872 case 0x3c: 9873 GETBYTE (); 9874 switch (op[2] & 0x00) 9875 { 9876 case 0x00: 9877 goto op_semantics_73; 9878 break; 9879 } 9880 break; 9881 case 0x3d: 9882 GETBYTE (); 9883 switch (op[2] & 0x00) 9884 { 9885 case 0x00: 9886 goto op_semantics_73; 9887 break; 9888 } 9889 break; 9890 case 0x3e: 9891 GETBYTE (); 9892 switch (op[2] & 0x00) 9893 { 9894 case 0x00: 9895 goto op_semantics_73; 9896 break; 9897 } 9898 break; 9899 case 0x60: 9900 GETBYTE (); 9901 switch (op[2] & 0x00) 9902 { 9903 case 0x00: 9904 { 9905 /** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */ 9906 #line 653 "rx-decode.opc" 9907 int rsrc AU = (op[2] >> 4) & 0x0f; 9908 #line 653 "rx-decode.opc" 9909 int rdst AU = op[2] & 0x0f; 9910 if (trace) 9911 { 9912 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9913 "/** 1111 1101 0110 0000 rsrc rdst shlr %2, %0 */", 9914 op[0], op[1], op[2]); 9915 printf (" rsrc = 0x%x,", rsrc); 9916 printf (" rdst = 0x%x\n", rdst); 9917 } 9918 SYNTAX("shlr %2, %0"); 9919 #line 653 "rx-decode.opc" 9920 ID(shlr); S2R(rsrc); SR(rdst); DR(rdst); F__SZC; 9921 9922 } 9923 break; 9924 } 9925 break; 9926 case 0x61: 9927 GETBYTE (); 9928 switch (op[2] & 0x00) 9929 { 9930 case 0x00: 9931 { 9932 /** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */ 9933 #line 643 "rx-decode.opc" 9934 int rsrc AU = (op[2] >> 4) & 0x0f; 9935 #line 643 "rx-decode.opc" 9936 int rdst AU = op[2] & 0x0f; 9937 if (trace) 9938 { 9939 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9940 "/** 1111 1101 0110 0001 rsrc rdst shar %2, %0 */", 9941 op[0], op[1], op[2]); 9942 printf (" rsrc = 0x%x,", rsrc); 9943 printf (" rdst = 0x%x\n", rdst); 9944 } 9945 SYNTAX("shar %2, %0"); 9946 #line 643 "rx-decode.opc" 9947 ID(shar); S2R(rsrc); SR(rdst); DR(rdst); F_0SZC; 9948 9949 } 9950 break; 9951 } 9952 break; 9953 case 0x62: 9954 GETBYTE (); 9955 switch (op[2] & 0x00) 9956 { 9957 case 0x00: 9958 { 9959 /** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */ 9960 #line 633 "rx-decode.opc" 9961 int rsrc AU = (op[2] >> 4) & 0x0f; 9962 #line 633 "rx-decode.opc" 9963 int rdst AU = op[2] & 0x0f; 9964 if (trace) 9965 { 9966 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9967 "/** 1111 1101 0110 0010 rsrc rdst shll %2, %0 */", 9968 op[0], op[1], op[2]); 9969 printf (" rsrc = 0x%x,", rsrc); 9970 printf (" rdst = 0x%x\n", rdst); 9971 } 9972 SYNTAX("shll %2, %0"); 9973 #line 633 "rx-decode.opc" 9974 ID(shll); S2R(rsrc); SR(rdst); DR(rdst); F_OSZC; 9975 9976 } 9977 break; 9978 } 9979 break; 9980 case 0x64: 9981 GETBYTE (); 9982 switch (op[2] & 0x00) 9983 { 9984 case 0x00: 9985 { 9986 /** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */ 9987 #line 677 "rx-decode.opc" 9988 int rsrc AU = (op[2] >> 4) & 0x0f; 9989 #line 677 "rx-decode.opc" 9990 int rdst AU = op[2] & 0x0f; 9991 if (trace) 9992 { 9993 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 9994 "/** 1111 1101 0110 0100 rsrc rdst rotr %1, %0 */", 9995 op[0], op[1], op[2]); 9996 printf (" rsrc = 0x%x,", rsrc); 9997 printf (" rdst = 0x%x\n", rdst); 9998 } 9999 SYNTAX("rotr %1, %0"); 10000 #line 677 "rx-decode.opc" 10001 ID(rotr); SR(rsrc); DR(rdst); F__SZC; 10002 10003 } 10004 break; 10005 } 10006 break; 10007 case 0x65: 10008 GETBYTE (); 10009 switch (op[2] & 0x00) 10010 { 10011 case 0x00: 10012 { 10013 /** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */ 10014 #line 680 "rx-decode.opc" 10015 int rsrc AU = (op[2] >> 4) & 0x0f; 10016 #line 680 "rx-decode.opc" 10017 int rdst AU = op[2] & 0x0f; 10018 if (trace) 10019 { 10020 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10021 "/** 1111 1101 0110 0101 rsrc rdst revw %1, %0 */", 10022 op[0], op[1], op[2]); 10023 printf (" rsrc = 0x%x,", rsrc); 10024 printf (" rdst = 0x%x\n", rdst); 10025 } 10026 SYNTAX("revw %1, %0"); 10027 #line 680 "rx-decode.opc" 10028 ID(revw); SR(rsrc); DR(rdst); 10029 10030 } 10031 break; 10032 } 10033 break; 10034 case 0x66: 10035 GETBYTE (); 10036 switch (op[2] & 0x00) 10037 { 10038 case 0x00: 10039 { 10040 /** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */ 10041 #line 671 "rx-decode.opc" 10042 int rsrc AU = (op[2] >> 4) & 0x0f; 10043 #line 671 "rx-decode.opc" 10044 int rdst AU = op[2] & 0x0f; 10045 if (trace) 10046 { 10047 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10048 "/** 1111 1101 0110 0110 rsrc rdst rotl %1, %0 */", 10049 op[0], op[1], op[2]); 10050 printf (" rsrc = 0x%x,", rsrc); 10051 printf (" rdst = 0x%x\n", rdst); 10052 } 10053 SYNTAX("rotl %1, %0"); 10054 #line 671 "rx-decode.opc" 10055 ID(rotl); SR(rsrc); DR(rdst); F__SZC; 10056 10057 } 10058 break; 10059 } 10060 break; 10061 case 0x67: 10062 GETBYTE (); 10063 switch (op[2] & 0x00) 10064 { 10065 case 0x00: 10066 { 10067 /** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */ 10068 #line 683 "rx-decode.opc" 10069 int rsrc AU = (op[2] >> 4) & 0x0f; 10070 #line 683 "rx-decode.opc" 10071 int rdst AU = op[2] & 0x0f; 10072 if (trace) 10073 { 10074 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10075 "/** 1111 1101 0110 0111 rsrc rdst revl %1, %0 */", 10076 op[0], op[1], op[2]); 10077 printf (" rsrc = 0x%x,", rsrc); 10078 printf (" rdst = 0x%x\n", rdst); 10079 } 10080 SYNTAX("revl %1, %0"); 10081 #line 683 "rx-decode.opc" 10082 ID(revl); SR(rsrc); DR(rdst); 10083 10084 /*----------------------------------------------------------------------*/ 10085 /* BRANCH */ 10086 10087 } 10088 break; 10089 } 10090 break; 10091 case 0x68: 10092 GETBYTE (); 10093 switch (op[2] & 0x00) 10094 { 10095 case 0x00: 10096 op_semantics_74: 10097 { 10098 /** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */ 10099 #line 926 "rx-decode.opc" 10100 int c AU = op[1] & 0x01; 10101 #line 926 "rx-decode.opc" 10102 int rsrc AU = (op[2] >> 4) & 0x0f; 10103 #line 926 "rx-decode.opc" 10104 int rdst AU = op[2] & 0x0f; 10105 if (trace) 10106 { 10107 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10108 "/** 1111 1101 0110 100c rsrc rdst mvtc %1, %0 */", 10109 op[0], op[1], op[2]); 10110 printf (" c = 0x%x,", c); 10111 printf (" rsrc = 0x%x,", rsrc); 10112 printf (" rdst = 0x%x\n", rdst); 10113 } 10114 SYNTAX("mvtc %1, %0"); 10115 #line 926 "rx-decode.opc" 10116 ID(mov); SR(rsrc); DR(c*16+rdst + 16); 10117 10118 } 10119 break; 10120 } 10121 break; 10122 case 0x69: 10123 GETBYTE (); 10124 switch (op[2] & 0x00) 10125 { 10126 case 0x00: 10127 goto op_semantics_74; 10128 break; 10129 } 10130 break; 10131 case 0x6a: 10132 GETBYTE (); 10133 switch (op[2] & 0x00) 10134 { 10135 case 0x00: 10136 op_semantics_75: 10137 { 10138 /** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */ 10139 #line 929 "rx-decode.opc" 10140 int s AU = op[1] & 0x01; 10141 #line 929 "rx-decode.opc" 10142 int rsrc AU = (op[2] >> 4) & 0x0f; 10143 #line 929 "rx-decode.opc" 10144 int rdst AU = op[2] & 0x0f; 10145 if (trace) 10146 { 10147 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10148 "/** 1111 1101 0110 101s rsrc rdst mvfc %1, %0 */", 10149 op[0], op[1], op[2]); 10150 printf (" s = 0x%x,", s); 10151 printf (" rsrc = 0x%x,", rsrc); 10152 printf (" rdst = 0x%x\n", rdst); 10153 } 10154 SYNTAX("mvfc %1, %0"); 10155 #line 929 "rx-decode.opc" 10156 ID(mov); SR((s*16+rsrc) + 16); DR(rdst); 10157 10158 /*----------------------------------------------------------------------*/ 10159 /* INTERRUPTS */ 10160 10161 } 10162 break; 10163 } 10164 break; 10165 case 0x6b: 10166 GETBYTE (); 10167 switch (op[2] & 0x00) 10168 { 10169 case 0x00: 10170 goto op_semantics_75; 10171 break; 10172 } 10173 break; 10174 case 0x6c: 10175 GETBYTE (); 10176 switch (op[2] & 0x00) 10177 { 10178 case 0x00: 10179 op_semantics_76: 10180 { 10181 /** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */ 10182 #line 674 "rx-decode.opc" 10183 int i AU = op[1] & 0x01; 10184 #line 674 "rx-decode.opc" 10185 int mmmm AU = (op[2] >> 4) & 0x0f; 10186 #line 674 "rx-decode.opc" 10187 int rdst AU = op[2] & 0x0f; 10188 if (trace) 10189 { 10190 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10191 "/** 1111 1101 0110 110i mmmm rdst rotr #%1, %0 */", 10192 op[0], op[1], op[2]); 10193 printf (" i = 0x%x,", i); 10194 printf (" mmmm = 0x%x,", mmmm); 10195 printf (" rdst = 0x%x\n", rdst); 10196 } 10197 SYNTAX("rotr #%1, %0"); 10198 #line 674 "rx-decode.opc" 10199 ID(rotr); SC(i*16+mmmm); DR(rdst); F__SZC; 10200 10201 } 10202 break; 10203 } 10204 break; 10205 case 0x6d: 10206 GETBYTE (); 10207 switch (op[2] & 0x00) 10208 { 10209 case 0x00: 10210 goto op_semantics_76; 10211 break; 10212 } 10213 break; 10214 case 0x6e: 10215 GETBYTE (); 10216 switch (op[2] & 0x00) 10217 { 10218 case 0x00: 10219 op_semantics_77: 10220 { 10221 /** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */ 10222 #line 668 "rx-decode.opc" 10223 int i AU = op[1] & 0x01; 10224 #line 668 "rx-decode.opc" 10225 int mmmm AU = (op[2] >> 4) & 0x0f; 10226 #line 668 "rx-decode.opc" 10227 int rdst AU = op[2] & 0x0f; 10228 if (trace) 10229 { 10230 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10231 "/** 1111 1101 0110 111i mmmm rdst rotl #%1, %0 */", 10232 op[0], op[1], op[2]); 10233 printf (" i = 0x%x,", i); 10234 printf (" mmmm = 0x%x,", mmmm); 10235 printf (" rdst = 0x%x\n", rdst); 10236 } 10237 SYNTAX("rotl #%1, %0"); 10238 #line 668 "rx-decode.opc" 10239 ID(rotl); SC(i*16+mmmm); DR(rdst); F__SZC; 10240 10241 } 10242 break; 10243 } 10244 break; 10245 case 0x6f: 10246 GETBYTE (); 10247 switch (op[2] & 0x00) 10248 { 10249 case 0x00: 10250 goto op_semantics_77; 10251 break; 10252 } 10253 break; 10254 case 0x70: 10255 GETBYTE (); 10256 switch (op[2] & 0xf0) 10257 { 10258 case 0x20: 10259 op_semantics_78: 10260 { 10261 /** 1111 1101 0111 im00 0010rdst adc #%1, %0 */ 10262 #line 451 "rx-decode.opc" 10263 int im AU = (op[1] >> 2) & 0x03; 10264 #line 451 "rx-decode.opc" 10265 int rdst AU = op[2] & 0x0f; 10266 if (trace) 10267 { 10268 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10269 "/** 1111 1101 0111 im00 0010rdst adc #%1, %0 */", 10270 op[0], op[1], op[2]); 10271 printf (" im = 0x%x,", im); 10272 printf (" rdst = 0x%x\n", rdst); 10273 } 10274 SYNTAX("adc #%1, %0"); 10275 #line 451 "rx-decode.opc" 10276 ID(adc); SC(IMMex(im)); DR(rdst); F_OSZC; 10277 10278 } 10279 break; 10280 case 0x40: 10281 op_semantics_79: 10282 { 10283 /** 1111 1101 0111 im00 0100rdst max #%1, %0 */ 10284 #line 533 "rx-decode.opc" 10285 int im AU = (op[1] >> 2) & 0x03; 10286 #line 533 "rx-decode.opc" 10287 int rdst AU = op[2] & 0x0f; 10288 if (trace) 10289 { 10290 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10291 "/** 1111 1101 0111 im00 0100rdst max #%1, %0 */", 10292 op[0], op[1], op[2]); 10293 printf (" im = 0x%x,", im); 10294 printf (" rdst = 0x%x\n", rdst); 10295 } 10296 SYNTAX("max #%1, %0"); 10297 #line 533 "rx-decode.opc" 10298 ID(max); DR(rdst); SC(IMMex(im)); 10299 10300 } 10301 break; 10302 case 0x50: 10303 op_semantics_80: 10304 { 10305 /** 1111 1101 0111 im00 0101rdst min #%1, %0 */ 10306 #line 552 "rx-decode.opc" 10307 int im AU = (op[1] >> 2) & 0x03; 10308 #line 552 "rx-decode.opc" 10309 int rdst AU = op[2] & 0x0f; 10310 if (trace) 10311 { 10312 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10313 "/** 1111 1101 0111 im00 0101rdst min #%1, %0 */", 10314 op[0], op[1], op[2]); 10315 printf (" im = 0x%x,", im); 10316 printf (" rdst = 0x%x\n", rdst); 10317 } 10318 SYNTAX("min #%1, %0"); 10319 #line 552 "rx-decode.opc" 10320 ID(min); DR(rdst); SC(IMMex(im)); 10321 10322 } 10323 break; 10324 case 0x60: 10325 op_semantics_81: 10326 { 10327 /** 1111 1101 0111 im00 0110rdst emul #%1, %0 */ 10328 #line 582 "rx-decode.opc" 10329 int im AU = (op[1] >> 2) & 0x03; 10330 #line 582 "rx-decode.opc" 10331 int rdst AU = op[2] & 0x0f; 10332 if (trace) 10333 { 10334 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10335 "/** 1111 1101 0111 im00 0110rdst emul #%1, %0 */", 10336 op[0], op[1], op[2]); 10337 printf (" im = 0x%x,", im); 10338 printf (" rdst = 0x%x\n", rdst); 10339 } 10340 SYNTAX("emul #%1, %0"); 10341 #line 582 "rx-decode.opc" 10342 ID(emul); DR(rdst); SC(IMMex(im)); 10343 10344 } 10345 break; 10346 case 0x70: 10347 op_semantics_82: 10348 { 10349 /** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */ 10350 #line 594 "rx-decode.opc" 10351 int im AU = (op[1] >> 2) & 0x03; 10352 #line 594 "rx-decode.opc" 10353 int rdst AU = op[2] & 0x0f; 10354 if (trace) 10355 { 10356 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10357 "/** 1111 1101 0111 im00 0111rdst emulu #%1, %0 */", 10358 op[0], op[1], op[2]); 10359 printf (" im = 0x%x,", im); 10360 printf (" rdst = 0x%x\n", rdst); 10361 } 10362 SYNTAX("emulu #%1, %0"); 10363 #line 594 "rx-decode.opc" 10364 ID(emulu); DR(rdst); SC(IMMex(im)); 10365 10366 } 10367 break; 10368 case 0x80: 10369 op_semantics_83: 10370 { 10371 /** 1111 1101 0111 im00 1000rdst div #%1, %0 */ 10372 #line 606 "rx-decode.opc" 10373 int im AU = (op[1] >> 2) & 0x03; 10374 #line 606 "rx-decode.opc" 10375 int rdst AU = op[2] & 0x0f; 10376 if (trace) 10377 { 10378 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10379 "/** 1111 1101 0111 im00 1000rdst div #%1, %0 */", 10380 op[0], op[1], op[2]); 10381 printf (" im = 0x%x,", im); 10382 printf (" rdst = 0x%x\n", rdst); 10383 } 10384 SYNTAX("div #%1, %0"); 10385 #line 606 "rx-decode.opc" 10386 ID(div); DR(rdst); SC(IMMex(im)); F_O___; 10387 10388 } 10389 break; 10390 case 0x90: 10391 op_semantics_84: 10392 { 10393 /** 1111 1101 0111 im00 1001rdst divu #%1, %0 */ 10394 #line 618 "rx-decode.opc" 10395 int im AU = (op[1] >> 2) & 0x03; 10396 #line 618 "rx-decode.opc" 10397 int rdst AU = op[2] & 0x0f; 10398 if (trace) 10399 { 10400 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10401 "/** 1111 1101 0111 im00 1001rdst divu #%1, %0 */", 10402 op[0], op[1], op[2]); 10403 printf (" im = 0x%x,", im); 10404 printf (" rdst = 0x%x\n", rdst); 10405 } 10406 SYNTAX("divu #%1, %0"); 10407 #line 618 "rx-decode.opc" 10408 ID(divu); DR(rdst); SC(IMMex(im)); F_O___; 10409 10410 } 10411 break; 10412 case 0xc0: 10413 op_semantics_85: 10414 { 10415 /** 1111 1101 0111 im00 1100rdst tst #%1, %2 */ 10416 #line 430 "rx-decode.opc" 10417 int im AU = (op[1] >> 2) & 0x03; 10418 #line 430 "rx-decode.opc" 10419 int rdst AU = op[2] & 0x0f; 10420 if (trace) 10421 { 10422 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10423 "/** 1111 1101 0111 im00 1100rdst tst #%1, %2 */", 10424 op[0], op[1], op[2]); 10425 printf (" im = 0x%x,", im); 10426 printf (" rdst = 0x%x\n", rdst); 10427 } 10428 SYNTAX("tst #%1, %2"); 10429 #line 430 "rx-decode.opc" 10430 ID(and); SC(IMMex(im)); S2R(rdst); F__SZ_; 10431 10432 } 10433 break; 10434 case 0xd0: 10435 op_semantics_86: 10436 { 10437 /** 1111 1101 0111 im00 1101rdst xor #%1, %0 */ 10438 #line 409 "rx-decode.opc" 10439 int im AU = (op[1] >> 2) & 0x03; 10440 #line 409 "rx-decode.opc" 10441 int rdst AU = op[2] & 0x0f; 10442 if (trace) 10443 { 10444 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10445 "/** 1111 1101 0111 im00 1101rdst xor #%1, %0 */", 10446 op[0], op[1], op[2]); 10447 printf (" im = 0x%x,", im); 10448 printf (" rdst = 0x%x\n", rdst); 10449 } 10450 SYNTAX("xor #%1, %0"); 10451 #line 409 "rx-decode.opc" 10452 ID(xor); SC(IMMex(im)); DR(rdst); F__SZ_; 10453 10454 } 10455 break; 10456 case 0xe0: 10457 op_semantics_87: 10458 { 10459 /** 1111 1101 0111 im00 1110rdst stz #%1, %0 */ 10460 #line 355 "rx-decode.opc" 10461 int im AU = (op[1] >> 2) & 0x03; 10462 #line 355 "rx-decode.opc" 10463 int rdst AU = op[2] & 0x0f; 10464 if (trace) 10465 { 10466 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10467 "/** 1111 1101 0111 im00 1110rdst stz #%1, %0 */", 10468 op[0], op[1], op[2]); 10469 printf (" im = 0x%x,", im); 10470 printf (" rdst = 0x%x\n", rdst); 10471 } 10472 SYNTAX("stz #%1, %0"); 10473 #line 355 "rx-decode.opc" 10474 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_z); 10475 10476 } 10477 break; 10478 case 0xf0: 10479 op_semantics_88: 10480 { 10481 /** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */ 10482 #line 358 "rx-decode.opc" 10483 int im AU = (op[1] >> 2) & 0x03; 10484 #line 358 "rx-decode.opc" 10485 int rdst AU = op[2] & 0x0f; 10486 if (trace) 10487 { 10488 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10489 "/** 1111 1101 0111 im00 1111rdst stnz #%1, %0 */", 10490 op[0], op[1], op[2]); 10491 printf (" im = 0x%x,", im); 10492 printf (" rdst = 0x%x\n", rdst); 10493 } 10494 SYNTAX("stnz #%1, %0"); 10495 #line 358 "rx-decode.opc" 10496 ID(stcc); SC(IMMex(im)); DR(rdst); S2cc(RXC_nz); 10497 10498 /*----------------------------------------------------------------------*/ 10499 /* RTSD */ 10500 10501 } 10502 break; 10503 default: UNSUPPORTED(); break; 10504 } 10505 break; 10506 case 0x72: 10507 GETBYTE (); 10508 switch (op[2] & 0xf0) 10509 { 10510 case 0x00: 10511 { 10512 /** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */ 10513 #line 826 "rx-decode.opc" 10514 int rdst AU = op[2] & 0x0f; 10515 if (trace) 10516 { 10517 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10518 "/** 1111 1101 0111 0010 0000 rdst fsub #%1, %0 */", 10519 op[0], op[1], op[2]); 10520 printf (" rdst = 0x%x\n", rdst); 10521 } 10522 SYNTAX("fsub #%1, %0"); 10523 #line 826 "rx-decode.opc" 10524 ID(fsub); DR(rdst); SC(IMM(0)); F__SZ_; 10525 10526 } 10527 break; 10528 case 0x10: 10529 { 10530 /** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */ 10531 #line 820 "rx-decode.opc" 10532 int rdst AU = op[2] & 0x0f; 10533 if (trace) 10534 { 10535 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10536 "/** 1111 1101 0111 0010 0001 rdst fcmp #%1, %0 */", 10537 op[0], op[1], op[2]); 10538 printf (" rdst = 0x%x\n", rdst); 10539 } 10540 SYNTAX("fcmp #%1, %0"); 10541 #line 820 "rx-decode.opc" 10542 ID(fcmp); DR(rdst); SC(IMM(0)); F_OSZ_; 10543 10544 } 10545 break; 10546 case 0x20: 10547 { 10548 /** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */ 10549 #line 814 "rx-decode.opc" 10550 int rdst AU = op[2] & 0x0f; 10551 if (trace) 10552 { 10553 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10554 "/** 1111 1101 0111 0010 0010 rdst fadd #%1, %0 */", 10555 op[0], op[1], op[2]); 10556 printf (" rdst = 0x%x\n", rdst); 10557 } 10558 SYNTAX("fadd #%1, %0"); 10559 #line 814 "rx-decode.opc" 10560 ID(fadd); DR(rdst); SC(IMM(0)); F__SZ_; 10561 10562 } 10563 break; 10564 case 0x30: 10565 { 10566 /** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */ 10567 #line 835 "rx-decode.opc" 10568 int rdst AU = op[2] & 0x0f; 10569 if (trace) 10570 { 10571 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10572 "/** 1111 1101 0111 0010 0011 rdst fmul #%1, %0 */", 10573 op[0], op[1], op[2]); 10574 printf (" rdst = 0x%x\n", rdst); 10575 } 10576 SYNTAX("fmul #%1, %0"); 10577 #line 835 "rx-decode.opc" 10578 ID(fmul); DR(rdst); SC(IMM(0)); F__SZ_; 10579 10580 } 10581 break; 10582 case 0x40: 10583 { 10584 /** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */ 10585 #line 841 "rx-decode.opc" 10586 int rdst AU = op[2] & 0x0f; 10587 if (trace) 10588 { 10589 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10590 "/** 1111 1101 0111 0010 0100 rdst fdiv #%1, %0 */", 10591 op[0], op[1], op[2]); 10592 printf (" rdst = 0x%x\n", rdst); 10593 } 10594 SYNTAX("fdiv #%1, %0"); 10595 #line 841 "rx-decode.opc" 10596 ID(fdiv); DR(rdst); SC(IMM(0)); F__SZ_; 10597 10598 } 10599 break; 10600 default: UNSUPPORTED(); break; 10601 } 10602 break; 10603 case 0x73: 10604 GETBYTE (); 10605 switch (op[2] & 0xe0) 10606 { 10607 case 0x00: 10608 op_semantics_89: 10609 { 10610 /** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */ 10611 #line 923 "rx-decode.opc" 10612 int im AU = (op[1] >> 2) & 0x03; 10613 #line 923 "rx-decode.opc" 10614 int crdst AU = op[2] & 0x1f; 10615 if (trace) 10616 { 10617 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10618 "/** 1111 1101 0111 im11 000crdst mvtc #%1, %0 */", 10619 op[0], op[1], op[2]); 10620 printf (" im = 0x%x,", im); 10621 printf (" crdst = 0x%x\n", crdst); 10622 } 10623 SYNTAX("mvtc #%1, %0"); 10624 #line 923 "rx-decode.opc" 10625 ID(mov); SC(IMMex(im)); DR(crdst + 16); 10626 10627 } 10628 break; 10629 default: UNSUPPORTED(); break; 10630 } 10631 break; 10632 case 0x74: 10633 GETBYTE (); 10634 switch (op[2] & 0xf0) 10635 { 10636 case 0x20: 10637 goto op_semantics_78; 10638 break; 10639 case 0x40: 10640 goto op_semantics_79; 10641 break; 10642 case 0x50: 10643 goto op_semantics_80; 10644 break; 10645 case 0x60: 10646 goto op_semantics_81; 10647 break; 10648 case 0x70: 10649 goto op_semantics_82; 10650 break; 10651 case 0x80: 10652 goto op_semantics_83; 10653 break; 10654 case 0x90: 10655 goto op_semantics_84; 10656 break; 10657 case 0xc0: 10658 goto op_semantics_85; 10659 break; 10660 case 0xd0: 10661 goto op_semantics_86; 10662 break; 10663 case 0xe0: 10664 goto op_semantics_87; 10665 break; 10666 case 0xf0: 10667 goto op_semantics_88; 10668 break; 10669 default: UNSUPPORTED(); break; 10670 } 10671 break; 10672 case 0x77: 10673 GETBYTE (); 10674 switch (op[2] & 0xe0) 10675 { 10676 case 0x00: 10677 goto op_semantics_89; 10678 break; 10679 default: UNSUPPORTED(); break; 10680 } 10681 break; 10682 case 0x78: 10683 GETBYTE (); 10684 switch (op[2] & 0xf0) 10685 { 10686 case 0x20: 10687 goto op_semantics_78; 10688 break; 10689 case 0x40: 10690 goto op_semantics_79; 10691 break; 10692 case 0x50: 10693 goto op_semantics_80; 10694 break; 10695 case 0x60: 10696 goto op_semantics_81; 10697 break; 10698 case 0x70: 10699 goto op_semantics_82; 10700 break; 10701 case 0x80: 10702 goto op_semantics_83; 10703 break; 10704 case 0x90: 10705 goto op_semantics_84; 10706 break; 10707 case 0xc0: 10708 goto op_semantics_85; 10709 break; 10710 case 0xd0: 10711 goto op_semantics_86; 10712 break; 10713 case 0xe0: 10714 goto op_semantics_87; 10715 break; 10716 case 0xf0: 10717 goto op_semantics_88; 10718 break; 10719 default: UNSUPPORTED(); break; 10720 } 10721 break; 10722 case 0x7b: 10723 GETBYTE (); 10724 switch (op[2] & 0xe0) 10725 { 10726 case 0x00: 10727 goto op_semantics_89; 10728 break; 10729 default: UNSUPPORTED(); break; 10730 } 10731 break; 10732 case 0x7c: 10733 GETBYTE (); 10734 switch (op[2] & 0xf0) 10735 { 10736 case 0x20: 10737 goto op_semantics_78; 10738 break; 10739 case 0x40: 10740 goto op_semantics_79; 10741 break; 10742 case 0x50: 10743 goto op_semantics_80; 10744 break; 10745 case 0x60: 10746 goto op_semantics_81; 10747 break; 10748 case 0x70: 10749 goto op_semantics_82; 10750 break; 10751 case 0x80: 10752 goto op_semantics_83; 10753 break; 10754 case 0x90: 10755 goto op_semantics_84; 10756 break; 10757 case 0xc0: 10758 goto op_semantics_85; 10759 break; 10760 case 0xd0: 10761 goto op_semantics_86; 10762 break; 10763 case 0xe0: 10764 goto op_semantics_87; 10765 break; 10766 case 0xf0: 10767 goto op_semantics_88; 10768 break; 10769 default: UNSUPPORTED(); break; 10770 } 10771 break; 10772 case 0x7f: 10773 GETBYTE (); 10774 switch (op[2] & 0xe0) 10775 { 10776 case 0x00: 10777 goto op_semantics_89; 10778 break; 10779 default: UNSUPPORTED(); break; 10780 } 10781 break; 10782 case 0x80: 10783 GETBYTE (); 10784 switch (op[2] & 0x00) 10785 { 10786 case 0x00: 10787 op_semantics_90: 10788 { 10789 /** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */ 10790 #line 656 "rx-decode.opc" 10791 int immmm AU = op[1] & 0x1f; 10792 #line 656 "rx-decode.opc" 10793 int rsrc AU = (op[2] >> 4) & 0x0f; 10794 #line 656 "rx-decode.opc" 10795 int rdst AU = op[2] & 0x0f; 10796 if (trace) 10797 { 10798 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 10799 "/** 1111 1101 100immmm rsrc rdst shlr #%2, %1, %0 */", 10800 op[0], op[1], op[2]); 10801 printf (" immmm = 0x%x,", immmm); 10802 printf (" rsrc = 0x%x,", rsrc); 10803 printf (" rdst = 0x%x\n", rdst); 10804 } 10805 SYNTAX("shlr #%2, %1, %0"); 10806 #line 656 "rx-decode.opc" 10807 ID(shlr); S2C(immmm); SR(rsrc); DR(rdst); F__SZC; 10808 10809 /*----------------------------------------------------------------------*/ 10810 /* ROTATE */ 10811 10812 } 10813 break; 10814 } 10815 break; 10816 case 0x81: 10817 GETBYTE (); 10818 switch (op[2] & 0x00) 10819 { 10820 case 0x00: 10821 goto op_semantics_90; 10822 break; 10823 } 10824 break; 10825 case 0x82: 10826 GETBYTE (); 10827 switch (op[2] & 0x00) 10828 { 10829 case 0x00: 10830 goto op_semantics_90; 10831 break; 10832 } 10833 break; 10834 case 0x83: 10835 GETBYTE (); 10836 switch (op[2] & 0x00) 10837 { 10838 case 0x00: 10839 goto op_semantics_90; 10840 break; 10841 } 10842 break; 10843 case 0x84: 10844 GETBYTE (); 10845 switch (op[2] & 0x00) 10846 { 10847 case 0x00: 10848 goto op_semantics_90; 10849 break; 10850 } 10851 break; 10852 case 0x85: 10853 GETBYTE (); 10854 switch (op[2] & 0x00) 10855 { 10856 case 0x00: 10857 goto op_semantics_90; 10858 break; 10859 } 10860 break; 10861 case 0x86: 10862 GETBYTE (); 10863 switch (op[2] & 0x00) 10864 { 10865 case 0x00: 10866 goto op_semantics_90; 10867 break; 10868 } 10869 break; 10870 case 0x87: 10871 GETBYTE (); 10872 switch (op[2] & 0x00) 10873 { 10874 case 0x00: 10875 goto op_semantics_90; 10876 break; 10877 } 10878 break; 10879 case 0x88: 10880 GETBYTE (); 10881 switch (op[2] & 0x00) 10882 { 10883 case 0x00: 10884 goto op_semantics_90; 10885 break; 10886 } 10887 break; 10888 case 0x89: 10889 GETBYTE (); 10890 switch (op[2] & 0x00) 10891 { 10892 case 0x00: 10893 goto op_semantics_90; 10894 break; 10895 } 10896 break; 10897 case 0x8a: 10898 GETBYTE (); 10899 switch (op[2] & 0x00) 10900 { 10901 case 0x00: 10902 goto op_semantics_90; 10903 break; 10904 } 10905 break; 10906 case 0x8b: 10907 GETBYTE (); 10908 switch (op[2] & 0x00) 10909 { 10910 case 0x00: 10911 goto op_semantics_90; 10912 break; 10913 } 10914 break; 10915 case 0x8c: 10916 GETBYTE (); 10917 switch (op[2] & 0x00) 10918 { 10919 case 0x00: 10920 goto op_semantics_90; 10921 break; 10922 } 10923 break; 10924 case 0x8d: 10925 GETBYTE (); 10926 switch (op[2] & 0x00) 10927 { 10928 case 0x00: 10929 goto op_semantics_90; 10930 break; 10931 } 10932 break; 10933 case 0x8e: 10934 GETBYTE (); 10935 switch (op[2] & 0x00) 10936 { 10937 case 0x00: 10938 goto op_semantics_90; 10939 break; 10940 } 10941 break; 10942 case 0x8f: 10943 GETBYTE (); 10944 switch (op[2] & 0x00) 10945 { 10946 case 0x00: 10947 goto op_semantics_90; 10948 break; 10949 } 10950 break; 10951 case 0x90: 10952 GETBYTE (); 10953 switch (op[2] & 0x00) 10954 { 10955 case 0x00: 10956 goto op_semantics_90; 10957 break; 10958 } 10959 break; 10960 case 0x91: 10961 GETBYTE (); 10962 switch (op[2] & 0x00) 10963 { 10964 case 0x00: 10965 goto op_semantics_90; 10966 break; 10967 } 10968 break; 10969 case 0x92: 10970 GETBYTE (); 10971 switch (op[2] & 0x00) 10972 { 10973 case 0x00: 10974 goto op_semantics_90; 10975 break; 10976 } 10977 break; 10978 case 0x93: 10979 GETBYTE (); 10980 switch (op[2] & 0x00) 10981 { 10982 case 0x00: 10983 goto op_semantics_90; 10984 break; 10985 } 10986 break; 10987 case 0x94: 10988 GETBYTE (); 10989 switch (op[2] & 0x00) 10990 { 10991 case 0x00: 10992 goto op_semantics_90; 10993 break; 10994 } 10995 break; 10996 case 0x95: 10997 GETBYTE (); 10998 switch (op[2] & 0x00) 10999 { 11000 case 0x00: 11001 goto op_semantics_90; 11002 break; 11003 } 11004 break; 11005 case 0x96: 11006 GETBYTE (); 11007 switch (op[2] & 0x00) 11008 { 11009 case 0x00: 11010 goto op_semantics_90; 11011 break; 11012 } 11013 break; 11014 case 0x97: 11015 GETBYTE (); 11016 switch (op[2] & 0x00) 11017 { 11018 case 0x00: 11019 goto op_semantics_90; 11020 break; 11021 } 11022 break; 11023 case 0x98: 11024 GETBYTE (); 11025 switch (op[2] & 0x00) 11026 { 11027 case 0x00: 11028 goto op_semantics_90; 11029 break; 11030 } 11031 break; 11032 case 0x99: 11033 GETBYTE (); 11034 switch (op[2] & 0x00) 11035 { 11036 case 0x00: 11037 goto op_semantics_90; 11038 break; 11039 } 11040 break; 11041 case 0x9a: 11042 GETBYTE (); 11043 switch (op[2] & 0x00) 11044 { 11045 case 0x00: 11046 goto op_semantics_90; 11047 break; 11048 } 11049 break; 11050 case 0x9b: 11051 GETBYTE (); 11052 switch (op[2] & 0x00) 11053 { 11054 case 0x00: 11055 goto op_semantics_90; 11056 break; 11057 } 11058 break; 11059 case 0x9c: 11060 GETBYTE (); 11061 switch (op[2] & 0x00) 11062 { 11063 case 0x00: 11064 goto op_semantics_90; 11065 break; 11066 } 11067 break; 11068 case 0x9d: 11069 GETBYTE (); 11070 switch (op[2] & 0x00) 11071 { 11072 case 0x00: 11073 goto op_semantics_90; 11074 break; 11075 } 11076 break; 11077 case 0x9e: 11078 GETBYTE (); 11079 switch (op[2] & 0x00) 11080 { 11081 case 0x00: 11082 goto op_semantics_90; 11083 break; 11084 } 11085 break; 11086 case 0x9f: 11087 GETBYTE (); 11088 switch (op[2] & 0x00) 11089 { 11090 case 0x00: 11091 goto op_semantics_90; 11092 break; 11093 } 11094 break; 11095 case 0xa0: 11096 GETBYTE (); 11097 switch (op[2] & 0x00) 11098 { 11099 case 0x00: 11100 op_semantics_91: 11101 { 11102 /** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */ 11103 #line 646 "rx-decode.opc" 11104 int immmm AU = op[1] & 0x1f; 11105 #line 646 "rx-decode.opc" 11106 int rsrc AU = (op[2] >> 4) & 0x0f; 11107 #line 646 "rx-decode.opc" 11108 int rdst AU = op[2] & 0x0f; 11109 if (trace) 11110 { 11111 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11112 "/** 1111 1101 101immmm rsrc rdst shar #%2, %1, %0 */", 11113 op[0], op[1], op[2]); 11114 printf (" immmm = 0x%x,", immmm); 11115 printf (" rsrc = 0x%x,", rsrc); 11116 printf (" rdst = 0x%x\n", rdst); 11117 } 11118 SYNTAX("shar #%2, %1, %0"); 11119 #line 646 "rx-decode.opc" 11120 ID(shar); S2C(immmm); SR(rsrc); DR(rdst); F_0SZC; 11121 11122 11123 } 11124 break; 11125 } 11126 break; 11127 case 0xa1: 11128 GETBYTE (); 11129 switch (op[2] & 0x00) 11130 { 11131 case 0x00: 11132 goto op_semantics_91; 11133 break; 11134 } 11135 break; 11136 case 0xa2: 11137 GETBYTE (); 11138 switch (op[2] & 0x00) 11139 { 11140 case 0x00: 11141 goto op_semantics_91; 11142 break; 11143 } 11144 break; 11145 case 0xa3: 11146 GETBYTE (); 11147 switch (op[2] & 0x00) 11148 { 11149 case 0x00: 11150 goto op_semantics_91; 11151 break; 11152 } 11153 break; 11154 case 0xa4: 11155 GETBYTE (); 11156 switch (op[2] & 0x00) 11157 { 11158 case 0x00: 11159 goto op_semantics_91; 11160 break; 11161 } 11162 break; 11163 case 0xa5: 11164 GETBYTE (); 11165 switch (op[2] & 0x00) 11166 { 11167 case 0x00: 11168 goto op_semantics_91; 11169 break; 11170 } 11171 break; 11172 case 0xa6: 11173 GETBYTE (); 11174 switch (op[2] & 0x00) 11175 { 11176 case 0x00: 11177 goto op_semantics_91; 11178 break; 11179 } 11180 break; 11181 case 0xa7: 11182 GETBYTE (); 11183 switch (op[2] & 0x00) 11184 { 11185 case 0x00: 11186 goto op_semantics_91; 11187 break; 11188 } 11189 break; 11190 case 0xa8: 11191 GETBYTE (); 11192 switch (op[2] & 0x00) 11193 { 11194 case 0x00: 11195 goto op_semantics_91; 11196 break; 11197 } 11198 break; 11199 case 0xa9: 11200 GETBYTE (); 11201 switch (op[2] & 0x00) 11202 { 11203 case 0x00: 11204 goto op_semantics_91; 11205 break; 11206 } 11207 break; 11208 case 0xaa: 11209 GETBYTE (); 11210 switch (op[2] & 0x00) 11211 { 11212 case 0x00: 11213 goto op_semantics_91; 11214 break; 11215 } 11216 break; 11217 case 0xab: 11218 GETBYTE (); 11219 switch (op[2] & 0x00) 11220 { 11221 case 0x00: 11222 goto op_semantics_91; 11223 break; 11224 } 11225 break; 11226 case 0xac: 11227 GETBYTE (); 11228 switch (op[2] & 0x00) 11229 { 11230 case 0x00: 11231 goto op_semantics_91; 11232 break; 11233 } 11234 break; 11235 case 0xad: 11236 GETBYTE (); 11237 switch (op[2] & 0x00) 11238 { 11239 case 0x00: 11240 goto op_semantics_91; 11241 break; 11242 } 11243 break; 11244 case 0xae: 11245 GETBYTE (); 11246 switch (op[2] & 0x00) 11247 { 11248 case 0x00: 11249 goto op_semantics_91; 11250 break; 11251 } 11252 break; 11253 case 0xaf: 11254 GETBYTE (); 11255 switch (op[2] & 0x00) 11256 { 11257 case 0x00: 11258 goto op_semantics_91; 11259 break; 11260 } 11261 break; 11262 case 0xb0: 11263 GETBYTE (); 11264 switch (op[2] & 0x00) 11265 { 11266 case 0x00: 11267 goto op_semantics_91; 11268 break; 11269 } 11270 break; 11271 case 0xb1: 11272 GETBYTE (); 11273 switch (op[2] & 0x00) 11274 { 11275 case 0x00: 11276 goto op_semantics_91; 11277 break; 11278 } 11279 break; 11280 case 0xb2: 11281 GETBYTE (); 11282 switch (op[2] & 0x00) 11283 { 11284 case 0x00: 11285 goto op_semantics_91; 11286 break; 11287 } 11288 break; 11289 case 0xb3: 11290 GETBYTE (); 11291 switch (op[2] & 0x00) 11292 { 11293 case 0x00: 11294 goto op_semantics_91; 11295 break; 11296 } 11297 break; 11298 case 0xb4: 11299 GETBYTE (); 11300 switch (op[2] & 0x00) 11301 { 11302 case 0x00: 11303 goto op_semantics_91; 11304 break; 11305 } 11306 break; 11307 case 0xb5: 11308 GETBYTE (); 11309 switch (op[2] & 0x00) 11310 { 11311 case 0x00: 11312 goto op_semantics_91; 11313 break; 11314 } 11315 break; 11316 case 0xb6: 11317 GETBYTE (); 11318 switch (op[2] & 0x00) 11319 { 11320 case 0x00: 11321 goto op_semantics_91; 11322 break; 11323 } 11324 break; 11325 case 0xb7: 11326 GETBYTE (); 11327 switch (op[2] & 0x00) 11328 { 11329 case 0x00: 11330 goto op_semantics_91; 11331 break; 11332 } 11333 break; 11334 case 0xb8: 11335 GETBYTE (); 11336 switch (op[2] & 0x00) 11337 { 11338 case 0x00: 11339 goto op_semantics_91; 11340 break; 11341 } 11342 break; 11343 case 0xb9: 11344 GETBYTE (); 11345 switch (op[2] & 0x00) 11346 { 11347 case 0x00: 11348 goto op_semantics_91; 11349 break; 11350 } 11351 break; 11352 case 0xba: 11353 GETBYTE (); 11354 switch (op[2] & 0x00) 11355 { 11356 case 0x00: 11357 goto op_semantics_91; 11358 break; 11359 } 11360 break; 11361 case 0xbb: 11362 GETBYTE (); 11363 switch (op[2] & 0x00) 11364 { 11365 case 0x00: 11366 goto op_semantics_91; 11367 break; 11368 } 11369 break; 11370 case 0xbc: 11371 GETBYTE (); 11372 switch (op[2] & 0x00) 11373 { 11374 case 0x00: 11375 goto op_semantics_91; 11376 break; 11377 } 11378 break; 11379 case 0xbd: 11380 GETBYTE (); 11381 switch (op[2] & 0x00) 11382 { 11383 case 0x00: 11384 goto op_semantics_91; 11385 break; 11386 } 11387 break; 11388 case 0xbe: 11389 GETBYTE (); 11390 switch (op[2] & 0x00) 11391 { 11392 case 0x00: 11393 goto op_semantics_91; 11394 break; 11395 } 11396 break; 11397 case 0xbf: 11398 GETBYTE (); 11399 switch (op[2] & 0x00) 11400 { 11401 case 0x00: 11402 goto op_semantics_91; 11403 break; 11404 } 11405 break; 11406 case 0xc0: 11407 GETBYTE (); 11408 switch (op[2] & 0x00) 11409 { 11410 case 0x00: 11411 op_semantics_92: 11412 { 11413 /** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */ 11414 #line 636 "rx-decode.opc" 11415 int immmm AU = op[1] & 0x1f; 11416 #line 636 "rx-decode.opc" 11417 int rsrc AU = (op[2] >> 4) & 0x0f; 11418 #line 636 "rx-decode.opc" 11419 int rdst AU = op[2] & 0x0f; 11420 if (trace) 11421 { 11422 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11423 "/** 1111 1101 110immmm rsrc rdst shll #%2, %1, %0 */", 11424 op[0], op[1], op[2]); 11425 printf (" immmm = 0x%x,", immmm); 11426 printf (" rsrc = 0x%x,", rsrc); 11427 printf (" rdst = 0x%x\n", rdst); 11428 } 11429 SYNTAX("shll #%2, %1, %0"); 11430 #line 636 "rx-decode.opc" 11431 ID(shll); S2C(immmm); SR(rsrc); DR(rdst); F_OSZC; 11432 11433 11434 } 11435 break; 11436 } 11437 break; 11438 case 0xc1: 11439 GETBYTE (); 11440 switch (op[2] & 0x00) 11441 { 11442 case 0x00: 11443 goto op_semantics_92; 11444 break; 11445 } 11446 break; 11447 case 0xc2: 11448 GETBYTE (); 11449 switch (op[2] & 0x00) 11450 { 11451 case 0x00: 11452 goto op_semantics_92; 11453 break; 11454 } 11455 break; 11456 case 0xc3: 11457 GETBYTE (); 11458 switch (op[2] & 0x00) 11459 { 11460 case 0x00: 11461 goto op_semantics_92; 11462 break; 11463 } 11464 break; 11465 case 0xc4: 11466 GETBYTE (); 11467 switch (op[2] & 0x00) 11468 { 11469 case 0x00: 11470 goto op_semantics_92; 11471 break; 11472 } 11473 break; 11474 case 0xc5: 11475 GETBYTE (); 11476 switch (op[2] & 0x00) 11477 { 11478 case 0x00: 11479 goto op_semantics_92; 11480 break; 11481 } 11482 break; 11483 case 0xc6: 11484 GETBYTE (); 11485 switch (op[2] & 0x00) 11486 { 11487 case 0x00: 11488 goto op_semantics_92; 11489 break; 11490 } 11491 break; 11492 case 0xc7: 11493 GETBYTE (); 11494 switch (op[2] & 0x00) 11495 { 11496 case 0x00: 11497 goto op_semantics_92; 11498 break; 11499 } 11500 break; 11501 case 0xc8: 11502 GETBYTE (); 11503 switch (op[2] & 0x00) 11504 { 11505 case 0x00: 11506 goto op_semantics_92; 11507 break; 11508 } 11509 break; 11510 case 0xc9: 11511 GETBYTE (); 11512 switch (op[2] & 0x00) 11513 { 11514 case 0x00: 11515 goto op_semantics_92; 11516 break; 11517 } 11518 break; 11519 case 0xca: 11520 GETBYTE (); 11521 switch (op[2] & 0x00) 11522 { 11523 case 0x00: 11524 goto op_semantics_92; 11525 break; 11526 } 11527 break; 11528 case 0xcb: 11529 GETBYTE (); 11530 switch (op[2] & 0x00) 11531 { 11532 case 0x00: 11533 goto op_semantics_92; 11534 break; 11535 } 11536 break; 11537 case 0xcc: 11538 GETBYTE (); 11539 switch (op[2] & 0x00) 11540 { 11541 case 0x00: 11542 goto op_semantics_92; 11543 break; 11544 } 11545 break; 11546 case 0xcd: 11547 GETBYTE (); 11548 switch (op[2] & 0x00) 11549 { 11550 case 0x00: 11551 goto op_semantics_92; 11552 break; 11553 } 11554 break; 11555 case 0xce: 11556 GETBYTE (); 11557 switch (op[2] & 0x00) 11558 { 11559 case 0x00: 11560 goto op_semantics_92; 11561 break; 11562 } 11563 break; 11564 case 0xcf: 11565 GETBYTE (); 11566 switch (op[2] & 0x00) 11567 { 11568 case 0x00: 11569 goto op_semantics_92; 11570 break; 11571 } 11572 break; 11573 case 0xd0: 11574 GETBYTE (); 11575 switch (op[2] & 0x00) 11576 { 11577 case 0x00: 11578 goto op_semantics_92; 11579 break; 11580 } 11581 break; 11582 case 0xd1: 11583 GETBYTE (); 11584 switch (op[2] & 0x00) 11585 { 11586 case 0x00: 11587 goto op_semantics_92; 11588 break; 11589 } 11590 break; 11591 case 0xd2: 11592 GETBYTE (); 11593 switch (op[2] & 0x00) 11594 { 11595 case 0x00: 11596 goto op_semantics_92; 11597 break; 11598 } 11599 break; 11600 case 0xd3: 11601 GETBYTE (); 11602 switch (op[2] & 0x00) 11603 { 11604 case 0x00: 11605 goto op_semantics_92; 11606 break; 11607 } 11608 break; 11609 case 0xd4: 11610 GETBYTE (); 11611 switch (op[2] & 0x00) 11612 { 11613 case 0x00: 11614 goto op_semantics_92; 11615 break; 11616 } 11617 break; 11618 case 0xd5: 11619 GETBYTE (); 11620 switch (op[2] & 0x00) 11621 { 11622 case 0x00: 11623 goto op_semantics_92; 11624 break; 11625 } 11626 break; 11627 case 0xd6: 11628 GETBYTE (); 11629 switch (op[2] & 0x00) 11630 { 11631 case 0x00: 11632 goto op_semantics_92; 11633 break; 11634 } 11635 break; 11636 case 0xd7: 11637 GETBYTE (); 11638 switch (op[2] & 0x00) 11639 { 11640 case 0x00: 11641 goto op_semantics_92; 11642 break; 11643 } 11644 break; 11645 case 0xd8: 11646 GETBYTE (); 11647 switch (op[2] & 0x00) 11648 { 11649 case 0x00: 11650 goto op_semantics_92; 11651 break; 11652 } 11653 break; 11654 case 0xd9: 11655 GETBYTE (); 11656 switch (op[2] & 0x00) 11657 { 11658 case 0x00: 11659 goto op_semantics_92; 11660 break; 11661 } 11662 break; 11663 case 0xda: 11664 GETBYTE (); 11665 switch (op[2] & 0x00) 11666 { 11667 case 0x00: 11668 goto op_semantics_92; 11669 break; 11670 } 11671 break; 11672 case 0xdb: 11673 GETBYTE (); 11674 switch (op[2] & 0x00) 11675 { 11676 case 0x00: 11677 goto op_semantics_92; 11678 break; 11679 } 11680 break; 11681 case 0xdc: 11682 GETBYTE (); 11683 switch (op[2] & 0x00) 11684 { 11685 case 0x00: 11686 goto op_semantics_92; 11687 break; 11688 } 11689 break; 11690 case 0xdd: 11691 GETBYTE (); 11692 switch (op[2] & 0x00) 11693 { 11694 case 0x00: 11695 goto op_semantics_92; 11696 break; 11697 } 11698 break; 11699 case 0xde: 11700 GETBYTE (); 11701 switch (op[2] & 0x00) 11702 { 11703 case 0x00: 11704 goto op_semantics_92; 11705 break; 11706 } 11707 break; 11708 case 0xdf: 11709 GETBYTE (); 11710 switch (op[2] & 0x00) 11711 { 11712 case 0x00: 11713 goto op_semantics_92; 11714 break; 11715 } 11716 break; 11717 case 0xe0: 11718 GETBYTE (); 11719 switch (op[2] & 0xf0) 11720 { 11721 case 0x00: 11722 case 0x10: 11723 case 0x20: 11724 case 0x30: 11725 case 0x40: 11726 case 0x50: 11727 case 0x60: 11728 case 0x70: 11729 case 0x80: 11730 case 0x90: 11731 case 0xa0: 11732 case 0xb0: 11733 case 0xc0: 11734 case 0xd0: 11735 case 0xe0: 11736 op_semantics_93: 11737 { 11738 /** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */ 11739 #line 902 "rx-decode.opc" 11740 int bittt AU = op[1] & 0x1f; 11741 #line 902 "rx-decode.opc" 11742 int cond AU = (op[2] >> 4) & 0x0f; 11743 #line 902 "rx-decode.opc" 11744 int rdst AU = op[2] & 0x0f; 11745 if (trace) 11746 { 11747 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11748 "/** 1111 1101 111 bittt cond rdst bm%2 #%1, %0%S0 */", 11749 op[0], op[1], op[2]); 11750 printf (" bittt = 0x%x,", bittt); 11751 printf (" cond = 0x%x,", cond); 11752 printf (" rdst = 0x%x\n", rdst); 11753 } 11754 SYNTAX("bm%2 #%1, %0%S0"); 11755 #line 902 "rx-decode.opc" 11756 ID(bmcc); BWL(LSIZE); S2cc(cond); SC(bittt); DR(rdst); 11757 11758 /*----------------------------------------------------------------------*/ 11759 /* CONTROL REGISTERS */ 11760 11761 } 11762 break; 11763 case 0xf0: 11764 op_semantics_94: 11765 { 11766 /** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */ 11767 #line 895 "rx-decode.opc" 11768 int bittt AU = op[1] & 0x1f; 11769 #line 895 "rx-decode.opc" 11770 int rdst AU = op[2] & 0x0f; 11771 if (trace) 11772 { 11773 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 11774 "/** 1111 1101 111bittt 1111 rdst bnot #%1, %0 */", 11775 op[0], op[1], op[2]); 11776 printf (" bittt = 0x%x,", bittt); 11777 printf (" rdst = 0x%x\n", rdst); 11778 } 11779 SYNTAX("bnot #%1, %0"); 11780 #line 895 "rx-decode.opc" 11781 ID(bnot); BWL(LSIZE); SC(bittt); DR(rdst); 11782 11783 11784 } 11785 break; 11786 } 11787 break; 11788 case 0xe1: 11789 GETBYTE (); 11790 switch (op[2] & 0xf0) 11791 { 11792 case 0x00: 11793 case 0x10: 11794 case 0x20: 11795 case 0x30: 11796 case 0x40: 11797 case 0x50: 11798 case 0x60: 11799 case 0x70: 11800 case 0x80: 11801 case 0x90: 11802 case 0xa0: 11803 case 0xb0: 11804 case 0xc0: 11805 case 0xd0: 11806 case 0xe0: 11807 goto op_semantics_93; 11808 break; 11809 case 0xf0: 11810 goto op_semantics_94; 11811 break; 11812 } 11813 break; 11814 case 0xe2: 11815 GETBYTE (); 11816 switch (op[2] & 0xf0) 11817 { 11818 case 0x00: 11819 case 0x10: 11820 case 0x20: 11821 case 0x30: 11822 case 0x40: 11823 case 0x50: 11824 case 0x60: 11825 case 0x70: 11826 case 0x80: 11827 case 0x90: 11828 case 0xa0: 11829 case 0xb0: 11830 case 0xc0: 11831 case 0xd0: 11832 case 0xe0: 11833 goto op_semantics_93; 11834 break; 11835 case 0xf0: 11836 goto op_semantics_94; 11837 break; 11838 } 11839 break; 11840 case 0xe3: 11841 GETBYTE (); 11842 switch (op[2] & 0xf0) 11843 { 11844 case 0x00: 11845 case 0x10: 11846 case 0x20: 11847 case 0x30: 11848 case 0x40: 11849 case 0x50: 11850 case 0x60: 11851 case 0x70: 11852 case 0x80: 11853 case 0x90: 11854 case 0xa0: 11855 case 0xb0: 11856 case 0xc0: 11857 case 0xd0: 11858 case 0xe0: 11859 goto op_semantics_93; 11860 break; 11861 case 0xf0: 11862 goto op_semantics_94; 11863 break; 11864 } 11865 break; 11866 case 0xe4: 11867 GETBYTE (); 11868 switch (op[2] & 0xf0) 11869 { 11870 case 0x00: 11871 case 0x10: 11872 case 0x20: 11873 case 0x30: 11874 case 0x40: 11875 case 0x50: 11876 case 0x60: 11877 case 0x70: 11878 case 0x80: 11879 case 0x90: 11880 case 0xa0: 11881 case 0xb0: 11882 case 0xc0: 11883 case 0xd0: 11884 case 0xe0: 11885 goto op_semantics_93; 11886 break; 11887 case 0xf0: 11888 goto op_semantics_94; 11889 break; 11890 } 11891 break; 11892 case 0xe5: 11893 GETBYTE (); 11894 switch (op[2] & 0xf0) 11895 { 11896 case 0x00: 11897 case 0x10: 11898 case 0x20: 11899 case 0x30: 11900 case 0x40: 11901 case 0x50: 11902 case 0x60: 11903 case 0x70: 11904 case 0x80: 11905 case 0x90: 11906 case 0xa0: 11907 case 0xb0: 11908 case 0xc0: 11909 case 0xd0: 11910 case 0xe0: 11911 goto op_semantics_93; 11912 break; 11913 case 0xf0: 11914 goto op_semantics_94; 11915 break; 11916 } 11917 break; 11918 case 0xe6: 11919 GETBYTE (); 11920 switch (op[2] & 0xf0) 11921 { 11922 case 0x00: 11923 case 0x10: 11924 case 0x20: 11925 case 0x30: 11926 case 0x40: 11927 case 0x50: 11928 case 0x60: 11929 case 0x70: 11930 case 0x80: 11931 case 0x90: 11932 case 0xa0: 11933 case 0xb0: 11934 case 0xc0: 11935 case 0xd0: 11936 case 0xe0: 11937 goto op_semantics_93; 11938 break; 11939 case 0xf0: 11940 goto op_semantics_94; 11941 break; 11942 } 11943 break; 11944 case 0xe7: 11945 GETBYTE (); 11946 switch (op[2] & 0xf0) 11947 { 11948 case 0x00: 11949 case 0x10: 11950 case 0x20: 11951 case 0x30: 11952 case 0x40: 11953 case 0x50: 11954 case 0x60: 11955 case 0x70: 11956 case 0x80: 11957 case 0x90: 11958 case 0xa0: 11959 case 0xb0: 11960 case 0xc0: 11961 case 0xd0: 11962 case 0xe0: 11963 goto op_semantics_93; 11964 break; 11965 case 0xf0: 11966 goto op_semantics_94; 11967 break; 11968 } 11969 break; 11970 case 0xe8: 11971 GETBYTE (); 11972 switch (op[2] & 0xf0) 11973 { 11974 case 0x00: 11975 case 0x10: 11976 case 0x20: 11977 case 0x30: 11978 case 0x40: 11979 case 0x50: 11980 case 0x60: 11981 case 0x70: 11982 case 0x80: 11983 case 0x90: 11984 case 0xa0: 11985 case 0xb0: 11986 case 0xc0: 11987 case 0xd0: 11988 case 0xe0: 11989 goto op_semantics_93; 11990 break; 11991 case 0xf0: 11992 goto op_semantics_94; 11993 break; 11994 } 11995 break; 11996 case 0xe9: 11997 GETBYTE (); 11998 switch (op[2] & 0xf0) 11999 { 12000 case 0x00: 12001 case 0x10: 12002 case 0x20: 12003 case 0x30: 12004 case 0x40: 12005 case 0x50: 12006 case 0x60: 12007 case 0x70: 12008 case 0x80: 12009 case 0x90: 12010 case 0xa0: 12011 case 0xb0: 12012 case 0xc0: 12013 case 0xd0: 12014 case 0xe0: 12015 goto op_semantics_93; 12016 break; 12017 case 0xf0: 12018 goto op_semantics_94; 12019 break; 12020 } 12021 break; 12022 case 0xea: 12023 GETBYTE (); 12024 switch (op[2] & 0xf0) 12025 { 12026 case 0x00: 12027 case 0x10: 12028 case 0x20: 12029 case 0x30: 12030 case 0x40: 12031 case 0x50: 12032 case 0x60: 12033 case 0x70: 12034 case 0x80: 12035 case 0x90: 12036 case 0xa0: 12037 case 0xb0: 12038 case 0xc0: 12039 case 0xd0: 12040 case 0xe0: 12041 goto op_semantics_93; 12042 break; 12043 case 0xf0: 12044 goto op_semantics_94; 12045 break; 12046 } 12047 break; 12048 case 0xeb: 12049 GETBYTE (); 12050 switch (op[2] & 0xf0) 12051 { 12052 case 0x00: 12053 case 0x10: 12054 case 0x20: 12055 case 0x30: 12056 case 0x40: 12057 case 0x50: 12058 case 0x60: 12059 case 0x70: 12060 case 0x80: 12061 case 0x90: 12062 case 0xa0: 12063 case 0xb0: 12064 case 0xc0: 12065 case 0xd0: 12066 case 0xe0: 12067 goto op_semantics_93; 12068 break; 12069 case 0xf0: 12070 goto op_semantics_94; 12071 break; 12072 } 12073 break; 12074 case 0xec: 12075 GETBYTE (); 12076 switch (op[2] & 0xf0) 12077 { 12078 case 0x00: 12079 case 0x10: 12080 case 0x20: 12081 case 0x30: 12082 case 0x40: 12083 case 0x50: 12084 case 0x60: 12085 case 0x70: 12086 case 0x80: 12087 case 0x90: 12088 case 0xa0: 12089 case 0xb0: 12090 case 0xc0: 12091 case 0xd0: 12092 case 0xe0: 12093 goto op_semantics_93; 12094 break; 12095 case 0xf0: 12096 goto op_semantics_94; 12097 break; 12098 } 12099 break; 12100 case 0xed: 12101 GETBYTE (); 12102 switch (op[2] & 0xf0) 12103 { 12104 case 0x00: 12105 case 0x10: 12106 case 0x20: 12107 case 0x30: 12108 case 0x40: 12109 case 0x50: 12110 case 0x60: 12111 case 0x70: 12112 case 0x80: 12113 case 0x90: 12114 case 0xa0: 12115 case 0xb0: 12116 case 0xc0: 12117 case 0xd0: 12118 case 0xe0: 12119 goto op_semantics_93; 12120 break; 12121 case 0xf0: 12122 goto op_semantics_94; 12123 break; 12124 } 12125 break; 12126 case 0xee: 12127 GETBYTE (); 12128 switch (op[2] & 0xf0) 12129 { 12130 case 0x00: 12131 case 0x10: 12132 case 0x20: 12133 case 0x30: 12134 case 0x40: 12135 case 0x50: 12136 case 0x60: 12137 case 0x70: 12138 case 0x80: 12139 case 0x90: 12140 case 0xa0: 12141 case 0xb0: 12142 case 0xc0: 12143 case 0xd0: 12144 case 0xe0: 12145 goto op_semantics_93; 12146 break; 12147 case 0xf0: 12148 goto op_semantics_94; 12149 break; 12150 } 12151 break; 12152 case 0xef: 12153 GETBYTE (); 12154 switch (op[2] & 0xf0) 12155 { 12156 case 0x00: 12157 case 0x10: 12158 case 0x20: 12159 case 0x30: 12160 case 0x40: 12161 case 0x50: 12162 case 0x60: 12163 case 0x70: 12164 case 0x80: 12165 case 0x90: 12166 case 0xa0: 12167 case 0xb0: 12168 case 0xc0: 12169 case 0xd0: 12170 case 0xe0: 12171 goto op_semantics_93; 12172 break; 12173 case 0xf0: 12174 goto op_semantics_94; 12175 break; 12176 } 12177 break; 12178 case 0xf0: 12179 GETBYTE (); 12180 switch (op[2] & 0xf0) 12181 { 12182 case 0x00: 12183 case 0x10: 12184 case 0x20: 12185 case 0x30: 12186 case 0x40: 12187 case 0x50: 12188 case 0x60: 12189 case 0x70: 12190 case 0x80: 12191 case 0x90: 12192 case 0xa0: 12193 case 0xb0: 12194 case 0xc0: 12195 case 0xd0: 12196 case 0xe0: 12197 goto op_semantics_93; 12198 break; 12199 case 0xf0: 12200 goto op_semantics_94; 12201 break; 12202 } 12203 break; 12204 case 0xf1: 12205 GETBYTE (); 12206 switch (op[2] & 0xf0) 12207 { 12208 case 0x00: 12209 case 0x10: 12210 case 0x20: 12211 case 0x30: 12212 case 0x40: 12213 case 0x50: 12214 case 0x60: 12215 case 0x70: 12216 case 0x80: 12217 case 0x90: 12218 case 0xa0: 12219 case 0xb0: 12220 case 0xc0: 12221 case 0xd0: 12222 case 0xe0: 12223 goto op_semantics_93; 12224 break; 12225 case 0xf0: 12226 goto op_semantics_94; 12227 break; 12228 } 12229 break; 12230 case 0xf2: 12231 GETBYTE (); 12232 switch (op[2] & 0xf0) 12233 { 12234 case 0x00: 12235 case 0x10: 12236 case 0x20: 12237 case 0x30: 12238 case 0x40: 12239 case 0x50: 12240 case 0x60: 12241 case 0x70: 12242 case 0x80: 12243 case 0x90: 12244 case 0xa0: 12245 case 0xb0: 12246 case 0xc0: 12247 case 0xd0: 12248 case 0xe0: 12249 goto op_semantics_93; 12250 break; 12251 case 0xf0: 12252 goto op_semantics_94; 12253 break; 12254 } 12255 break; 12256 case 0xf3: 12257 GETBYTE (); 12258 switch (op[2] & 0xf0) 12259 { 12260 case 0x00: 12261 case 0x10: 12262 case 0x20: 12263 case 0x30: 12264 case 0x40: 12265 case 0x50: 12266 case 0x60: 12267 case 0x70: 12268 case 0x80: 12269 case 0x90: 12270 case 0xa0: 12271 case 0xb0: 12272 case 0xc0: 12273 case 0xd0: 12274 case 0xe0: 12275 goto op_semantics_93; 12276 break; 12277 case 0xf0: 12278 goto op_semantics_94; 12279 break; 12280 } 12281 break; 12282 case 0xf4: 12283 GETBYTE (); 12284 switch (op[2] & 0xf0) 12285 { 12286 case 0x00: 12287 case 0x10: 12288 case 0x20: 12289 case 0x30: 12290 case 0x40: 12291 case 0x50: 12292 case 0x60: 12293 case 0x70: 12294 case 0x80: 12295 case 0x90: 12296 case 0xa0: 12297 case 0xb0: 12298 case 0xc0: 12299 case 0xd0: 12300 case 0xe0: 12301 goto op_semantics_93; 12302 break; 12303 case 0xf0: 12304 goto op_semantics_94; 12305 break; 12306 } 12307 break; 12308 case 0xf5: 12309 GETBYTE (); 12310 switch (op[2] & 0xf0) 12311 { 12312 case 0x00: 12313 case 0x10: 12314 case 0x20: 12315 case 0x30: 12316 case 0x40: 12317 case 0x50: 12318 case 0x60: 12319 case 0x70: 12320 case 0x80: 12321 case 0x90: 12322 case 0xa0: 12323 case 0xb0: 12324 case 0xc0: 12325 case 0xd0: 12326 case 0xe0: 12327 goto op_semantics_93; 12328 break; 12329 case 0xf0: 12330 goto op_semantics_94; 12331 break; 12332 } 12333 break; 12334 case 0xf6: 12335 GETBYTE (); 12336 switch (op[2] & 0xf0) 12337 { 12338 case 0x00: 12339 case 0x10: 12340 case 0x20: 12341 case 0x30: 12342 case 0x40: 12343 case 0x50: 12344 case 0x60: 12345 case 0x70: 12346 case 0x80: 12347 case 0x90: 12348 case 0xa0: 12349 case 0xb0: 12350 case 0xc0: 12351 case 0xd0: 12352 case 0xe0: 12353 goto op_semantics_93; 12354 break; 12355 case 0xf0: 12356 goto op_semantics_94; 12357 break; 12358 } 12359 break; 12360 case 0xf7: 12361 GETBYTE (); 12362 switch (op[2] & 0xf0) 12363 { 12364 case 0x00: 12365 case 0x10: 12366 case 0x20: 12367 case 0x30: 12368 case 0x40: 12369 case 0x50: 12370 case 0x60: 12371 case 0x70: 12372 case 0x80: 12373 case 0x90: 12374 case 0xa0: 12375 case 0xb0: 12376 case 0xc0: 12377 case 0xd0: 12378 case 0xe0: 12379 goto op_semantics_93; 12380 break; 12381 case 0xf0: 12382 goto op_semantics_94; 12383 break; 12384 } 12385 break; 12386 case 0xf8: 12387 GETBYTE (); 12388 switch (op[2] & 0xf0) 12389 { 12390 case 0x00: 12391 case 0x10: 12392 case 0x20: 12393 case 0x30: 12394 case 0x40: 12395 case 0x50: 12396 case 0x60: 12397 case 0x70: 12398 case 0x80: 12399 case 0x90: 12400 case 0xa0: 12401 case 0xb0: 12402 case 0xc0: 12403 case 0xd0: 12404 case 0xe0: 12405 goto op_semantics_93; 12406 break; 12407 case 0xf0: 12408 goto op_semantics_94; 12409 break; 12410 } 12411 break; 12412 case 0xf9: 12413 GETBYTE (); 12414 switch (op[2] & 0xf0) 12415 { 12416 case 0x00: 12417 case 0x10: 12418 case 0x20: 12419 case 0x30: 12420 case 0x40: 12421 case 0x50: 12422 case 0x60: 12423 case 0x70: 12424 case 0x80: 12425 case 0x90: 12426 case 0xa0: 12427 case 0xb0: 12428 case 0xc0: 12429 case 0xd0: 12430 case 0xe0: 12431 goto op_semantics_93; 12432 break; 12433 case 0xf0: 12434 goto op_semantics_94; 12435 break; 12436 } 12437 break; 12438 case 0xfa: 12439 GETBYTE (); 12440 switch (op[2] & 0xf0) 12441 { 12442 case 0x00: 12443 case 0x10: 12444 case 0x20: 12445 case 0x30: 12446 case 0x40: 12447 case 0x50: 12448 case 0x60: 12449 case 0x70: 12450 case 0x80: 12451 case 0x90: 12452 case 0xa0: 12453 case 0xb0: 12454 case 0xc0: 12455 case 0xd0: 12456 case 0xe0: 12457 goto op_semantics_93; 12458 break; 12459 case 0xf0: 12460 goto op_semantics_94; 12461 break; 12462 } 12463 break; 12464 case 0xfb: 12465 GETBYTE (); 12466 switch (op[2] & 0xf0) 12467 { 12468 case 0x00: 12469 case 0x10: 12470 case 0x20: 12471 case 0x30: 12472 case 0x40: 12473 case 0x50: 12474 case 0x60: 12475 case 0x70: 12476 case 0x80: 12477 case 0x90: 12478 case 0xa0: 12479 case 0xb0: 12480 case 0xc0: 12481 case 0xd0: 12482 case 0xe0: 12483 goto op_semantics_93; 12484 break; 12485 case 0xf0: 12486 goto op_semantics_94; 12487 break; 12488 } 12489 break; 12490 case 0xfc: 12491 GETBYTE (); 12492 switch (op[2] & 0xf0) 12493 { 12494 case 0x00: 12495 case 0x10: 12496 case 0x20: 12497 case 0x30: 12498 case 0x40: 12499 case 0x50: 12500 case 0x60: 12501 case 0x70: 12502 case 0x80: 12503 case 0x90: 12504 case 0xa0: 12505 case 0xb0: 12506 case 0xc0: 12507 case 0xd0: 12508 case 0xe0: 12509 goto op_semantics_93; 12510 break; 12511 case 0xf0: 12512 goto op_semantics_94; 12513 break; 12514 } 12515 break; 12516 case 0xfd: 12517 GETBYTE (); 12518 switch (op[2] & 0xf0) 12519 { 12520 case 0x00: 12521 case 0x10: 12522 case 0x20: 12523 case 0x30: 12524 case 0x40: 12525 case 0x50: 12526 case 0x60: 12527 case 0x70: 12528 case 0x80: 12529 case 0x90: 12530 case 0xa0: 12531 case 0xb0: 12532 case 0xc0: 12533 case 0xd0: 12534 case 0xe0: 12535 goto op_semantics_93; 12536 break; 12537 case 0xf0: 12538 goto op_semantics_94; 12539 break; 12540 } 12541 break; 12542 case 0xfe: 12543 GETBYTE (); 12544 switch (op[2] & 0xf0) 12545 { 12546 case 0x00: 12547 case 0x10: 12548 case 0x20: 12549 case 0x30: 12550 case 0x40: 12551 case 0x50: 12552 case 0x60: 12553 case 0x70: 12554 case 0x80: 12555 case 0x90: 12556 case 0xa0: 12557 case 0xb0: 12558 case 0xc0: 12559 case 0xd0: 12560 case 0xe0: 12561 goto op_semantics_93; 12562 break; 12563 case 0xf0: 12564 goto op_semantics_94; 12565 break; 12566 } 12567 break; 12568 case 0xff: 12569 GETBYTE (); 12570 switch (op[2] & 0xf0) 12571 { 12572 case 0x00: 12573 case 0x10: 12574 case 0x20: 12575 case 0x30: 12576 case 0x40: 12577 case 0x50: 12578 case 0x60: 12579 case 0x70: 12580 case 0x80: 12581 case 0x90: 12582 case 0xa0: 12583 case 0xb0: 12584 case 0xc0: 12585 case 0xd0: 12586 case 0xe0: 12587 goto op_semantics_93; 12588 break; 12589 case 0xf0: 12590 goto op_semantics_94; 12591 break; 12592 } 12593 break; 12594 default: UNSUPPORTED(); break; 12595 } 12596 break; 12597 case 0xfe: 12598 GETBYTE (); 12599 switch (op[1] & 0xff) 12600 { 12601 case 0x00: 12602 GETBYTE (); 12603 switch (op[2] & 0x00) 12604 { 12605 case 0x00: 12606 op_semantics_95: 12607 { 12608 /** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */ 12609 #line 301 "rx-decode.opc" 12610 int sz AU = (op[1] >> 4) & 0x03; 12611 #line 301 "rx-decode.opc" 12612 int isrc AU = op[1] & 0x0f; 12613 #line 301 "rx-decode.opc" 12614 int bsrc AU = (op[2] >> 4) & 0x0f; 12615 #line 301 "rx-decode.opc" 12616 int rdst AU = op[2] & 0x0f; 12617 if (trace) 12618 { 12619 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 12620 "/** 1111 1110 00sz isrc bsrc rdst mov%s %0, [%1, %2] */", 12621 op[0], op[1], op[2]); 12622 printf (" sz = 0x%x,", sz); 12623 printf (" isrc = 0x%x,", isrc); 12624 printf (" bsrc = 0x%x,", bsrc); 12625 printf (" rdst = 0x%x\n", rdst); 12626 } 12627 SYNTAX("mov%s %0, [%1, %2]"); 12628 #line 301 "rx-decode.opc" 12629 ID(movbir); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 12630 12631 } 12632 break; 12633 } 12634 break; 12635 case 0x01: 12636 GETBYTE (); 12637 switch (op[2] & 0x00) 12638 { 12639 case 0x00: 12640 goto op_semantics_95; 12641 break; 12642 } 12643 break; 12644 case 0x02: 12645 GETBYTE (); 12646 switch (op[2] & 0x00) 12647 { 12648 case 0x00: 12649 goto op_semantics_95; 12650 break; 12651 } 12652 break; 12653 case 0x03: 12654 GETBYTE (); 12655 switch (op[2] & 0x00) 12656 { 12657 case 0x00: 12658 goto op_semantics_95; 12659 break; 12660 } 12661 break; 12662 case 0x04: 12663 GETBYTE (); 12664 switch (op[2] & 0x00) 12665 { 12666 case 0x00: 12667 goto op_semantics_95; 12668 break; 12669 } 12670 break; 12671 case 0x05: 12672 GETBYTE (); 12673 switch (op[2] & 0x00) 12674 { 12675 case 0x00: 12676 goto op_semantics_95; 12677 break; 12678 } 12679 break; 12680 case 0x06: 12681 GETBYTE (); 12682 switch (op[2] & 0x00) 12683 { 12684 case 0x00: 12685 goto op_semantics_95; 12686 break; 12687 } 12688 break; 12689 case 0x07: 12690 GETBYTE (); 12691 switch (op[2] & 0x00) 12692 { 12693 case 0x00: 12694 goto op_semantics_95; 12695 break; 12696 } 12697 break; 12698 case 0x08: 12699 GETBYTE (); 12700 switch (op[2] & 0x00) 12701 { 12702 case 0x00: 12703 goto op_semantics_95; 12704 break; 12705 } 12706 break; 12707 case 0x09: 12708 GETBYTE (); 12709 switch (op[2] & 0x00) 12710 { 12711 case 0x00: 12712 goto op_semantics_95; 12713 break; 12714 } 12715 break; 12716 case 0x0a: 12717 GETBYTE (); 12718 switch (op[2] & 0x00) 12719 { 12720 case 0x00: 12721 goto op_semantics_95; 12722 break; 12723 } 12724 break; 12725 case 0x0b: 12726 GETBYTE (); 12727 switch (op[2] & 0x00) 12728 { 12729 case 0x00: 12730 goto op_semantics_95; 12731 break; 12732 } 12733 break; 12734 case 0x0c: 12735 GETBYTE (); 12736 switch (op[2] & 0x00) 12737 { 12738 case 0x00: 12739 goto op_semantics_95; 12740 break; 12741 } 12742 break; 12743 case 0x0d: 12744 GETBYTE (); 12745 switch (op[2] & 0x00) 12746 { 12747 case 0x00: 12748 goto op_semantics_95; 12749 break; 12750 } 12751 break; 12752 case 0x0e: 12753 GETBYTE (); 12754 switch (op[2] & 0x00) 12755 { 12756 case 0x00: 12757 goto op_semantics_95; 12758 break; 12759 } 12760 break; 12761 case 0x0f: 12762 GETBYTE (); 12763 switch (op[2] & 0x00) 12764 { 12765 case 0x00: 12766 goto op_semantics_95; 12767 break; 12768 } 12769 break; 12770 case 0x10: 12771 GETBYTE (); 12772 switch (op[2] & 0x00) 12773 { 12774 case 0x00: 12775 goto op_semantics_95; 12776 break; 12777 } 12778 break; 12779 case 0x11: 12780 GETBYTE (); 12781 switch (op[2] & 0x00) 12782 { 12783 case 0x00: 12784 goto op_semantics_95; 12785 break; 12786 } 12787 break; 12788 case 0x12: 12789 GETBYTE (); 12790 switch (op[2] & 0x00) 12791 { 12792 case 0x00: 12793 goto op_semantics_95; 12794 break; 12795 } 12796 break; 12797 case 0x13: 12798 GETBYTE (); 12799 switch (op[2] & 0x00) 12800 { 12801 case 0x00: 12802 goto op_semantics_95; 12803 break; 12804 } 12805 break; 12806 case 0x14: 12807 GETBYTE (); 12808 switch (op[2] & 0x00) 12809 { 12810 case 0x00: 12811 goto op_semantics_95; 12812 break; 12813 } 12814 break; 12815 case 0x15: 12816 GETBYTE (); 12817 switch (op[2] & 0x00) 12818 { 12819 case 0x00: 12820 goto op_semantics_95; 12821 break; 12822 } 12823 break; 12824 case 0x16: 12825 GETBYTE (); 12826 switch (op[2] & 0x00) 12827 { 12828 case 0x00: 12829 goto op_semantics_95; 12830 break; 12831 } 12832 break; 12833 case 0x17: 12834 GETBYTE (); 12835 switch (op[2] & 0x00) 12836 { 12837 case 0x00: 12838 goto op_semantics_95; 12839 break; 12840 } 12841 break; 12842 case 0x18: 12843 GETBYTE (); 12844 switch (op[2] & 0x00) 12845 { 12846 case 0x00: 12847 goto op_semantics_95; 12848 break; 12849 } 12850 break; 12851 case 0x19: 12852 GETBYTE (); 12853 switch (op[2] & 0x00) 12854 { 12855 case 0x00: 12856 goto op_semantics_95; 12857 break; 12858 } 12859 break; 12860 case 0x1a: 12861 GETBYTE (); 12862 switch (op[2] & 0x00) 12863 { 12864 case 0x00: 12865 goto op_semantics_95; 12866 break; 12867 } 12868 break; 12869 case 0x1b: 12870 GETBYTE (); 12871 switch (op[2] & 0x00) 12872 { 12873 case 0x00: 12874 goto op_semantics_95; 12875 break; 12876 } 12877 break; 12878 case 0x1c: 12879 GETBYTE (); 12880 switch (op[2] & 0x00) 12881 { 12882 case 0x00: 12883 goto op_semantics_95; 12884 break; 12885 } 12886 break; 12887 case 0x1d: 12888 GETBYTE (); 12889 switch (op[2] & 0x00) 12890 { 12891 case 0x00: 12892 goto op_semantics_95; 12893 break; 12894 } 12895 break; 12896 case 0x1e: 12897 GETBYTE (); 12898 switch (op[2] & 0x00) 12899 { 12900 case 0x00: 12901 goto op_semantics_95; 12902 break; 12903 } 12904 break; 12905 case 0x1f: 12906 GETBYTE (); 12907 switch (op[2] & 0x00) 12908 { 12909 case 0x00: 12910 goto op_semantics_95; 12911 break; 12912 } 12913 break; 12914 case 0x20: 12915 GETBYTE (); 12916 switch (op[2] & 0x00) 12917 { 12918 case 0x00: 12919 goto op_semantics_95; 12920 break; 12921 } 12922 break; 12923 case 0x21: 12924 GETBYTE (); 12925 switch (op[2] & 0x00) 12926 { 12927 case 0x00: 12928 goto op_semantics_95; 12929 break; 12930 } 12931 break; 12932 case 0x22: 12933 GETBYTE (); 12934 switch (op[2] & 0x00) 12935 { 12936 case 0x00: 12937 goto op_semantics_95; 12938 break; 12939 } 12940 break; 12941 case 0x23: 12942 GETBYTE (); 12943 switch (op[2] & 0x00) 12944 { 12945 case 0x00: 12946 goto op_semantics_95; 12947 break; 12948 } 12949 break; 12950 case 0x24: 12951 GETBYTE (); 12952 switch (op[2] & 0x00) 12953 { 12954 case 0x00: 12955 goto op_semantics_95; 12956 break; 12957 } 12958 break; 12959 case 0x25: 12960 GETBYTE (); 12961 switch (op[2] & 0x00) 12962 { 12963 case 0x00: 12964 goto op_semantics_95; 12965 break; 12966 } 12967 break; 12968 case 0x26: 12969 GETBYTE (); 12970 switch (op[2] & 0x00) 12971 { 12972 case 0x00: 12973 goto op_semantics_95; 12974 break; 12975 } 12976 break; 12977 case 0x27: 12978 GETBYTE (); 12979 switch (op[2] & 0x00) 12980 { 12981 case 0x00: 12982 goto op_semantics_95; 12983 break; 12984 } 12985 break; 12986 case 0x28: 12987 GETBYTE (); 12988 switch (op[2] & 0x00) 12989 { 12990 case 0x00: 12991 goto op_semantics_95; 12992 break; 12993 } 12994 break; 12995 case 0x29: 12996 GETBYTE (); 12997 switch (op[2] & 0x00) 12998 { 12999 case 0x00: 13000 goto op_semantics_95; 13001 break; 13002 } 13003 break; 13004 case 0x2a: 13005 GETBYTE (); 13006 switch (op[2] & 0x00) 13007 { 13008 case 0x00: 13009 goto op_semantics_95; 13010 break; 13011 } 13012 break; 13013 case 0x2b: 13014 GETBYTE (); 13015 switch (op[2] & 0x00) 13016 { 13017 case 0x00: 13018 goto op_semantics_95; 13019 break; 13020 } 13021 break; 13022 case 0x2c: 13023 GETBYTE (); 13024 switch (op[2] & 0x00) 13025 { 13026 case 0x00: 13027 goto op_semantics_95; 13028 break; 13029 } 13030 break; 13031 case 0x2d: 13032 GETBYTE (); 13033 switch (op[2] & 0x00) 13034 { 13035 case 0x00: 13036 goto op_semantics_95; 13037 break; 13038 } 13039 break; 13040 case 0x2e: 13041 GETBYTE (); 13042 switch (op[2] & 0x00) 13043 { 13044 case 0x00: 13045 goto op_semantics_95; 13046 break; 13047 } 13048 break; 13049 case 0x2f: 13050 GETBYTE (); 13051 switch (op[2] & 0x00) 13052 { 13053 case 0x00: 13054 goto op_semantics_95; 13055 break; 13056 } 13057 break; 13058 case 0x40: 13059 GETBYTE (); 13060 switch (op[2] & 0x00) 13061 { 13062 case 0x00: 13063 op_semantics_96: 13064 { 13065 /** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */ 13066 #line 298 "rx-decode.opc" 13067 int sz AU = (op[1] >> 4) & 0x03; 13068 #line 298 "rx-decode.opc" 13069 int isrc AU = op[1] & 0x0f; 13070 #line 298 "rx-decode.opc" 13071 int bsrc AU = (op[2] >> 4) & 0x0f; 13072 #line 298 "rx-decode.opc" 13073 int rdst AU = op[2] & 0x0f; 13074 if (trace) 13075 { 13076 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13077 "/** 1111 1110 01sz isrc bsrc rdst mov%s [%1, %2], %0 */", 13078 op[0], op[1], op[2]); 13079 printf (" sz = 0x%x,", sz); 13080 printf (" isrc = 0x%x,", isrc); 13081 printf (" bsrc = 0x%x,", bsrc); 13082 printf (" rdst = 0x%x\n", rdst); 13083 } 13084 SYNTAX("mov%s [%1, %2], %0"); 13085 #line 298 "rx-decode.opc" 13086 ID(movbi); sBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 13087 13088 } 13089 break; 13090 } 13091 break; 13092 case 0x41: 13093 GETBYTE (); 13094 switch (op[2] & 0x00) 13095 { 13096 case 0x00: 13097 goto op_semantics_96; 13098 break; 13099 } 13100 break; 13101 case 0x42: 13102 GETBYTE (); 13103 switch (op[2] & 0x00) 13104 { 13105 case 0x00: 13106 goto op_semantics_96; 13107 break; 13108 } 13109 break; 13110 case 0x43: 13111 GETBYTE (); 13112 switch (op[2] & 0x00) 13113 { 13114 case 0x00: 13115 goto op_semantics_96; 13116 break; 13117 } 13118 break; 13119 case 0x44: 13120 GETBYTE (); 13121 switch (op[2] & 0x00) 13122 { 13123 case 0x00: 13124 goto op_semantics_96; 13125 break; 13126 } 13127 break; 13128 case 0x45: 13129 GETBYTE (); 13130 switch (op[2] & 0x00) 13131 { 13132 case 0x00: 13133 goto op_semantics_96; 13134 break; 13135 } 13136 break; 13137 case 0x46: 13138 GETBYTE (); 13139 switch (op[2] & 0x00) 13140 { 13141 case 0x00: 13142 goto op_semantics_96; 13143 break; 13144 } 13145 break; 13146 case 0x47: 13147 GETBYTE (); 13148 switch (op[2] & 0x00) 13149 { 13150 case 0x00: 13151 goto op_semantics_96; 13152 break; 13153 } 13154 break; 13155 case 0x48: 13156 GETBYTE (); 13157 switch (op[2] & 0x00) 13158 { 13159 case 0x00: 13160 goto op_semantics_96; 13161 break; 13162 } 13163 break; 13164 case 0x49: 13165 GETBYTE (); 13166 switch (op[2] & 0x00) 13167 { 13168 case 0x00: 13169 goto op_semantics_96; 13170 break; 13171 } 13172 break; 13173 case 0x4a: 13174 GETBYTE (); 13175 switch (op[2] & 0x00) 13176 { 13177 case 0x00: 13178 goto op_semantics_96; 13179 break; 13180 } 13181 break; 13182 case 0x4b: 13183 GETBYTE (); 13184 switch (op[2] & 0x00) 13185 { 13186 case 0x00: 13187 goto op_semantics_96; 13188 break; 13189 } 13190 break; 13191 case 0x4c: 13192 GETBYTE (); 13193 switch (op[2] & 0x00) 13194 { 13195 case 0x00: 13196 goto op_semantics_96; 13197 break; 13198 } 13199 break; 13200 case 0x4d: 13201 GETBYTE (); 13202 switch (op[2] & 0x00) 13203 { 13204 case 0x00: 13205 goto op_semantics_96; 13206 break; 13207 } 13208 break; 13209 case 0x4e: 13210 GETBYTE (); 13211 switch (op[2] & 0x00) 13212 { 13213 case 0x00: 13214 goto op_semantics_96; 13215 break; 13216 } 13217 break; 13218 case 0x4f: 13219 GETBYTE (); 13220 switch (op[2] & 0x00) 13221 { 13222 case 0x00: 13223 goto op_semantics_96; 13224 break; 13225 } 13226 break; 13227 case 0x50: 13228 GETBYTE (); 13229 switch (op[2] & 0x00) 13230 { 13231 case 0x00: 13232 goto op_semantics_96; 13233 break; 13234 } 13235 break; 13236 case 0x51: 13237 GETBYTE (); 13238 switch (op[2] & 0x00) 13239 { 13240 case 0x00: 13241 goto op_semantics_96; 13242 break; 13243 } 13244 break; 13245 case 0x52: 13246 GETBYTE (); 13247 switch (op[2] & 0x00) 13248 { 13249 case 0x00: 13250 goto op_semantics_96; 13251 break; 13252 } 13253 break; 13254 case 0x53: 13255 GETBYTE (); 13256 switch (op[2] & 0x00) 13257 { 13258 case 0x00: 13259 goto op_semantics_96; 13260 break; 13261 } 13262 break; 13263 case 0x54: 13264 GETBYTE (); 13265 switch (op[2] & 0x00) 13266 { 13267 case 0x00: 13268 goto op_semantics_96; 13269 break; 13270 } 13271 break; 13272 case 0x55: 13273 GETBYTE (); 13274 switch (op[2] & 0x00) 13275 { 13276 case 0x00: 13277 goto op_semantics_96; 13278 break; 13279 } 13280 break; 13281 case 0x56: 13282 GETBYTE (); 13283 switch (op[2] & 0x00) 13284 { 13285 case 0x00: 13286 goto op_semantics_96; 13287 break; 13288 } 13289 break; 13290 case 0x57: 13291 GETBYTE (); 13292 switch (op[2] & 0x00) 13293 { 13294 case 0x00: 13295 goto op_semantics_96; 13296 break; 13297 } 13298 break; 13299 case 0x58: 13300 GETBYTE (); 13301 switch (op[2] & 0x00) 13302 { 13303 case 0x00: 13304 goto op_semantics_96; 13305 break; 13306 } 13307 break; 13308 case 0x59: 13309 GETBYTE (); 13310 switch (op[2] & 0x00) 13311 { 13312 case 0x00: 13313 goto op_semantics_96; 13314 break; 13315 } 13316 break; 13317 case 0x5a: 13318 GETBYTE (); 13319 switch (op[2] & 0x00) 13320 { 13321 case 0x00: 13322 goto op_semantics_96; 13323 break; 13324 } 13325 break; 13326 case 0x5b: 13327 GETBYTE (); 13328 switch (op[2] & 0x00) 13329 { 13330 case 0x00: 13331 goto op_semantics_96; 13332 break; 13333 } 13334 break; 13335 case 0x5c: 13336 GETBYTE (); 13337 switch (op[2] & 0x00) 13338 { 13339 case 0x00: 13340 goto op_semantics_96; 13341 break; 13342 } 13343 break; 13344 case 0x5d: 13345 GETBYTE (); 13346 switch (op[2] & 0x00) 13347 { 13348 case 0x00: 13349 goto op_semantics_96; 13350 break; 13351 } 13352 break; 13353 case 0x5e: 13354 GETBYTE (); 13355 switch (op[2] & 0x00) 13356 { 13357 case 0x00: 13358 goto op_semantics_96; 13359 break; 13360 } 13361 break; 13362 case 0x5f: 13363 GETBYTE (); 13364 switch (op[2] & 0x00) 13365 { 13366 case 0x00: 13367 goto op_semantics_96; 13368 break; 13369 } 13370 break; 13371 case 0x60: 13372 GETBYTE (); 13373 switch (op[2] & 0x00) 13374 { 13375 case 0x00: 13376 goto op_semantics_96; 13377 break; 13378 } 13379 break; 13380 case 0x61: 13381 GETBYTE (); 13382 switch (op[2] & 0x00) 13383 { 13384 case 0x00: 13385 goto op_semantics_96; 13386 break; 13387 } 13388 break; 13389 case 0x62: 13390 GETBYTE (); 13391 switch (op[2] & 0x00) 13392 { 13393 case 0x00: 13394 goto op_semantics_96; 13395 break; 13396 } 13397 break; 13398 case 0x63: 13399 GETBYTE (); 13400 switch (op[2] & 0x00) 13401 { 13402 case 0x00: 13403 goto op_semantics_96; 13404 break; 13405 } 13406 break; 13407 case 0x64: 13408 GETBYTE (); 13409 switch (op[2] & 0x00) 13410 { 13411 case 0x00: 13412 goto op_semantics_96; 13413 break; 13414 } 13415 break; 13416 case 0x65: 13417 GETBYTE (); 13418 switch (op[2] & 0x00) 13419 { 13420 case 0x00: 13421 goto op_semantics_96; 13422 break; 13423 } 13424 break; 13425 case 0x66: 13426 GETBYTE (); 13427 switch (op[2] & 0x00) 13428 { 13429 case 0x00: 13430 goto op_semantics_96; 13431 break; 13432 } 13433 break; 13434 case 0x67: 13435 GETBYTE (); 13436 switch (op[2] & 0x00) 13437 { 13438 case 0x00: 13439 goto op_semantics_96; 13440 break; 13441 } 13442 break; 13443 case 0x68: 13444 GETBYTE (); 13445 switch (op[2] & 0x00) 13446 { 13447 case 0x00: 13448 goto op_semantics_96; 13449 break; 13450 } 13451 break; 13452 case 0x69: 13453 GETBYTE (); 13454 switch (op[2] & 0x00) 13455 { 13456 case 0x00: 13457 goto op_semantics_96; 13458 break; 13459 } 13460 break; 13461 case 0x6a: 13462 GETBYTE (); 13463 switch (op[2] & 0x00) 13464 { 13465 case 0x00: 13466 goto op_semantics_96; 13467 break; 13468 } 13469 break; 13470 case 0x6b: 13471 GETBYTE (); 13472 switch (op[2] & 0x00) 13473 { 13474 case 0x00: 13475 goto op_semantics_96; 13476 break; 13477 } 13478 break; 13479 case 0x6c: 13480 GETBYTE (); 13481 switch (op[2] & 0x00) 13482 { 13483 case 0x00: 13484 goto op_semantics_96; 13485 break; 13486 } 13487 break; 13488 case 0x6d: 13489 GETBYTE (); 13490 switch (op[2] & 0x00) 13491 { 13492 case 0x00: 13493 goto op_semantics_96; 13494 break; 13495 } 13496 break; 13497 case 0x6e: 13498 GETBYTE (); 13499 switch (op[2] & 0x00) 13500 { 13501 case 0x00: 13502 goto op_semantics_96; 13503 break; 13504 } 13505 break; 13506 case 0x6f: 13507 GETBYTE (); 13508 switch (op[2] & 0x00) 13509 { 13510 case 0x00: 13511 goto op_semantics_96; 13512 break; 13513 } 13514 break; 13515 case 0xc0: 13516 GETBYTE (); 13517 switch (op[2] & 0x00) 13518 { 13519 case 0x00: 13520 op_semantics_97: 13521 { 13522 /** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */ 13523 #line 304 "rx-decode.opc" 13524 int sz AU = (op[1] >> 4) & 0x03; 13525 #line 304 "rx-decode.opc" 13526 int isrc AU = op[1] & 0x0f; 13527 #line 304 "rx-decode.opc" 13528 int bsrc AU = (op[2] >> 4) & 0x0f; 13529 #line 304 "rx-decode.opc" 13530 int rdst AU = op[2] & 0x0f; 13531 if (trace) 13532 { 13533 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13534 "/** 1111 1110 11sz isrc bsrc rdst movu%s [%1, %2], %0 */", 13535 op[0], op[1], op[2]); 13536 printf (" sz = 0x%x,", sz); 13537 printf (" isrc = 0x%x,", isrc); 13538 printf (" bsrc = 0x%x,", bsrc); 13539 printf (" rdst = 0x%x\n", rdst); 13540 } 13541 SYNTAX("movu%s [%1, %2], %0"); 13542 #line 304 "rx-decode.opc" 13543 ID(movbi); uBWL(sz); DR(rdst); SRR(isrc); S2R(bsrc); F_____; 13544 13545 } 13546 break; 13547 } 13548 break; 13549 case 0xc1: 13550 GETBYTE (); 13551 switch (op[2] & 0x00) 13552 { 13553 case 0x00: 13554 goto op_semantics_97; 13555 break; 13556 } 13557 break; 13558 case 0xc2: 13559 GETBYTE (); 13560 switch (op[2] & 0x00) 13561 { 13562 case 0x00: 13563 goto op_semantics_97; 13564 break; 13565 } 13566 break; 13567 case 0xc3: 13568 GETBYTE (); 13569 switch (op[2] & 0x00) 13570 { 13571 case 0x00: 13572 goto op_semantics_97; 13573 break; 13574 } 13575 break; 13576 case 0xc4: 13577 GETBYTE (); 13578 switch (op[2] & 0x00) 13579 { 13580 case 0x00: 13581 goto op_semantics_97; 13582 break; 13583 } 13584 break; 13585 case 0xc5: 13586 GETBYTE (); 13587 switch (op[2] & 0x00) 13588 { 13589 case 0x00: 13590 goto op_semantics_97; 13591 break; 13592 } 13593 break; 13594 case 0xc6: 13595 GETBYTE (); 13596 switch (op[2] & 0x00) 13597 { 13598 case 0x00: 13599 goto op_semantics_97; 13600 break; 13601 } 13602 break; 13603 case 0xc7: 13604 GETBYTE (); 13605 switch (op[2] & 0x00) 13606 { 13607 case 0x00: 13608 goto op_semantics_97; 13609 break; 13610 } 13611 break; 13612 case 0xc8: 13613 GETBYTE (); 13614 switch (op[2] & 0x00) 13615 { 13616 case 0x00: 13617 goto op_semantics_97; 13618 break; 13619 } 13620 break; 13621 case 0xc9: 13622 GETBYTE (); 13623 switch (op[2] & 0x00) 13624 { 13625 case 0x00: 13626 goto op_semantics_97; 13627 break; 13628 } 13629 break; 13630 case 0xca: 13631 GETBYTE (); 13632 switch (op[2] & 0x00) 13633 { 13634 case 0x00: 13635 goto op_semantics_97; 13636 break; 13637 } 13638 break; 13639 case 0xcb: 13640 GETBYTE (); 13641 switch (op[2] & 0x00) 13642 { 13643 case 0x00: 13644 goto op_semantics_97; 13645 break; 13646 } 13647 break; 13648 case 0xcc: 13649 GETBYTE (); 13650 switch (op[2] & 0x00) 13651 { 13652 case 0x00: 13653 goto op_semantics_97; 13654 break; 13655 } 13656 break; 13657 case 0xcd: 13658 GETBYTE (); 13659 switch (op[2] & 0x00) 13660 { 13661 case 0x00: 13662 goto op_semantics_97; 13663 break; 13664 } 13665 break; 13666 case 0xce: 13667 GETBYTE (); 13668 switch (op[2] & 0x00) 13669 { 13670 case 0x00: 13671 goto op_semantics_97; 13672 break; 13673 } 13674 break; 13675 case 0xcf: 13676 GETBYTE (); 13677 switch (op[2] & 0x00) 13678 { 13679 case 0x00: 13680 goto op_semantics_97; 13681 break; 13682 } 13683 break; 13684 case 0xd0: 13685 GETBYTE (); 13686 switch (op[2] & 0x00) 13687 { 13688 case 0x00: 13689 goto op_semantics_97; 13690 break; 13691 } 13692 break; 13693 case 0xd1: 13694 GETBYTE (); 13695 switch (op[2] & 0x00) 13696 { 13697 case 0x00: 13698 goto op_semantics_97; 13699 break; 13700 } 13701 break; 13702 case 0xd2: 13703 GETBYTE (); 13704 switch (op[2] & 0x00) 13705 { 13706 case 0x00: 13707 goto op_semantics_97; 13708 break; 13709 } 13710 break; 13711 case 0xd3: 13712 GETBYTE (); 13713 switch (op[2] & 0x00) 13714 { 13715 case 0x00: 13716 goto op_semantics_97; 13717 break; 13718 } 13719 break; 13720 case 0xd4: 13721 GETBYTE (); 13722 switch (op[2] & 0x00) 13723 { 13724 case 0x00: 13725 goto op_semantics_97; 13726 break; 13727 } 13728 break; 13729 case 0xd5: 13730 GETBYTE (); 13731 switch (op[2] & 0x00) 13732 { 13733 case 0x00: 13734 goto op_semantics_97; 13735 break; 13736 } 13737 break; 13738 case 0xd6: 13739 GETBYTE (); 13740 switch (op[2] & 0x00) 13741 { 13742 case 0x00: 13743 goto op_semantics_97; 13744 break; 13745 } 13746 break; 13747 case 0xd7: 13748 GETBYTE (); 13749 switch (op[2] & 0x00) 13750 { 13751 case 0x00: 13752 goto op_semantics_97; 13753 break; 13754 } 13755 break; 13756 case 0xd8: 13757 GETBYTE (); 13758 switch (op[2] & 0x00) 13759 { 13760 case 0x00: 13761 goto op_semantics_97; 13762 break; 13763 } 13764 break; 13765 case 0xd9: 13766 GETBYTE (); 13767 switch (op[2] & 0x00) 13768 { 13769 case 0x00: 13770 goto op_semantics_97; 13771 break; 13772 } 13773 break; 13774 case 0xda: 13775 GETBYTE (); 13776 switch (op[2] & 0x00) 13777 { 13778 case 0x00: 13779 goto op_semantics_97; 13780 break; 13781 } 13782 break; 13783 case 0xdb: 13784 GETBYTE (); 13785 switch (op[2] & 0x00) 13786 { 13787 case 0x00: 13788 goto op_semantics_97; 13789 break; 13790 } 13791 break; 13792 case 0xdc: 13793 GETBYTE (); 13794 switch (op[2] & 0x00) 13795 { 13796 case 0x00: 13797 goto op_semantics_97; 13798 break; 13799 } 13800 break; 13801 case 0xdd: 13802 GETBYTE (); 13803 switch (op[2] & 0x00) 13804 { 13805 case 0x00: 13806 goto op_semantics_97; 13807 break; 13808 } 13809 break; 13810 case 0xde: 13811 GETBYTE (); 13812 switch (op[2] & 0x00) 13813 { 13814 case 0x00: 13815 goto op_semantics_97; 13816 break; 13817 } 13818 break; 13819 case 0xdf: 13820 GETBYTE (); 13821 switch (op[2] & 0x00) 13822 { 13823 case 0x00: 13824 goto op_semantics_97; 13825 break; 13826 } 13827 break; 13828 case 0xe0: 13829 GETBYTE (); 13830 switch (op[2] & 0x00) 13831 { 13832 case 0x00: 13833 goto op_semantics_97; 13834 break; 13835 } 13836 break; 13837 case 0xe1: 13838 GETBYTE (); 13839 switch (op[2] & 0x00) 13840 { 13841 case 0x00: 13842 goto op_semantics_97; 13843 break; 13844 } 13845 break; 13846 case 0xe2: 13847 GETBYTE (); 13848 switch (op[2] & 0x00) 13849 { 13850 case 0x00: 13851 goto op_semantics_97; 13852 break; 13853 } 13854 break; 13855 case 0xe3: 13856 GETBYTE (); 13857 switch (op[2] & 0x00) 13858 { 13859 case 0x00: 13860 goto op_semantics_97; 13861 break; 13862 } 13863 break; 13864 case 0xe4: 13865 GETBYTE (); 13866 switch (op[2] & 0x00) 13867 { 13868 case 0x00: 13869 goto op_semantics_97; 13870 break; 13871 } 13872 break; 13873 case 0xe5: 13874 GETBYTE (); 13875 switch (op[2] & 0x00) 13876 { 13877 case 0x00: 13878 goto op_semantics_97; 13879 break; 13880 } 13881 break; 13882 case 0xe6: 13883 GETBYTE (); 13884 switch (op[2] & 0x00) 13885 { 13886 case 0x00: 13887 goto op_semantics_97; 13888 break; 13889 } 13890 break; 13891 case 0xe7: 13892 GETBYTE (); 13893 switch (op[2] & 0x00) 13894 { 13895 case 0x00: 13896 goto op_semantics_97; 13897 break; 13898 } 13899 break; 13900 case 0xe8: 13901 GETBYTE (); 13902 switch (op[2] & 0x00) 13903 { 13904 case 0x00: 13905 goto op_semantics_97; 13906 break; 13907 } 13908 break; 13909 case 0xe9: 13910 GETBYTE (); 13911 switch (op[2] & 0x00) 13912 { 13913 case 0x00: 13914 goto op_semantics_97; 13915 break; 13916 } 13917 break; 13918 case 0xea: 13919 GETBYTE (); 13920 switch (op[2] & 0x00) 13921 { 13922 case 0x00: 13923 goto op_semantics_97; 13924 break; 13925 } 13926 break; 13927 case 0xeb: 13928 GETBYTE (); 13929 switch (op[2] & 0x00) 13930 { 13931 case 0x00: 13932 goto op_semantics_97; 13933 break; 13934 } 13935 break; 13936 case 0xec: 13937 GETBYTE (); 13938 switch (op[2] & 0x00) 13939 { 13940 case 0x00: 13941 goto op_semantics_97; 13942 break; 13943 } 13944 break; 13945 case 0xed: 13946 GETBYTE (); 13947 switch (op[2] & 0x00) 13948 { 13949 case 0x00: 13950 goto op_semantics_97; 13951 break; 13952 } 13953 break; 13954 case 0xee: 13955 GETBYTE (); 13956 switch (op[2] & 0x00) 13957 { 13958 case 0x00: 13959 goto op_semantics_97; 13960 break; 13961 } 13962 break; 13963 case 0xef: 13964 GETBYTE (); 13965 switch (op[2] & 0x00) 13966 { 13967 case 0x00: 13968 goto op_semantics_97; 13969 break; 13970 } 13971 break; 13972 default: UNSUPPORTED(); break; 13973 } 13974 break; 13975 case 0xff: 13976 GETBYTE (); 13977 switch (op[1] & 0xff) 13978 { 13979 case 0x00: 13980 GETBYTE (); 13981 switch (op[2] & 0x00) 13982 { 13983 case 0x00: 13984 op_semantics_98: 13985 { 13986 /** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */ 13987 #line 508 "rx-decode.opc" 13988 int rdst AU = op[1] & 0x0f; 13989 #line 508 "rx-decode.opc" 13990 int srca AU = (op[2] >> 4) & 0x0f; 13991 #line 508 "rx-decode.opc" 13992 int srcb AU = op[2] & 0x0f; 13993 if (trace) 13994 { 13995 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 13996 "/** 1111 1111 0000 rdst srca srcb sub %2, %1, %0 */", 13997 op[0], op[1], op[2]); 13998 printf (" rdst = 0x%x,", rdst); 13999 printf (" srca = 0x%x,", srca); 14000 printf (" srcb = 0x%x\n", srcb); 14001 } 14002 SYNTAX("sub %2, %1, %0"); 14003 #line 508 "rx-decode.opc" 14004 ID(sub); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 14005 14006 /*----------------------------------------------------------------------*/ 14007 /* SBB */ 14008 14009 } 14010 break; 14011 } 14012 break; 14013 case 0x01: 14014 GETBYTE (); 14015 switch (op[2] & 0x00) 14016 { 14017 case 0x00: 14018 goto op_semantics_98; 14019 break; 14020 } 14021 break; 14022 case 0x02: 14023 GETBYTE (); 14024 switch (op[2] & 0x00) 14025 { 14026 case 0x00: 14027 goto op_semantics_98; 14028 break; 14029 } 14030 break; 14031 case 0x03: 14032 GETBYTE (); 14033 switch (op[2] & 0x00) 14034 { 14035 case 0x00: 14036 goto op_semantics_98; 14037 break; 14038 } 14039 break; 14040 case 0x04: 14041 GETBYTE (); 14042 switch (op[2] & 0x00) 14043 { 14044 case 0x00: 14045 goto op_semantics_98; 14046 break; 14047 } 14048 break; 14049 case 0x05: 14050 GETBYTE (); 14051 switch (op[2] & 0x00) 14052 { 14053 case 0x00: 14054 goto op_semantics_98; 14055 break; 14056 } 14057 break; 14058 case 0x06: 14059 GETBYTE (); 14060 switch (op[2] & 0x00) 14061 { 14062 case 0x00: 14063 goto op_semantics_98; 14064 break; 14065 } 14066 break; 14067 case 0x07: 14068 GETBYTE (); 14069 switch (op[2] & 0x00) 14070 { 14071 case 0x00: 14072 goto op_semantics_98; 14073 break; 14074 } 14075 break; 14076 case 0x08: 14077 GETBYTE (); 14078 switch (op[2] & 0x00) 14079 { 14080 case 0x00: 14081 goto op_semantics_98; 14082 break; 14083 } 14084 break; 14085 case 0x09: 14086 GETBYTE (); 14087 switch (op[2] & 0x00) 14088 { 14089 case 0x00: 14090 goto op_semantics_98; 14091 break; 14092 } 14093 break; 14094 case 0x0a: 14095 GETBYTE (); 14096 switch (op[2] & 0x00) 14097 { 14098 case 0x00: 14099 goto op_semantics_98; 14100 break; 14101 } 14102 break; 14103 case 0x0b: 14104 GETBYTE (); 14105 switch (op[2] & 0x00) 14106 { 14107 case 0x00: 14108 goto op_semantics_98; 14109 break; 14110 } 14111 break; 14112 case 0x0c: 14113 GETBYTE (); 14114 switch (op[2] & 0x00) 14115 { 14116 case 0x00: 14117 goto op_semantics_98; 14118 break; 14119 } 14120 break; 14121 case 0x0d: 14122 GETBYTE (); 14123 switch (op[2] & 0x00) 14124 { 14125 case 0x00: 14126 goto op_semantics_98; 14127 break; 14128 } 14129 break; 14130 case 0x0e: 14131 GETBYTE (); 14132 switch (op[2] & 0x00) 14133 { 14134 case 0x00: 14135 goto op_semantics_98; 14136 break; 14137 } 14138 break; 14139 case 0x0f: 14140 GETBYTE (); 14141 switch (op[2] & 0x00) 14142 { 14143 case 0x00: 14144 goto op_semantics_98; 14145 break; 14146 } 14147 break; 14148 case 0x20: 14149 GETBYTE (); 14150 switch (op[2] & 0x00) 14151 { 14152 case 0x00: 14153 op_semantics_99: 14154 { 14155 /** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */ 14156 #line 475 "rx-decode.opc" 14157 int rdst AU = op[1] & 0x0f; 14158 #line 475 "rx-decode.opc" 14159 int srca AU = (op[2] >> 4) & 0x0f; 14160 #line 475 "rx-decode.opc" 14161 int srcb AU = op[2] & 0x0f; 14162 if (trace) 14163 { 14164 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14165 "/** 1111 1111 0010 rdst srca srcb add %2, %1, %0 */", 14166 op[0], op[1], op[2]); 14167 printf (" rdst = 0x%x,", rdst); 14168 printf (" srca = 0x%x,", srca); 14169 printf (" srcb = 0x%x\n", srcb); 14170 } 14171 SYNTAX("add %2, %1, %0"); 14172 #line 475 "rx-decode.opc" 14173 ID(add); DR(rdst); SR(srcb); S2R(srca); F_OSZC; 14174 14175 /*----------------------------------------------------------------------*/ 14176 /* CMP */ 14177 14178 } 14179 break; 14180 } 14181 break; 14182 case 0x21: 14183 GETBYTE (); 14184 switch (op[2] & 0x00) 14185 { 14186 case 0x00: 14187 goto op_semantics_99; 14188 break; 14189 } 14190 break; 14191 case 0x22: 14192 GETBYTE (); 14193 switch (op[2] & 0x00) 14194 { 14195 case 0x00: 14196 goto op_semantics_99; 14197 break; 14198 } 14199 break; 14200 case 0x23: 14201 GETBYTE (); 14202 switch (op[2] & 0x00) 14203 { 14204 case 0x00: 14205 goto op_semantics_99; 14206 break; 14207 } 14208 break; 14209 case 0x24: 14210 GETBYTE (); 14211 switch (op[2] & 0x00) 14212 { 14213 case 0x00: 14214 goto op_semantics_99; 14215 break; 14216 } 14217 break; 14218 case 0x25: 14219 GETBYTE (); 14220 switch (op[2] & 0x00) 14221 { 14222 case 0x00: 14223 goto op_semantics_99; 14224 break; 14225 } 14226 break; 14227 case 0x26: 14228 GETBYTE (); 14229 switch (op[2] & 0x00) 14230 { 14231 case 0x00: 14232 goto op_semantics_99; 14233 break; 14234 } 14235 break; 14236 case 0x27: 14237 GETBYTE (); 14238 switch (op[2] & 0x00) 14239 { 14240 case 0x00: 14241 goto op_semantics_99; 14242 break; 14243 } 14244 break; 14245 case 0x28: 14246 GETBYTE (); 14247 switch (op[2] & 0x00) 14248 { 14249 case 0x00: 14250 goto op_semantics_99; 14251 break; 14252 } 14253 break; 14254 case 0x29: 14255 GETBYTE (); 14256 switch (op[2] & 0x00) 14257 { 14258 case 0x00: 14259 goto op_semantics_99; 14260 break; 14261 } 14262 break; 14263 case 0x2a: 14264 GETBYTE (); 14265 switch (op[2] & 0x00) 14266 { 14267 case 0x00: 14268 goto op_semantics_99; 14269 break; 14270 } 14271 break; 14272 case 0x2b: 14273 GETBYTE (); 14274 switch (op[2] & 0x00) 14275 { 14276 case 0x00: 14277 goto op_semantics_99; 14278 break; 14279 } 14280 break; 14281 case 0x2c: 14282 GETBYTE (); 14283 switch (op[2] & 0x00) 14284 { 14285 case 0x00: 14286 goto op_semantics_99; 14287 break; 14288 } 14289 break; 14290 case 0x2d: 14291 GETBYTE (); 14292 switch (op[2] & 0x00) 14293 { 14294 case 0x00: 14295 goto op_semantics_99; 14296 break; 14297 } 14298 break; 14299 case 0x2e: 14300 GETBYTE (); 14301 switch (op[2] & 0x00) 14302 { 14303 case 0x00: 14304 goto op_semantics_99; 14305 break; 14306 } 14307 break; 14308 case 0x2f: 14309 GETBYTE (); 14310 switch (op[2] & 0x00) 14311 { 14312 case 0x00: 14313 goto op_semantics_99; 14314 break; 14315 } 14316 break; 14317 case 0x30: 14318 GETBYTE (); 14319 switch (op[2] & 0x00) 14320 { 14321 case 0x00: 14322 op_semantics_100: 14323 { 14324 /** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */ 14325 #line 576 "rx-decode.opc" 14326 int rdst AU = op[1] & 0x0f; 14327 #line 576 "rx-decode.opc" 14328 int srca AU = (op[2] >> 4) & 0x0f; 14329 #line 576 "rx-decode.opc" 14330 int srcb AU = op[2] & 0x0f; 14331 if (trace) 14332 { 14333 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14334 "/** 1111 1111 0011 rdst srca srcb mul %2, %1, %0 */", 14335 op[0], op[1], op[2]); 14336 printf (" rdst = 0x%x,", rdst); 14337 printf (" srca = 0x%x,", srca); 14338 printf (" srcb = 0x%x\n", srcb); 14339 } 14340 SYNTAX("mul %2, %1, %0"); 14341 #line 576 "rx-decode.opc" 14342 ID(mul); DR(rdst); SR(srcb); S2R(srca); F_____; 14343 14344 /*----------------------------------------------------------------------*/ 14345 /* EMUL */ 14346 14347 } 14348 break; 14349 } 14350 break; 14351 case 0x31: 14352 GETBYTE (); 14353 switch (op[2] & 0x00) 14354 { 14355 case 0x00: 14356 goto op_semantics_100; 14357 break; 14358 } 14359 break; 14360 case 0x32: 14361 GETBYTE (); 14362 switch (op[2] & 0x00) 14363 { 14364 case 0x00: 14365 goto op_semantics_100; 14366 break; 14367 } 14368 break; 14369 case 0x33: 14370 GETBYTE (); 14371 switch (op[2] & 0x00) 14372 { 14373 case 0x00: 14374 goto op_semantics_100; 14375 break; 14376 } 14377 break; 14378 case 0x34: 14379 GETBYTE (); 14380 switch (op[2] & 0x00) 14381 { 14382 case 0x00: 14383 goto op_semantics_100; 14384 break; 14385 } 14386 break; 14387 case 0x35: 14388 GETBYTE (); 14389 switch (op[2] & 0x00) 14390 { 14391 case 0x00: 14392 goto op_semantics_100; 14393 break; 14394 } 14395 break; 14396 case 0x36: 14397 GETBYTE (); 14398 switch (op[2] & 0x00) 14399 { 14400 case 0x00: 14401 goto op_semantics_100; 14402 break; 14403 } 14404 break; 14405 case 0x37: 14406 GETBYTE (); 14407 switch (op[2] & 0x00) 14408 { 14409 case 0x00: 14410 goto op_semantics_100; 14411 break; 14412 } 14413 break; 14414 case 0x38: 14415 GETBYTE (); 14416 switch (op[2] & 0x00) 14417 { 14418 case 0x00: 14419 goto op_semantics_100; 14420 break; 14421 } 14422 break; 14423 case 0x39: 14424 GETBYTE (); 14425 switch (op[2] & 0x00) 14426 { 14427 case 0x00: 14428 goto op_semantics_100; 14429 break; 14430 } 14431 break; 14432 case 0x3a: 14433 GETBYTE (); 14434 switch (op[2] & 0x00) 14435 { 14436 case 0x00: 14437 goto op_semantics_100; 14438 break; 14439 } 14440 break; 14441 case 0x3b: 14442 GETBYTE (); 14443 switch (op[2] & 0x00) 14444 { 14445 case 0x00: 14446 goto op_semantics_100; 14447 break; 14448 } 14449 break; 14450 case 0x3c: 14451 GETBYTE (); 14452 switch (op[2] & 0x00) 14453 { 14454 case 0x00: 14455 goto op_semantics_100; 14456 break; 14457 } 14458 break; 14459 case 0x3d: 14460 GETBYTE (); 14461 switch (op[2] & 0x00) 14462 { 14463 case 0x00: 14464 goto op_semantics_100; 14465 break; 14466 } 14467 break; 14468 case 0x3e: 14469 GETBYTE (); 14470 switch (op[2] & 0x00) 14471 { 14472 case 0x00: 14473 goto op_semantics_100; 14474 break; 14475 } 14476 break; 14477 case 0x3f: 14478 GETBYTE (); 14479 switch (op[2] & 0x00) 14480 { 14481 case 0x00: 14482 goto op_semantics_100; 14483 break; 14484 } 14485 break; 14486 case 0x40: 14487 GETBYTE (); 14488 switch (op[2] & 0x00) 14489 { 14490 case 0x00: 14491 op_semantics_101: 14492 { 14493 /** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */ 14494 #line 385 "rx-decode.opc" 14495 int rdst AU = op[1] & 0x0f; 14496 #line 385 "rx-decode.opc" 14497 int srca AU = (op[2] >> 4) & 0x0f; 14498 #line 385 "rx-decode.opc" 14499 int srcb AU = op[2] & 0x0f; 14500 if (trace) 14501 { 14502 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14503 "/** 1111 1111 0100 rdst srca srcb and %2, %1, %0 */", 14504 op[0], op[1], op[2]); 14505 printf (" rdst = 0x%x,", rdst); 14506 printf (" srca = 0x%x,", srca); 14507 printf (" srcb = 0x%x\n", srcb); 14508 } 14509 SYNTAX("and %2, %1, %0"); 14510 #line 385 "rx-decode.opc" 14511 ID(and); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 14512 14513 /*----------------------------------------------------------------------*/ 14514 /* OR */ 14515 14516 } 14517 break; 14518 } 14519 break; 14520 case 0x41: 14521 GETBYTE (); 14522 switch (op[2] & 0x00) 14523 { 14524 case 0x00: 14525 goto op_semantics_101; 14526 break; 14527 } 14528 break; 14529 case 0x42: 14530 GETBYTE (); 14531 switch (op[2] & 0x00) 14532 { 14533 case 0x00: 14534 goto op_semantics_101; 14535 break; 14536 } 14537 break; 14538 case 0x43: 14539 GETBYTE (); 14540 switch (op[2] & 0x00) 14541 { 14542 case 0x00: 14543 goto op_semantics_101; 14544 break; 14545 } 14546 break; 14547 case 0x44: 14548 GETBYTE (); 14549 switch (op[2] & 0x00) 14550 { 14551 case 0x00: 14552 goto op_semantics_101; 14553 break; 14554 } 14555 break; 14556 case 0x45: 14557 GETBYTE (); 14558 switch (op[2] & 0x00) 14559 { 14560 case 0x00: 14561 goto op_semantics_101; 14562 break; 14563 } 14564 break; 14565 case 0x46: 14566 GETBYTE (); 14567 switch (op[2] & 0x00) 14568 { 14569 case 0x00: 14570 goto op_semantics_101; 14571 break; 14572 } 14573 break; 14574 case 0x47: 14575 GETBYTE (); 14576 switch (op[2] & 0x00) 14577 { 14578 case 0x00: 14579 goto op_semantics_101; 14580 break; 14581 } 14582 break; 14583 case 0x48: 14584 GETBYTE (); 14585 switch (op[2] & 0x00) 14586 { 14587 case 0x00: 14588 goto op_semantics_101; 14589 break; 14590 } 14591 break; 14592 case 0x49: 14593 GETBYTE (); 14594 switch (op[2] & 0x00) 14595 { 14596 case 0x00: 14597 goto op_semantics_101; 14598 break; 14599 } 14600 break; 14601 case 0x4a: 14602 GETBYTE (); 14603 switch (op[2] & 0x00) 14604 { 14605 case 0x00: 14606 goto op_semantics_101; 14607 break; 14608 } 14609 break; 14610 case 0x4b: 14611 GETBYTE (); 14612 switch (op[2] & 0x00) 14613 { 14614 case 0x00: 14615 goto op_semantics_101; 14616 break; 14617 } 14618 break; 14619 case 0x4c: 14620 GETBYTE (); 14621 switch (op[2] & 0x00) 14622 { 14623 case 0x00: 14624 goto op_semantics_101; 14625 break; 14626 } 14627 break; 14628 case 0x4d: 14629 GETBYTE (); 14630 switch (op[2] & 0x00) 14631 { 14632 case 0x00: 14633 goto op_semantics_101; 14634 break; 14635 } 14636 break; 14637 case 0x4e: 14638 GETBYTE (); 14639 switch (op[2] & 0x00) 14640 { 14641 case 0x00: 14642 goto op_semantics_101; 14643 break; 14644 } 14645 break; 14646 case 0x4f: 14647 GETBYTE (); 14648 switch (op[2] & 0x00) 14649 { 14650 case 0x00: 14651 goto op_semantics_101; 14652 break; 14653 } 14654 break; 14655 case 0x50: 14656 GETBYTE (); 14657 switch (op[2] & 0x00) 14658 { 14659 case 0x00: 14660 op_semantics_102: 14661 { 14662 /** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */ 14663 #line 403 "rx-decode.opc" 14664 int rdst AU = op[1] & 0x0f; 14665 #line 403 "rx-decode.opc" 14666 int srca AU = (op[2] >> 4) & 0x0f; 14667 #line 403 "rx-decode.opc" 14668 int srcb AU = op[2] & 0x0f; 14669 if (trace) 14670 { 14671 printf ("\033[33m%s\033[0m %02x %02x %02x\n", 14672 "/** 1111 1111 0101 rdst srca srcb or %2, %1, %0 */", 14673 op[0], op[1], op[2]); 14674 printf (" rdst = 0x%x,", rdst); 14675 printf (" srca = 0x%x,", srca); 14676 printf (" srcb = 0x%x\n", srcb); 14677 } 14678 SYNTAX("or %2, %1, %0"); 14679 #line 403 "rx-decode.opc" 14680 ID(or); DR(rdst); SR(srcb); S2R(srca); F__SZ_; 14681 14682 /*----------------------------------------------------------------------*/ 14683 /* XOR */ 14684 14685 } 14686 break; 14687 } 14688 break; 14689 case 0x51: 14690 GETBYTE (); 14691 switch (op[2] & 0x00) 14692 { 14693 case 0x00: 14694 goto op_semantics_102; 14695 break; 14696 } 14697 break; 14698 case 0x52: 14699 GETBYTE (); 14700 switch (op[2] & 0x00) 14701 { 14702 case 0x00: 14703 goto op_semantics_102; 14704 break; 14705 } 14706 break; 14707 case 0x53: 14708 GETBYTE (); 14709 switch (op[2] & 0x00) 14710 { 14711 case 0x00: 14712 goto op_semantics_102; 14713 break; 14714 } 14715 break; 14716 case 0x54: 14717 GETBYTE (); 14718 switch (op[2] & 0x00) 14719 { 14720 case 0x00: 14721 goto op_semantics_102; 14722 break; 14723 } 14724 break; 14725 case 0x55: 14726 GETBYTE (); 14727 switch (op[2] & 0x00) 14728 { 14729 case 0x00: 14730 goto op_semantics_102; 14731 break; 14732 } 14733 break; 14734 case 0x56: 14735 GETBYTE (); 14736 switch (op[2] & 0x00) 14737 { 14738 case 0x00: 14739 goto op_semantics_102; 14740 break; 14741 } 14742 break; 14743 case 0x57: 14744 GETBYTE (); 14745 switch (op[2] & 0x00) 14746 { 14747 case 0x00: 14748 goto op_semantics_102; 14749 break; 14750 } 14751 break; 14752 case 0x58: 14753 GETBYTE (); 14754 switch (op[2] & 0x00) 14755 { 14756 case 0x00: 14757 goto op_semantics_102; 14758 break; 14759 } 14760 break; 14761 case 0x59: 14762 GETBYTE (); 14763 switch (op[2] & 0x00) 14764 { 14765 case 0x00: 14766 goto op_semantics_102; 14767 break; 14768 } 14769 break; 14770 case 0x5a: 14771 GETBYTE (); 14772 switch (op[2] & 0x00) 14773 { 14774 case 0x00: 14775 goto op_semantics_102; 14776 break; 14777 } 14778 break; 14779 case 0x5b: 14780 GETBYTE (); 14781 switch (op[2] & 0x00) 14782 { 14783 case 0x00: 14784 goto op_semantics_102; 14785 break; 14786 } 14787 break; 14788 case 0x5c: 14789 GETBYTE (); 14790 switch (op[2] & 0x00) 14791 { 14792 case 0x00: 14793 goto op_semantics_102; 14794 break; 14795 } 14796 break; 14797 case 0x5d: 14798 GETBYTE (); 14799 switch (op[2] & 0x00) 14800 { 14801 case 0x00: 14802 goto op_semantics_102; 14803 break; 14804 } 14805 break; 14806 case 0x5e: 14807 GETBYTE (); 14808 switch (op[2] & 0x00) 14809 { 14810 case 0x00: 14811 goto op_semantics_102; 14812 break; 14813 } 14814 break; 14815 case 0x5f: 14816 GETBYTE (); 14817 switch (op[2] & 0x00) 14818 { 14819 case 0x00: 14820 goto op_semantics_102; 14821 break; 14822 } 14823 break; 14824 default: UNSUPPORTED(); break; 14825 } 14826 break; 14827 default: UNSUPPORTED(); break; 14828 } 14829 #line 959 "rx-decode.opc" 14830 14831 return rx->n_bytes; 14832 } 14833