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