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